tomato 0.0.1.prealpha1 → 0.0.1.prealpha2

data/README.rdoc

@@ -20,44 +20,105 @@ hope to release it as a real gem after it's reached a sufficient level of functi
 When JS code is executed, it'll do its thing internally and then return the result:
 
   tomato.run("(1+1);") # => 2
+
+==== Bindings
+
+You can bind Ruby methods to JavaScript, as well. You can bind an instance method of Tomato like so:
+
+  tomato.bind_method(:inspect)
+  tomato.run("inspect();")  #=> "#<Tomato>"
   
-When JS code encounters an error of some kind, it'll get raised in Ruby:
+Or, perhaps more usefully, you can bind an instance method of some other object:
 
-  tomato.run("throw 'error';")
+  tomato.bind_method(:inspect, 5)
+  tomato.run("inspect();")  #=> "5"
   
+It's also easy to bind methods to arbitrary JavaScript objects. If a JS object in the chain doesn't exist, Tomato will
+silently generate it for you on-the-fly:
+
+
+  def say(something)
+    puts something
+  end
+  
+  tomato.bind_method(:say, self, :to => "person.mouth")
+  
+  # Tomato generated both the "person" and "mouth" objects for us:
+  tomato.run "person.mouth.say('Hello there');"
+
   # Produces:
-  # 
-  # Tomato::Error: (dynamic):error
-  # throw 'error';
-  # ^
   #
-  #     from (irb):3:in `run'
-  #	    from (irb):3
+  # Hello there
+  #  => nil
+  
+  puts tomato.run("this")
   
-You can bind Ruby methods to JavaScript, as well. CURRENTLY only Tomato instance methods are supported. This will be
-extended in the near future to include any method on any object. Current implementation of method binding looks like
-this:
+  # Produces:
+  #
+  # {"person":{"mouth":{}}}
+  #  => nil 
 
-  tomato.bind_method(:inspect)
-  tomato.run("inspect();")  #=> "#<Tomato>"
+In the spirit of true Ruby dynamicism, (is that a word?), you can feel free to re-bind new methods over old ones:
+
+  tomato.bind_method(:say)
+  tomato.run("say('something');")
+  #=> error! say is not an instance method of Tomato
   
-For now (until a better method binding is implemented) you can add methods. You can do this before OR after binding it:
+  tomato.bind_method(:say, self)
+  def say(something); puts something; end
+  tomato.run("say('something');")
+  #=> something
+  
+You can also easily bind an entire object to JavaScript:
 
-  tomato.bind_method(:say_hello)
-  def tomato.say_hello
-    puts "Hi there!"
+  # By default objects are mapped to 'ruby.[object_class_name]'
+  tomato.bind_object(Time.now)
+  tomato.run("ruby.time.to_s();")
+  #=> "2010-06-25 18:12:23 -0400"
+  
+  # Or give it an object name or chain of names:
+  tomato.bind_object(Time.now, "time.current")
+  tomato.run("time.current.to_s();")
+  #=> "2010-06-25 18:12:23 -0400"
+  
+Even better, you can also bind a whole class and instantiate it from within JavaScript. If you return the object to
+Ruby, it'll be seamlessly converted into the corresponding Ruby object.
+  
+  class Person
+    def initialize(name)
+      @name = name
+    end
+    attr_accessor :name, :age
   end
-  tomato.run("say_hello();")
+  
+  tomato.bind_object(Person, "world.Person")
+  tomato.run <<-end_js
+    var colin = new world.Person("Colin");
+    colin.age = 25;
+    colin;
+  end_js
+  
+  #=> #<Person:0x00000100dbbc50 @name="Colin", @age=25>  
+
+==== Error Handling
+
+When JS code encounters an error of some kind, it'll get raised in Ruby:
+
+  tomato.run("throw 'error';")
   
   # Produces:
+  # 
+  # Tomato::Error: (dynamic):error
+  # throw 'error';
+  # ^
   #
-  # Hi there!
-  #  => nil
+  #     from (irb):3:in `run'
+  #	    from (irb):3
   
 You can also catch Ruby errors in JavaScript:
 
-  tomato.bind_method(:raise_err)
-  def tomato.raise_err
+  tomato.bind_method(:raise_err, self)
+  def raise_err
     raise ArgumentError, "Not what I meant!"
   end
   tomato.run("try { raise_err(); } catch(e) {}");
@@ -68,8 +129,8 @@ You can also catch Ruby errors in JavaScript:
   
 Or let them bubble up to Ruby:
 
-  tomato.bind_method(:raise_err)
-  def tomato.raise_err
+  tomato.bind_method(:raise_err, self)
+  def raise_err
     raise ArgumentError, "Not what I meant!"
   end
   begin
@@ -83,8 +144,6 @@ Or let them bubble up to Ruby:
   # Error: Not what I meant!
   #  => nil 
 
-That's all I've implemented so far, but I think it looks pretty cool.
-
 === Object Types
 
 Some objects in Ruby don't exist in JS. So far the ones I've implemented are Hashes and Symbols.
@@ -92,7 +151,17 @@ Some objects in Ruby don't exist in JS. So far the ones I've implemented are Has
 ==== Symbols
 
 A Symbol is converted to an object in JS with a "symbol" attribute and a "toString()" method. That same object, if
-returned to Ruby, is converted back to a Symbol.
+returned to Ruby, is converted back to a Symbol. Examples:
+
+  def fetch_a_symbol
+    :a_symbol
+  end
+  
+  t = Tomato.new
+  t.bind_method(:fetch_a_symbol, self)
+  t.run("fetch_a_symbol()")            #=> :a_symbol 
+  t.run("fetch_a_symbol().symbol")     #=> "a_symbol"
+  t.run("fetch_a_symbol().toString()") #=> "a_symbol"
  
 
 ==== Hashes
@@ -127,11 +196,26 @@ That should be all there is to it.
    
 == Performance
 
-Too early to tell. Benchmarking will be done as I get closer to a real release.
+  ruby-1.9.1-p378 > javascript = <<-end_js
+  ruby-1.9.1-p378">   var str = "";
+  ruby-1.9.1-p378">   for (var i = 0; i < 1000000; i++)
+  ruby-1.9.1-p378">     str = 'a';
+  ruby-1.9.1-p378"> end_js
+  ruby-1.9.1-p378 > require 'benchmark'
+  ruby-1.9.1-p378 > require 'tomato'
+  ruby-1.9.1-p378 > t = Tomato.new
+  ruby-1.9.1-p378 >
+  ruby-1.9.1-p378 > # Setup complete, let's start the test
+  ruby-1.9.1-p378 > puts Benchmark.measure { for i in 1..1000000; str = 'a'; end }
+  ruby-1.9.1-p378 >  0.350000   0.000000   0.350000 (  0.358106)
+  ruby-1.9.1-p378 >
+  ruby-1.9.1-p378 > puts Benchmark.measure { t.run(javascript) }
+  ruby-1.9.1-p378 >  0.010000   0.000000   0.010000 (  0.012603)
+  
+'Nuff said.
 
-Since V8's JavaScript code is compiled into byte code, this MAY (untested) have a positive impact on performance
-in some applications. Just translate your code to JavaScript and let V8 compile it to byte code. I'm hoping for some
-cool results.
+Since V8's JavaScript code is compiled into byte code, this can have a positive impact on performance
+in some applications. Just translate your code to JavaScript and let Tomato compile it into byte code.
 
 == Note on Patches/Pull Requests
  

data/Rakefile

@@ -11,6 +11,7 @@ begin
     gem.email = "sinisterchipmunk@gmail.com"
     gem.homepage = "http://www.thoughtsincomputation.com"
     gem.authors = ["Colin MacKenzie IV"]
+    gem.add_dependency "sc-core-ext", ">= 1.2.0"
     gem.add_development_dependency "rspec", ">= 1.3.0"
     gem.files = FileList['**/*']
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings

data/VERSION

@@ -1 +1 @@
-0.0.1.prealpha1
+0.0.1.prealpha2

data/ext/tomato/Makefile

@@ -4,19 +4,17 @@ SHELL = /bin/sh
 #### Start of system configuration section. ####
 
 srcdir = .
-topdir = /Users/colin/.rvm/rubies/ruby-1.9.2-preview3/include/ruby-1.9.1
-hdrdir = /Users/colin/.rvm/rubies/ruby-1.9.2-preview3/include/ruby-1.9.1
-arch_hdrdir = /Users/colin/.rvm/rubies/ruby-1.9.2-preview3/include/ruby-1.9.1/$(arch)
+topdir = /Users/colin/.rvm/rubies/ruby-1.9.1-p378/include/ruby-1.9.1
+hdrdir = /Users/colin/.rvm/rubies/ruby-1.9.1-p378/include/ruby-1.9.1
+arch_hdrdir = /Users/colin/.rvm/rubies/ruby-1.9.1-p378/include/ruby-1.9.1/$(arch)
 VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
-prefix = $(DESTDIR)/Users/colin/.rvm/rubies/ruby-1.9.2-preview3
-rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+prefix = $(DESTDIR)/Users/colin/.rvm/rubies/ruby-1.9.1-p378
 exec_prefix = $(prefix)
 vendorhdrdir = $(rubyhdrdir)/vendor_ruby
 sitehdrdir = $(rubyhdrdir)/site_ruby
-rubyhdrdir = $(includedir)/$(RUBY_BASE_NAME)-$(ruby_version)
-vendordir = $(rubylibprefix)/vendor_ruby
-sitedir = $(rubylibprefix)/site_ruby
-ridir = $(datarootdir)/$(RI_BASE_NAME)
+rubyhdrdir = $(includedir)/$(RUBY_INSTALL_NAME)-$(ruby_version)
+vendordir = $(libdir)/$(RUBY_INSTALL_NAME)/vendor_ruby
+sitedir = $(libdir)/$(RUBY_INSTALL_NAME)/site_ruby
 mandir = $(datarootdir)/man
 localedir = $(datarootdir)/locale
 libdir = $(exec_prefix)/lib
@@ -36,7 +34,7 @@ datarootdir = $(prefix)/share
 libexecdir = $(exec_prefix)/libexec
 sbindir = $(exec_prefix)/sbin
 bindir = $(exec_prefix)/bin
-rubylibdir = $(rubylibprefix)/$(ruby_version)
+rubylibdir = $(libdir)/$(ruby_install_name)/$(ruby_version)
 archdir = $(rubylibdir)/$(arch)
 sitelibdir = $(sitedir)/$(ruby_version)
 sitearchdir = $(sitelibdir)/$(sitearch)
@@ -53,35 +51,34 @@ OUTFLAG = -o
 COUTFLAG = -o 
 
 RUBY_EXTCONF_H = 
-cflags   =  $(optflags) $(debugflags) $(warnflags)
-optflags = -O3
-debugflags = -ggdb
-warnflags = -Wextra -Wno-unused-parameter -Wno-parentheses -Wpointer-arith -Wwrite-strings -Wno-missing-field-initializers -Wshorten-64-to-32 -Wno-long-long
-CFLAGS   = -fno-common $(cflags)  -fno-common -pipe 
+cflags   = $(optflags) $(debugflags) $(warnflags)
+optflags = -O2
+debugflags = -g
+warnflags = -Wall -Wno-parentheses
+CFLAGS   =  -fno-common  $(cflags)  -fno-common -pipe -fno-common 
 INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir) -I/Users/colin/projects/gems/tomato/ext/tomato/external/build/v8/include
 DEFS     = 
-CPPFLAGS =  -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags) -Wall -g -rdynamic
-CXXFLAGS = $(CFLAGS) $(cxxflags)
+CPPFLAGS =   -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags) -Wall -g -rdynamic
+CXXFLAGS = $(CFLAGS)  $(cxxflags)
 ldflags  = -L. -L/usr/local/lib
-dldflags = -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress -Wl,-flat_namespace
-ARCH_FLAG = 
-DLDFLAGS = $(ldflags) $(dldflags)
-LDSHARED = $(CC) -dynamic -bundle
-LDSHAREDXX = $(CXX) -dynamic -bundle
+dldflags = 
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = cc -dynamic -bundle -undefined suppress -flat_namespace
+LDSHAREDXX = $(LDSHARED)
 AR = ar
 EXEEXT = 
 
-RUBY_BASE_NAME = ruby
 RUBY_INSTALL_NAME = ruby
-RUBY_SO_NAME = ruby.1.9.1
-arch = x86_64-darwin10.4.0
-sitearch = $(arch)
+RUBY_SO_NAME = ruby
+arch = i386-darwin10.4.0
+sitearch = i386-darwin10.4.0
 ruby_version = 1.9.1
-ruby = /Users/colin/.rvm/rubies/ruby-1.9.2-preview3/bin/ruby
+ruby = /Users/colin/.rvm/rubies/ruby-1.9.1-p378/bin/ruby
 RUBY = $(ruby)
 RM = rm -f
 RM_RF = $(RUBY) -run -e rm -- -rf
-RMDIRS = rmdir -p
+RMDIRS = $(RUBY) -run -e rmdir -- -p
 MAKEDIRS = mkdir -p
 INSTALL = /usr/bin/install -c
 INSTALL_PROG = $(INSTALL) -m 0755
@@ -104,9 +101,9 @@ extout =
 extout_prefix = 
 target_prefix = 
 LOCAL_LIBS = 
-LIBS = $(LIBRUBYARG_SHARED) -lobjc -lpthread  -lpthread -ldl -lobjc  -lv8
-SRCS = binding_methods.cpp conversions_to_js.cpp conversions_to_rb.cpp errors.cpp tomato.cpp v8.cpp
-OBJS = binding_methods.o conversions_to_js.o conversions_to_rb.o errors.o tomato.o v8.o
+LIBS = $(LIBRUBYARG_SHARED) -lobjc -lpthread  -lpthread -ldl -lobjc   -lv8
+SRCS = binding_methods.cpp conversions_to_js.cpp conversions_to_rb.cpp errors.cpp object_chain.cpp tomato.cpp v8.cpp
+OBJS = binding_methods.o conversions_to_js.o conversions_to_rb.o errors.o object_chain.o tomato.o v8.o
 TARGET = tomato
 DLLIB = $(TARGET).bundle
 EXTSTATIC = 
@@ -125,8 +122,6 @@ CLEANOBJS     = *.o  *.bak
 
 all:    $(DLLIB)
 static: $(STATIC_LIB)
-.PHONY: all install static install-so install-rb
-.PHONY: clean clean-so clean-rb
 
 clean-rb-default::
 clean-rb::
@@ -148,8 +143,7 @@ install: install-so install-rb
 install-so: $(RUBYARCHDIR)
 install-so: $(RUBYARCHDIR)/$(DLLIB)
 $(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
-	@-$(MAKEDIRS) $(@D)
-	$(INSTALL_PROG) $(DLLIB) $(@D)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
 install-rb: pre-install-rb install-rb-default
 install-rb-default: pre-install-rb-default
 pre-install-rb: Makefile
@@ -185,14 +179,15 @@ $(DLLIB): $(OBJS) Makefile
 
 
 ###
-binding_methods.o: binding_methods.cpp tomato.h
+binding_methods.o: binding_methods.cpp tomato.h binding_methods.h
 conversions_to_js.o: conversions_to_js.cpp tomato.h
 conversions_to_rb.o: conversions_to_rb.cpp tomato.h
 errors.o: errors.cpp tomato.h
+object_chain.o: object_chain.cpp tomato.h binding_methods.h
 tomato.o: tomato.cpp tomato.h
 v8.o: v8.cpp tomato.h
 
 test: all
 	@echo Running specs...
-	spec -O spec/spec.opts spec
+	spec spec -c
 

data/ext/tomato/binding_methods.cpp

@@ -1,9 +1,7 @@
 #include "tomato.h"
+#include "binding_methods.h"
 
 static VALUE bound_method_call(VALUE args);
-static Handle<Value> bound_method(const Arguments& args);
-static int store_rb_message(const Arguments &args, V8Tomato **out_tomato, VALUE *out_receiver, ID *out_method_id);
-
 
 Handle<Value> bound_method(const Arguments& args)
 {
@@ -13,12 +11,17 @@ Handle<Value> bound_method(const Arguments& args)
   ID rb_method_id;
   V8Tomato *tomato;
   int code = store_rb_message(args, &tomato, &receiver, &rb_method_id);
-  if (code == -1)
-    return ThrowException(String::New("Error: _tomato is not an object (BUG: please report)"));
+  switch(code)
+  {
+    case -1: return ThrowException(String::New("Error: _tomato is not an object (BUG: please report)"));
+    case -2: return ThrowException(String::New("Error: _tomato_receiver_index is not an Int32 (BUG: please report)"));
+    case -3: return ThrowException(String::New("Error: _tomato_receiver_index is greater than @receivers.length (BUG: please report)"));
+  };
 
-  VALUE rbargs = rb_ary_new2(2);
+  VALUE rbargs = rb_ary_new2(2+args.Length());
   rb_ary_store(rbargs, 0, receiver);
   rb_ary_store(rbargs, 1, ID2SYM(rb_method_id));
+  store_args(tomato, rbargs, args);
   
   int error;
   VALUE result = rb_protect(bound_method_call, rbargs, &error);
@@ -30,27 +33,50 @@ Handle<Value> bound_method(const Arguments& args)
   return js_value_of(tomato, result);
 }
 
+void store_args(V8Tomato *tomato, VALUE rbargs, const Arguments &args)
+{
+  int length = args.Length();
+  int offset = RARRAY_LEN(rbargs);
+  for (int i = 0; i < length; i++)
+    rb_ary_store(rbargs, offset+i, ruby_value_of(tomato, args[i]));
+}
+
 static VALUE bound_method_call(VALUE args)
 {
-  VALUE receiver = rb_ary_entry(args, 0);
-  VALUE rb_method_id = SYM2ID(rb_ary_entry(args, 1));
-  
-  VALUE result = rb_funcall(receiver, rb_method_id, 0);
-  
+  VALUE receiver = rb_ary_shift(args);
+  VALUE rb_method_id = SYM2ID(rb_ary_shift(args));
+  VALUE result = rb_funcall2(receiver, rb_method_id, RARRAY_LEN(args), RARRAY_PTR(args));
   return result;
 }
 
 int store_rb_message(const Arguments &args, V8Tomato **out_tomato, VALUE *out_receiver, ID *out_method_id)
 {
+  // get the function
   Handle<Function> function = args.Callee();
-  Handle<String> _tomato = String::New("_tomato");
-  if (!function->Get(_tomato)->IsExternal())
-    return -1;
+  
+  // pull the binding data from the function (stored there by fTomato_bind_method)
+  Local<Value> v8_tomato         = function->Get(String::New("_tomato"));
+  Local<Value> v8_receiver_index = function->Get(String::New("_tomato_receiver_index"));
+  
+  // make sure the data is what we expect it to be
+  if (!v8_tomato->IsExternal())      return -1;
+  if (!v8_receiver_index->IsInt32()) return -2;
     
-  V8Tomato *tomato = (V8Tomato *)Local<External>::Cast(function->Get(_tomato))->Value();
-  VALUE receiver = tomato->rb_instance;
+  // find the tomato
+  V8Tomato *tomato = (V8Tomato *)Local<External>::Cast(v8_tomato)->Value();
+  
+  // find the receiver index, and make sure it's a valid index
+  int receiver_index = v8_receiver_index->Int32Value();
+  VALUE receivers = rb_iv_get(tomato->rb_instance, "@receivers"); //rb_funcall(tomato->rb_instance, rb_intern("receivers"));
+  if (RARRAY_LEN(receivers) < receiver_index) return -3;
+  
+  // get the receiver
+  VALUE receiver = (RARRAY_PTR(receivers)[receiver_index]);
+
+  // get the method name from the function name
   String::Utf8Value method_name(function->GetName());
 
+  // store the output and return success.
   *out_tomato = tomato;
   *out_method_id = rb_intern(ToCString(method_name));
   *out_receiver = receiver;
@@ -59,22 +85,23 @@ int store_rb_message(const Arguments &args, V8Tomato **out_tomato, VALUE *out_re
 
 VALUE fTomato_bind_method(int argc, VALUE *argv, VALUE self)
 {
-  if (argc != 1) rb_raise(rb_eArgError, "Expected name of method");
+  if (argc != 3) rb_raise(rb_eArgError,
+    "Expected: _bind_method(method_name<str>, receiver_index<int>, object_chain<array[string] or nil>)");
   const char *method_name = rb_id2name(rb_to_id(argv[0]));
   
   V8Tomato *tomato;
   Data_Get_Struct(self, V8Tomato, tomato);
   
   HandleScope handle_scope;
-  Context::Scope context_scope(tomato->context);  
-  Handle<Value> value = tomato->context->Global();
+  Context::Scope context_scope(tomato->context);
+  Handle<Value> value = find_or_create_object_chain(tomato, argv[2]);
   if (value->IsObject())
   {
     Handle<Object> object = Handle<Object>::Cast(value);
-    Handle<Value> proto_value = object->GetPrototype();
     Handle<Function> function = FunctionTemplate::New(bound_method)->GetFunction();
 
     function->Set(String::New("_tomato"), External::New(tomato));
+    function->Set(String::New("_tomato_receiver_index"), Int32::New(FIX2INT(argv[1])));
     function->SetName(String::New(method_name));
 
     object->Set(String::New(method_name), function);