@putout/compare

@putout/compare

Compare AST-nodes according to 🦎PutoutScript.

Install

npm i @putout/compare

API

getTemplateValues(node, template)

Get template values from node according to 🦎PutouScript template.

• node - AST-node or code that will be generated;
• template - 🦎PutouScript;

const {operator} = require('putout');
const {template} = operator;
const node = template.ast('const [] = a');

getTemplateValues(node, 'const __array = array');
// returns
({
    __array: {
        type: 'ArrayPattern',
        //...etc
    },
});

compare(node: string | Node, template: string | Node [, options: Options])

• node - AST-node or code that will be generated;
• template - AST-node with support of template variables.
• options - (optional) - object with properties:
  • findUp (default: true) - find up template node;

compareAll(node: string | Node, templates: string[] | Node|Nodes[], [, options: Options])

Compare nodes feats templates.

compareAny(node: string | Node, templates: string[] | Node|Nodes[], [, options: Options])

Compare any nodes that feats one of templates

compareAny(path, 'const __a = __b', {
    findUp: false,
});

Supported template variables:

__

Any node.

compare('const x = data', 'const __ = __');
compare('const {x} = data', 'const __ = __');
compare('const x = {data}', 'const __ = __');
// returns
true;

__object

ObjectPattern or ObjectExpression with any count of properties.

compare('const {} = data', 'const __object = __');
compare('const {hello} = data', 'const __object = __');
// returns
true;

__array

ArrayPattern or ArrayExpression with any count of elements.

compare('const [] = data', 'const __array = __');
compare('const [hello] = data', 'const __array = __');
compare('const hello = [data]', 'const __ = __array');
// returns
true;

__args, __args__a

Any count of arguments:

compare('(a, b, c) => {}', '(__args) => {}');
compare('(a, b) => {}', '(__args) => {}');
compare('() => {}', '(__args) => {}');
// returns
true;

Or linked arguments:

compare('((a) => fn(a))(value)', '((__args__a) => __c(__args__a))(__args__b)');
// returns
true;

compare('((a) => fn(42))(value)', '((__args__a) => __c(__args__a))(__args__b)');
// returns
false;

__imports

Any count of imports:

compare('import React, {Component} from "react"', 'import __imports from "react"');

"__"

Any string literal.

compare('const a = "hello"', 'const __ = "__"');

__a

Linked literal

compare('const __a = "hello"', 'const __a = "hello"');

"__a"

Linked string literal.

compare('const a = "hello"', 'const __a = "__b"');

__a

Linked template literal.

compare('const a = `hello`', 'const __a = `__b`');
// returns
true;

__body

Any BlockStatement.

compare('const a = () => 0', 'const a = () => __body');
// returns
false;

compare('const a = () => {}', 'const a = () => __body');
// returns
true;

__nop

Any Function with no arguments and empty body;

compare('const a = () => {}', 'const __a = __nop');
// returns
true;

compare('const a = async () => {}', 'const a = __nop');
// returns
true;

__identifier

Any Identifier

compare('const a = 5', 'const __identifier = 5');
// returns
true;

/__a/

Any regexp

compare('const a = /hello/g', 'const a = /__a/');
// returns
true;

License

MIT