mustang 0.0.1 → 0.1.0

data/ext/v8/v8_value.h

@@ -0,0 +1,19 @@
+#ifndef __V8_VALUE_H
+#define __V8_VALUE_H
+
+#include "v8_main.h"
+
+using namespace v8;
+
+/* V8::Value class */
+RUBY_EXTERN VALUE rb_cV8Value;
+/* V8::Primitive class */
+RUBY_EXTERN VALUE rb_cV8Primitive;
+
+/* API */
+Handle<Value> to_v8_value(VALUE value);
+VALUE rb_v8_value_new2(VALUE data);
+void Init_V8_Value();
+void Init_V8_Primitive();
+
+#endif//__V8_VALUE_H

data/gemspec.yml

@@ -1,5 +1,5 @@
 name: mustang
-version: 0.0.1
+version: 0.1.0
 summary: Awesome V8 JavaScript engine embedded into Ruby's shiny body.
 description:
   Ruby proxy library for Google V8 JavaScript engine. 
@@ -16,3 +16,4 @@ development_dependencies:
   ore-tasks: ~> 0.4
   rspec: ~> 2.0
   mocha: >= 0.9
+  rake-compiler: ~> 0.7

data/lib/core_ext/class.rb

@@ -0,0 +1,14 @@
+class Class
+  # Returns list of public instance methods of current class excluding methods
+  # inherited from the <tt>Object</tt>.
+  def declared_methods
+    klass, result = self, []
+
+    while not klass == Object
+      result += klass.instance_methods(false)
+      klass = klass.superclass
+    end
+
+    result
+  end
+end # Class

data/lib/core_ext/object.rb

@@ -0,0 +1,12 @@
+require 'v8'
+
+class Object
+  # From now on each object can be easily converted to <tt>V8::*</tt> object
+  # using <tt>#to_v8</tt> method. 
+  include V8::Cast
+
+  # Returns <tt>true</tt> when given object is reflected from within V8.
+  def v8?
+    kind_of?(V8::Data)
+  end
+end # Object

data/lib/core_ext/symbol.rb

@@ -0,0 +1,23 @@
+class Symbol
+  # Returns symbol with function name normalized for javascript. eg:
+  #
+  #   :foo.to_js_func_name     # => :foo
+  #   :'foo='.to_js_func_name  # => :set_foo
+  #   :'foo!'.to_js_func_name  # => :foo_bang
+  #   :'foo?'.to_js_func_name  # => :is_foo
+  #   :'+'.to_js_func_name     # => nil
+  #
+  def to_js_func_name
+    js = self.to_s
+    js = "set_#{js}" if js =~ /\=$/ 
+    js = "#{js}_bang" if js =~ /\!$/ 
+    js = "is_#{js}" if js =~ /\?$/ 
+    js = js.gsub(/[^\w\d\_]+/, "")
+
+    if js.empty? || (js == 'set_' && self.to_s != 'set_') 
+      return nil
+    else 
+      return js.to_sym
+    end
+  end
+end # Symbol

data/lib/mustang.rb

@@ -0,0 +1,44 @@
+require 'v8'
+require 'v8/context'
+require 'v8/object'
+require 'v8/string'
+require 'v8/integer'
+require 'v8/number'
+require 'v8/array'
+require 'v8/date'
+require 'v8/regexp'
+require 'v8/function'
+require 'v8/external'
+require 'v8/error'
+
+require 'support/delegated'
+
+require 'core_ext/object'
+require 'core_ext/class'
+require 'core_ext/symbol'
+
+require 'mustang/context'
+
+module Mustang
+  extend Delegated
+
+  def self.delegate
+    global
+  end
+
+  # Global context.
+  def self.global
+    @global or reset!
+  end
+
+  # Resets global context state. Appartently just creates new global
+  # context and enters it. 
+  def self.reset!(*args, &block)
+    @global = GlobalContext.new(*args, &block)
+  end
+
+  # We need enter into global context to avoid segfaults. Apart of my laziness
+  # keeping one global context is much easier than handling errors in all 
+  # V8 datatypes implementation... 
+  enter
+end # Mustang

data/lib/mustang/context.rb

@@ -0,0 +1,69 @@
+module Mustang
+  # Raised when file specified to load doesn't exist. 
+  class ScriptNotFoundError < Errno::ENOENT 
+  end
+
+  # Raised when try to exit from global context. 
+  class ImmortalContextError < RuntimeError
+  end
+
+  # Extended and more user-friendly version of <tt>Mustang::V8::Context</tt>.
+  class Context < V8::Context
+    # Evaluates given javascript source. Before evaluation it's able to
+    # set given local variables within current context, eg:
+    #
+    #   rt = Mustang::Context.new
+    #   rt.evaluate("foo=1")                     # => 1
+    #   rt.evaluate("bar=foo+spam", :spam => 10) # => 11
+    #   rt.evaliate("bar")                       # => 11
+    #
+    def evaluate(source, locals={}, filename="<eval>")
+      res = super(source, filename)
+      errors << res if res.v8? and res.error?
+      return res
+    end
+    alias_method :eval, :evaluate
+
+    # Loads and evaluates given list of javascript files, eg:
+    #
+    #   rt = Mustang::Runtime.new
+    #   rt.load("foo.js", "bar.js")
+    #
+    def load(*files)
+      files.map { |filename|
+        if File.exists?(filename)
+          evaluate(File.read(filename), {}, filename)
+        else
+          raise ScriptNotFoundError, "Script `#{filename}' does not exts."
+        end
+      }.last
+    end
+
+    # Returns list of errors encountered within this context. 
+    def errors
+      @errors ||= []
+    end
+
+    # Returns <tt>true</tt> when it is global (immortal) context.
+    def global?
+      false
+    end
+  end # Context
+
+  # This kind of context is used by <tt>Mustang</tt> module. 
+  class GlobalContext < Context
+    def initialize(*)
+      super 
+      enter
+    end
+
+    def exit
+      # We have to disable exit, because global context is immortal. 
+      raise ImmortalContextError, "Global context can't be exited"
+    end
+    
+    def global?
+      true
+    end
+  end # GlobalContext
+end # Mustang

data/lib/mustang/errors.rb

@@ -0,0 +1,36 @@
+require 'ostruct'
+
+module Mustang
+  # Javascript errors container. Its objects keeps list of errors encountered
+  # during code evaluation.
+  class Errors < Array
+    # Single error info entry.
+    class Error < OpenStruct; end
+
+    def initialize(runtime)
+      @runtime = runtime
+      super()
+    end
+
+    def push(errinfo)
+      errinfo = Error.new(errinfo)
+      print_error(errinfo) if @runtime.debug?
+      super(errinfo)
+    end
+
+    private
+    
+    def print_error(err)
+      $stderr.write("(JS) %s " % err.message)
+      if err.file and err.line
+        $stderr.write("in file `%s' at line %d\n" % [err.file, err.line])
+        if err.snippet and err.pos
+          $stderr.write("  %s\n  " % err.snippet)
+          err.pos.first.times { $stderr.write(" ") }
+          [(err.pos.first)..(err.pos.last)].each { $stderr.write("^") }
+          $stderr.write("\n")
+        end
+      end
+    end
+  end # Errors
+end # Mustang

data/lib/support/delegated.rb

@@ -0,0 +1,25 @@
+# Delegates all missing methods to object specified by <tt>#delegate</tt> method.
+module Delegated
+  alias_method :old_method_missing, :method_missing
+  alias_method :old_respond_to?, :respond_to?
+
+  def method_missing(meth, *args, &block) # :nodoc:
+    if (old_respond_to?(:delegate) && delegate.respond_to?(meth))
+      delegate.send(meth, *args, &block)
+    else
+      old_method_missing(meth, *args, &block)
+    end
+  end
+
+  def respond_to?(meth) # :nodoc:
+    if (old_respond_to?(:delegate))
+      delegate.respond_to?(meth) or old_respond_to?(meth)
+    else
+      old_respond_to?(meth)
+    end
+  end
+
+  def to_s # :nodoc:
+    delegate.to_s
+  end
+end # Delegated

data/lib/v8/array.rb

@@ -0,0 +1,21 @@
+require 'support/delegated'
+
+module V8
+  class Array
+    include Comparable
+    include Enumerable
+    include Delegated
+
+    def <=>(other)
+      to_a <=> other
+    end
+
+    def each(*args, &block)
+      to_a.each(*args, &block)
+    end
+
+    def delegate
+      to_a
+    end
+  end # Array
+end # V8

data/lib/v8/context.rb

@@ -0,0 +1,13 @@
+module V8
+  class Context
+    def get(key)
+      prototype[key]
+    end
+    alias_method :[], :get
+
+    def set(key, value)
+      prototype[key] = value
+    end
+    alias_method :[]=, :set
+  end # Context
+end # V8

data/lib/v8/date.rb

@@ -0,0 +1,20 @@
+require 'support/delegated'
+
+module V8
+  class Date
+    include Comparable
+    include Delegated
+
+    def to_time
+      Time.at(to_i);
+    end
+    
+    def <=>(other)
+      to_time <=> other
+    end
+
+    def delegate
+      to_time
+    end
+  end # Date
+end # V8

data/lib/v8/error.rb

@@ -0,0 +1,15 @@
+module V8
+  class Error
+    def inspect
+      "#{name}: #{message}"
+    end
+
+    def to_s
+      message
+    end
+
+    def name
+      self.class.name.delete("V8::")
+    end
+  end # Error
+end # V8

data/lib/v8/external.rb

@@ -0,0 +1,16 @@
+require 'support/delegated'
+
+module V8
+  class External
+    include Comparable
+    include Delegated
+
+    def <=>(other)
+      to_obj <=> other
+    end
+
+    def delegate
+      to_obj
+    end
+  end # External
+end # V8

data/lib/v8/function.rb

@@ -0,0 +1,11 @@
+module V8
+  class Function
+    def call(*args, &block)
+      call_on(@receiver, *args, &block);
+    end
+
+    def to_proc
+      origin.to_proc if origin
+    end
+  end # Function
+end # V8

data/lib/v8/integer.rb

@@ -0,0 +1,16 @@
+require 'support/delegated'
+
+module V8
+  class Integer
+    include Comparable
+    include Delegated
+
+    def <=>(other)
+      to_i <=> other
+    end
+
+    def delegate
+      to_i
+    end
+  end # Integer
+end # V8

data/lib/v8/number.rb

@@ -0,0 +1,16 @@
+require 'support/delegated'
+
+module V8
+  class Number
+    include Comparable
+    include Delegated
+
+    def <=>(other)
+      to_f <=> other
+    end
+
+    def delegate
+      to_f
+    end
+  end # Number
+end # V8

data/lib/v8/object.rb

@@ -0,0 +1,66 @@
+require 'support/delegated'
+
+module V8
+  class Object
+    class << self
+      alias_method :native_new, :new
+      
+      def new(*args, &block)
+        res = native_new(*args)
+        res.send(:reflect_from, args.first)        
+      end
+    end
+    
+    def respond_to?(meth)
+      !self[meth].undefined? or super
+    end
+
+    def method_missing(meth, *args, &block)
+      if respond_to?(meth)
+        property = self[meth]
+
+        if property.is_a?(V8::Function)
+          return property.call_on(self, *args, &block)
+        else
+          return property
+        end
+      end
+
+      super
+    end
+
+    include Comparable
+    include Enumerable
+    include Delegated
+
+    def to_hash
+      Hash[*keys.map {|key| [key.to_s, get(key)] }.flatten(1)]
+    end
+
+    def <=>(other)
+      to_hash <=> other
+    end
+
+    def each(*args, &block)
+      to_hash.each(*args, &block)
+    end
+
+    def delegate
+      to_hash
+    end
+
+    private
+
+    def reflect_from(obj)
+      if !obj.nil? and !obj.v8? and !obj.is_a?(Hash)
+        obj.class.declared_methods.each { |meth|
+          if func_name = meth.to_sym.to_js_func_name
+            func = set(func_name, obj.method(meth))
+            func.bind(obj)
+          end
+        }
+      end
+      self
+    end
+  end # Object
+end # V8