tomato 0.0.1.prealpha1 → 0.0.1.prealpha2

data/ext/tomato/tomato.cpp

@@ -13,6 +13,20 @@ static VALUE fTomato_execute(VALUE self, const char *javascript, const char *fil
 static void tomato_mark(V8Tomato *tomato);
 static void tomato_free(V8Tomato *tomato);
 
+static v8::Handle<v8::Value> debug(const Arguments &args)
+{
+  Handle<Value> arg;
+  V8Tomato *tomato = (V8Tomato *)(Handle<External>::Cast(args.Holder()->Get(String::New("_tomato")))->Value());
+  for (int i = 0; i < args.Length(); i++)
+  {
+    arg = args[i];
+    if (i > 0) printf(", ");
+    String::Utf8Value str(inspect_js(tomato, args[i]));
+    printf("<%s>", ToCString(str));
+  }
+  printf("\n");
+  return Null();
+}
 
 extern "C"
 void Init_tomato(void)
@@ -37,7 +51,10 @@ void Init_tomato(void)
   
   /* instance method "bind_method" */
   rb_define_method(cTomato, "_bind_method", (ruby_method_vararg *)&fTomato_bind_method, -1);
-
+  
+  /* instance method "_bind_class" */
+  rb_define_method(cTomato, "_bind_class", (ruby_method_vararg *)&fTomato_bind_class, 2);
+  
   /* init error-specific junk */
   err_init();
 }
@@ -50,9 +67,11 @@ static VALUE fTomato_allocate(VALUE klass)
   
   HandleScope handle_scope;
   Handle<ObjectTemplate> global = ObjectTemplate::New();
+  global->Set(String::New("debug"), FunctionTemplate::New(debug));
+  global->Set(String::New("_tomato"), External::New(tomato), DontEnum);
   tomato->context = Context::New(NULL, global);
   tomato->rb_instance = instance;
-  
+
   return instance;  
 }
 
@@ -68,6 +87,7 @@ static VALUE fTomato_version(VALUE self)
   return rb_str_new2(V8::GetVersion());
 }
 
+/* Runs a String of JavaScript code. */
 static VALUE fTomato_run(int argc, VALUE *argv, VALUE self)
 {
   if (argc == 0)

data/ext/tomato/tomato.h

@@ -28,9 +28,13 @@ extern VALUE cTomato;
 extern VALUE cTomatoError;
 extern VALUE rb_cTime;
 
+/* in object_chain.cpp */
+extern Handle<Value> find_or_create_object_chain(V8Tomato *tomato, VALUE chain);
+extern VALUE fTomato_bind_class(VALUE self, VALUE klass, VALUE chain);
+
 /* in conversions_to_rb.cpp */
 extern VALUE ruby_value_of(V8Tomato *tomato, Handle<Value> result);
-extern void  inspect_js(V8Tomato *tomato, Handle<Value> obj);
+extern Handle<Value> inspect_js(V8Tomato *tomato, Handle<Value> obj);
 
 /* in conversions_to_js.cpp */
 extern Handle<Value> js_value_of(V8Tomato *tomato,  VALUE value);

data/lib/tomato.rb

@@ -1,12 +1,114 @@
 $LOAD_PATH << File.expand_path("../../ext/tomato", __FILE__)
 require 'tomato.so'
+require 'sc-core-ext'
 
 class Tomato
-  def bind_method(method_name)
-    _bind_method(method_name)
+  # Bind a method to the JavaScript world. If no other arguments are given, the method will be called on this
+  # instance of Tomato. For instance, the following code:
+  #   t = Tomato.new
+  #   t.bind_method(:inspect)
+  #   t.run("inspect();")
+  # ...will result in calling t.inspect.
+  #
+  # To bind the method to a specific object, pass the object itself in as a second argument or with an :object
+  # option:
+  #   t.bind_method(:inspect, my_funky_object)
+  #   t.run("inspect();")
+  #   # -or-
+  #   t.bind_method(:inspect, :object => my_funky_object)
+  #   t.run("inspect();")
+  #   
+  # Both of the above examples would result in a call to my_funky_object.inspect.
+  #
+  # You can also pass a :to option to bind the method to a specific object. If the specified object chain
+  # does not exist, Tomato will generate generic objects to suit. Examples:
+  # 
+  #   t.bind_method(:inspect, my_funky_object, :to => "funky")
+  #   t.run("funky.inspect();")
+  # 
+  #   t.bind_method(:inspect, my_funky_object, :to => "funky_objects.my_object")
+  #   t.run("funky_objects.my_object.inspect();")
+  #
+  def bind_method(method_name, *args)
+    options = args.extract_options!
+    receiver = options[:object] || args.first || self
+    chain = options[:to] ? split_chain(options[:to]) : nil
+    # Bind the method to JS.
+    _bind_method(method_name, receiver_index(receiver), chain)
+  end
+  
+  # Binds an entire Ruby object to the specified JavaScript object chain.
+  #
+  # If the chain is omitted, and the object itself is a Class, then the chain will be the qualified name
+  # of the class.
+  #
+  # Example:
+  #  tomato.bind_object(Time)
+  #  tomato.run("Time.now()")
+  #   #=> 2010-06-25 18:02:52 -0400
+  #
+  # The same goes for Modules.
+  #
+  # Finally, if the chain is omitted and the object is an instance of a Class and not a Class itself, then
+  # the object will be bound to "ruby.[unqualified_name]". If the unqualified name is already in use, it will
+  # be overwritten.
+  #
+  # Example:
+  #  time = Time.now
+  #  tomato.bind_object(time)
+  #  tomato.run("ruby.time.to_s()")
+  #   #=> "2010-06-25 18:08:06 -0400"
+  #  tomato.bind_object(time)
+  #  tomato.run("ruby.time.to_s()")
+  #   #=> "2010-06-25 18:08:29 -0400"
+  def bind_object(obj, chain = nil)
+    if (obj.kind_of?(Class) || obj.kind_of?(Module))
+      if chain.nil?
+        chain = obj.name.gsub(/\:\:/, '.')
+        chain = chain[1..-1] if chain[0] == ?.
+      end
+      # This sets up an object chain with the last created object as a Function, which can
+      # then be instiated with "new [Object]()" in JS.
+      #
+      # Objects of the same name in the chain are replaced, but their sub-objects are copied over
+      # so it should be transparent to the user.
+      return false unless _bind_class(receiver_index(obj), split_chain(chain))
+    elsif chain.nil?
+      unqualified_name = obj.class.name.gsub(/.*\:\:([^\:])?$/, '\1').underscore
+      chain = "ruby.#{unqualified_name}"
+    end
+    
+    obj.public_methods.each do |method_name|
+      bind_method(method_name, obj, :to => chain)
+    end
+    obj
+  end
+  
+  # Attempts to bind this object to the JavaScript world. If it's a String or Symbol, it will be treated
+  # as a call to #bind_method; otherwise, a call to #bind_object.
+  def bind(target, *args)
+    if target.kind_of?(String) || target.kind_of?(Symbol)
+      bind_method(target, *args)
+    else
+      bind_object(target, *args)
+    end
   end
   
   def inspect
     "#<Tomato>"
   end
+  
+  private
+  def split_chain(str)
+    str.split(/\./)
+  end
+  
+  def receivers
+    @receivers ||= []
+  end
+  
+  def receiver_index(receiver)
+    receivers << receiver unless receivers.include?(receiver)
+    receivers.index(receiver)
+  end
 end

data/spec/lib/bound_class_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "Tomato bound objects" do
+  subject { Tomato.new }
+  
+  class ::TestObject
+    attr_accessor :i
+    
+    def initialize; @i = 1; end
+    
+    def ==(other)
+      other.kind_of?(TestObject)
+    end
+  end
+  
+  it "should map attribute getters to corresponding Ruby methods" do
+    subject.bind_object(TestObject, "TO")
+    subject.run('var v = new TO(); v.i;').should == 1
+  end
+  
+  it "should map attribute setters to corresponding Ruby methods" do
+    subject.bind_object(TestObject, "TO")
+    result = subject.run('var v = new TO(); v.i = 5; v;')
+    result.i.should == 5
+  end
+  
+  it "should be bind-able with an explicit chain" do
+    subject.bind_object(TestObject, "TO")
+    proc { subject.run("new TO();") }.should_not raise_error
+  end
+  
+  it "should be instantiatable" do
+    subject.bind_object(TestObject)
+    subject.run("new TestObject();").should == TestObject.new
+  end
+  
+  it "should not lose sub-objects" do
+    subject.bind_object("hello", "TestObject.string")
+    subject.bind_object(TestObject)
+    subject.run("TestObject.string.inspect()").should == '"hello"'
+  end
+  
+  it "should allow sub-bindings" do
+    subject.bind_object(TestObject)
+    subject.bind_object("hello", "TestObject.string")
+    subject.run("TestObject.string.inspect()").should == '"hello"'
+  end
+end

data/spec/lib/bound_methods_spec.rb

@@ -8,6 +8,26 @@ describe "Tomato bound methods" do
     proc { subject.run("(inspect());") }.should_not raise_error
   end
   
+  it "should map Ruby methods to JS on a specific object within JS" do
+    subject.bind_method(:inspect, "hello", :to => "greeting")
+    subject.run("greeting.inspect();").should == '"hello"'
+  end
+  
+  it "should map Ruby methods to JS on an object chain within JS" do
+    subject.bind_method(:inspect, "hello", :to => "greeting.first")
+    subject.run("greeting.first.inspect();").should == '"hello"'
+  end
+  
+  it "should map Ruby methods to Javascript on a specific object without a hash" do
+    subject.bind_method(:inspect, "hello").should == true
+    subject.run("(inspect());").should == '"hello"'
+  end
+  
+  it "should map Ruby methods to Javascript on a specific object with a hash" do
+    subject.bind_method(:inspect, :object => "hello").should == true
+    subject.run("(inspect());").should == '"hello"'
+  end
+  
   it "should accept arguments" do
     subject.bind_method(:echo)
     def subject.echo(i); i; end

data/spec/lib/bound_object_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe "Tomato bound objects" do
+  subject { Tomato.new }
+  
+  it "should bind a Ruby class to an implicit chain" do
+    now = Time.now.to_i
+    
+    subject.bind_object(Time)
+    subject.run("Time.at(#{now})").should == Time.at(now)
+  end
+
+  it "should bind a Ruby object to an explicit chain" do
+    time = Time.now
+    subject.bind_object(time, "current_time")
+    subject.run("current_time.to_s()").should == time.to_s
+  end
+  
+  it "should bind a Ruby object's singleton methods" do
+    time = Time.now
+    def time.as_string; to_s; end
+    time.should respond_to(:as_string)
+    
+    subject.bind_object(time, "current_time")
+    subject.run("current_time.as_string()").should == time.to_s
+  end
+  
+  it "should bind a Ruby object to an implicit chain under 'ruby.[unqualified_object_class_name]'" do
+    time = Time.now
+    subject.bind_object(time)
+    subject.run("ruby.time.to_s()").should == time.to_s
+  end
+end

data/spec/lib/conversions_spec.rb

@@ -1,9 +1,23 @@
 require 'spec_helper'
 
 describe "Tomato conversions" do
-  context "from Ruby to JS to Ruby" do
-    subject { Tomato.new }
+  subject { Tomato.new }
     
+  context "from JS to Ruby" do
+    it "should handle objects" do
+      pending "how to do it? JSON?"
+    end
+    
+    it "should handle classes" do
+      pending "how to do it? Prototype?"
+    end
+    
+    it "should handle modules" do
+      pending "how to do it? Prototype?"
+    end
+  end
+  
+  context "from Ruby to JS to Ruby" do
     def handle(value)
       $test_value = value
       def subject.a_method; $test_value; end
@@ -27,18 +41,6 @@ describe "Tomato conversions" do
       handle(nil).should == nil
     end
     
-    it "should handle objects" do
-      pending "how to do it? JSON?"
-    end
-    
-    it "should handle classes" do
-      pending "how to do it? Prototype?"
-    end
-    
-    it "should handle modules" do
-      pending "how to do it? Prototype?"
-    end
-    
     it "should handle floats" do
       handle(1.05).should == 1.05
     end
@@ -87,28 +89,5 @@ describe "Tomato conversions" do
     it "should handle symbols" do
       handle(:symbol).should == :symbol
     end
-=begin
-    case T_NIL     :
-    case T_OBJECT  :
-    //case T_CLASS   :
-    //case T_MODULE  :
-    case T_FLOAT   :
-    case T_STRING  :
-    case T_REGEXP  :
-    case T_ARRAY   :
-    case T_HASH    :
-    //case T_STRUCT  :
-    case T_BIGNUM  :
-    case T_FIXNUM  :
-    //case T_COMPLEX :
-    //case T_RATIONAL:
-    //case T_FILE    :
-    case T_TRUE    :
-    case T_FALSE   :
-    //case T_DATA    :
-    case T_SYMBOL  :
-      symbol_from(object)
-      break;
-=end
   end
 end

data/t.rb

@@ -0,0 +1,6 @@
+require 'lib/tomato'
+t = Tomato.new
+t.run("debug()")
+t.bind_object(String, "rb.string")
+t.run("debug(new rb.string());")
+puts t.run("var v = new rb.string('Hi there!'); debug(v.to_s()); v;").inspect

data/tomato.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tomato}
-  s.version = "0.0.1.prealpha1"
+  s.version = "0.0.1.prealpha2"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Colin MacKenzie IV"]
-  s.date = %q{2010-06-25}
+  s.date = %q{2010-06-26}
   s.description = %q{Leverages Google's V8 JavaScript library to interface Ruby code with JavaScript code.}
   s.email = %q{sinisterchipmunk@gmail.com}
   s.extensions = ["ext/tomato/extconf.rb"]
@@ -25,6 +25,7 @@ Gem::Specification.new do |s|
      "ext/tomato/IMPORTANT",
      "ext/tomato/Makefile",
      "ext/tomato/binding_methods.cpp",
+     "ext/tomato/binding_methods.h",
      "ext/tomato/binding_methods.o",
      "ext/tomato/conversions_to_js.cpp",
      "ext/tomato/conversions_to_js.o",
@@ -3330,6 +3331,8 @@ Gem::Specification.new do |s|
      "ext/tomato/external/v8/tools/windows-tick-processor.bat",
      "ext/tomato/external/v8/tools/windows-tick-processor.py",
      "ext/tomato/mkmf.log",
+     "ext/tomato/object_chain.cpp",
+     "ext/tomato/object_chain.o",
      "ext/tomato/tomato.bundle",
      "ext/tomato/tomato.cpp",
      "ext/tomato/tomato.h",
@@ -3339,10 +3342,13 @@ Gem::Specification.new do |s|
      "lib/tomato.rb",
      "pkg/tomato-0.0.1.gem",
      "pkg/tomato-0.0.1.prealpha1.gem",
+     "spec/lib/bound_class_spec.rb",
      "spec/lib/bound_methods_spec.rb",
+     "spec/lib/bound_object_spec.rb",
      "spec/lib/conversions_spec.rb",
      "spec/lib/tomato_spec.rb",
      "spec/spec_helper.rb",
+     "t.rb",
      "tomato.gemspec"
   ]
   s.homepage = %q{http://www.thoughtsincomputation.com}
@@ -3351,7 +3357,9 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Leverages Google's V8 JavaScript library to interface Ruby code with JavaScript code.}
   s.test_files = [
-    "spec/lib/bound_methods_spec.rb",
+    "spec/lib/bound_class_spec.rb",
+     "spec/lib/bound_methods_spec.rb",
+     "spec/lib/bound_object_spec.rb",
      "spec/lib/conversions_spec.rb",
      "spec/lib/tomato_spec.rb",
      "spec/spec_helper.rb"
@@ -3362,11 +3370,14 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sc-core-ext>, [">= 1.2.0"])
       s.add_development_dependency(%q<rspec>, [">= 1.3.0"])
     else
+      s.add_dependency(%q<sc-core-ext>, [">= 1.2.0"])
       s.add_dependency(%q<rspec>, [">= 1.3.0"])
     end
   else
+    s.add_dependency(%q<sc-core-ext>, [">= 1.2.0"])
     s.add_dependency(%q<rspec>, [">= 1.3.0"])
   end
 end