mustang 0.0.1 → 0.1.0

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Isolate

@@ -0,0 +1,9 @@
+# -*- ruby -*-
+
+gem "ore-tasks", "~> 0.4"
+
+env :development, :test do
+  gem "rspec", "~> 2.5"
+  gem "mocha", ">= 0.9"
+  gem "rake-compiler", "~> 0.7"
+end

data/README.md

@@ -1,18 +1,12 @@
 # Mustang - V8 engine in Ruby's body
 
 Mustang is ruby proxy library for awesome Google V8 JavaScript engine. 
-It embeds the V8 engine as a C++ extension (using Rice).
 
 ## Installation
 
-Using rubygems:
-
-    $ gem install mustang
-
-Manualy:
-
     $ git clone git://github.com/nu7hatch/mustang.git
     $ cd mustang
+    $ rake compile
     $ rake install
 
 ## Usage
@@ -21,10 +15,10 @@ For now it's only proof of concept. It implements very simple evaluation of java
 
     require 'mustang'
     
-    rt = Mustang::Runtime.new
-    rt.evaluate("'Hello' + ' World!';") # => 'Hello World!'
-    rt.evaluate("var a=1;")
-    rt.evaluate("a+5;") # => 6
+    cxt = Mustang::Context.new
+    cxt.eval("'Hello' + ' World!';") # => 'Hello World!'
+    cxt.eval("var a=1;")
+    cxt.eval("a+5;") # => 6
 
 ## Note on Patches/Pull Requests
  
@@ -36,6 +30,6 @@ For now it's only proof of concept. It implements very simple evaluation of java
   (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
-== Copyright
+## Copyright
 
 Copyright (c) 2010 Kriss 'nu7hatch' Kowalik. See LICENSE for details.

data/Rakefile

@@ -1,5 +1,11 @@
 # -*- ruby -*-
 
+begin 
+  require 'isolate/now'
+rescue LoadError
+  STDERR.puts "Run `gem install isolate` to install 'isolate'."
+end
+
 begin
   require 'ore/tasks'
   Ore::Tasks.new
@@ -7,22 +13,35 @@ rescue LoadError
   STDERR.puts "Run `gem install ore-tasks` to install 'ore/tasks'."
 end
 
+begin
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new("v8") do |ext|
+    ext.lib_dir = 'lib'
+    ext.source_pattern = "*.{cpp,h}"
+    #ext.config_options << '--with-v8-include'
+    #ext.config_options << '--with-v8-lib'
+  end
+rescue LoadError
+  STDERR.puts "Run `gem install rake-compiler` to install 'rake-compiler'."
+end
+
 begin
   require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = ENV['RSPEC_OPTS']
+  end
 rescue LoadError
   task :spec do
     abort 'Run `gem install rspec` to install RSpec'
   end
 end
 
-task :test => :spec
+task :test => [:clean, :compile, :spec]
 task :default => :test
 
-begin 
+begin
   require 'metric_fu'
 rescue LoadError
-  STDERR.puts "Run `gem install metric_fu` to install Metric-Fu"
 end
 
 require 'rake/rdoctask'
@@ -32,3 +51,10 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+task :init_mustang do
+  require 'mustang'
+  $c = Mustang::Context.new
+end 
+
+Rake::Task[:console].prerequisites << :init_mustang

data/TODO.md

@@ -0,0 +1,9 @@
+# TODO list
+
+* better exceptions handling
+* V8::Integer should inherit V8::Number
+* specs for Mustang's classes
+* specs for support modules
+* v8 debug stuff
+* support for ObjectTemplates
+* reflecting ruby classes to FunctionTemplates

data/ext/v8/extconf.rb

@@ -0,0 +1,56 @@
+require 'rbconfig'
+require 'mkmf'
+
+def darwin?
+  RUBY_PLATFORM =~ /darwin/
+end
+
+def cpu_x64?
+  unless defined?(RUBY_ENGINE) and RUBY_ENGINE == 'rbx'
+    !!(RbConfig::MAKEFILE_CONFIG['arch'] =~ /x86_64/ ||
+       RbConfig::MAKEFILE_CONFIG['target_cpu'] == 'x86_64' ||
+       RbConfig::MAKEFILE_CONFIG['build_cpu'] == 'x86_64' ||
+       RbConfig::MAKEFILE_CONFIG['ARCH_FLAG'] =~ /x86_64/)
+  else
+    ['x'].pack('y').size == 8
+  end
+end
+
+def make_sure_scons_installed!
+  unless `hash scons; echo $?`.to_i == 0
+    raise RuntimeError, "ERROR: To compile V8 engine you need to install the Scons library!"
+  end
+end
+
+def compile_v8!(v8_dir)
+  Dir.chdir v8_dir do 
+    if Dir["**/libv8.a"].empty?
+      make_sure_scons_installed!
+      defaults, ENV['CCFLAGS'] = ENV['CCFLAGS'], V8_FLAGS
+      build_cmd = "scons mode=release snapshot=off library=static arch=#{V8_ARCH}"
+      puts build_cmd
+      system build_cmd
+      ENV['CCFLAGS'] = defaults
+    end
+  end
+end
+
+V8_DIR = File.expand_path("../../../vendor/v8", __FILE__)
+V8_ARCH = cpu_x64? ? 'x64' : 'ia32' 
+V8_FLAGS = '-fPIC -fno-builtin-memcpy'
+           
+compile_v8!(V8_DIR)
+
+dir_config('mustang/v8')
+find_header('v8.h', File.join(V8_DIR, "include"))
+have_library('pthread')
+have_library('objc') if darwin?
+
+CONFIG['LDSHARED'] = '$(CXX) -shared' unless darwin?
+$LOCAL_LIBS << Dir[File.join(V8_DIR, "**/**/libv8.a")].first
+
+%w[-Wall -g -rdynamic -fPIC].each { |flag|
+  $CPPFLAGS += " #{flag}" unless $CPPFLAGS.include?(flag)
+}
+
+create_makefile('v8')

data/ext/v8/v8.cpp

@@ -0,0 +1,37 @@
+#include "v8_main.h"
+#include "v8_cast.h"
+#include "v8_base.h"
+#include "v8_context.h"
+#include "v8_value.h"
+#include "v8_object.h"
+#include "v8_string.h"
+#include "v8_integer.h"
+#include "v8_number.h"
+#include "v8_date.h"
+#include "v8_array.h"
+#include "v8_function.h"
+#include "v8_regexp.h"
+#include "v8_external.h"
+#include "v8_errors.h"
+
+extern "C" void Init_v8() {
+  Init_V8();
+  Init_V8_Cast();
+  Init_V8_Data();
+  Init_V8_Empty();
+  Init_V8_Undefined();
+  Init_V8_Null();
+  Init_V8_Context();
+  Init_V8_Value();
+  Init_V8_Primitive();
+  Init_V8_Object();
+  Init_V8_String();
+  Init_V8_Integer();
+  Init_V8_Number();
+  Init_V8_Date();
+  Init_V8_Array();
+  Init_V8_Function();
+  Init_V8_Regexp();
+  Init_V8_External();
+  Init_V8_Errors();
+}

data/ext/v8/v8_array.cpp

@@ -0,0 +1,161 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_object.h"
+#include "v8_string.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+VALUE rb_cV8Array;
+UNWRAPPER(Array);
+
+/* Typecasting helpers */
+
+Handle<Value> to_v8_array(VALUE value)
+{
+  HandleScope scope;
+  Local<Array> ary = Array::New();
+
+  for (int i = 0; i < RARRAY_LEN(value); i++) {
+    ary->Set(i, to_v8(rb_ary_entry(value, i)));
+  }
+  
+  return ary;
+}
+
+/* V8::Array methods */
+
+/*
+ * call-seq:
+ *   V8::Array.new         => new_array
+ *   V8::Array.new(array)  => new_array
+ *
+ * Returns a new V8 array.
+ *
+ */
+static VALUE rb_v8_array_new(VALUE klass, VALUE data)
+{
+  HandleScope scope;
+  VALUE ary = rb_funcall2(data, rb_intern("to_a"), 0, NULL);
+  VALUE self = v8_ref_new(klass, to_v8_array(ary));
+
+  v8_set_peer(self);
+  return self;
+}
+
+/*
+ * call-seq:
+ *   ary.to_a  => array
+ *
+ * Returns referenced array data represented as ruby array.
+ *
+ */
+static VALUE rb_v8_array_to_a(VALUE self)
+{
+  HandleScope scope;
+  VALUE ary = rb_ary_new();
+  Handle<Array> v8ary = unwrap(self);
+  
+  for (unsigned int i = 0; i < v8ary->Length(); i++) {
+    rb_ary_store(ary, i, to_ruby(v8ary->Get(i)));
+  }
+
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   ary[key]      => value
+ *   ary.get(key)  => value
+ *
+ * Returns value of specified array entry.
+ *
+ *   ary = cxt.evaluate("['foo', 'bar'];")
+ *   ary[0] # => 'foo'
+ *
+ */
+static VALUE rb_v8_array_get(VALUE self, VALUE key)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->Get(NUM2UINT(key)));
+}
+
+/*
+ * call-seq:
+ *   ary[key] = value     => value
+ *   ary.set(key, value)  => value
+ *
+ * Sets given value under specified key.
+ *
+ */
+static VALUE rb_v8_array_set(VALUE self, VALUE key, VALUE value)
+{
+  HandleScope scope;
+  Handle<Value> _value = to_v8(value);
+  unwrap(self)->Set(NUM2UINT(key), _value);  
+  return to_ruby(_value);
+}
+
+/*
+ * call-seq:
+ *   ary.push(value)  => value
+ *   ary << value     => value
+ *
+ * Appends given value to referenced array.
+ *
+ */
+static VALUE rb_v8_array_push(VALUE self, VALUE value)
+{
+  HandleScope scope;
+  Handle<Value> _value = to_v8(value);
+  Handle<Array> ary = unwrap(self);
+  ary->Set(ary->Length(), _value);  
+  return to_ruby(_value);
+}
+
+// TODO: #pop
+// TODO: #delete
+// TODO: #delete_key
+
+/*
+ * call-seq:
+ *   ary.length  => size
+ *   ary.size    => size
+ *
+ * Returns number of items stored in this array.
+ *
+ */
+VALUE rb_v8_array_length(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->Length());
+}
+
+/* Public constructors */
+
+VALUE rb_v8_array_new2(VALUE data)
+{
+  return rb_v8_array_new(rb_cV8Array, data);
+}
+
+VALUE rb_v8_array_new3()
+{
+  return rb_v8_array_new(rb_cV8Array, rb_ary_new());
+}
+
+
+/* V8::Array initializer. */
+void Init_V8_Array()
+{
+  rb_cV8Array = rb_define_class_under(rb_mV8, "Array", rb_cV8Object);
+  rb_define_singleton_method(rb_cV8Array, "new", RUBY_METHOD_FUNC(rb_v8_array_new), -2);
+  rb_define_method(rb_cV8Array, "to_a", RUBY_METHOD_FUNC(rb_v8_array_to_a), 0);
+  rb_define_method(rb_cV8Array, "[]", RUBY_METHOD_FUNC(rb_v8_array_get), 1);
+  rb_define_method(rb_cV8Array, "get", RUBY_METHOD_FUNC(rb_v8_array_get), 1);
+  rb_define_method(rb_cV8Array, "[]=", RUBY_METHOD_FUNC(rb_v8_array_set), 2);
+  rb_define_method(rb_cV8Array, "set", RUBY_METHOD_FUNC(rb_v8_array_set), 2);
+  rb_define_method(rb_cV8Array, "push", RUBY_METHOD_FUNC(rb_v8_array_push), 1);
+  rb_define_method(rb_cV8Array, "<<", RUBY_METHOD_FUNC(rb_v8_array_push), 1);
+  rb_define_method(rb_cV8Array, "length", RUBY_METHOD_FUNC(rb_v8_array_length), 0);
+  rb_define_method(rb_cV8Array, "size", RUBY_METHOD_FUNC(rb_v8_array_length), 0);  
+}

data/ext/v8/v8_array.h

@@ -0,0 +1,17 @@
+#ifndef __V8_ARRAY_H
+#define __V8_ARRAY_H
+
+#include "v8_main.h"
+
+using namespace v8;
+
+/* V8::Array class */
+RUBY_EXTERN VALUE rb_cV8Array;
+
+/* API */
+Handle<Value> to_v8_array(VALUE value);
+VALUE rb_v8_array_new2(VALUE data);
+VALUE rb_v8_array_new3();
+void Init_V8_Array();
+
+#endif//__V8_ARRAY_H

data/ext/v8/v8_base.cpp

@@ -0,0 +1,147 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_base.h"
+#include "v8_errors.h"
+#include "v8_value.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+VALUE rb_cV8Data;
+VALUE rb_cV8EmptyClass;
+VALUE rb_cV8UndefinedClass;
+VALUE rb_cV8NullClass;
+
+/* V8::Data methods */
+
+/*
+ * call-seq:
+ *   data.value?  => true or false
+ *
+ * Returns <code>true</code> when value is a javascript value..
+ *
+ */
+static VALUE rb_v8_data_value_p(VALUE self)
+{
+  return rb_obj_is_kind_of(self, rb_cV8Value);
+}
+
+/*
+ * call-seq:
+ *   data.error?  => true or false
+ *
+ * Returns <code>true</code> when value is a handled javascipt exception.
+ *
+ */
+static VALUE rb_v8_data_error_p(VALUE self)
+{
+  return rb_obj_is_kind_of(self, rb_eV8Error);
+}
+
+/*
+ * call-seq:
+ *   data.null?  => true or false
+ *
+ * Returns <code>true</code> when value is a javascipt null.
+ *
+ */
+static VALUE rb_v8_data_null_p(VALUE self)
+{
+  return rb_obj_is_kind_of(self, rb_cV8NullClass);
+}
+
+/*
+ * call-seq:
+ *   data.empty?  => true or false
+ *
+ * Returns <code>true</code> when value is empty.
+ *
+ */
+static VALUE rb_v8_data_empty_p(VALUE self)
+{
+  return rb_obj_is_kind_of(self, rb_cV8EmptyClass);
+}
+
+/*
+ * call-seq:
+ *   data.undefined?  => true or false
+ *
+ * Returns <code>true</code> when value is undefined.
+ *
+ */
+static VALUE rb_v8_data_undefined_p(VALUE self)
+{
+  return rb_obj_is_kind_of(self, rb_cV8UndefinedClass);
+}
+
+/* V8::Null methods */
+
+/*
+ * call-seq:
+ *   null.to_s  => "NULL"
+ *
+ */
+static VALUE rb_v8_null_to_s(VALUE self)
+{
+  return rb_str_new2("NULL");
+}
+
+/* V8::Empty methods */
+
+/*
+ * call-seq:
+ *   empty.to_s  => "Empty"
+ *
+ */
+static VALUE rb_v8_empty_to_s(VALUE self)
+{
+  return rb_str_new2("Empty");
+}
+
+/* V8::Undefined methods */
+
+/*
+ * call-seq:
+ *   undefined.to_s  => "Undefined"
+ *
+ */
+static VALUE rb_v8_undefined_to_s(VALUE self)
+{
+  return rb_str_new2("Undefined");
+}
+
+
+/* V8::Data initializer */
+void Init_V8_Data()
+{  
+  rb_cV8Data = rb_define_class_under(rb_mV8, "Data", rb_cObject);
+  rb_define_method(rb_cV8Data, "error?", RUBY_METHOD_FUNC(rb_v8_data_error_p), 0);
+  rb_define_method(rb_cV8Data, "null?", RUBY_METHOD_FUNC(rb_v8_data_null_p), 0);
+  rb_define_method(rb_cV8Data, "empty?", RUBY_METHOD_FUNC(rb_v8_data_empty_p), 0);
+  rb_define_method(rb_cV8Data, "undefined?", RUBY_METHOD_FUNC(rb_v8_data_undefined_p), 0);
+  rb_define_method(rb_cV8Data, "value?", RUBY_METHOD_FUNC(rb_v8_data_value_p), 0);
+}
+
+/* V8::Empty initializer */
+void Init_V8_Empty()
+{
+  rb_cV8EmptyClass = rb_define_class_under(rb_mV8, "EmptyClass", rb_cV8Data);
+  rb_define_method(rb_cV8EmptyClass, "to_s", RUBY_METHOD_FUNC(rb_v8_empty_to_s), 0);
+  rb_define_const(rb_mV8, "Empty", rb_funcall2(rb_cV8EmptyClass, rb_intern("new"), 0, NULL));
+}
+
+/* V8::Undefined initializer */
+void Init_V8_Undefined()
+{
+  rb_cV8UndefinedClass = rb_define_class_under(rb_mV8, "UndefinedClass", rb_cV8Data);
+  rb_define_method(rb_cV8UndefinedClass, "to_s", RUBY_METHOD_FUNC(rb_v8_undefined_to_s), 0);
+  rb_define_const(rb_mV8, "Undefined", rb_funcall2(rb_cV8UndefinedClass, rb_intern("new"), 0, NULL));
+}
+
+/* V8::Null initializer */
+void Init_V8_Null()
+{
+  rb_cV8NullClass = rb_define_class_under(rb_mV8, "NullClass", rb_cV8Data);
+  rb_define_method(rb_cV8NullClass, "to_s", RUBY_METHOD_FUNC(rb_v8_null_to_s), 0);  
+  rb_define_const(rb_mV8, "Null", rb_funcall2(rb_cV8NullClass, rb_intern("new"), 0, NULL));
+}