therubyracer 0.4.0

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2009-12-14
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,48 @@
+Doxyfile
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+docs/data_conversion.txt
+ext/v8/convert_ruby.cpp
+ext/v8/convert_ruby.h
+ext/v8/convert_string.cpp
+ext/v8/convert_string.h
+ext/v8/convert_v8.cpp
+ext/v8/convert_v8.h
+ext/v8/converters.cpp
+ext/v8/converters.h
+ext/v8/extconf.rb
+ext/v8/v8.cpp
+ext/v8/v8_cxt.cpp
+ext/v8/v8_cxt.h
+ext/v8/v8_func.cpp
+ext/v8/v8_func.h
+ext/v8/v8_msg.cpp
+ext/v8/v8_msg.h
+ext/v8/v8_obj.cpp
+ext/v8/v8_obj.h
+ext/v8/v8_ref.cpp
+ext/v8/v8_ref.h
+ext/v8/v8_script.cpp
+ext/v8/v8_script.h
+ext/v8/v8_standalone.cpp
+ext/v8/v8_standalone.h
+ext/v8/v8_str.cpp
+ext/v8/v8_str.h
+ext/v8/v8_template.cpp
+ext/v8/v8_template.h
+lib/v8.rb
+lib/v8/context.rb
+lib/v8/object.rb
+lib/v8/to.rb
+script/console
+script/destroy
+script/generate
+spec/redjs/README.txt
+spec/redjs/jsapi_spec.rb
+spec/redjs_helper.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake
+therubyracer.gemspec

data/README.rdoc

@@ -0,0 +1,49 @@
+= therubyracer
+
+* http://github.com/cowboyd/therubyracer
+
+== DESCRIPTION:
+
+Embed the V8 Javascript interpreter into Ruby.
+
+== FEATURES/PROBLEMS:
+
+* Inspires fun.
+* Not close to production ready.
+
+== SYNOPSIS:
+
+  Check back in February 2009 for an alpha release.
+
+== REQUIREMENTS:
+
+* libv8 >= 0.4.0
+
+== INSTALL:
+
+* sudo gem install therubyracer
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIXME full name
+
+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,36 @@
+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
+
+Rake::ExtensionTask.new("v8", $hoe.spec) do |ext|
+  ext.lib_dir = "lib/v8"
+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/convert_ruby.cpp

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

data/ext/v8/convert_ruby.h

@@ -0,0 +1,106 @@
+#ifndef __convert_ruby_h__
+#define __convert_ruby_h__
+
+#include <ruby.h>
+#include <v8.h>
+#include "v8_ref.h"
+#include "v8_obj.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() {}
+
+
+    RET operator() (VALUE& value) {
+        switch (TYPE(value)) {
+        case T_FIXNUM:
+          return dest.pushInt(FIX2INT(value));
+        case T_FLOAT:
+          return dest.pushDouble(NUM2DBL(value));
+        case T_STRING:
+          return convertString(value);
+        case T_NIL:
+          return dest.pushNull();
+        case T_TRUE:
+          return dest.pushBool(true);
+        case T_FALSE:
+          return dest.pushBool(false);
+        case T_DATA:
+          VALUE clsProc = rb_eval("::Proc");
+          VALUE clsMethod = rb_eval("::Method");
+          VALUE smartMatch = rb_intern("===");
+          if (RTEST(rb_funcall(clsProc, smartMatch, value)) || RTEST(rbfuncall(clsMethod, smartMatch, value))) {
+            
+          }
+        }
+        return dest.pushUndefined();
+    }
+    
+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;
+    }
+    
+    VALUE pushObject(v8::Handle<v8::Object>& value) {
+      return V8_Ref_Create(V8_C_Object, value);
+    }
+};
+
+
+#endif

data/ext/v8/convert_string.cpp

@@ -0,0 +1,10 @@
+#include "convert_string.h"
+
+StringDest::StringDest() {
+}
+
+StringDest::~StringDest(){
+}
+
+const std::string StringDest::TRUE("true");
+const std::string StringDest::FALSE("false");

data/ext/v8/convert_string.h

@@ -0,0 +1,73 @@
+#ifndef __convert_string_h__
+#define __convert_string_h__
+
+#include "v8.h"
+#include <string>
+
+/**
+ * StringDest is a data type conversion destination that converts
+ * any argument into a string.  It should have all methods listed
+ * in data_conversion.txt so it can be used as a template argument
+ * for a conversion source class.
+ */
+class StringDest {
+
+public:
+    StringDest();
+    ~StringDest();
+
+    std::string pushString(const std::string& value) {
+        return value;
+    }
+
+#ifdef FIGURED_OUT_INT_ISSUES
+    const char* pushInt(int32_t value) {
+        char buffer[64];
+        std::sprintf(buffer, "%d", value);
+        convertedValue = buffer;
+        return convertedValue.c_str();
+    }
+#endif
+
+    std::string pushInt(int64_t value) {
+        char buffer[64];
+        std::sprintf(buffer, "%lld", value);
+        std::string convertedValue(buffer);   
+        return convertedValue;
+    }
+
+    std::string pushDouble(double value) {
+        char buffer[64];
+        std::sprintf(buffer, "%g", value);
+        std::string convertedValue(buffer);   
+        return convertedValue;
+    }
+
+    std::string pushBool(bool value) {
+        std::string convertedValue(value ? TRUE : FALSE);
+        return convertedValue;
+    }
+
+    std::string pushNull() {
+      printf("I bet we aren't even getting here<br/>");
+        return ""; // this kind of sucks
+    }
+    
+    std::string pushUndefined() {
+        return "undefined"; // this too
+    }
+
+private:
+
+    /**
+     * constant "true" used for pushBool
+     */
+    static const std::string TRUE;
+
+    /**
+     * constant "false" used for pushBool
+     */
+    static const std::string FALSE;
+};
+
+#endif

data/ext/v8/convert_v8.cpp

@@ -0,0 +1,9 @@
+#include "convert_v8.h"
+
+V8LocalDest::V8LocalDest() {
+    
+}
+
+V8LocalDest::~V8LocalDest() {
+    
+}

data/ext/v8/convert_v8.h

@@ -0,0 +1,113 @@
+#ifndef __convert_v8_h__
+#define __convert_v8_h__
+
+#include <v8.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string>
+
+template<class T, class R> class V8HandleSource {
+
+  T dest;
+
+ public:
+
+  V8HandleSource() {}
+  ~V8HandleSource() {}
+
+  R operator() (v8::Handle<v8::Value>& value) {
+    
+    if (value.IsEmpty()) {
+      return dest.pushNull();
+    }
+
+    if (value->IsUndefined()) {
+      return dest.pushNull();
+    }
+
+    if(value->IsNull()) {
+      return dest.pushNull();
+    }
+    
+    if(value->IsTrue()) {
+      return dest.pushBool(true);
+    }
+
+    if(value->IsFalse()) {
+      return dest.pushBool(false);
+    }
+
+    if(value->IsString()) {
+      v8::Local<v8::String> str = value->ToString();
+      char buffer[1024];
+      int strlen = str->Length();
+      std::string output(strlen, 0);
+      for (int total = 0; total < strlen;) {
+        int written = str->WriteAscii(buffer, total, 1024);
+        output.replace(total, written, buffer);
+        total += written;
+      }
+      return dest.pushString(output);
+    }
+
+    if(value->IsInt32()) {
+      return dest.pushInt(value->Int32Value());
+    }
+
+    if(value->IsNumber()) {
+      return dest.pushDouble(value->NumberValue());
+    }
+    
+    if (value->IsObject()) {
+      v8::Local<v8::Object> object(v8::Object::Cast(*value));
+      return dest.pushObject(object);
+    }
+    
+    return dest.pushNull();
+  }
+
+};
+
+/**
+ * StringDest is a data type conversion destination that converts
+ * any argument into a string.  It should have all methods listed
+ * in data_conversion.txt so it can be used as a template argument
+ * for a conversion source class.
+ */
+class V8LocalDest {
+
+public:
+    V8LocalDest();
+    ~V8LocalDest();
+
+    v8::Local<v8::Value> pushString(const std::string& value) {
+        return v8::Local<v8::Value>::New(v8::String::New(value.c_str()));
+    }
+
+    v8::Local<v8::Value> pushInt(int64_t value) {
+        return v8::Local<v8::Value>::New(v8::Integer::New(value));
+    }
+
+    v8::Local<v8::Value> pushDouble(double value) {
+        return v8::Local<v8::Value>::New(v8::Number::New(value));
+    }
+
+    v8::Local<v8::Value> pushBool(bool value) {
+        return v8::Local<v8::Value>::New(v8::Boolean::New(value));
+    }
+
+    v8::Local<v8::Value> pushNull() {
+      return v8::Local<v8::Value>::New(v8::Null());
+    }
+    
+    v8::Local<v8::Value> pushUndefined() {
+      return v8::Local<v8::Value>::New(v8::Undefined());
+    }
+    
+    // v8:Local<v8:Value> pushFunction(Function) {
+    //   
+    // }
+};
+
+
+#endif