rkelly-remix 0.0.1

data/lib/rkelly/nodes/node.rb

@@ -0,0 +1,94 @@
+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
+        @comments = []
+        @range = CharRange::EMPTY
+        @filename = nil
+      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
+
+      def pointcut(pattern)
+        case pattern
+        when String
+          ast = RKelly::Parser.new.parse(pattern)
+          # Only take the first statement
+          finder = ast.value.first.class.to_s =~ /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
+
+      def to_sexp
+        SexpVisitor.new.accept(self)
+      end
+
+      def to_ecma
+        ECMAVisitor.new.accept(self)
+      end
+
+      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
+
+      def each(&block)
+        EnumerableVisitor.new(block).accept(self)
+      end
+
+      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 @value =~ /^[A-Z]/
+          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/nodes.rb

@@ -0,0 +1,25 @@
+require 'rkelly/nodes/node'
+require 'rkelly/nodes/function_expr_node'
+require 'rkelly/nodes/binary_node'
+require 'rkelly/nodes/bracket_accessor_node'
+require 'rkelly/nodes/case_clause_node'
+require 'rkelly/nodes/comma_node'
+require 'rkelly/nodes/conditional_node'
+require 'rkelly/nodes/dot_accessor_node'
+require 'rkelly/nodes/for_in_node'
+require 'rkelly/nodes/for_node'
+require 'rkelly/nodes/function_call_node'
+require 'rkelly/nodes/function_decl_node'
+require 'rkelly/nodes/function_expr_node'
+require 'rkelly/nodes/if_node'
+require 'rkelly/nodes/label_node'
+require 'rkelly/nodes/new_expr_node'
+require 'rkelly/nodes/not_strict_equal_node'
+require 'rkelly/nodes/op_equal_node'
+require 'rkelly/nodes/postfix_node'
+require 'rkelly/nodes/prefix_node'
+require 'rkelly/nodes/property_node'
+require 'rkelly/nodes/resolve_node'
+require 'rkelly/nodes/strict_equal_node'
+require 'rkelly/nodes/try_node'
+require 'rkelly/nodes/var_decl_node'

data/lib/rkelly/parser.rb

@@ -0,0 +1,89 @@
+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+$/
+      eval(<<-eoawesomehack)
+        def #{im}(val, _values, result)
+          r = super(val.map { |v|
+              v.is_a?(Token) ? v.to_racc_token[1] : v
+            }, _values, result)
+
+          suitable_values = val.flatten.find_all {|v| v.is_a?(Node) || v.is_a?(Token) }
+          first = suitable_values.first
+          last = suitable_values.last
+          if first
+            r.range = CharRange.new(first.range.from, last.range.to) if r.respond_to?(:range)
+            r.filename = @filename if r.respond_to?(:filename)
+          end
+          r
+        end
+      eoawesomehack
+    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
+
+    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
+
+    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 =~ /^\/\//
+        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 = RKelly::Token.new(';', ';')).to_racc_token
+      end
+
+      @prev_token = n_token
+      v = n_token.to_racc_token
+      v[1] = n_token
+      v
+    end
+  end
+end

data/lib/rkelly/runtime/ruby_function.rb

@@ -0,0 +1,13 @@
+module RKelly
+  class Runtime
+    class RubyFunction
+      def initialize(&block)
+        @code = block
+      end
+
+      def call(chain, *args)
+        @code.call(*args)
+      end
+    end
+  end
+end

data/lib/rkelly/runtime/scope_chain.rb

@@ -0,0 +1,57 @@
+module RKelly
+  class Runtime
+    class ScopeChain
+      include RKelly::JS
+
+      def initialize(scope = Scope.new)
+        @chain = [GlobalObject.new]
+      end
+
+      def <<(scope)
+        @chain << scope
+      end
+
+      def has_property?(name)
+        scope = @chain.reverse.find { |x|
+          x.has_property?(name)
+        }
+        scope ? scope[name] : nil
+      end
+      
+      def [](name)
+        property = has_property?(name)
+        return property if property
+        @chain.last.properties[name]
+      end
+
+      def []=(name, value)
+        @chain.last.properties[name] = value
+      end
+
+      def pop
+        @chain.pop
+      end
+
+      def this
+        @chain.last
+      end
+
+      def new_scope(&block)
+        @chain << Scope.new
+        result = yield(self)
+        @chain.pop
+        result
+      end
+
+      def return=(value)
+        @chain.last.return = value
+      end
+
+      def return; @chain.last.return; end
+
+      def returned?
+        @chain.last.returned?
+      end
+    end
+  end
+end

data/lib/rkelly/runtime.rb

@@ -0,0 +1,36 @@
+require 'rkelly/js'
+require 'rkelly/runtime/scope_chain'
+
+module RKelly
+  class Runtime
+    UNDEFINED = RKelly::JS::Property.new(:undefined, :undefined)
+
+    def initialize
+      @parser = Parser.new
+      @scope  = ScopeChain.new
+    end
+
+    # Execute +js+
+    def execute(js)
+      function_visitor  = Visitors::FunctionVisitor.new(@scope)
+      eval_visitor      = Visitors::EvaluationVisitor.new(@scope)
+      tree = @parser.parse(js)
+      function_visitor.accept(tree)
+      eval_visitor.accept(tree)
+      @scope
+    end
+
+    def call_function(function_name, *args)
+      function = @scope[function_name].value
+      @scope.new_scope { |chain|
+        function.js_call(chain, *(args.map { |x|
+          RKelly::JS::Property.new(:param, x)
+        }))
+      }.value
+    end
+
+    def define_function(function, &block)
+      @scope[function.to_s].function = block
+    end
+  end
+end

data/lib/rkelly/syntax_error.rb

@@ -0,0 +1,4 @@
+module RKelly
+  class SyntaxError < ::SyntaxError
+  end
+end

data/lib/rkelly/token.rb

@@ -0,0 +1,24 @@
+module RKelly
+  class Token
+    attr_accessor :name, :value, :transformer, :range
+    def initialize(name, value, &transformer)
+      @name         = name
+      @value        = value
+      @transformer  = transformer
+    end
+
+    # For backwards compatibility
+    def line
+      @range.from.line
+    end
+
+    def to_racc_token
+      return transformer.call(name, value) if transformer
+      [name, value]
+    end
+
+    def to_s
+      return "#{self.name}: #{self.value}"
+    end
+  end
+end

data/lib/rkelly/tokenizer.rb

@@ -0,0 +1,193 @@
+require 'rkelly/lexeme'
+require 'rkelly/char_range'
+require 'strscan'
+
+module RKelly
+  class Tokenizer
+    KEYWORDS = Hash[%w{
+      break case catch continue default delete do else finally for function
+      if in instanceof new return switch this throw try typeof var void while
+      with
+
+      const true false null debugger
+    }.map {|kw| [kw, kw.upcase.to_sym] }]
+
+    RESERVED = Hash[%w{
+      abstract boolean byte char class double enum export extends
+      final float goto implements import int interface long native package
+      private protected public short static super synchronized throws
+      transient volatile
+    }.map {|kw| [kw, true] }]
+
+    LITERALS = {
+      # Punctuators
+      '=='  => :EQEQ,
+      '!='  => :NE,
+      '===' => :STREQ,
+      '!==' => :STRNEQ,
+      '<='  => :LE,
+      '>='  => :GE,
+      '||'  => :OR,
+      '&&'  => :AND,
+      '++'  => :PLUSPLUS,
+      '--'  => :MINUSMINUS,
+      '<<'  => :LSHIFT,
+      '<<=' => :LSHIFTEQUAL,
+      '>>'  => :RSHIFT,
+      '>>=' => :RSHIFTEQUAL,
+      '>>>' => :URSHIFT,
+      '>>>='=> :URSHIFTEQUAL,
+      '&='  => :ANDEQUAL,
+      '%='  => :MODEQUAL,
+      '^='  => :XOREQUAL,
+      '|='  => :OREQUAL,
+      '+='  => :PLUSEQUAL,
+      '-='  => :MINUSEQUAL,
+      '*='  => :MULTEQUAL,
+      '/='  => :DIVEQUAL,
+    }
+
+    # Some keywords can be followed by regular expressions (eg, return and throw).
+    # Others can be followed by division.
+    KEYWORDS_THAT_IMPLY_DIVISION = {
+      'this' => true,
+      'true' => true,
+      'false' => true,
+      'null' => true,
+    }
+
+    KEYWORDS_THAT_IMPLY_REGEX = KEYWORDS.reject {|k,v| KEYWORDS_THAT_IMPLY_DIVISION[k] }
+
+    SINGLE_CHARS_THAT_IMPLY_DIVISION = {
+      ')' => true,
+      ']' => true,
+      '}' => true,
+    }
+
+    def initialize(&block)
+      @lexemes = Hash.new {|hash, key| hash[key] = [] }
+
+      token(:COMMENT, /\/(?:\*(?:.)*?\*\/|\/[^\n]*)/m, ['/'])
+      token(:STRING, /"(?:[^"\\]*(?:\\.[^"\\]*)*)"|'(?:[^'\\]*(?:\\.[^'\\]*)*)'/m, ["'", '"'])
+      token(:S, /[\s\r\n]*/m, [" ", "\t", "\r", "\n", "\f"])
+
+      # A regexp to match floating point literals (but not integer literals).
+      digits = ('0'..'9').to_a
+      token(:NUMBER, /\d+\.\d*(?:[eE][-+]?\d+)?|\d+(?:\.\d*)?[eE][-+]?\d+|\.\d+(?:[eE][-+]?\d+)?/m, digits+['.']) do |type, value|
+        value.gsub!(/\.(\D)/, '.0\1') if value =~ /\.\w/
+        value.gsub!(/\.$/, '.0') if value =~ /\.$/
+        value.gsub!(/^\./, '0.') if value =~ /^\./
+        [type, eval(value)]
+      end
+      token(:NUMBER, /0[xX][\da-fA-F]+|0[0-7]*|\d+/, digits) do |type, value|
+        [type, eval(value)]
+      end
+
+      word_chars = ('a'..'z').to_a + ('A'..'Z').to_a + ['_', '$']
+      token(:RAW_IDENT, /([_\$A-Za-z][_\$0-9A-Za-z]*)/, word_chars) do |type,value|
+        if KEYWORDS[value]
+          [KEYWORDS[value], value]
+        elsif RESERVED[value]
+          [:RESERVED, value]
+        else
+          [:IDENT, value]
+        end
+      end
+
+      # To distinguish regular expressions from comments, we require that
+      # regular expressions start with a non * character (ie, not look like
+      # /*foo*/). Note that we can't depend on the length of the match to
+      # correctly distinguish, since `/**/i` is longer if matched as a regular
+      # expression than as matched as a comment.
+      # Incidentally, we're also not matching empty regular expressions
+      # (eg, // and //g). Here we could depend on match length and priority to
+      # determine that these are actually comments, but it turns out to be
+      # easier to not match them in the first place.
+      token(:REGEXP, %r{
+             /                  (?# beginning )
+
+             (?:
+               [^\r\n\[/\\]+      (?# any char except \r \n [ / \ )
+               |
+               \\ [^\r\n]         (?# escape sequence )
+               |
+               \[ (?:[^\]\\]|\\.)* \]   (?# [...] can contain any char including / )
+                                        (?# only \ and ] have to be escaped here )
+             )+
+
+             /[gim]*            (?# ending + modifiers )
+      }x, ['/'])
+
+      literal_chars = LITERALS.keys.map {|k| k.slice(0,1) }.uniq
+      literal_regex = Regexp.new(LITERALS.keys.sort_by { |x|
+          x.length
+        }.reverse.map { |x| "#{x.gsub(/([|+*^])/, '\\\\\1')}" }.join('|'))
+      token(:LITERALS, literal_regex, literal_chars) do |type, value|
+        [LITERALS[value], value]
+      end
+
+      symbols = ('!'..'/').to_a + (':'..'@').to_a + ('['..'^').to_a + ['`'] + ('{'..'~').to_a
+      token(:SINGLE_CHAR, /./, symbols) do |type, value|
+        [value, value]
+      end
+    end
+
+    def tokenize(string)
+      raw_tokens(string).map { |x| x.to_racc_token }
+    end
+
+    def raw_tokens(string)
+      scanner = StringScanner.new(string)
+      tokens = []
+      range = CharRange::EMPTY
+      accepting_regexp = true
+      while !scanner.eos?
+        token = match_lexeme(scanner, accepting_regexp)
+
+        if token.name != :S
+          accepting_regexp = followable_by_regex(token)
+        end
+
+        scanner.pos += token.value.length
+        token.range = range = range.next(token.value)
+        tokens << token
+      end
+      tokens
+    end
+
+    private
+
+    # Returns the token of the first matching lexeme
+    def match_lexeme(scanner, accepting_regexp)
+      @lexemes[scanner.peek(1)].each do |lexeme|
+        next if lexeme.name == :REGEXP && !accepting_regexp
+
+        token = lexeme.match(scanner)
+        return token if token
+      end
+    end
+
+    # Registers a lexeme and maps it to all the characters it can
+    # begin with.  So later when scanning the source we only need to
+    # match those lexemes that can begin with the character we're at.
+    def token(name, pattern, chars, &block)
+      lexeme = Lexeme.new(name, pattern, &block)
+      chars.each do |c|
+        @lexemes[c] << lexeme
+      end
+    end
+
+    def followable_by_regex(current_token)
+      case current_token.name
+      when :RAW_IDENT
+        KEYWORDS_THAT_IMPLY_REGEX[current_token.value]
+      when :NUMBER
+        false
+      when :SINGLE_CHAR
+        !SINGLE_CHARS_THAT_IMPLY_DIVISION[current_token.value]
+      else
+        true
+      end
+    end
+  end
+end

data/lib/rkelly/visitable.rb

@@ -0,0 +1,16 @@
+module RKelly
+  module Visitable
+    # Based off the visitor pattern from RubyGarden
+    def accept(visitor, &block)
+      klass = self.class.ancestors.find { |ancestor|
+        visitor.respond_to?("visit_#{ancestor.name.split(/::/)[-1]}")
+      }
+
+      if klass
+        visitor.send(:"visit_#{klass.name.split(/::/)[-1]}", self, &block)
+      else
+        raise "No visitor for '#{self.class}'"
+      end
+    end
+  end
+end