parsejs 0.0.1

data/lib/parsejs/scope.rb

@@ -0,0 +1,183 @@
+require "parsejs/visitor"
+
+module ParseJS
+  module AST
+    module Scope
+      attr_accessor :scope_variables, :parent_variables, :variable_access
+      attr_accessor :parent_scope, :child_scopes
+
+      def variable_in_scope?(name)
+        return true if variable?(name)
+        parent_scope && parent_scope.variable_in_scope?(name)
+      end
+
+      def variable?(name)
+        scope_variable?(name) || parent_variable?(name) || variable_access?(name)
+      end
+
+      def scope_variable?(name)
+        scope_variables && scope_variables.include?(name)
+      end
+
+      def parent_variable?(name)
+        parent_variables && parent_variables.include?(name)
+      end
+
+      def variable_access?(name)
+        variable_access && variable_access.include?(name)
+      end
+
+      # determine whether there is a reference for a particular variable
+      # to a parent scope.
+      def parent_variable_access?(name)
+        # if this scope has a "var x = 1" type of declaration for this name,
+        # it is not referencing a parent scope.
+        return false if scope_variable?(name)
+
+        # otherwise, if there is a variable access for this name, it's
+        # referencing a parent scope.
+        variable_access?(name)
+      end
+
+      # determine whether a variable can be added without causing damage
+      # to child scopes.
+      def available_variable?(name)
+        # if the current scope is already using the variable, it's
+        # unavailable.
+        return false if variable?(name)
+
+        # if any of the child scopes reference the variable as a
+        # parent variable, it's not available.
+        !any_child_references_parent_variable?(name)
+      end
+
+      def any_child_references_parent_variable?(name)
+        unless child_scopes.nil?
+          # this should really check if all descendent scopes see a
+          # scope variable before they see a parent refernce
+
+          return false if child_scopes.all? { |s| s.scope_variable?(name) }
+
+          child_scopes.any? do |s|
+            s.parent_variable_access?(name) ||
+              s.parent_variable?(name) ||
+              s.any_child_references_parent_variable?(name)
+          end
+        end
+      end
+    end
+
+    class ProcessVariables < Visitor
+      include ParseJS::Visitor::ScopeManager
+
+      def self.process(ast)
+        new.visit(ast)
+      end
+
+      def push_scope_variable(name)
+        vars = current_scope.scope_variables ||= Set.new
+        vars << name
+      end
+
+      def push_parent_variable(name)
+        vars = current_scope.parent_variables ||= Set.new
+        vars << name
+      end
+
+      def push_variable_access(name)
+        vars = current_scope.variable_access ||= Set.new
+        vars << name
+      end
+
+      def possible_variable_access(var)
+        push_variable_access var.val if var && var.type?("Identifier")
+      end
+
+      def possible_variable_access_array(arr)
+        arr.each { |arg| possible_variable_access arg }
+      end
+
+      def visit_VariableDeclarator(decl)
+        push_scope_variable decl.id.val
+        possible_variable_access decl.init
+
+        super
+      end
+
+      def visit_MemberExpression(expr)
+        possible_variable_access expr.object
+
+        super
+      end
+
+      def visit_CallExpression(expr)
+        possible_variable_access expr.callee
+        possible_variable_access_array expr.args
+
+        super
+      end
+
+      def visit_NewExpression(expr)
+        possible_variable_access expr.callee
+        possible_variable_access_array expr.args if expr.args
+
+        super
+      end
+
+      def visit_ArrayExpression(expr)
+        possible_variable_access_array expr.elements
+
+        super
+      end
+
+      def visit_AssignmentExpression(expr)
+        if expr.left.type?("Identifier")
+          push_parent_variable expr.left.val
+        end
+
+        possible_variable_access expr.right
+
+        super
+      end
+
+      def visit_Property(prop)
+        possible_variable_access prop.value
+
+        super
+      end
+
+      def visit_SequenceExpression(expr)
+        possible_variable_access_array expr.expressions
+
+        super
+      end
+
+      def visit_UpdateExpression(expr)
+        possible_variable_access expr.argument
+
+        super
+      end
+
+      def visit_UnaryExpression(expr)
+        possible_variable_access expr.argument
+
+        super
+      end
+
+      def visit_BinaryExpression(expr)
+        possible_variable_access expr.left
+        possible_variable_access expr.right
+
+        super
+      end
+
+      def visit_ConditionalExpression(expr)
+        possible_variable_access expr.alternate
+        possible_variable_access expr.consequent
+        possible_variable_access expr.test
+
+        super
+      end
+    end
+  end
+end

data/lib/parsejs/stringifier.rb

@@ -0,0 +1,450 @@
+require "parsejs/visitor"
+require "json"
+
+module ParseJS
+  require "pp"
+
+  class Stringifier < Visitor
+    def self.to_string(ast)
+      stringifier = new(ast)
+      yield stringifier if block_given?
+      stringifier.to_string
+    end
+
+    attr_accessor :include_comments
+
+    def initialize(ast)
+      @ast = ast
+      @indent = 0
+      @include_comments = false
+    end
+
+    def accept(node)
+      return "" if node.nil?
+
+      nl = @newline
+
+      out = if node.cuddly?
+        " " << super
+      elsif @newline
+        @newline = false
+        current_indent << super
+      else
+        super
+      end
+
+      out << newline if node.needs_newline? && needs_newline?(out)
+
+      out
+    end
+
+    def indent
+      @indent += 1
+    end
+
+    def outdent
+      @indent -= 1
+    end
+
+    def current_indent
+      "  " * @indent
+    end
+
+    def newline
+      @newline = true
+      "\n"
+    end
+
+    def cuddle(node, out, more=false)
+      if node.cuddly?
+        node.cuddle! if more
+      else
+        indent
+        out << newline
+      end
+
+      out << accept(node)
+
+      if more && node.cuddly?
+        out << " "
+        @newline = false
+      end
+
+      unless node.cuddly?
+        outdent
+        out << current_indent if more
+      end
+    end
+
+    def without_newline
+      old, @skip_newline = @skip_newline, true
+      ret = yield
+      @skip_newline = old
+      ret
+    end
+
+    def needs_newline?(out)
+      out !~ /\n$/ && !@skip_newline
+    end
+
+    def strip_newline(str)
+      @newline = false
+      str.sub(/\n$/, '')
+    end
+
+    def to_string
+      accept @ast
+    end
+
+    def params(node)
+      map(node).join(", ")
+    end
+
+    def each(node)
+      node.each { |element| accept(element) }
+    end
+
+    def visit_Program(program)
+      map(program.elements).join("")
+    end
+
+    def visit_ExpressionStatement(statement)
+      accept(statement.expression) + ";"
+    end
+
+    def visit_SequenceExpression(expression)
+      out = ""
+      out << "(" if expression.parens
+      exprs = params(expression.expressions)
+      exprs = strip_newline(exprs) if expression.parens
+      out << exprs
+      out << ")" if expression.parens
+      out
+    end
+
+    def visit_Literal(literal)
+      case val = literal.val
+      when nil
+        "null"
+      when ParseJS::AST::Node
+        accept val
+      else
+        val.inspect
+      end
+    end
+
+    def visit_String(string)
+      string.quote + super + string.quote
+    end
+
+    def visit_RegExp(regex)
+      "/#{super.join("/")}"
+    end
+
+    def visit_DebuggerStatement(expr)
+      "#{super};"
+    end
+
+    def visit_UnaryExpression(unary)
+      op, argument = super
+      space = op =~ /\w/ ? sp : ""
+      "#{op}#{space}#{argument}"
+    end
+
+    def visit_AssignmentExpression(expr)
+      left, op, right = super
+      "#{left} #{op} #{right}"
+    end
+
+    def visit_CallExpression(expr)
+      out = strip_newline(accept(expr.callee))
+      args = params(expr.args)
+      args = strip_newline(args)
+      out << "(" + args + ")"
+    end
+
+    def visit_ArrayExpression(expr)
+
+      "[" + begin
+
+        last, out = expr.elements.size - 1, ""
+        expr.elements.each_with_index do |element, i|
+          if element.nil?
+            out << ","
+            out << " " unless i == last
+          else
+            out << accept(element)
+            out << ", " unless i == last
+          end
+        end
+        out
+
+      end + "]"
+    end
+
+    def visit_ObjectExpression(expr)
+      if expr.properties.length > 2
+        out = "{" << newline
+        indent
+
+        last = expr.properties.size - 1
+        expr.properties.each_with_index do |prop, i|
+          out << strip_newline(accept(prop))
+          out << "," unless last == i
+          out << newline
+        end
+
+        outdent
+        out << current_indent << "}"
+      else
+        "{#{params(expr.properties)}}"
+      end
+    end
+
+    def visit_Property(property)
+      comments, key, value = super
+
+      "#{comments.join}#{key}: #{value}"
+    end
+
+    def visit_CommentedStatement(statement)
+      comments, statement = super
+      "#{comments.join}#{statement}"
+    end
+
+    def visit_MemberExpression(expr)
+      left = strip_newline(accept(expr.object))
+      right = accept(expr.property)
+
+      if expr.computed
+        "#{left}[#{right}]"
+      else
+        "#{left}.#{right}"
+      end
+    end
+
+    def visit_NewExpression(expr)
+      callee, args = super
+
+      left = "new #{callee}"
+      arg_string = "(#{args.join(", ")})" if args
+      return "#{left}#{arg_string}"
+    end
+
+    def visit_BinaryExpression(expr)
+      left = strip_newline(accept(expr.left))
+      right = accept(expr.right)
+
+      "#{left} #{expr.op} #{right}"
+    end
+
+    def visit_BlockStatement(statement)
+      out = "{" << newline
+      indent
+      out << super.join
+      outdent
+      out << current_indent << "}"
+      @newline = false unless statement.cuddly
+      out
+    end
+
+    def visit_IfStatement(statement)
+      consequent = statement.consequent
+      alternate = statement.alternate
+
+      out = "if (" + accept(statement.test) + ")"
+
+      cuddle(consequent, out, alternate)
+
+      if alternate
+        out << "else"
+        cuddle(alternate, out, false)
+      end
+
+      out
+    end
+
+    def visit_WhileStatement(statement)
+      test = statement.test
+      body = statement.body
+
+      out = "while (" + accept(test) + ")"
+      cuddle(body, out, false)
+      out
+    end
+
+    def visit_DoWhileStatement(statement)
+      out = "do"
+      cuddle(statement.body, out, true)
+      out << "while (" + accept(statement.test) + ");"
+    end
+
+    def visit_ForStatement(statement)
+      init = statement.init
+      test = statement.test
+      update = statement.update
+      body = statement.body
+      out = ""
+
+      without_newline do
+        out << "for (" + accept(init) + ";"
+        test = accept(test)
+        out << " #{test}" unless test.empty?
+        out << ";"
+        update = accept(update)
+        out << " #{update}" unless update.empty?
+        out << ")"
+      end
+
+      cuddle(body, out, false)
+      out
+    end
+
+    def visit_VariableDeclaration(decl)
+      kind, declarations, semicolon = super
+      "#{kind} #{declarations.join(", ")}#{";" if semicolon}"
+    end
+
+    def visit_VariableDeclarator(decl)
+      id, init = super
+
+      out = id
+      out << (init ? " = #{init}" : "")
+    end
+
+    def visit_UpdateExpression(expr)
+      op, prefix, argument = super
+
+      op += " " if op =~ /\w/
+
+      if prefix
+        "#{op}#{argument}"
+      else
+        "#{argument}#{op}"
+      end
+    end
+
+    def visit_ForInStatement(statement)
+      left = statement.left
+      right = statement.right
+      body = statement.body
+
+      out = ""
+
+      without_newline do
+        out << "for (" + accept(left) + " in " + accept(right) + ")"
+      end
+
+      cuddle(body, out, false)
+      out
+    end
+
+    def visit_SwitchStatement(statement)
+      out = ""
+
+      without_newline do
+        out << "switch (" + accept(statement.discriminant) + ") {" << newline
+        indent
+      end
+
+      out << map(statement.cases).join
+      outdent
+      out << current_indent << "}" << newline
+    end
+
+    def visit_SwitchCase(switch)
+      if switch.test
+        out = "case #{accept(switch.test)}:" << newline
+      else
+        out = "default:" << newline
+      end
+
+      indent
+      out << map(switch.consequent).join
+      outdent
+      out
+    end
+
+    def visit_ThrowStatement(statement)
+      "throw #{super};"
+    end
+
+    def visit_TryStatement(statement)
+      handler = statement.handler
+      finalizer = statement.finalizer
+
+      out = "try"
+
+      cuddle(statement.block, out, handler || finalizer)
+
+      if handler
+        out << "catch (" + accept(handler.param) + ")"
+        cuddle(handler.body, out, finalizer)
+      end
+
+      if finalizer
+        out << "finally"
+        cuddle(finalizer, out, false)
+      end
+
+      out
+    end
+
+    def visit_FunctionDeclaration(decl)
+      id = decl.id
+      parameters = decl.params.list
+      body = decl.body
+
+      out = "function " + accept(id) + "("
+      out << params(parameters)
+      out << ") {" << newline
+
+      indent
+      out << map(decl.body).join
+      outdent
+      out << current_indent << "}"
+    end
+
+    def labeled(name, label)
+      out = name
+      out << " #{label}" if label
+      out << ";"
+    end
+
+    def visit_ReturnStatement(statement)
+      labeled("return", super)
+    end
+
+    def visit_BreakStatement(statement)
+      labeled("break", super)
+    end
+
+    def visit_ContinueStatement(statement)
+      labeled("continue", super)
+    end
+
+    def visit_ConditionalExpression(expr)
+      out = strip_newline(accept(expr.test))
+      out << " ? " << strip_newline(accept(expr.consequent))
+      out << " : " << accept(expr.alternate)
+    end
+
+    def visit_Comment(comment)
+      return "" unless include_comments
+      if comment.type == 'singleline'
+        "//" + comment.body + newline
+      else
+        body = comment.body.split("\n")
+        first = body.shift
+        out = "/*" + first + newline + body.map { |s| "#{current_indent}#{s}" }.join(newline) + "*/"
+        out << "\n" if comment.newline
+        out
+      end
+    end
+
+  private
+    def sp
+      " "
+    end
+  end
+end