johnson 2.0.0.pre1 → 2.0.0.pre2

data/lib/johnson/spidermonkey/mutable_tree_visitor.rb

@@ -1,242 +0,0 @@
-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

@@ -1,17 +0,0 @@
-module Johnson #:nodoc:
-  module SpiderMonkey #:nodoc:
-    class RubyLandProxy < Johnson::RubyLandProxy # native
-      module Callable
-        def call_using(this, *args)
-          native_call(this, *args)
-        end
-      end
-    end
-    class RubyLandScript < Johnson::SpiderMonkey::RubyLandProxy # native
-      def break(linenum, &block)
-        runtime.set_trap(self, linenum, block)
-        runtime.traps << [self, linenum]
-      end
-    end
-  end
-end

data/lib/johnson/spidermonkey/runtime.rb

@@ -1,74 +0,0 @@
-module Johnson #:nodoc:
-  module SpiderMonkey #:nodoc:
-    class Runtime < Johnson::Runtime # native
-      def version
-        SpiderMonkey::VERSION
-      end
-
-      CONTEXT_MAP_KEY = :johnson_context_map
-
-      attr_reader :traps
-      def initialize(options={})
-        @debugger = nil
-        @gcthings = {}
-        @traps = []
-        initialize_native(options)
-        super()
-      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 debugger?
-        not @debugger.nil?
-      end
-
-      def current_context
-        contexts = (Thread.current[CONTEXT_MAP_KEY] ||= {})
-        contexts[self.object_id] ||= Context.new(self)
-      end
-
-      alias :evaluate_compiled_script_without_clearing_traps :evaluate_compiled_script
-      def evaluate_compiled_script script
-        evaluate_compiled_script_without_clearing_traps(script)
-      ensure
-        @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
-        native_compile(script, filename, linenum)
-      end
-
-      class << self
-
-        def parse_io *args
-          Johnson::SpiderMonkey::ImmutableNode.parse_io( *args )
-        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/test/johnson/spidermonkey/context_test.rb

@@ -1,21 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
-
-module Johnson
-  module SpiderMonkey
-    class ContextTest < Johnson::TestCase
-      def setup
-        @runtime = Johnson::Runtime.new(Johnson::SpiderMonkey::Runtime)
-      end
-      
-      def test_wraps_global_unfuckedly
-        assert_same(@runtime.global, @runtime.evaluate("this"))
-      end
-      
-      def test_provides_basic_runtime_interface
-        assert(@runtime.respond_to?(:evaluate))
-        assert(@runtime.respond_to?(:[]))
-        assert(@runtime.respond_to?(:[]=))
-      end
-    end
-  end
-end

data/test/johnson/spidermonkey/immutable_node_test.rb

@@ -1,34 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
-
-require 'stringio'
-
-module Johnson
-  module SpiderMonkey
-    class ImmutableNodeTest < Johnson::TestCase
-      include Johnson::SpiderMonkey
-
-      def test_initialize
-        node = nil
-        assert_nothing_raised {
-          node = ImmutableNode.new
-        }
-      end
-
-      def test_parse_some_shit
-        assert_nothing_raised {
-          node = ImmutableNode.parse_io(StringIO.new('var x = 10;'))
-        }
-      end
-
-      def test_index
-        node = ImmutableNode.parse_io(StringIO.new('var x = 10;'))
-        assert_equal(0, node.index)
-      end
-
-      def test_line
-        node = ImmutableNode.parse_io(StringIO.new('var x = 10;'))
-        assert_equal(0, node.line)
-      end
-    end
-  end
-end

data/test/johnson/spidermonkey/js_land_proxy_test.rb

@@ -1,273 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
-
-module Johnson
-  module SpiderMonkey
-    class JSLandProxyTest < Johnson::TestCase
-      module AModule
-      end
-      
-      class AClass
-        attr_reader :args
-        
-        def initialize(*args)
-          @args = args
-        end
-      end
-      
-      class Foo
-        class Inner
-        end
-        
-        def self.bar; 10; end
-
-        attr_accessor :bar
-        
-        def initialize
-          @bar = 10
-        end
-        
-        def x2(x)
-          x * 2
-        end
-        
-        def add(*args)
-          args.inject { |m,n| m += n }
-        end
-        
-        def xform(arg)
-          yield(arg)          
-        end
-      end
-      
-      class Indexable
-        def initialize
-          @store = {}
-        end
-        
-        def [](key)
-          @store[key]
-        end
-        
-        def []=(key, value)
-          @store[key] = value
-        end
-        
-        def key?(key)
-          @store.key?(key)
-        end
-      end
-
-      def setup
-        @runtime = Johnson::Runtime.new(Johnson::SpiderMonkey::Runtime)
-      end
-
-      def test_find_constants
-        assert_js_equal($LOAD_PATH, "Ruby['$LOAD_PATH']")
-      end
-
-      def test_proxies_get_reused
-        @runtime["foo"] = @runtime["bar"] = Foo.new
-        assert_js_equal(true, "foo === bar")
-      end
-
-      def test_attributes_get_added_to_ruby
-        foo = @runtime["foo"] = Foo.new
-        assert !foo.respond_to?(:johnson)
-        @runtime.evaluate("foo.johnson = 'explode';")
-        assert foo.respond_to?(:johnson)
-        assert_equal('explode', foo.johnson)
-        assert_js_equal('explode', 'foo.johnson')
-        assert !Foo.new.respond_to?(:johnson)
-      end
-
-      def test_assign_function_as_attribute
-        foo = @runtime["foo"] = Foo.new
-        assert !foo.respond_to?(:johnson)
-        f = @runtime.evaluate("foo.johnson = function() { return 'explode'; }")
-        assert foo.respond_to?(:johnson)
-        assert_equal('explode', foo.johnson)
-        assert_js_equal('explode', 'foo.johnson()')
-        assert_js_equal(f, 'foo.johnson')
-        assert !Foo.new.respond_to?(:johnson)
-      end
-
-      def test_assign_function_as_attribute_with_this
-        foo = @runtime["foo"] = Foo.new
-        @runtime.evaluate("foo.ex_squared = function(x) { return this.x2(x); }")
-        assert_equal(4, foo.ex_squared(2))
-        @runtime.evaluate("foo.ex_squared = 20;")
-        assert_equal(20, foo.ex_squared)
-      end
-
-      def test_use_ruby_global_object
-        func = @runtime.evaluate("function(x) { return this.x2(x); }")
-        foo  = Foo.new
-        assert_equal(4, func.call_using(foo, 2))
-      end
-      
-      def test_proxies_roundtrip
-        @runtime["foo"] = foo = Foo.new
-        assert_same(foo, @runtime.evaluate("foo"))
-      end
-      
-      def test_proxies_classes
-        @runtime["Foo"] = Foo
-        assert_same(Foo, @runtime.evaluate("Foo"))
-      end
-      
-      def test_proxies_modules
-        @runtime["AModule"] = AModule
-        assert_same(AModule, @runtime.evaluate("AModule"))
-      end
-      
-      def test_proxies_hashes
-        @runtime["beatles"] = { "george" => "guitar" }
-        assert_equal("guitar", @runtime.evaluate("beatles['george']"))
-      end
-      
-      def test_getter_calls_0_arity_method
-        @runtime["foo"] = Foo.new
-        assert_js_equal(10, "foo.bar")
-      end
-      
-      def test_getter_calls_indexer
-        @runtime["foo"] = indexable = Indexable.new
-        indexable["bar"] = 10
-        
-        assert_js_equal(10, "foo.bar")
-      end
-      
-      def test_getter_returns_nil_for_unknown_properties
-        @runtime["foo"] = Foo.new
-        assert_js_equal(nil, "foo.quux")
-      end
-
-      def test_setter_calls_key=
-        @runtime["foo"] = foo = Foo.new
-        assert_js_equal(42, "foo.bar = 42")
-        assert_equal(42, foo.bar)
-      end
-      
-      def test_setter_calls_indexer
-        @runtime["foo"] = indexable = Indexable.new
-        assert_js_equal(42, "foo.monkey = 42")
-        assert_equal(42, indexable["monkey"])
-      end
-      
-      def test_calls_attr_reader
-        @runtime["foo"] = Foo.new
-        assert_js_equal(10, "foo.bar")
-      end
-      
-      def test_calls_1_arity_method
-        @runtime["foo"] = Foo.new
-        assert_js_equal(10, "foo.x2(5)")
-      end
-      
-      def test_calls_n_arity_method
-        @runtime["foo"] = Foo.new
-        assert_js_equal(10, "foo.add(4, 2, 2, 1, 1)")
-      end
-      
-      def test_calls_class_method
-        @runtime["Foo"] = Foo
-        assert_js_equal(Foo.bar, "Foo.bar()")
-      end
-      
-      def test_accesses_consts
-        @runtime["Foo"] = Foo
-        assert_same(Foo::Inner, @runtime.evaluate("Foo.Inner"))
-      end
-            
-      def test_can_create_new_instances_in_js
-        @runtime["AClass"] = AClass
-        foo = @runtime.evaluate("AClass.new()")
-        assert_kind_of(AClass, foo)
-      end
-      
-      def test_class_proxies_provide_a_ctor
-        @runtime["AClass"] = AClass
-        foo = @runtime.evaluate("new AClass()")
-        assert_kind_of(AClass, foo)
-        
-        bar = @runtime.evaluate("new AClass(1, 2, 3)")
-        assert_equal([1, 2, 3], bar.args)
-      end
-      
-      def test_dwims_blocks
-        @runtime["foo"] = Foo.new
-        assert_js_equal(4, "foo.xform(2, function(x) { return x * 2 })")
-      end
-      
-      def test_dwims_blocks_for_0_arity_methods
-        @runtime[:arr] = [1, 2, 3]
-        assert_js_equal([2, 4, 6], "arr.collect(function(x) { return x * 2 })")
-      end
-      
-      def test_scope_for_with
-        assert_js_equal(84, "with (rb) { b + b }", :b => 1, :rb => { "b" => 42 })
-      end
-      
-      def test_lambdas_for_with
-        assert_js_equal(84, "with (rb) { b(42) }", :rb => { "b" => lambda { |x| x * 2 } })
-      end
-      
-      class MethodForWith
-        def b(x); x * 2; end
-      end
-      
-      def test_method_for_with
-        assert_js_equal(84, "with (rb) { b(42) }", :rb => MethodForWith.new)
-      end
-
-      def test_raises_string_to_ruby
-        assert_raise(Johnson::Error) { @runtime.evaluate("throw 'my string';") }
-      end
-
-      def test_raises_object_to_ruby
-        assert_raise(Johnson::Error) { @runtime.evaluate("throw { bad: true };") }
-      end
-
-      def test_raises_exception_to_ruby
-        assert_raise(Johnson::Error) { @runtime.evaluate("undefinedValue();") }
-      end
-
-      def test_js_property_false_should_not_invoke
-        klass = Class.new do
-          def bar ; 10 ; end
-          def js_property?(name) ; false ; end
-        end
-        @runtime['foo'] = foo = klass.new
-        assert_equal foo.method(:bar), @runtime.evaluate("foo.bar")
-      end
-
-      def test_js_property_nil_should_not_invoke
-        klass = Class.new do
-          def bar ; 10 ; end
-          def js_property?(name) ; nil ; end
-        end
-        foo = klass.new
-        assert_js_equal(foo.method(:bar), "foo.bar", :foo => foo)
-      end
-
-      def test_js_property_true_should_invoke_0_arity
-        klass = Class.new do
-          def bar ; 10 ; end
-          def js_property?(name) ; true ; end
-        end
-        assert_js_equal(10, "foo.bar", :foo => klass.new)
-      end
-
-      def test_js_property_on_n_arity_should_raise_exception
-        klass = Class.new do
-          def bar(n) ; 10 + n ; end
-          def js_property?(name) ; true ; end
-        end
-        @runtime['foo'] = klass.new
-        assert_raises(ArgumentError) do
-          @runtime.evaluate("foo.bar")
-        end
-      end
-    end
-  end
-end