therubyracer 0.4.7-x86-darwin-9

data/README.rdoc

@@ -0,0 +1,157 @@
+= therubyracer
+
+* http://github.com/cowboyd/therubyracer
+
+== DESCRIPTION:
+
+Embed the V8 Javascript interpreter into Ruby.
+
+== FEATURES/PROBLEMS:
+
+* 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:
+
+  require 'v8'
+  
+# evaluate some simple javascript
+
+  V8.eval("7 * 6") #=> 42
+
+# embed values into the scope of your context
+
+  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
+
+# 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:
+
+* python >= 2.5 (required to compile v8)
+
+== INSTALL:
+* gem install therubyracer
+
+== DEVELOP
+* git clone git://github.com/cowboyd/therubyracer.git
+* cd therubyracer
+* rake compile
+
+== LICENSE:
+
+(The MIT License)
+
+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
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+begin
+  require './lib/v8' 
+rescue LoadError
+  #it will fail to load if we don't have the extensions compiled yet
+end
+
+gem 'rake-compiler', '>= 0.4.1'
+require "rake/extensiontask"
+
+
+Hoe.plugin :newgem
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'therubyracer' do
+  developer 'Charles Lowell', 'cowboyd@thefrontside.net'
+  developer 'Bill Robertson', 'billrobertson42@gmail.com'
+  self.rubyforge_name = self.name
+  self.spec_extras = { :extensions => ["ext/v8/extconf.rb"] }
+  self.clean_globs << "lib/v8/*.{o,so,bundle,a,log,dll}"
+end
+
+UPSTREAM_SRC  = File.dirname(__FILE__) + "/ext/v8/upstream"
+SCONS_SRC     = "#{UPSTREAM_SRC}/scons"
+V8_SRC      = "#{UPSTREAM_SRC}/2.0.6"
+
+task "clean-v8" => "clean" do
+  sh "rm -f #{V8_SRC}/libv8.a"
+  sh "rm -rf #{SCONS_SRC}/build"
+  sh "rm -rf #{SCONS_SRC}/install"
+  sh "rm -rf #{V8_SRC}/obj"
+end
+
+
+Rake::ExtensionTask.new("v8", $hoe.spec) do |ext|
+  ext.lib_dir = "lib/v8"
+  ext.source_pattern = "*.{cpp,h}"
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/docs/data_conversion.txt

@@ -0,0 +1,18 @@
+Short list of types that a receiver should handle:
+
+type           		expected method
+-------------------------------
+<null>         		pushNull
+boolean        		pushBool
+int64          		pushInt (overloaded on 64-bit int)
+double         		pushDouble
+const std::string&	pushString
+???					pushUndefined
+
+int32          		pushInt (overloaded on 32-bit int)
+
+for lack of any better ideas have these functions return true on
+success and false on error
+
+--
+should add more later.

data/ext/v8/callbacks.cpp

@@ -0,0 +1,160 @@
+#include <ruby.h>
+
+#include "callbacks.h"
+#include "converters.h"
+
+using namespace v8;
+
+namespace {
+  VALUE unwrap(const AccessorInfo& info) {
+    return (VALUE)External::Unwrap(info.Data());
+  }
+  
+  Local<Array> TO_ARRAY(Arguments& args) {
+    Local<Array> array = Array::New(args.Length());
+    for (int i = 0; i < args.Length(); i++) {
+      array->Set(Integer::New(i), args[i]);
+    }
+  }
+  
+  Local<Value> Racer_Call_Ruby_Method(VALUE object, VALUE method, Local<Array> args) {
+    VALUE * arguments = new VALUE[args->Length()];
+    for (unsigned int i = 0; i < args->Length(); i++) {
+      Handle<Value> val = args->Get(Integer::New(i));
+      arguments[i] = V82RB(val);
+    }
+    VALUE result = rb_funcall2(object, rb_to_id(method), args->Length(), arguments);
+    Local<Value> converted = RB2V8(result);
+    return converted;
+  }
+  
+  Local<Value> Racer_Access_Ruby_Property(VALUE object, VALUE name) { 
+    VALUE method = rb_funcall(object, rb_intern("method"), 1, name);
+    if (FIX2INT(rb_funcall(method, rb_intern("arity"), 0)) == 0) {
+      return Racer_Call_Ruby_Method(object, name, Array::New(0));      
+    } else {
+      return RB2V8(method);
+    }        
+  }
+}
+
+Handle<Value> RacerRubyInvocationCallback(const Arguments& args) {
+  VALUE code = (VALUE)External::Unwrap(args.Data());
+  if (NIL_P(code)) {
+    return Null();
+  } else {      
+    VALUE* arguments = new VALUE[args.Length()];
+    for(int c=0;c<args.Length(); ++c) {
+      Handle<Value> val = args[c];
+      arguments[c] = V82RB(val);
+    }
+      
+    VALUE result = rb_funcall2(code, rb_intern("call"), args.Length(), arguments);
+    delete [] arguments;
+    
+    Handle<Value> convertedResult = RB2V8(result);
+    return convertedResult  ;
+  }
+}
+
+
+
+
+/**
+ * NamedProperty[Getter|Setter] are used as interceptors on object.
+ * See ObjectTemplate::SetNamedPropertyHandler.
+ */
+
+Handle<Value> RacerRubyNamedPropertyGetter(Local<String> property, const AccessorInfo& info) {
+  // printf("Getter '%s'<br/>", *String::AsciiValue(property));
+  if (property->Length() == 0) {
+    return Handle<Value>();
+  }
+  VALUE object = unwrap(info);
+  VALUE camel_name = V82RB((Local<Value>&)property);
+  VALUE perl_name = rb_funcall(V8_To, rb_intern("perl_case"), 1, camel_name);
+  VALUE methods = rb_funcall(object, rb_intern("public_methods"), 1, Qfalse);
+  
+  if (RTEST(rb_ary_includes(methods, perl_name))) {
+    return Racer_Access_Ruby_Property(object, perl_name);
+  }
+  if (RTEST(rb_ary_includes(methods, camel_name))) {
+    return Racer_Access_Ruby_Property(object, camel_name);
+  }
+  return Handle<Value>();
+}
+
+/**
+ * Returns the value if the setter intercepts the request.
+ * Otherwise, returns an empty handle.
+ */
+Handle<Value> RacerRubyNamedPropertySetter(Local<String> property, Local<Value> value, const AccessorInfo& info) {
+  if (property->Length() == 0) {
+    return Handle<Value>();
+  }
+  // printf("Setter: '%s'<br/>", *String::AsciiValue(property));
+  std::string setter = V82String((Handle<Value>&)property);
+  setter += "=";
+  Local<String> setter_name = String::New(setter.c_str());
+  VALUE object = unwrap(info);
+  VALUE camel_name = V82RB((Local<Value>&)setter_name);
+  VALUE perl_name = rb_funcall(V8_To, rb_intern("perl_case"), 1, camel_name);
+  VALUE methods = rb_funcall(object, rb_intern("public_methods"), 1, Qfalse);
+  Local<Array> args = Array::New(1);
+  args->Set(Integer::New(0), value);
+  if (RTEST(rb_ary_includes(methods, perl_name))) {    
+    Racer_Call_Ruby_Method(object, perl_name, args);
+    return value;
+  }
+  if (RTEST(rb_ary_includes(methods, camel_name))) {
+    Racer_Call_Ruby_Method(object, camel_name, args);
+    return value;
+  }    
+  return Handle<Value>();
+}
+
+/**
+ * Returns a non-empty handle if the interceptor intercepts the request.
+ * The result is true if the property exists and false otherwise.
+ */
+Handle<Boolean> RacerRubyNamedPropertyQuery(Local<String> property, const AccessorInfo& info) {
+  printf("Query: '%s'<br/>", *String::AsciiValue(property));
+  if (property->Length() == 0) {
+    return False();
+  }
+  VALUE object = unwrap(info);
+  VALUE methods = rb_funcall(object, rb_intern("public_methods"), 1, Qfalse);
+  VALUE attr_name = V82RB((Local<Value>&)property);
+  VALUE perl_name = rb_funcall(V8_To, rb_intern("perl_case"), 1, attr_name);
+  
+  if (RTEST(rb_ary_includes(methods, attr_name)) || RTEST(rb_ary_includes(methods, perl_name))) {
+    return True();
+  } else {
+    return Handle<Boolean>();
+  }
+}
+
+/**
+ * Returns a non-empty handle if the deleter intercepts the request.
+ * The return value is true if the property could be deleted and false
+ * otherwise.
+ */
+Handle<Boolean> RacerRubyNamedPropertyDeleter(Local<String> property, const AccessorInfo& info) {
+  return False();
+}
+
+/**
+ * Returns an array containing the names of the properties the named
+ * property getter intercepts.
+ */
+Handle<Array> RacerRubyNamedPropertyEnumerator(const AccessorInfo& info) {
+  VALUE object = unwrap(info);
+  VALUE methods = rb_funcall(object, rb_intern("public_methods"), 1, Qfalse);
+  int length = RARRAY_LEN(methods);
+  Local<Array> properties = Array::New(length);
+  for (int i = 0; i < length; i++) {
+    VALUE camel_name = rb_funcall(V8_To, rb_intern("camel_case"), 1, rb_ary_entry(methods, i));
+    properties->Set(Integer::New(i), RB2V8(camel_name));
+  }
+  return properties;
+}

data/ext/v8/callbacks.h

@@ -0,0 +1,14 @@
+#ifndef CALLBACKS_H_8VK3LWBG
+#define CALLBACKS_H_8VK3LWBG
+
+#include <v8.h>
+
+v8::Handle<v8::Value> RacerRubyInvocationCallback(const v8::Arguments& args); 
+
+v8::Handle<v8::Value> RacerRubyNamedPropertyGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+v8::Handle<v8::Value> RacerRubyNamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info);
+v8::Handle<v8::Boolean> RacerRubyNamedPropertyQuery(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+v8::Handle<v8::Boolean> RacerRubyNamedPropertyDeleter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+v8::Handle<v8::Array> RacerRubyNamedPropertyEnumerator(const v8::AccessorInfo& info);
+
+#endif /* end of include guard: CALLBACKS_H_8VK3LWBG */

data/ext/v8/convert_ruby.cpp

@@ -0,0 +1,8 @@
+#include "convert_ruby.h"
+
+
+RubyValueDest::RubyValueDest() {
+}
+
+RubyValueDest::~RubyValueDest() {
+}

data/ext/v8/convert_ruby.h

@@ -0,0 +1,99 @@
+#ifndef __convert_ruby_h__
+#define __convert_ruby_h__
+
+#include <ruby.h>
+#include <string>
+
+/**
+ * A RubyValueSource takes a Destination class and a return
+ * type as a template argument, it converts a Ruby Value to
+ * the appropriate intermediate type and feed it to an 
+ * instance Destination type.  
+ * 
+ * The destination type should have a default constructor, 
+ * and provide the methods detailed in data_conversion.txt
+ * \tparam DEST destination type for the converted data
+ * \tparam RET is the return type of T's methods
+ */
+
+template<class DEST, class RET> class RubyValueSource {
+
+    /**
+    * An instance of the destination class
+    */
+    DEST dest;
+
+    public:
+    RubyValueSource() {}
+    ~RubyValueSource() {}
+
+
+    bool operator() (VALUE& value, RET& result) {
+        switch (TYPE(value)) {
+        case T_FIXNUM:
+          result = dest.pushInt(FIX2INT(value));
+          return true;
+        case T_FLOAT:
+          result = dest.pushDouble(NUM2DBL(value));
+          return true;
+        case T_STRING:
+          result = convertString(value);
+          return true;
+        case T_NIL:
+          result = dest.pushNull();
+          return true;
+        case T_TRUE:
+          result = dest.pushBool(true);
+          return true;
+        case T_FALSE:
+          result = dest.pushBool(false);
+          return true;
+        }
+        return false;
+    }
+    
+private:
+    RET convertString(VALUE& value) {
+        std::string stringValue(RSTRING(value)->ptr);
+        return dest.pushString(stringValue);
+    }
+};
+
+/**
+ * A RubyValueDest class receives on of the types defined in
+ * data_conversion.txt, and converts it to the appropriate
+ * Ruby VALUE.
+ */
+class RubyValueDest {
+
+    public:
+    RubyValueDest();
+    ~RubyValueDest();
+
+    VALUE pushString(const std::string& value) {
+        return rb_str_new2(value.c_str());
+    }
+
+    VALUE pushInt(int64_t value) {
+        return INT2FIX(value);
+    }
+
+    VALUE pushDouble(double value) {
+        return rb_float_new(value);
+    }
+
+    VALUE pushBool(bool value) {
+        return value ? Qtrue : Qfalse;
+    }
+
+    VALUE pushNull() {
+        return Qnil;
+    }
+
+    VALUE pushUndefined() {
+        return Qnil;
+    }
+};
+
+
+#endif