johnson 1.1.0

data/lib/johnson/spidermonkey/js_land_proxy.rb

@@ -0,0 +1,62 @@
+module Johnson
+  module SpiderMonkey
+    module JSLandProxy #:nodoc:
+      def self.send_with_possible_block(target, symbol, args)
+        block = args.pop if args.last.is_a?(RubyLandProxy) && args.last.function?
+        target.__send__(symbol, *args, &block)
+      end
+      
+      def self.treat_all_properties_as_methods(target)
+        def target.js_property?(name); true; end
+      end
+          
+      def self.js_property?(target, name)
+        # FIXME: that rescue is gross; handles, e.g., "name?"
+        (target.send(:instance_variable_defined?, "@#{name}") rescue false) ||
+          (target.respond_to?(:js_property?) && target.__send__(:js_property?, name))
+      end
+      
+      def self.call_proc_by_oid(oid, *args)
+        id2ref(oid).call(*args)
+      end
+      
+      def self.id2ref(oid)
+        ObjectSpace._id2ref(oid)
+      end
+      
+      def self.autovivified(target, attribute)
+        target.send(:__johnson_js_properties)[attribute]
+      end
+
+      def self.autovivified?(target, attribute)
+        target.respond_to?(:__johnson_js_properties) &&
+          target.send(:__johnson_js_properties).key?(attribute)
+      end
+
+      def self.autovivify(target, attribute, value)
+        (class << target; self; end).instance_eval do
+          unless target.respond_to?(:__johnson_js_properties)
+            define_method(:__johnson_js_properties) do
+              @__johnson_js_properties ||= {}
+            end
+          end
+          
+          define_method(:"#{attribute}=") do |arg|
+            send(:__johnson_js_properties)[attribute] = arg
+          end
+          
+          define_method(:"#{attribute}") do |*args|
+            js_prop = send(:__johnson_js_properties)[attribute]
+            if js_prop.is_a?(RubyLandProxy) && js_prop.function?
+              js_prop.call_using(self, *args)
+            else
+              js_prop
+            end
+          end
+        end
+
+        target.send(:"#{attribute}=", value)
+      end
+    end
+  end
+end

data/lib/johnson/spidermonkey/mutable_tree_visitor.rb

@@ -0,0 +1,242 @@
+module Johnson
+  module SpiderMonkey
+    class MutableTreeVisitor
+      include Johnson::Nodes
+
+      def visit_For(ro_node)
+        For.new(  ro_node.line,
+                  ro_node.index,
+                  ro_node.pn_left.pn_kid1 && ro_node.pn_left.pn_kid1.accept(self),
+                  ro_node.pn_left.pn_kid2 && ro_node.pn_left.pn_kid2.accept(self),
+                  ro_node.pn_left.pn_kid3 && ro_node.pn_left.pn_kid3.accept(self),
+                  ro_node.pn_right.accept(self)
+               )
+      end
+
+      def visit_Name(ro_node)
+        Name.new(ro_node.line, ro_node.index, ro_node.name)
+      end
+
+      def visit_Number(ro_node)
+        Number.new(ro_node.line, ro_node.index, ro_node.pn_dval)
+      end
+
+      def visit_String(ro_node)
+        Nodes::String.new(  ro_node.line,
+                            ro_node.index,
+                            ro_node.name )
+      end
+
+      def visit_Regexp(ro_node)
+        Regexp.new( ro_node.line,
+                    ro_node.index,
+                    ro_node.regexp )
+      end
+
+      def visit_Function(ro_node)
+        Function.new( ro_node.line,
+                      ro_node.index,
+                      ro_node.function_name,
+                      ro_node.function_args,
+                      ro_node.function_body.accept(self) )
+      end
+
+      def visit_LexicalScope(ro_node)
+        LexicalScope.new(
+          ro_node.line,
+          ro_node.index,
+          Name.new(ro_node.line, ro_node.index, "unnamed"), # lexical scope nodes don't hold a name
+          ro_node.pn_expr.accept(self))
+      end
+
+      %w{ Label AssignExpr DotAccessor }.each do |type|
+        define_method(:"visit_#{type}") do |ro_node|
+          Nodes.const_get(type).new(
+            ro_node.line,
+            ro_node.index,
+            Name.new(ro_node.line, ro_node.index, ro_node.name),
+            ro_node.pn_expr.accept(self)
+          )
+        end
+      end
+
+      %w{
+        SourceElements
+        VarStatement
+        LetStatement
+        Comma
+        ObjectLiteral
+        ArrayLiteral
+        New
+        FunctionCall
+        Import
+        Export
+      }.each do |list_op|
+        define_method(:"visit_#{list_op}") do |ro_node|
+          Nodes.const_get(list_op).new( ro_node.line,
+                                        ro_node.index,
+                                        ro_node.children.map { |c|
+                                          c.accept(self)
+                                        }.compact)
+        end
+      end
+
+      {
+        'Null'      => nil,
+        'True'      => true,
+        'False'     => false,
+        'This'      => 'this',
+        'Continue'  => 'continue',
+        'Break'     => 'break',
+      }.each do |type,val|
+        define_method(:"visit_#{type}") do |ro_node|
+          Nodes.const_get(type).new(
+                                    ro_node.line,
+                                    ro_node.index,
+                                    val
+                                   )
+        end
+      end
+
+      def visit_Try(ro_node)
+        Try.new(
+          ro_node.line,
+          ro_node.index,
+          ro_node.pn_kid1 && ro_node.pn_kid1.accept(self),
+          if ro_node.pn_kid2
+            case ro_node.pn_kid2.pn_type
+            when :tok_reserved
+              ro_node.pn_kid2.children.map { |x| x.pn_expr.accept(self) }
+            else
+              raise "HALP some other catch #{ro_node.line}, #{ro_node.index}"
+            end
+          else
+            nil
+          end,
+          ro_node.pn_kid3 && ro_node.pn_kid3.accept(self)
+        )
+      end
+
+      %w{
+        Ternary
+        If
+        Catch
+      }.each do |node|
+        define_method(:"visit_#{node}") do |ro_node|
+          Nodes.const_get(node).new(
+            ro_node.line,
+            ro_node.index,
+            ro_node.pn_kid1 && ro_node.pn_kid1.accept(self),
+            ro_node.pn_kid2 && ro_node.pn_kid2.accept(self),
+            ro_node.pn_kid3 && ro_node.pn_kid3.accept(self)
+          )
+        end
+      end
+
+      %w{
+        BitwiseNot
+        Delete
+        Not
+        Parenthesis
+        PostfixDecrement
+        PostfixIncrement
+        PrefixDecrement
+        PrefixIncrement
+        Return
+        Throw
+        Typeof
+        UnaryNegative
+        UnaryPositive
+        Void
+      }.each do |node|
+        define_method(:"visit_#{node}") do |ro_node|
+          Nodes.const_get(node).new(ro_node.line,
+                                    ro_node.index,
+                                    ro_node.pn_kid && ro_node.pn_kid.accept(self))
+        end
+      end
+
+      %w{
+        And
+        BracketAccess
+        DoWhile
+        Case
+        Default
+        While
+        With
+        Equal
+        Switch
+        In
+        InstanceOf
+        GetterProperty
+        ForIn
+        GreaterThan
+        LessThan
+        GreaterThanOrEqual
+        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
+      }.each do |bin_op|
+        define_method(:"visit_#{bin_op}") do |ro_node|
+          if ro_node.children.length > 1
+            kids = ro_node.children.reverse
+            tree = self.class.const_get(bin_op).new(
+                          ro_node.line,
+                          ro_node.index,
+                          kids[1].accept(self),
+                          kids[0].accept(self)
+            )
+            2.times { kids.shift }
+            kids.each do |kid|
+              tree = self.class.const_get(bin_op).new(
+                            ro_node.line,
+                            ro_node.index,
+                            kid.accept(self),
+                            tree
+              )
+            end
+            tree
+          else
+            self.class.const_get(bin_op).new(
+                          ro_node.line,
+                          ro_node.index,
+                          ro_node.pn_left && ro_node.pn_left.accept(self),
+                          ro_node.pn_right && ro_node.pn_right.accept(self)
+                       )
+          end
+        end
+      end
+
+      def accept(target)
+        target.accept(self)
+      end
+    end
+  end
+end

data/lib/johnson/spidermonkey/ruby_land_proxy.rb

@@ -0,0 +1,54 @@
+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
+      
+      # FIXME: need to revisit array vs non-array proxy, to_a/to_ary semantics, etc.
+      alias_method :size, :length
+      alias_method :to_ary, :to_a
+      
+      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,103 @@
+module Johnson #:nodoc:
+  module SpiderMonkey #:nodoc:
+    class Runtime # native
+      CONTEXT_MAP_KEY = :johnson_context_map
+
+      def initialize(options={})
+        @debugger = nil
+        @compiled_scripts = {}
+        @gcthings = {}
+        @traps = []
+        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(object_id)
+        @gcthings.delete(object_id) if defined? @gcthings
+      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
+
+      def evaluate_compiled script
+        evaluate_compiled_script(script)
+        @traps.each do |trap_tuple|
+          clear_trap(*trap_tuple)
+        end
+      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)
+        @traps << [compiled_script, linenum]
+      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