therubyracer 0.4.2 → 0.4.3

data/History.txt

@@ -1,4 +1,20 @@
-=== 0.0.1 2009-12-14
+=== 0.4.3 2010-10-11
+* N major enhancements:
+  * access properties on Ruby objects with their camel case equivalents
+  * reflect JavaScript objects into Ruby and access their properties
+  * load JavaScript source from an IO object or by filename
 
+=== 0.4.2 2010-10-10
 * 1 major enhancement:
-  * Initial release
+  * embed Ruby Objects into Javascript and call their methods
+
+=== 0.4.1 2010-01-09
+
+* 3 major enhancements:
+  * embed bare Proc and Method objects into JavaScript and call them
+  * catch JavaScript exceptions from Ruby
+
+=== 0.4.0 2009-12-21
+
+* 1 major enhancements:
+  * evaluate JavaScript code from inside Ruby.

data/README.rdoc

@@ -8,26 +8,127 @@ Embed the V8 Javascript interpreter into Ruby.
 
 == FEATURES/PROBLEMS:
 
-* Inspires fun.
-* Not close to production ready.
+* Evaluate Javascript from with in Ruby
+* Embed your Ruby objects into the Javascript world
+* Manipulate JavaScript objects and call JavaScript functions from Ruby
+* API compatible with the The Ruby Rhino (for JRuby: http://github.com/cowboyd/therubyrhino)
+* Currently ALPHA software. 
 
 == SYNOPSIS:
 
-  Check back in February 2009 for an alpha release.
-
+  require 'v8'
+  
+# evaluate some simple javascript
+
+  V8::Context.open do |cxt|
+    cxt['foo'] = "bar"
+    cxt.eval('foo') # => "bar"
+  end
+
+# evaluate a ruby function from javascript
+  
+  V8::Context.open do |context|
+    context["say"] = lambda {|word, times| word * times}
+    context.eval("say("Hello", 3)") #=> HelloHelloHello
+  end
+  
+# embed a ruby object into your javascript environment
+
+  class MyMath
+    def plus(lhs, rhs)
+      lhs + rhs
+    end
+  end
+
+  V8::Context.open do |context|
+    context["math"] = MyMath.new
+    context.eval("math.plus(20,22)") #=> 42
+  end
+
+#COMING SOON!
+# make a ruby object *be* your javascript environment
+  math = MyMath.new
+  V8::Context.open(:with => math) do |context|
+    context.eval("plus(20,22)") #=> 42
+  end
+  
+  #or the equivalent
+  
+  math.eval_js("plus(20,22)")
+
+# Configure your embedding setup
+
+  #COMING SOON!
+  # Make your standard objects (Object, String, etc...) immutable
+  V8::Context.open(:sealed => true) do |context|
+    context.eval("Object.prototype.toString = function() {}") # this is an error!
+  end
+  
+  #COMING SOON!
+  #limit the number of instructions that can be executed in order to prevent
+  #rogue scripts
+  V8::Context.open do |context|
+    context.instruction_limit = 100000
+    context.eval("while (true);") # => Error!
+  end
+
+==== Different ways of loading javascript source
+
+In addition to just evaluating strings, you can also use streams such as files.
+
+# evaluate bytes read from any File/IO object:
+  File.open("mysource.js") do |file|
+    eval_js file, "mysource.js"
+  end
+
+# or load it by filename
+  V8::Context.open do |context|
+    context.load("mysource.js")
+  end
+
+=== Safe by default
+
+The Ruby Racer is designed to let you evaluate javascript as safely as possible unless you tell it to do something more
+dangerous. The default context is a hermetically sealed javascript environment with only the standard javascript objects
+and functions. Nothing from the ruby world is accessible at all.
+
+For ruby objects that you explicitly embed into javascript, only the +public+ methods *defined in their classes* are
+exposed by default. E.g.
+
+  class A
+    def a
+      "a"
+    end
+  end
+
+  class B < A
+    def b
+      "b"
+    end
+  end
+
+
+  V8::Context.open do |cxt|
+    cxt['a'] = A.new
+    cxt['b'] = B.new
+    cxt.eval("a.a()") # => 'a'
+    cxt.eval("b.b()") # => 'b'
+    cxt.eval("b.a()") # => 'TypeError: undefined property 'a' is not a function'
+  end
+  
 == REQUIREMENTS:
 
 * libv8 >= 0.4.0
 
 == INSTALL:
-
+* download, build and install V8: http://code.google.com/apis/v8/build.html
 * sudo gem install therubyracer
 
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2009 FIXME full name
+Copyright (c) 2009 Charles Lowell
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/ext/v8/converters.cpp

@@ -9,6 +9,8 @@ namespace {
   std::string UNDEFINED_STR("undefined");
 }
 
+VALUE V8_To;
+
 VALUE V82RB(Handle<Value>& value) {
   convert_v8_to_rb_t convert;
   VALUE result;
@@ -16,6 +18,16 @@ VALUE V82RB(Handle<Value>& value) {
     return result;
   }
   
+  if (value->IsArray()) {  
+    Local<Array> array(Array::Cast(*value));
+    VALUE rb_array = rb_ary_new2(array->Length());
+    for (unsigned int i = 0; i < array->Length(); i++) {
+      Local<Value> value = array->Get(Integer::New(i));
+      rb_ary_push(rb_array, V82RB(value));
+    }
+    return rb_array;
+  }
+  
   if (value->IsObject()) {
     Local<Object> object(Object::Cast(*value));
     return V8_Ref_Create(V8_C_Object, value);
@@ -39,12 +51,16 @@ Local<Value> RB2V8(VALUE value) {
   
   Local<ObjectTemplate> tmpl = ObjectTemplate::New();
   VALUE methods = rb_funcall(value, rb_intern("public_methods"), 1, Qfalse);
-  int len = RARRAY(methods)->len;
+  int len = RARRAY_LEN(methods);
   for (int i = 0; i < len; i++) {
-    VALUE method_name = RARRAY(methods)->ptr[i];
+    VALUE method_name = RARRAY_PTR(methods)[i];
+    VALUE camel_method_name = rb_funcall(V8_To, rb_intern("camelcase"), 1, method_name);
     VALUE method = rb_funcall(value, rb_intern("method"), 1, method_name);
     Local<String> keystr = (String *)*RB2V8(method_name);
-    tmpl->Set(keystr, RB2V8(method));
+    Local<String> camelstr = (String *)*RB2V8(camel_method_name);
+    Local<Value> fun = RB2V8(method);
+    tmpl->Set(keystr, fun);
+    tmpl->Set(camelstr, fun);
   }
   return tmpl->NewInstance();
 }

data/ext/v8/converters.h

@@ -6,6 +6,8 @@
 #include "convert_v8.h"
 #include <cstring>
 
+extern VALUE V8_To;
+
 typedef RubyValueSource<V8LocalDest, v8::Local<v8::Value> > convert_rb_to_v8_t; 
 typedef V8HandleSource<RubyValueDest, VALUE> convert_v8_to_rb_t;
 

data/ext/v8/v8.cpp

@@ -6,6 +6,7 @@
 #include "v8_script.h"
 #include "v8_template.h"
 #include "v8_standalone.h"
+#include "converters.h"
 
 #include <stdio.h>
 
@@ -29,6 +30,8 @@ extern "C" {
       
         rb_mModule = rb_define_module("V8");
         rb_define_singleton_method(rb_mModule, "what_is_this?", (VALUE(*)(...)) v8_what_is_this, 1);
+        
+        V8_To = rb_define_module_under(rb_mModule, "To");
                 
         //native module setup
         VALUE rb_mNative = rb_define_module_under(rb_mModule, "C");
@@ -63,6 +66,7 @@ extern "C" {
         rb_define_singleton_method(V8_C_Object, "new", (VALUE(*)(...))v8_Object_New, 0);
         rb_define_method(V8_C_Object, "Get", (VALUE(*)(...))v8_Object_Get, 1);
         rb_define_method(V8_C_Object, "Set", (VALUE(*)(...))v8_Object_Set, 2);
+        rb_define_method(V8_C_Object, "GetPropertyNames", (VALUE(*)(...)) v8_Object_GetPropertyNames, 0);
         
         V8_C_Message = rb_define_class_under(rb_mNative, "Message", rb_cObject);
         rb_define_method(V8_C_Message, "Get", (VALUE(*)(...))v8_Message_Get, 0);

data/ext/v8/v8_obj.cpp

@@ -8,6 +8,12 @@ using namespace v8;
 
 VALUE V8_C_Object;
 
+namespace {
+  Local<Object> unwrap(VALUE robj) {
+    return V8_Ref_Get<Object>(robj);
+  }
+}
+
 VALUE v8_Object_New(VALUE clazz) {
   HandleScope handles;
   return V8_Ref_Create(clazz, Object::New());
@@ -15,17 +21,24 @@ VALUE v8_Object_New(VALUE clazz) {
 
 VALUE v8_Object_Get(VALUE self, VALUE key) {
   HandleScope handles;  
-  Local<Object> obj = V8_Ref_Get<Object>(self);
-  VALUE keystr = rb_funcall(key,rb_intern("to_s"), 0);
+  Local<Object> obj = unwrap(self);
+  VALUE keystr = rb_str_to_str(key);
   Local<Value> value = obj->Get(RB2V8(keystr));
   return V82RB(value);
 }
 
 VALUE v8_Object_Set(VALUE self, VALUE key, VALUE value) {
   HandleScope handles;
-  Local<Object> obj = V8_Ref_Get<Object>(self);
+  Local<Object> obj = unwrap(self);
+
   VALUE keystr = rb_funcall(key, rb_intern("to_s"), 0);
-  
   obj->Set(RB2V8(keystr), RB2V8(value));
   return Qnil;
 }
+
+VALUE v8_Object_GetPropertyNames(VALUE self) {
+  HandleScope handles;
+  Local<Object> object = unwrap(self);  
+  Local<Value> names = object->GetPropertyNames();
+  return V82RB(names);
+}

data/ext/v8/v8_obj.h

@@ -8,4 +8,5 @@ extern VALUE V8_C_Object;
 VALUE v8_Object_New(VALUE clazz);
 VALUE v8_Object_Get(VALUE self, VALUE key);
 VALUE v8_Object_Set(VALUE self, VALUE key, VALUE value);
+VALUE v8_Object_GetPropertyNames(VALUE self);
 #endif

data/lib/v8.rb

@@ -2,7 +2,7 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module V8
-  VERSION = '0.4.2'
+  VERSION = '0.4.3'
   require 'v8/v8' #native glue
   require 'v8/to'
   require 'v8/context'

data/lib/v8/context.rb

@@ -10,7 +10,10 @@ module V8
       end if block_given?
     end
     
-    def eval(javascript)
+    def eval(javascript, sourcename = '<eval>', line = 1)
+      if IO === javascript || StringIO === javascript
+        javascript = javascript.read()
+      end
       @native.eval(javascript).tap do |result|
         raise JavascriptError.new(result) if result.kind_of?(C::Message)
         return To.ruby(result)
@@ -21,6 +24,16 @@ module V8
       self.eval(*args)
     end
     
+    def load(filename)
+      File.open(filename) do |file|
+        evaluate file, filename, 1
+      end      
+    end
+    
+    def [](key)
+      To.ruby(@native.Global().Get(key.to_s))
+    end
+    
     def []=(key, value)
       value.tap do 
         @native.Global().tap do |scope|
@@ -41,4 +54,6 @@ module V8
       super(v8_message.Get())
     end
   end
+  class RunawayScriptError < ContextError
+  end
 end

data/lib/v8/object.rb

@@ -1,12 +1,26 @@
 
 module V8
   class Object
+    include Enumerable
+    
     def initialize(native)
       @native = native
     end
     
     def [](key)
-      To.ruby(@native.Get(key))
+      To.ruby(@native.Get(key.to_s))
+    end
+    
+    def []=(key, value)
+      value.tap do
+        @native.Set(key.to_s, value)
+      end
+    end
+    
+    def each
+      for prop in @native.GetPropertyNames()
+        yield prop, self[prop]
+      end
     end
   end
 end

data/lib/v8/to.rb

@@ -20,6 +20,10 @@ module V8
           value
         end
       end
+      
+      def camelcase(str)
+        str.to_s.gsub(/_(\w)/) {$1.upcase}
+      end      
     end
   end
 end

data/spec/redjs/jsapi_spec.rb

@@ -269,7 +269,7 @@ describe "Ruby Javascript API" do
             cxt.eval('while (true);')
           end
         end
-      }.should raise_error(Rhino::RunawayScriptError)
+      }.should raise_error(RunawayScriptError)
     end
     
     it "has a private constructor" do
@@ -330,17 +330,21 @@ describe "Ruby Javascript API" do
     end
   
     it "can have its properties manipulated via ruby style [] hash access" do
-      @o["foo"] = 'bar'
-      evaljs('o.foo').should == "bar"
-      evaljs('o.blue = "blam"')
-      @o["blue"].should == "blam"
+      @cxt.open do
+        @o["foo"] = 'bar'
+        evaljs('o.foo').should == "bar"
+        evaljs('o.blue = "blam"')
+        @o["blue"].should == "blam"
+      end
     end
   
     it "doesn't matter if you use a symbol or a string to set a value" do
-      @o[:foo] = "bar"
-      @o['foo'].should == "bar"
-      @o['baz'] = "bang"
-      @o[:baz].should == "bang"
+      @cxt.open do
+        @o[:foo] = "bar"
+        @o['foo'].should == "bar"
+        @o['baz'] = "bang"
+        @o[:baz].should == "bang"
+      end
     end
   
     it "returns nil when the value is null, null, or not defined" do
@@ -358,8 +362,10 @@ EOJS
     end
 
     it "is enumenable" do
-      evaljs("o.foo = 'bar'; o.bang = 'baz'; o[5] = 'flip'")
-      @o.inject({}) {|i,p| k,v = p; i.tap {i[k] = v}}.should == {"foo" => 'bar', "bang" => 'baz', 5 => 'flip'}    
+      @cxt.open do
+        evaljs("o.foo = 'bar'; o.bang = 'baz'; o[5] = 'flip'")
+        @o.inject({}) {|i,p| k,v = p; i.tap {i[k] = v}}.should == {"foo" => 'bar', "bang" => 'baz', 5 => 'flip'}    
+      end
     end  
 end
 

data/therubyracer.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{therubyracer}
-  s.version = "0.4.1"
+  s.version = "0.4.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Charles Lowell", "Bill Robertson"]
-  s.date = %q{2010-01-10}
+  s.date = %q{2010-01-11}
   s.description = %q{Embed the V8 Javascript interpreter into Ruby.}
   s.email = ["cowboyd@thefrontside.net", "billrobertson42@gmail.com"]
   s.extensions = ["ext/v8/extconf.rb"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: therubyracer
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors: 
 - Charles Lowell
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-10 00:00:00 +02:00
+date: 2010-01-11 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency