snapdragon-parser

    1.0.0 • Public • Published

    snapdragon-parser NPM version NPM monthly downloads NPM total downloads Linux Build Status

    Easily parse a string to create an AST.

    Please consider following this project's author, Jon Schlinkert, and consider starring the project to show your ❤️ and support.

    Table of Contents

    Details

    Install

    Install with npm:

    $ npm install --save snapdragon-parser

    Usage

    Parser

    Create a new Parser with the given input and options.

    Params

    • input {String}
    • options {Object}

    Example

    const Parser = require('snapdragon-parser');
    const parser = new Parser();

    .node

    Create a new Node with the given value and type.

    Params

    • node {Object}: The object to use to create a node
    • returns {Object}: returns the created Node instance.

    Example

    const node = parser.node({type: 'slash', value: '/'});
    // sugar for
    const Node = require('snapdragon-node');
    const node = Node({type: 'slash', value: '/'});

    .isNode

    Returns true if the given value is an instance of snapdragon-node.

    Params

    • node {Object}
    • returns {Boolean}

    .set

    Register handler of the given type.

    Params

    • type {String}
    • handler {Function}

    Example

    parser.set('all', function(tok) {
      // do stuff to tok
      return tok;
    });

    .get

    Get a registered handler function.

    Params

    • type {String}
    • fn {Function}: The handler function to register.

    Example

    handlers.set('star', function() {
      // do parser, lexer, or compiler stuff
    });
    const star = handlers.get('star');

    .has

    Returns true if the parser has a registered handler of the given type.

    Params

    • {String}: type
    • returns {Boolean}

    Example

    parser.set('star', function() {});
    console.log(parser.has('star')); // true

    .capture

    Capture a node of the given type.

    Params

    • type {String}: (required)
    • regex {RegExp}: (optional)
    • lexerFn {Function}: (optional)
    • parserFn {Function}: (optional)
    • returns {Object}: Returns the Parser instance for chaining.

    .isInside

    Returns true if the parser is currently "inside" a node of the given type.

    Params

    • type {String}
    • returns {Boolean}

    .isBlock

    Returns true if node is a "block" node. Block nodes have a nodes array for keeping child nodes.

    Params

    • node {Object}
    • returns {Boolean}

    Example

    parser.isBlock(new Node()); //=> false
    parser.isBlock(new Node({ nodes: [] })); //=> true

    .isBlock

    Returns true if node is a new "block" node, with either no child nodes, or only an open node.

    Params

    • node {Object}
    • returns {Boolean}

    Example

    parser.isBlock(new Node()); //=> false
    parser.isBlock(new Node({ nodes: [] })); //=> true

    .isOpen

    Returns true if the given node is an "open" node.

    Params

    • node {Object}
    • returns {Object} parentNode

    .isClose

    Returns true if the given node is a "close" node.

    Params

    • node {Object}
    • returns {Object} parentNode

    .push

    Push a child node onto the node.nodes array of the current node on the stack.

    Params

    • node {Object}: (required)
    • returns {Object} node

    Events

    • emits: push

    Example

    parser.set('default', function(tok) {
      return this.push(this.node(tok));
    });

    .pop

    Pop the last node from the stack. If a

    Params

    • node {Object}: (optional)
    • returns {Object} node

    Events

    • emits: pop

    Example

    parser.set('default', function(tok) {
      return this.push(this.node(tok));
    });

    .next

    Get the next token from the lexer, then calls the registered parser handler for token.type on the token.

    • returns {Any}: Returns whatever value the handler returns.

    Expect the given type, or throw an exception.

    Params

    • type {String}

    Accept the given type.

    Params

    • {String}: type

    .parse

    Parses the given input string and returns an AST object.

    Params

    • input {String}
    • returns {Object}: Returns an AST (abstract syntax tree).

    Example

    const ast = parser.parse('foo/bar');

    Creates a new Parser instance with the given options, and copy the handlers from the current instance to the new instance.

    Params

    • options {Object}
    • parent {Object}: Optionally pass a different parser instance to copy handlers from.
    • returns {Object}: Returns a new Parser instance

    Concat nodes from another AST to node.nodes.

    Params

    • node {Object}
    • ast {Object}
    • returns {Object}

    .hasListeners

    Returns true if listeners are registered for even name.

    Params

    • name {String}
    • returns {Boolean}

    Params

    • fn {Function}
    • returns {Parser}: Returns the Parser instance.

    Example

    const myParser = new Parser();
    const plugin = parser => {
      // do stuff to parser instance
    };
    myParser.use(plugin);

    .error

    Throw a formatted error message with details including the cursor position.

    Params

    • msg {String}: Message to use in the Error.
    • node {Object}
    • returns {Undefined}

    Example

    parser.set('foo', function(tok) {
      if (tok.value !== 'foo') {
        throw this.error('expected token.value to be "foo"', tok);
      }
    });

    Get the part of the input string has has already been parsed.

    • returns {String}

    Params

    • parser {Object}
    • returns {Boolean}

    Example

    const Parser = require('parser');
    const parser = new Parser();
    console.log(Parser.isParser(parser)); //=> true
    console.log(Parser.isParser({})); //=> false

    About

    Contributing

    Pull requests and stars are always welcome. For bugs and feature requests, please create an issue.

    Please read the contributing guide for advice on opening issues, pull requests, and coding standards.

    Running Tests

    Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:

    $ npm install && npm test
    Building docs

    (This project's readme.md is generated by verb, please don't edit the readme directly. Any changes to the readme must be made in the .verb.md readme template.)

    To generate the readme, run the following command:

    $ npm install -g verbose/verb#dev verb-generate-readme && verb

    Related projects

    You might also be interested in these projects:

    Author

    Jon Schlinkert

    License

    Copyright © 2018, Jon Schlinkert. Released under the MIT License.


    This file was generated by verb-generate-readme, v0.8.0, on November 24, 2018.

    Install

    npm i snapdragon-parser

    DownloadsWeekly Downloads

    1,652

    Version

    1.0.0

    License

    MIT

    Unpacked Size

    27.8 kB

    Total Files

    4

    Last publish

    Collaborators

    • jonschlinkert