Nanoscale Parts Manufacturing
    Wondering what’s next for npm?Check out our public roadmap! »

    strong-trace-scopetracer

    1.0.3 • Public • Published

    strong-trace-scopetracer

    Modify scoped segments of JavaScript. Provide a mutating function and a filter test, and it will apply the mutator to scope blocks found in JavaScript strings.

    Example

    var ScopeTracer = require("strong-trace-scopetracer")
     
    var input = "// some javascript!\n\
    function foo() {\n\
      // In a function\n\
      var abc = 'ABC'\n\
      setTimeout(function () {\n\
        console.log(abc)\n\
      }, 10)\n\
    }\n\
    foo()\n"
     
    function mutate(content) {
      // We're putting things in single quotes, escape single quotes
      var name = this.fnName.replace(/'/g, "\\'")
      if (this.body.length === 0) {
        return []
      }
      return [{insertion: "console.log('entering " + name + "');", pos: this.body[0].range[0]}]
    }
     
    function nodeTest() {
      // Only functions, not outer enclosing scope.
      return this.path.length > 0
    }
     
    var tracer = ScopeTracer(mutate, nodeTest)
     
    var output = tracer.transform(input)
     
    console.log(output)
     
    /*
      // some javascript!
      function foo() {
        // In a function
        console.log('entering foo');var abc = 'ABC'
        setTimeout(function () {
          console.log('entering foo>setTimeout() fn argument');console.log(abc)
        }, 10)
      }
      foo()
    */
     
    eval(output)
     
    /*
      entering foo
      entering foo>setTimeout() fn argument
      ABC
    */
     

    API

    var scopetracer = require("scopetracer")(mutate[, nodeTest])

    Creates a tracer object that can be used to transform javascript strings.

    mutate(content[, extra[, ...]])

    The mutate function is called with the context of this being the scopenodes node defining this scope.

    This is usually a function, though will also include the outer Program enclosing scope.

    It is an Esprima AST node with a couple of additions added by scopenodes.

    To mutate the content, return an array of objects defining the insertions or replacements to make.

    Insertions are always safe, but it is up to you to make sure that replacements (using remove) do overlap other insertions or replacements.

    [
      {
        insertion: "string to insert",
        pos: 200, // Position to insert, relative to the Esprima "range" e.g. this.range[0]
        remove: 0, // optional, how many characters to remove from content prior to inserting
        pri: 0, // optional: insertion priority in case of a `pos` tie. Lower pri inserts before higher pri.
      },
      {
        // ... return as many mutations as you like
      }
    ]

    nodeTest(content[, extra[, ...]])

    The test function is called with the same context as mutate.

    It is simply expected to return true if mutate should be run or false if mutate is to be skipped for this node.

    The default nodeTest if not defined is function nodeTest() { return true; } i.e. always call mutate.

    scopetracer.transform(content[, extra[, ...]])

    Extract scope nodes, then transform them according to mutate and nodeTest.

    Any extra arguments will be added as arguments to mutate and nodeTest.

    Similar Projects

    falafel

    LICENSE

    MIT

    Install

    npm i strong-trace-scopetracer

    DownloadsWeekly Downloads

    2

    Version

    1.0.3

    License

    StrongLoop

    Last publish

    Collaborators

    • avatar
    • avatar
    • avatar
    • avatar
    • avatar
    • avatar