jbarnette-johnson 1.0.0.200806240111

data/lib/johnson/spidermonkey/ruby_land_proxy.rb

@@ -0,0 +1,52 @@
+module Johnson #:nodoc:
+  module SpiderMonkey #:nodoc:
+    class RubyLandProxy # native
+      include Enumerable
+      
+      def initialize
+        raise Johnson::Error, "#{self.class.name} is an internal support class."
+      end
+      
+      private :initialize
+      
+      alias_method :size, :length
+      
+      def to_proc
+        @proc ||= Proc.new { |*args| call(*args) }
+      end
+
+      def call(*args)
+        call_using(runtime.global, *args)
+      end
+
+      def call_using(this, *args)
+        native_call(this, *args)
+      end
+      
+      def inspect
+        toString
+      end
+      
+      def method_missing(sym, *args, &block)
+        args << block if block_given?
+        
+        name = sym.to_s
+        assignment = "=" == name[-1, 1]
+        
+        # default behavior if the slot's not there
+        return super unless assignment || respond_to?(sym)
+        
+        unless function_property?(name)
+          # for arity 0, treat it as a get
+          return self[name] if args.empty?
+
+          # arity 1 and quacking like an assignment, treat it as a set
+          return self[name[0..-2]] = args[0] if assignment && 1 == args.size
+        end        
+        
+        # okay, must really be a function
+        call_function_property(name, *args)
+      end
+    end
+  end
+end

data/lib/johnson/spidermonkey/runtime.rb

@@ -0,0 +1,94 @@
+module Johnson #:nodoc:
+  module SpiderMonkey #:nodoc:
+    class Runtime # native
+      CONTEXT_MAP_KEY = :johnson_context_map
+
+      def initialize(options={})
+        @debugger = nil
+        @compiled_scripts = {}
+        @gcthings = {}
+        initialize_native(options)
+        self["Ruby"] = Object
+      end
+      
+      # called from js_land_proxy.c:make_js_land_proxy
+      def add_gcthing(thing)
+        @gcthings[thing.object_id] = thing
+      end
+      
+      # called from js_land_proxy.c:finalize
+      def remove_gcthing(thing)
+        @gcthings.delete(thing.object_id)
+      end
+
+
+      def current_context
+        contexts = (Thread.current[CONTEXT_MAP_KEY] ||= {})
+        contexts[self.object_id] ||= Context.new(self)
+      end
+
+      def [](key)
+        global[key]
+      end
+      
+      def []=(key, value)
+        global[key] = value
+      end
+
+      ###
+      # Evaluate +script+ with +filename+ and +linenum+
+      def evaluate(script, filename = nil, linenum = nil)
+        compiled_script = compile(script, filename, linenum)
+        evaluate_compiled_script(compiled_script)
+      end
+
+      ###
+      # Compile +script+ with +filename+ and +linenum+
+      def compile(script, filename=nil, linenum=nil)
+        filename ||= 'none'
+        linenum  ||= 1
+        @compiled_scripts[filename] = native_compile(script, filename, linenum)
+      end
+
+      ###
+      # Yield to +block+ in +filename+ at +linenum+
+      def break(filename, linenum, &block)
+        raise "#{filename} has not been compiled" unless @compiled_scripts.key?(filename)
+
+        compiled_script = @compiled_scripts[filename]
+        set_trap(compiled_script, linenum, block)
+      end
+
+      class << self
+        def raise_js_exception(jsex)
+          raise jsex if Exception === jsex
+          raise Johnson::Error.new(jsex.to_s) unless Johnson::SpiderMonkey::RubyLandProxy === jsex
+
+          stack = jsex.stack rescue nil
+
+          message = jsex['message'] || jsex.to_s
+          at = "(#{jsex['fileName']}):#{jsex['lineNumber']}"
+          ex = Johnson::Error.new("#{message} at #{at}")
+          if stack
+            js_caller = stack.split("\n").find_all { |x| x != '@:0' }
+            ex.set_backtrace(js_caller + caller)
+          else
+            ex.set_backtrace(caller)
+          end
+
+          raise ex
+        end
+      end
+
+      private
+      # Called by SpiderMonkey's garbage collector to determine whether or
+      # not it should GC
+      def should_sm_gc?
+        return false if Thread.list.find_all { |t|
+          t.key?(CONTEXT_MAP_KEY)
+        }.length > 1
+        true
+      end
+    end
+  end
+end

data/lib/johnson/version.rb

@@ -0,0 +1,4 @@
+module Johnson #:nodoc:
+  # FIXME: Don't add the timestamp for "release" versions
+  VERSION = "1.0.0.#{Time.now.strftime("%Y%m%d%H%M")}".freeze
+end

data/lib/johnson/visitable.rb

@@ -0,0 +1,16 @@
+module Johnson
+  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}' at line #{line}"
+      end
+    end
+  end
+end

data/lib/johnson/visitors.rb

@@ -0,0 +1,4 @@
+require 'johnson/visitors/sexp_visitor'
+require 'johnson/visitors/ecma_visitor'
+require 'johnson/visitors/dot_visitor'
+require 'johnson/visitors/enumerating_visitor'

data/lib/johnson/visitors/dot_visitor.rb

@@ -0,0 +1,167 @@
+module Johnson
+  module Visitors
+    class DotVisitor
+      attr_accessor :nodes, :links
+
+      ESCAPE = /([<>"\\])/
+
+      class Node < Struct.new(:node_id, :label, :fields)
+        def to_s
+          f = fields.map { |field|
+            field.to_s.gsub(ESCAPE, '\\\\\1').gsub(/[\r\n]/, ' ')
+          }.join('\n')
+          f = "\\n#{f}" if f.length > 0
+          "\"#{node_id}\" [ label = \"#{label}#{f}\" ];"
+        end
+      end
+      class Link < Struct.new(:from, :to, :attributes)
+        def to_s
+          attrs = ''
+          if attributes
+            attrs = " [" + attributes.map { |attribute|
+              attribute.join(' = ')
+            }.join("; ") + "]"
+          end
+          "\"#{from}\" -> \"#{to}\"#{attrs};"
+        end
+      end
+
+      def initialize
+        @nodes = []
+        @links = []
+        @color = 'lightblue2'
+        @style = 'filled'
+        yield self if block_given?
+      end
+
+      def to_s
+        "digraph parsetree {\n" +
+          "  node [color=#{@color}, style=#{@style}];\n" +
+          @nodes.map { |n| n.to_s }.join("\n") +
+          @links.map { |n| n.to_s }.join("\n") +
+          "\n}"
+      end
+
+      def visit_SourceElements(o)
+        @nodes << Node.new(o.object_id, 'SourceElements', [])
+        o.value.each { |x|
+          @links << Link.new(o.object_id, x.object_id)
+          x.accept(self)
+        }
+      end
+
+      %w{
+        VarStatement
+        Comma
+        ObjectLiteral
+        ArrayLiteral
+        New
+        FunctionCall
+        Import
+        Export
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          @nodes << Node.new(o.object_id, type, [])
+          o.value.each { |x|
+            @links << Link.new(o.object_id, x.object_id)
+            x.accept(self)
+          }
+        end
+      end
+
+      %w{ Name Number Regexp String }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          @nodes << Node.new(o.object_id, type, [o.value])
+        end
+      end
+
+      %w{ Break Continue False Null This True }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          @nodes << Node.new(o.object_id, type, [])
+        end
+      end
+
+      def visit_Try(o)
+        @nodes << Node.new(o.object_id, 'Try', [])
+        @links << Link.new(o.object_id, o.cond.object_id, {'label' => 'cond' })
+        o.cond.accept(self)
+        if o.b_then
+          o.b_then.each { |x|
+            @links << Link.new(o.object_id, x.object_id, {'label' => 'b_then' })
+            x.accept(self)
+          }
+        end
+        if x = o.b_else
+          @links << Link.new(o.object_id, x.object_id, {'label' => 'b_else' })
+          x.accept(self)
+        end
+      end
+
+      {
+        'For'     => [:init, :cond, :update, :body],
+        'ForIn'   => [:in_cond, :body],
+        'Ternary' => [:cond, :b_then, :b_else],
+        'If'      => [:cond, :b_then, :b_else],
+        'Catch'   => [:cond, :b_then, :b_else],
+      }.each do |type,attrs|
+        define_method(:"visit_#{type}") do |o|
+          @nodes << Node.new(o.object_id, type, [])
+          attrs.each do |method|
+            if x = o.send(method)
+              @links << Link.new(o.object_id, x.object_id, {'label' => method })
+              x.accept(self)
+            end
+          end
+        end
+      end
+
+      ### UNARY NODES ###
+      %w{
+        BitwiseNot Delete Not Parenthesis PostfixDecrement PostfixIncrement
+        PrefixDecrement PrefixIncrement Return Throw Typeof UnaryNegative
+        UnaryPositive Void
+      }.each do |node|
+        define_method(:"visit_#{node}") do |o|
+          @nodes << Node.new(o.object_id, node, [])
+          if x = o.value
+            @links << Link.new(o.object_id, x.object_id)
+            x.accept(self)
+          end
+        end
+      end
+
+      ### FUNCTION NODES ###
+      def visit_Function(o)
+        @nodes << Node.new(o.object_id, 'Function', [o.arguments.join(', ')])
+        @links << Link.new(o.object_id, o.body.object_id, { 'label' => 'body' })
+        o.body.accept(self)
+      end
+
+      ### BINARY NODES ###
+      %w{
+        And AssignExpr BracketAccess Case Default DoWhile DotAccessor
+        Equal GetterProperty GreaterThan GreaterThanOrEqual In
+        InstanceOf Label LessThan LessThanOrEqual NotEqual OpAdd OpAddEqual
+        OpBitAnd OpBitAndEqual OpBitOr OpBitOrEqual OpBitXor OpBitXorEqual
+        OpDivide OpDivideEqual OpEqual OpLShift OpLShiftEqual OpMod
+        OpModEqual OpMultiply OpMultiplyEqual OpRShift OpRShiftEqual
+        OpSubtract OpSubtractEqual OpURShift OpURShiftEqual Or Property
+        SetterProperty StrictEqual StrictNotEqual Switch While With
+      }.each do |node|
+        define_method(:"visit_#{node}") do |o|
+          @nodes << Node.new(o.object_id, node, [])
+          [:left, :right].each do |side|
+            if x = o.send(side)
+              @links << Link.new(o.object_id, x.object_id, { 'label' => side })
+              x.accept(self)
+            end
+          end
+        end
+      end
+
+      def accept(target)
+        target.accept(self)
+      end
+    end
+  end
+end

data/lib/johnson/visitors/ecma_visitor.rb

@@ -0,0 +1,315 @@
+module Johnson
+  module Visitors
+    class EcmaVisitor
+      def initialize
+        @depth = 0
+      end
+
+      def visit_SourceElements(o)
+        newline = o.value.length > 0 ? "\n" : ' '
+        (@depth == 0 ? '' : "{#{newline}") +
+          indent {
+            o.value.map { |x|
+              code = x.accept(self)
+              semi = case x
+                     when Nodes::Function, Nodes::While, Nodes::If, Nodes::Try, Nodes::Switch, Nodes::Case, Nodes::Default, Nodes::For, Nodes::ForIn
+                       code =~ /\}\Z/ ? '' : ';'
+                     else
+                       ';'
+                     end
+              "#{indent}#{code}#{semi}"
+            }.join("\n")
+          } +
+          (@depth == 0 ? '' : "#{newline}}")
+      end
+
+      def visit_For(o)
+        "for(#{o.init ? o.init.accept(self) : ' '};" \
+          " #{o.cond && o.cond.accept(self)};" \
+          " #{o.update && o.update.accept(self)}) #{o.body.accept(self)}"
+      end
+
+      def visit_ForIn(o)
+        "for(#{o.in_cond.accept(self)}) #{o.body.accept(self)}"
+      end
+
+      def visit_Ternary(o)
+        "#{o.cond.accept(self)} ? #{o.b_then.accept(self)} : " \
+          "#{o.b_else.accept(self)}"
+      end
+
+      def visit_VarStatement(o)
+        "var #{o.value.map { |x| x.accept(self) }.join(', ')}"
+      end
+
+      def visit_ArrayLiteral(o)
+        "[#{o.value.map { |x| x.accept(self) }.join(', ')}]"
+      end
+
+      def visit_New(o)
+        rest = o.value.slice(1..-1)
+        "new #{o.value.first.accept(self)}"\
+          "(#{rest && rest.map { |x| x.accept(self) }.join(', ')})"
+      end
+
+      def visit_FunctionCall(o)
+        rest = o.value.slice(1..-1)
+        stmt =
+          if o.value.first.is_a?(Nodes::Function)
+            "(#{o.value.first.accept(self)})"
+          else
+            "#{o.value.first.accept(self)}"
+          end
+        "#{stmt}(#{rest && rest.map { |x| x.accept(self) }.join(', ')})"
+      end
+
+      def visit_Comma(o)
+        "#{o.value.map { |x| x.accept(self) }.join(', ') }"
+      end
+
+      %w{ Name Number Regexp }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          o.value
+        end
+      end
+
+      def visit_If(o)
+        semi = ''
+        semi = ';' if o.b_else && !o.b_then.is_a?(Nodes::SourceElements)
+
+        stmt = "if(#{o.cond.accept(self)}) #{o.b_then.accept(self)}#{semi}"
+        stmt += " else #{o.b_else.accept(self)}" if o.b_else
+        stmt
+      end
+
+      def visit_Function(o)
+        "function#{o.name && ' '}#{o.name}(#{o.arguments.join(', ')}) #{o.body.accept(self)}"
+      end
+
+      def visit_String(o)
+        h = {
+          "\b"  => '\b',
+          "\t"  => '\t',
+          "\n"  => '\n',
+          "\f"  => '\f',
+          "\r"  => '\r',
+        }
+        "\"#{o.value.gsub(/[\\]/, '\\\\\\').gsub(/"/, '\"').gsub(/[\b\t\n\f\r]/) { |m| h[m] }}\""
+      end
+
+      {
+        'Break'     => 'break',
+        'Continue'  => 'continue',
+        'Null'      => 'null',
+        'True'      => 'true',
+        'False'     => 'false',
+        'This'      => 'this',
+      }.each do |type,sym|
+        define_method(:"visit_#{type}") do |o|
+          sym
+        end
+      end
+
+      def visit_BracketAccess(o)
+        "#{o.left.accept(self)}[#{o.right.accept(self)}]"
+      end
+      
+      def visit_DoWhile(o)
+        semi = o.left.is_a?(Nodes::SourceElements) ? '' : ';'
+        "do #{o.left.accept(self)}#{semi} while(#{o.right.accept(self)})"
+      end
+
+      def visit_Try(o)
+        stmt = "try #{o.cond.accept(self)}"
+        o.b_then.each do |node|
+          stmt << " #{node.accept(self)}"
+        end if o.b_then
+        stmt << "#{o.b_else && ' finally '}" \
+          "#{o.b_else && o.b_else.accept(self)}" if o.b_else
+        stmt
+      end
+
+      def visit_Catch(o)
+        "catch(#{o.cond.accept(self)}) #{o.b_else.accept(self)}"
+      end
+
+      def visit_Delete(o)
+        "delete #{o.value.accept(self)}"
+      end
+
+      def visit_Export(o)
+        "export #{o.value.map { |x| x.accept(self) }.join(', ')}"
+      end
+
+      def visit_Import(o)
+        "import #{o.value.map { |x| x.accept(self) }.join(', ')}"
+      end
+
+      def visit_Throw(o)
+        "throw #{o.value.accept(self)}"
+      end
+
+      def visit_Void(o)
+        "void #{o.value.accept(self)}"
+      end
+
+      def visit_Return(o)
+        "return#{o.value && ' '}#{o.value && o.value.accept(self)}"
+      end
+
+      def visit_Typeof(o)
+        "typeof #{o.value.accept(self)}"
+      end
+
+      {
+        'UnaryPositive' => '+',
+        'UnaryNegative' => '-',
+        'BitwiseNot'    => '~',
+        'Not'           => '!',
+      }.each do |type,op|
+        define_method(:"visit_#{type}") do |o|
+          "#{op}#{o.value.accept(self)}"
+        end
+      end
+
+      def visit_Parenthesis(o)
+        "(#{o.value.accept(self)})"
+      end
+
+      def visit_While(o)
+        "while(#{o.left.accept(self)}) #{o.right.accept(self)}"
+      end
+
+      def visit_With(o)
+        "with(#{o.left.accept(self)}) #{o.right.accept(self)}"
+      end
+
+      def visit_Switch(o)
+        "switch(#{o.left.accept(self)}) #{o.right.accept(self)}"
+      end
+
+      def visit_Case(o)
+        "case #{o.left.accept(self)}: #{o.right.accept(self)}"
+      end
+
+      def visit_Default(o)
+        "default: #{o.right.accept(self)}"
+      end
+
+      def visit_Label(o)
+        "#{o.left.accept(self)}: #{o.right.accept(self)}"
+      end
+      alias :visit_Property :visit_Label
+
+      def visit_DotAccessor(o)
+        stmt =
+          if o.right.is_a?(Nodes::Function)
+            "(#{o.right.accept(self)})"
+          else
+            "#{o.right.accept(self)}"
+          end
+
+        rhs = o.left.accept(self)
+        if rhs =~ /\A\w+$/
+          stmt << ".#{rhs}"
+        else
+          stmt << "['#{rhs}']"
+        end
+        stmt
+      end
+
+      def visit_GetterProperty(o)
+        "get #{o.left.accept(self)}#{o.right.accept(self).gsub(/function/, '')}"
+      end
+
+      def visit_SetterProperty(o)
+        "set #{o.left.accept(self)}#{o.right.accept(self).gsub(/function/, '')}"
+      end
+
+      def visit_ObjectLiteral(o)
+        indent {
+          "{ #{o.value.map { |x| x.accept(self) }.join(",\n#{indent}")} }"
+        }
+      end
+
+      {
+        'PostfixIncrement'  => '++',
+        'PostfixDecrement'  => '--',
+      }.each do |type,op|
+        define_method(:"visit_#{type}") do |o|
+          "#{o.value.accept(self)}#{op}"
+        end
+      end
+
+      {
+        'PrefixIncrement'  => '++',
+        'PrefixDecrement'  => '--',
+      }.each do |type,op|
+        define_method(:"visit_#{type}") do |o|
+          "#{op}#{o.value.accept(self)}"
+        end
+      end
+
+      {
+        'OpEqual'             => '=',
+        'StrictNotEqual'      => '!==',
+        'StrictEqual'         => '===',
+        'Or'                  => '||',
+        'OpURShift'           => '>>>',
+        'OpURShiftEqual'      => '>>>=',
+        'OpSubtract'          => '-',
+        'OpSubtractEqual'     => '-=',
+        'OpRShift'            => '>>',
+        'OpRShiftEqual'       => '>>=',
+        'OpMultiply'          => '*',
+        'OpMultiplyEqual'     => '*=',
+        'OpMod'               => '%',
+        'OpModEqual'          => '%=',
+        'OpLShift'            => '<<',
+        'OpLShiftEqual'       => '<<=',
+        'OpDivide'            => '/',
+        'OpDivideEqual'       => '/=',
+        'OpBitXor'            => '^',
+        'OpBitXorEqual'       => '^=',
+        'OpBitOr'             => '|',
+        'OpBitOrEqual'        => '|=',
+        'OpBitAnd'            => '&',
+        'OpBitAndEqual'       => '&=',
+        'OpAdd'               => '+',
+        'OpAddEqual'          => '+=',
+        'NotEqual'            => '!=',
+        'LessThan'            => '<',
+        'LessThanOrEqual'     => '<=',
+        'GreaterThan'         => '>',
+        'GreaterThanOrEqual'  => '>=',
+        'And'                 => '&&',
+        'InstanceOf'          => 'instanceof',
+        'In'                  => 'in',
+        'Equal'               => '==',
+        'AssignExpr'          => '=',
+      }.each do |type,op|
+        define_method(:"visit_#{type}") do |o|
+          "#{o.left && o.left.accept(self)}" \
+            " #{op} " \
+            "#{o.right && o.right.accept(self)}"
+        end
+      end
+
+      def accept(target)
+        target.accept(self)
+      end
+
+      private
+      def indent
+        if block_given?
+          @depth += 1
+          x = yield
+          @depth -= 1
+          x
+        else
+          ' ' * (@depth - 1) * 2
+        end
+      end
+    end
+  end
+end