therubyracer 0.5.0-x86-linux → 0.11.0beta5-x86-linux

data/History.txt

@@ -1,51 +0,0 @@
-=== 0.5.0 2010-02-17
-* 1 major enhancement
-  * support for Linux 64 bit
-
-=== 0.4.9 2010-02-16
-* 1 major enhancement
-  * support for Linux 32 bit
-  
-=== 0.4.8 2010-02-08
-* 1 major enhancement
-  * 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

@@ -1,158 +0,0 @@
-= 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)
-* C++ compiler
-
-== 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/docs/data_conversion.txt

@@ -1,18 +0,0 @@
-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

@@ -1,160 +0,0 @@
-#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

@@ -1,14 +0,0 @@
-#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

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

data/ext/v8/convert_ruby.h

@@ -1,99 +0,0 @@
-#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_PTR(value));
-        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