therubyracer 0.4.9-x86-linux

data/History.txt

@@ -0,0 +1,43 @@
+=== 0.4.8 2010-02-08
+* 1 major enhancements
+  * expose line number and source name on JavascriptErrors.
+
+=== 0.4.5 2010-01-18
+* 3 major enhancements
+  * case munging so that ruby methods(perl_case) are accessed through javascript in camelCase.
+  * access 0-arity ruby methods as javascript properties
+  * invoke ruby setters from javascript as properties
+* 1 minor enhancements
+  * contexts detect whether they are open or not and open when needed
+
+=== 0.4.4 2010-01-14
+* 2 major enhancements:
+  * Ruby objects embedded into javascript are passed back to ruby as themselves and not a wrapped V8 object wrapping a ruby object.
+  * Use any ruby object as the scope of eval().
+* 5 minor enhancements:
+  * quick and dirty V8.eval() method added
+  * native objects have a reference to the context that created them.
+  * context now has equality check.
+  * expose InContext() and GetCurrent() methods.
+  * fix a couple of segmentation faults
+
+=== 0.4.3 2010-10-11
+* 3 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:
+  * 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

@@ -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,51 @@
+require 'rubygems'
+
+UPSTREAM  = "ext/v8/upstream"
+SCONS     = "#{UPSTREAM}/scons"
+V8_SRC      = "#{UPSTREAM}/2.0.6"
+
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = gemspec.rubyforge_project = "therubyracer"
+    gemspec.version = "0.4.9"
+    gemspec.summary = "Embed the V8 Javascript interpreter into Ruby"
+    gemspec.description = "Call javascript code and manipulate javascript objects from ruby. Call ruby code and manipulate ruby objects from javascript."
+    gemspec.email = "cowboyd@thefrontside.net"
+    gemspec.homepage = "http://github.com/cowboyd/therubyracer"
+    gemspec.authors = ["Charles Lowell", "Bill Robertson"]
+    gemspec.extra_rdoc_files = ["README.rdoc"]
+    gemspec.files.exclude "ext/**/test/*", "ext/**/samples/*", "ext/**/benchmarks/*", "#{UPSTREAM}/build"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+begin
+  gem 'rake-compiler', '>= 0.4.1'
+  require "rake/extensiontask"
+
+  Rake::ExtensionTask.new("v8", eval("#{Rake.application.jeweler.gemspec.to_ruby}")) do |ext|    
+    ext.lib_dir = "lib/v8"
+    ext.source_pattern = "*.{cpp,h}"
+  end  
+rescue LoadError
+  puts "Rake Compiler not available. Install it with: gem install rake-compiler"
+end
+
+desc "Build gem"
+task :gem => :build
+
+desc "Do not call this, call gem instead."
+task :build
+
+
+task "clean-v8" => "clean" do
+  sh "cd #{UPSTREAM} && make clean"
+end
+
+task :clean do
+  sh "rm -f ext/v8/Makefile"
+  sh "rm -rf pkg"
+end

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 */