@@ -149,6 +149,12 @@ function_p(VALUE self) JRETURN_RUBY(JS_TypeOfValue(context, proxy_value) == JSTYPE_FUNCTION ? Qtrue : Qfalse); } +static VALUE +callable_test_p(VALUE self, VALUE proxy) +{ + return function_p(proxy); +} + /* * call-seq: * respond_to?(symbol) @@ -501,12 +507,19 @@ static void finalize(RubyLandProxy* proxy) bool ruby_value_is_proxy(VALUE maybe_proxy) { - return proxy_class == CLASS_OF(maybe_proxy) || script_class == CLASS_OF(maybe_proxy); + return rb_obj_is_kind_of(maybe_proxy, proxy_class); } bool ruby_value_is_script_proxy(VALUE maybe_proxy) { - return script_class == CLASS_OF(maybe_proxy); + return rb_obj_is_kind_of(maybe_proxy, script_class); +} + +VALUE apply_wrappers(VALUE proxy) +{ + VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson")); + VALUE johnson_proxy = rb_const_get(johnson, rb_intern("RubyLandProxy")); + return rb_funcall(johnson_proxy, rb_intern("apply_wrappers"), 1, proxy); } JSBool unwrap_ruby_land_proxy(JohnsonRuntime* runtime, VALUE wrapped, jsval* retval) @@ -542,6 +555,9 @@ VALUE make_ruby_land_proxy(JohnsonRuntime* runtime, jsval value, const char cons PREPARE_RUBY_JROOTS(context, 1); JROOT(value); + VALUE rb_runtime = (VALUE)JS_GetRuntimePrivate(runtime->js); + rb_iv_set(proxy, "@runtime", rb_runtime); + our_proxy->runtime = runtime; our_proxy->key = (void *)value; our_proxy->self = proxy; @@ -552,10 +568,11 @@ VALUE make_ruby_land_proxy(JohnsonRuntime* runtime, jsval value, const char cons // put the proxy OID in the id map JCHECK(JS_HashTableAdd(runtime->jsids, (void *)value, (void *)our_proxy)); - VALUE rb_runtime = (VALUE)JS_GetRuntimePrivate(runtime->js); - rb_iv_set(proxy, "@runtime", rb_runtime); + VALUE final_proxy = JPROTECT(apply_wrappers, proxy); - JRETURN_RUBY(proxy); + our_proxy->self = final_proxy; + + JRETURN_RUBY(final_proxy); } } @@ -580,11 +597,15 @@ void init_Johnson_SpiderMonkey_Proxy(VALUE spidermonkey) rb_define_method(proxy_class, "length", length, 0); rb_define_method(proxy_class, "to_s", to_s, 0); - rb_define_private_method(proxy_class, "native_call", native_call, -1); rb_define_private_method(proxy_class, "runtime", runtime, 0); rb_define_private_method(proxy_class, "function_property?", function_property_p, 1); rb_define_private_method(proxy_class, "call_function_property", call_function_property, -1); + VALUE callable = rb_define_module_under(proxy_class, "Callable"); + rb_define_singleton_method(callable, "test?", callable_test_p, 1); + rb_define_private_method(callable, "native_call", native_call, -1); + + rb_funcall(johnson_proxy, rb_intern("insert_wrapper"), 1, callable); script_class = rb_define_class_under(spidermonkey, "RubyLandScript", proxy_class); } ext/spidermonkey/ruby_land_proxy.c @@ -1,5 +1,47 @@ module Johnson #:nodoc: class RubyLandProxy + class << self + def apply_wrappers(proxy) + wrappers.each do |(wrapper, test)| + next if test && !test.call(proxy) + next if wrapper.respond_to?(:test?) && !wrapper.test?(proxy) + + if wrapper.respond_to?(:call) + proxy = wrapper.call(proxy) + break unless Johnson::RubyLandProxy === proxy + else + proxy.send :extend, wrapper + end + end + proxy + end + def add_wrapper(wrapper, &test) + wrappers.push [wrapper, test] + end + def insert_wrapper(wrapper, &test) + wrappers.unshift [wrapper, test] + end + def wrappers + @wrappers ||= [] + end + end + + module Callable + def self.test?(proxy) + proxy.respond_to?(:call_using) + end + + def to_proc + @proc ||= Proc.new { |*args| call(*args) } + end + + def call(*args) + call_using(runtime.global, *args) + end + end + + add_wrapper Callable + include Enumerable # FIXME: need to revisit array vs non-array proxy, to_a/to_ary semantics, etc. @@ -11,14 +53,6 @@ module Johnson #:nodoc: end private :initialize - def to_proc - @proc ||= Proc.new { |*args| call(*args) } - end - - def call(*args) - call_using(runtime.global, *args) - end - def inspect toString end lib/johnson/ruby_land_proxy.rb @@ -1,8 +1,10 @@ module Johnson #:nodoc: module SpiderMonkey #:nodoc: class RubyLandProxy < Johnson::RubyLandProxy # native - def call_using(this, *args) - native_call(this, *args) + module Callable + def call_using(this, *args) + native_call(this, *args) + end end end class RubyLandScript < Johnson::SpiderMonkey::RubyLandProxy # native lib/johnson/spidermonkey/ruby_land_proxy.rb @@ -63,7 +63,9 @@ module Johnson end def test_calling_non_functions_complains - assert_raise(RuntimeError) { @runtime.evaluate("new Object()").call } + o = @runtime.evaluate("new Object()") + assert_equal(false, o.respond_to?(:call)) + assert_raise(NoMethodError) { o.call } end def test_functions_can_be_called test/johnson/spidermonkey/ruby_land_proxy_test.rb 46d4f089f34a90a0a4e2305de7a57e2cf903dd4f Matthew Draper matthew@trebex.net http://github.com/jbarnette/johnson/commit/1df39ce9780f1b24dfd49716c99abe909781be46 1df39ce9780f1b24dfd49716c99abe909781be46 2009-10-03T20:55:00-07:00 2009-10-03T20:47:56-07:00 Apply wrappers during RubyLandProxy creation. This allows pure-ruby code to control how different JS values are presented to the rest of ruby-land. Such wrappers provide for the most common case, but there's also a need to be able to define a conversion to be applied each time the proxy is required, too. And then we need corresponding functionality in js-land. 3ebf7cec40693a5084236a1490b3b866c3074fd1 Matthew Draper matthew@trebex.net