README

@putout/compare

Compare AST-nodes.

Install

npm i @putout/compare

API

getTemplateValues(node, template)

node - AST-node or code that will be generated;
template - template string with template variables;

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 feets templates.

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

Compare any nodes that feets 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;

__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

Usage no npm install needed!