ParsedJS

A standard Javascript expression tree visitor, on top of esprima parser

It relies on esprima to parse a Javascript expression, and it provides a visitor to walk through the expression tree

Also, it defines a basic model of Javascript class and method definitions

It's not an introspection model, as it operates on static source code, but it allows for static source code inspection and edition

Installation

npm install o-parsed-js

Documentation

http://o-programming-language.org/

Usage

ParseTreeVisitor subclass

Create a subclass of ParseTreeVisitor

As an example, the class below parses expressions to perform simple arithmetical operations

const { ParseTreeVisitor } = require('o-parsed-js')

class Calculator extends ParseTreeVisitor {
  doesHandleExpressionType (treeNodeType) {
    const allowedExpressionTypes = [
      'BinaryExpression',
      'ExpressionStatement',
      'Literal',
      'Program'
    ]
    return allowedExpressionTypes.includes(treeNodeType)
  }

  evaluate (text) {
    return this.parseAndVisitString(text)
  }

  visitBinaryExpression (binaryExpression) {
    const left = this.visit(binaryExpression.left)
    const right = this.visit(binaryExpression.right)

    switch (binaryExpression.operator) {
      case '+':
        return left + right
      case '-':
        return left - right
      case '*':
        return left * right
      case '/':
        return left / right
      default:
        throw new Error(`Uknown operator ${binaryExpression.operator}`)
    }
  }

  visitExpressionStatement (expressionStatement) {
    return this.visit(expressionStatement.expression)
  }

  visitLiteral (literal) {
    if (!Type.isInteger(literal.value)) {
      throw new Error(`Uknown expression ${literal}`)
    }
    return literal.value
  }

  visitProgram (program) {
    return this.visit(program.body[0])
  }
}

const calculator = new Calculator()
calculator.evaluate('1+2') === 3

and implement the visit methods of interest

Stylist

Not stable yet

Don't use it, unless you have a test coverage of 100%

Javascript, class oriented, source code styler, to release programmers from caring about the format of the source code they write

Write the method, then run stylist

It'll re-arrange each method source code, to a uniform style, no matter who wrote it

I'm writting it as a replacement of eslint, for I want a class oriented parser

Also, it might set the grounds to, in a future, improve it with custom refactor rules, specific to object oriented code in javascript

Runs with

npx stylist