rkelly-turbo 0.1.0

data/lib/rkelly/nodes/binary_node.rb

@@ -0,0 +1,18 @@
+module RKelly
+  module Nodes
+    class BinaryNode < Node
+      attr_reader :left
+      def initialize(left, right)
+        super(right)
+        @left = left
+      end
+    end
+
+    %w[Subtract LessOrEqual GreaterOrEqual Add Multiply NotEqual
+       DoWhile Switch LogicalAnd UnsignedRightShift Modulus While
+       NotStrictEqual Less With In Greater BitOr StrictEqual LogicalOr
+       BitXOr LeftShift Equal BitAnd InstanceOf Divide RightShift].each do |node|
+      const_set "#{node}Node", Class.new(BinaryNode)
+    end
+  end
+end

data/lib/rkelly/nodes/bracket_accessor_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class BracketAccessorNode < Node
+      attr_reader :accessor
+      def initialize(resolve, accessor)
+        super(resolve)
+        @accessor = accessor
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/case_clause_node.rb

@@ -0,0 +1,11 @@
+require 'rkelly/nodes/binary_node'
+
+module RKelly
+  module Nodes
+    class CaseClauseNode < BinaryNode
+      def initialize(left, src = SourceElementsNode.new([]))
+        super
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/comma_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class CommaNode < Node
+      attr_reader :left
+      def initialize(left, right)
+        super(right)
+        @left = left
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/conditional_node.rb

@@ -0,0 +1,11 @@
+require 'rkelly/nodes/if_node'
+
+module RKelly
+  module Nodes
+    class ConditionalNode < IfNode
+      def initialize(test, true_block, else_block)
+        super
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/dot_accessor_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class DotAccessorNode < Node
+      attr_reader :accessor
+      def initialize(resolve, accessor)
+        super(resolve)
+        @accessor = accessor
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/for_in_node.rb

@@ -0,0 +1,12 @@
+module RKelly
+  module Nodes
+    class ForInNode < Node
+      attr_reader :left, :right
+      def initialize(left, right, block)
+        super(block)
+        @left = left
+        @right = right
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/for_node.rb

@@ -0,0 +1,13 @@
+module RKelly
+  module Nodes
+    class ForNode < Node
+      attr_reader :init, :test, :counter
+      def initialize(init, test, counter, body)
+        super(body)
+        @init = init
+        @test = test
+        @counter = counter
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/function_call_node.rb

@@ -0,0 +1,16 @@
+module RKelly
+  module Nodes
+    class FunctionCallNode < Node
+      attr_reader :arguments
+      def initialize(value, arguments)
+        super(value)
+        @arguments = arguments
+      end
+
+      def ==(other)
+        super && @arguments == other.arguments
+      end
+      alias :=~ :==
+    end
+  end
+end

data/lib/rkelly/nodes/function_decl_node.rb

@@ -0,0 +1,6 @@
+module RKelly
+  module Nodes
+    class FunctionDeclNode < FunctionExprNode
+    end
+  end
+end

data/lib/rkelly/nodes/function_expr_node.rb

@@ -0,0 +1,12 @@
+module RKelly
+  module Nodes
+    class FunctionExprNode < Node
+      attr_reader :function_body, :arguments
+      def initialize(name, body, args = [])
+        super(name)
+        @function_body = body
+        @arguments = args
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/if_node.rb

@@ -0,0 +1,12 @@
+module RKelly
+  module Nodes
+    class IfNode < Node
+      attr_reader :conditions, :else
+      def initialize(conditions, value, else_stmt = nil)
+        super(value)
+        @conditions = conditions
+        @else = else_stmt
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/label_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class LabelNode < Node
+      attr_reader :name
+      def initialize(name, value)
+        super(value)
+        @name = name
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/new_expr_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class NewExprNode < Node
+      attr_reader :arguments
+      def initialize(value, args)
+        super(value)
+        @arguments = args
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/node.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RKelly
+  module Nodes
+    class Node
+      include RKelly::Visitable
+      include RKelly::Visitors
+      include Enumerable
+
+      attr_accessor :value, :comments, :range, :filename
+      def initialize(value)
+        @value = value
+        @range = CharRange::EMPTY
+      end
+
+      def comments; @comments || []; end
+
+      # For backwards compatibility
+      def line
+        @range.from.line
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && @value == other.value
+      end
+      alias :=~ :==
+
+      def ===(other)
+        other.is_a?(self.class) && @value === other.value
+      end
+
+      # Matches nodes with the given pattern (usually a class name of
+      # the node) and returns an instance of PointcutVisitor on which
+      # #matches can be invoked to get the list of AST nodes that
+      # matched.
+      #
+      #     ast.pointcut(RKelly::Nodes::IfNode).matches --> array of nodes
+      #
+      def pointcut(pattern)
+        case pattern
+        when String
+          ast = RKelly::Parser.new.parse(pattern)
+          # Only take the first statement
+          finder = ast.value.first.class.name.end_with?("StatementNode") ?
+            ast.value.first.value : ast.value.first
+          visitor = PointcutVisitor.new(finder)
+        else
+          visitor = PointcutVisitor.new(pattern)
+        end
+
+        visitor.accept(self)
+        visitor
+      end
+      alias :/ :pointcut
+
+      # Generates an s-expression data structure like so:
+      #
+      #     "var x = 10;" --> [:var, [[:var_decl, :x, [:assign, [:lit, 10]]]]]]
+      #
+      def to_sexp
+        SexpVisitor.new.accept(self)
+      end
+
+      # Generates formatted and intented JavaScript source code.
+      def to_ecma
+        ECMAVisitor.new.accept(self)
+      end
+
+      # Generates a graph description in DOT language.  This can be
+      # fed into the dot program to generate a graph of the AST:
+      #
+      #     $ dot -Tpng generated-graph.dot -o graph.png
+      #
+      def to_dots
+        visitor = DotVisitor.new
+        visitor.accept(self)
+        header = <<-END
+digraph g {
+graph [ rankdir = "TB" ];
+node [
+  fontsize = "16"
+  shape = "ellipse"
+];
+edge [ ];
+        END
+        nodes = visitor.nodes.map { |x| x.to_s }.join("\n")
+        counter = 0
+        arrows = visitor.arrows.map { |x|
+          s = "#{x} [\nid = #{counter}\n];"
+          counter += 1
+          s
+        }.join("\n")
+        "#{header}\n#{nodes}\n#{arrows}\n}"
+      end
+
+      # Loops through all the syntax nodes.
+      def each(&block)
+        EnumerableVisitor.new(block).accept(self)
+      end
+
+      # This CRASHES!
+      # It calls method #s which is nowhere to be found.
+      def to_real_sexp
+        RealSexpVisitor.new.accept(self)
+      end
+    end
+
+    %w[EmptyStatement Parenthetical ExpressionStatement True Delete Return TypeOf
+       SourceElements Number LogicalNot AssignExpr FunctionBody
+       ObjectLiteral UnaryMinus Throw This BitwiseNot Element String
+       Array CaseBlock Null Break Parameter Block False Void Regexp
+       Arguments Attr Continue ConstStatement UnaryPlus VarStatement].each do |node|
+      eval "class #{node}Node < Node; end"
+    end
+  end
+end

data/lib/rkelly/nodes/not_strict_equal_node.rb

@@ -0,0 +1,6 @@
+module RKelly
+  module Nodes
+    class NotStrictEqualNode < BinaryNode
+    end
+  end
+end

data/lib/rkelly/nodes/op_equal_node.rb

@@ -0,0 +1,16 @@
+module RKelly
+  module Nodes
+    class OpEqualNode < Node
+      attr_reader :left
+      def initialize(left, right)
+        super(right)
+        @left = left
+      end
+    end
+
+    %w[Multiply Divide LShift Minus Plus Mod XOr RShift And URShift Or].each do |node|
+      eval "class Op#{node}EqualNode < OpEqualNode; end"
+    end
+
+  end
+end

data/lib/rkelly/nodes/postfix_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class PostfixNode < Node
+      attr_reader :operand
+      def initialize(operand, operator)
+        super(operator)
+        @operand = operand
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/prefix_node.rb

@@ -0,0 +1,6 @@
+module RKelly
+  module Nodes
+    class PrefixNode < PostfixNode
+    end
+  end
+end

data/lib/rkelly/nodes/property_node.rb

@@ -0,0 +1,13 @@
+module RKelly
+  module Nodes
+    class PropertyNode < Node
+      attr_reader :name
+      def initialize(name, value)
+        super(value)
+        @name = name
+      end
+    end
+
+    %w[Getter Setter].each {|node| eval "class #{node}PropertyNode < PropertyNode; end"}
+  end
+end

data/lib/rkelly/nodes/resolve_node.rb

@@ -0,0 +1,19 @@
+module RKelly
+  module Nodes
+    class ResolveNode < Node
+      def ==(other)
+        return true if super
+        if ('A'..'Z').include? @value[0]
+          place = [Object, Module, RKelly::Nodes].find { |x|
+            x.const_defined?(@value.to_sym)
+          }
+          return false unless place
+          klass = place.const_get(@value.to_sym)
+          return true if klass && other.is_a?(klass) || other.value.is_a?(klass)
+        end
+        false
+      end
+      alias :=~ :==
+    end
+  end
+end

data/lib/rkelly/nodes/strict_equal_node.rb

@@ -0,0 +1,6 @@
+module RKelly
+  module Nodes
+    class StrictEqualNode < BinaryNode
+    end
+  end
+end

data/lib/rkelly/nodes/try_node.rb

@@ -0,0 +1,13 @@
+module RKelly
+  module Nodes
+    class TryNode < Node
+      attr_reader :catch_var, :catch_block, :finally_block
+      def initialize(value, catch_var, catch_block, finally_block = nil)
+        super(value)
+        @catch_var = catch_var
+        @catch_block = catch_block
+        @finally_block = finally_block
+      end
+    end
+  end
+end

data/lib/rkelly/nodes/var_decl_node.rb

@@ -0,0 +1,15 @@
+module RKelly
+  module Nodes
+    class VarDeclNode < Node
+      attr_accessor :name, :type
+      def initialize(name, value, constant = false)
+        super(value)
+        @name = name
+        @constant = constant
+      end
+
+      def constant?; @constant; end
+      def variable?; !@constant; end
+    end
+  end
+end

data/lib/rkelly/parser.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'rkelly/tokenizer'
+require 'rkelly/generated_parser'
+
+
+module RKelly
+  class Parser < RKelly::GeneratedParser
+    TOKENIZER = Tokenizer.new
+
+    RKelly::GeneratedParser.instance_methods.each do |im|
+      next unless im.to_s =~ /^_reduce_\d+$/
+      define_method im do |val, _values, result|
+        r = super(val.map { |v|
+            v.is_a?(Token) ? v.to_racc_token[1] : v
+          }, _values, result)
+
+        if r.respond_to? :range
+          suitable_values = val.flatten.find_all {|v| v.is_a? Token or v.is_a? Node }
+          first = suitable_values.first
+          if first
+            r.range = CharRange.new(first.range.from, suitable_values.last.range.to)
+            r.filename = @filename if @filename
+          end
+        end
+        r
+      end
+    end
+
+    attr_accessor :logger
+    def initialize
+      @tokens = []
+      @logger = nil
+      @terminator = false
+      @prev_token = nil
+      @comments = []
+    end
+
+    # Parse +javascript+ and return an AST
+    def parse(javascript, filename = nil)
+      @tokens = TOKENIZER.raw_tokens(javascript)
+      @position = 0
+      @filename = filename
+      ast = do_parse
+      ast.comments = @comments if ast
+      ast
+    end
+
+    def yyabort
+      raise "something bad happened, please report a bug with sample JavaScript"
+    end
+
+    # When parsing finishes without all tokens being parsed, returns
+    # the token at which the parsing stopped.  Returns nil when parser
+    # reached to the very last token (but possibly still failed as it
+    # expeced more tokens).
+    #
+    # Useful for pin-pointing the position of a syntax error.
+    def stopped_at
+      if @position < @tokens.length
+        @tokens[@position-1]
+      else
+        nil
+      end
+    end
+
+    private
+    def on_error(error_token_id, error_value, value_stack)
+      if logger
+        logger.error(token_to_str(error_token_id))
+        logger.error("error value: #{error_value}")
+        logger.error("error stack: #{value_stack}")
+      end
+    end
+
+    SEMICOLON_TOKEN = RKelly::Token.new(';', ';').freeze
+
+    def next_token
+      @terminator = false
+      begin
+        return [false, false] if @position >= @tokens.length
+        n_token = @tokens[@position]
+        @position += 1
+        case @tokens[@position - 1].name
+        when :COMMENT
+          @comments << n_token
+          @terminator = true if n_token.value.start_with? "//"
+        when :S
+          @terminator = true if n_token.value =~ /[\r\n]/
+        end
+      end while([:COMMENT, :S].include?(n_token.name))
+
+      if @terminator &&
+          ((@prev_token && %w[continue break return throw].include?(@prev_token.value)) ||
+           (n_token && %w[++ --].include?(n_token.value)))
+        @position -= 1
+        return (@prev_token = SEMICOLON_TOKEN.dup).to_racc_token
+      end
+
+      @prev_token = n_token
+      v = n_token.to_racc_token
+      v[1] = n_token
+      v
+    end
+  end
+end