therubyracer 0.4.7-x86-darwin-10

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

@@ -0,0 +1,169 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /opt/local/lib/ruby/1.8/i686-darwin10
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+exec_prefix = $(prefix)
+prefix = $(DESTDIR)/opt/local
+sharedstatedir = $(prefix)/com
+mandir = $(DESTDIR)/opt/local/share/man
+psdir = $(docdir)
+oldincludedir = $(DESTDIR)/usr/include
+localedir = $(datarootdir)/locale
+bindir = $(exec_prefix)/bin
+libexecdir = $(exec_prefix)/libexec
+sitedir = $(libdir)/ruby/site_ruby
+htmldir = $(docdir)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+includedir = $(prefix)/include
+infodir = $(datarootdir)/info
+vendorlibdir = $(vendordir)/$(ruby_version)
+sysconfdir = $(prefix)/etc
+libdir = $(exec_prefix)/lib
+sbindir = $(exec_prefix)/sbin
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+vendordir = $(DESTDIR)/opt/local/lib/ruby/vendor_ruby
+datarootdir = $(prefix)/share
+pdfdir = $(docdir)
+archdir = $(rubylibdir)/$(arch)
+sitearchdir = $(sitelibdir)/$(sitearch)
+datadir = $(datarootdir)
+localstatedir = $(prefix)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+
+CC = /usr/bin/gcc-4.2
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -fno-common -O2 -arch x86_64  -fno-common -pipe -fno-common $(cflags) -arch x86_64
+INCFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =  -I/Users/cowboyd/Projects/therubyracer/ext/v8/upstream/2.0.6/include -I/opt/local/include -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags) -Wall
+CXXFLAGS = $(CFLAGS) 
+ldflags  = -L. -L/opt/local/lib
+dldflags = 
+archflag = -arch x86_64
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = $(CC) -dynamic -bundle -undefined suppress -flat_namespace
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+arch = i686-darwin10
+sitearch = i686-darwin10
+ruby_version = 1.8
+ruby = /opt/local/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir) /Users/cowboyd/Projects/therubyracer/ext/v8/upstream/2.0.6
+LIBPATH =  -L. -L$(libdir) -L/Users/cowboyd/Projects/therubyracer/ext/v8/upstream/2.0.6
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lobjc  
+SRCS = callbacks.cpp convert_ruby.cpp convert_string.cpp convert_v8.cpp converters.cpp v8.cpp v8_cxt.cpp v8_func.cpp v8_msg.cpp v8_obj.cpp v8_ref.cpp v8_script.cpp v8_standalone.cpp v8_str.cpp v8_template.cpp
+OBJS = callbacks.o convert_ruby.o convert_string.o convert_v8.o converters.o v8.o v8_cxt.o v8_func.o v8_msg.o v8_obj.o v8_ref.o v8_script.o v8_standalone.o v8_str.o v8_template.o
+TARGET = v8
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	@-$(RM) $@
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h
+
+test: all
+	@echo running spec...
+	spec -O spec/spec.opts spec/therubyracer_spec.rb
+
+docs/cpp:
+	mkdir -p docs/cpp
+
+docs: all docs/cpp
+	@echo Generate C++ docs to docs/cpp/html
+	doxygen Doxyfile
+

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;
+}