mustang 0.0.1 → 0.1.0

data/lib/v8/regexp.rb

@@ -0,0 +1,23 @@
+require 'support/delegated'
+
+module V8
+  class Regexp
+    include Delegated
+
+    def ==(other)
+      to_regexp == other
+    end
+
+    def ===(other)
+      to_regexp == other
+    end
+
+    def delegate
+      to_regexp
+    end
+
+    def to_regexp
+      ::Regexp.new(source, options)
+    end
+  end # Regexp
+end # V8

data/lib/v8/string.rb

@@ -0,0 +1,27 @@
+require 'support/delegated'
+
+module V8
+  class String
+    # On ruby 1.9+ we have to force UTF-8 encoding here...
+    if RUBY_VERSION > "1.9"
+      alias_method :native_to_utf8, :to_utf8
+
+      def to_utf8
+        native_to_utf8.force_encoding("UTF-8")
+      end
+    end
+
+    alias_method :to_s, :to_utf8
+
+    include Comparable
+    include Delegated
+
+    def <=>(other)
+      to_s <=> other
+    end
+
+    def delegate
+      to_s
+    end
+  end # String
+end # V8

data/mustang.gemspec

@@ -2,6 +2,9 @@
 
 begin
   Ore::Specification.new do |gemspec|
+    gemspec.files += `git ls-files`
+    gemspec.extensions << "ext/mustang/extconf.rb"
+    gemspec.require_paths = ["lib", "ext"]
   end
 rescue NameError
   begin

data/spec/core_ext/class_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Class do
+  describe "#declared_methods" do
+    it "returns all defined and inherited methods but not defined in the Object" do
+      class First
+        attr_accessor :foo
+        def to_s; end
+      end
+
+      class Second < First
+        attr_reader :bar
+      end
+
+      First.declared_methods.should == [:foo, :foo=, :to_s]
+      Second.declared_methods.should == [:bar, :foo, :foo=, :to_s]
+    end
+  end
+end

data/spec/core_ext/object_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Object do
+  setup_context
+
+  it "includes V8::Cast module" do
+    Object.included_modules.should include(V8::Cast)
+  end
+
+  describe "#v8?" do
+    it "returns false when object is not reflection from v8" do
+      Object.new.should_not be_v8
+    end
+    
+    it "returns true when object is reflection from v8" do
+      V8::Integer.new(1).should be_v8
+    end
+  end
+end

data/spec/core_ext/symbol_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Class do
+  describe "#to_js_func_name" do
+    it "returns name without changes when is compatible with js" do
+      :foo.to_js_func_name.should == :foo
+    end
+
+    it "changes '=' for 'set_' prefix" do
+      :foo=.to_js_func_name.should == :set_foo
+    end
+
+    it "changes '?' for 'is_' prefix" do
+      :foo?.to_js_func_name.should == :is_foo
+    end
+
+    it "changes '!' for '_bang' suffix" do
+      :foo!.to_js_func_name.should == :foo_bang
+    end
+
+    it "returns nil when method name is unconvertable to javascript" do
+      [:+, :-, :%, :&, :*, :~, :=~, :/, :>, :<, :>>, :<<, :'=', :'==', :'===', :'<=>'].each { |meth|
+        meth.to_js_func_name.should_not be
+      }
+    end
+  end
+end

data/spec/fixtures/test1.js

@@ -0,0 +1,2 @@
+var foo = "test1";
+foo = foo+"foo";

data/spec/fixtures/test2.js

@@ -0,0 +1,2 @@
+var bar = "bar";
+bar = "test2"+bar;

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+require 'rspec'
+require 'mocha'
+require 'mustang'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end
+
+def debug
+  require 'ruby-debug'
+  debugger
+end
+
+def setup_context
+  let(:cxt) { V8::Context.new }
+  before { cxt.enter }
+  after { cxt.exit }
+end

data/spec/v8/array_spec.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Array do 
+  subject { V8::Array }
+  setup_context
+
+  it "inherits V8::Object" do
+    subject.new(1,2,3).should be_kind_of(V8::Object)
+  end  
+  
+  describe ".new" do
+    context "when no params given" do
+      it "creates empty array" do
+        ary = subject.new
+        ary.should be
+        ary.should == []
+      end
+    end
+    
+    context "when array given" do
+      it "creates v8 array based on it" do
+        ary = subject.new(1,2,3)
+        ary.should == [1,2,3]
+      end
+    end
+  end
+
+  describe "#length" do
+    it "returns size of array" do
+      subject.new(1,2).length.should == 2
+    end
+    
+    it "is aliased with #size" do
+      subject.new(1,2).size.should == 2
+    end
+  end
+
+  describe "#to_a" do
+    it "returns ruby array representation of referenced v8 array" do
+      subject.new(1,2).to_a.should == [1,2]
+    end
+  end
+
+  describe "#push" do
+    it "appends given object to array" do
+      ary = subject.new
+      ary.push("foo")
+      ary[0].should == "foo"
+    end
+
+    it "is aliased with #<<" do
+      ary = subject.new
+      ary.push("foo")
+      ary[0].should == "foo"
+    end
+  end
+
+  describe "an instance" do
+    it "is comparable" do
+      ary = subject.new(1,2,3)
+      ary.should == [1,2,3]
+      ary.should_not == [2,3,4]
+      ary.should > [1,2]
+      ary.should < [1,2,3,4]
+      ary.should <= [1,2,3,4]
+      ary.should >= [1,2,3]
+    end
+
+    it "is enumerable" do
+      res = []
+      ary = subject.new(1,2,3)
+      ary.each {|x| res << x }
+      res.should == [1,2,3]
+    end
+
+    it "is delegated properly" do
+      ary = subject.new(1,2,3)
+      ary.delegate.should == ary.to_a
+    end
+  end
+
+  describe "in context" do
+    it "object reflected twice should be explicitly the same" do
+      cxt.eval("foo = [1,2,3]", "<eval>")
+      cxt[:foo].object_id.should == cxt[:foo].object_id
+    end
+  end
+end

data/spec/v8/cast_spec.rb

@@ -0,0 +1,151 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Cast do
+  setup_context
+
+  describe "#to_v8" do
+    it "converts current object to v8 compilant" do
+      [1,2,3].to_v8.should be_kind_of(V8::Array)
+      1.to_v8.should be_kind_of(V8::Integer)
+      "foo".to_v8.should be_kind_of(V8::String)
+      (1.5).to_v8.should be_kind_of(V8::Number)
+      {:foo => 1}.to_v8.should be_kind_of(V8::Object)
+    end
+  end
+end
+
+describe "Typecasting" do
+  setup_context
+
+  context "from js to ruby" do
+    it "converts null properly" do
+      null = cxt.eval("null", "<eval>")
+      null.should == V8::Null
+      null.should be_null
+    end
+
+    it "converts undefined value to nil" do
+      undefined = cxt.eval("undefined", "<eval>")
+      undefined.should == V8::Undefined
+      undefined.should be_undefined
+    end
+
+    it "converts boolean values properly" do
+      cxt.eval("true", "<eval>").should be_true
+      cxt.eval("false", "<eval>").should be_false
+    end
+
+    it "converts strings properly" do
+      cxt.eval("'foo'", "<eval>").should == "foo"
+    end
+
+    it "converts integers properly" do
+      cxt.eval("1", "<eval>").should == 1
+      cxt.eval("-1", "<eval>").should == -1
+    end
+
+    it "converts float numbers properly" do
+      cxt.eval("1.4", "<eval>").should == 1.4
+    end
+
+    it "converts arrays properly" do
+      cxt.eval("[1,2,3]", "<eval>").should == [1,2,3]
+    end
+
+    it "converts objects properly" do
+      obj = cxt.eval("var o = {foo: 1, bar: 2, func: function() { return 1 }}; o", "<eval>")
+      obj[:foo].should == 1
+      obj[:bar].should == 2
+      obj[:func].should be_kind_of(V8::Function)
+    end
+
+    it "converts regexps properly" do
+      cxt.eval("/foo/i", "<eval>").should == /foo/i
+    end
+  end
+
+  context "from ruby to js" do
+    it "converts nil to null" do
+      cxt[:foo] = nil
+      cxt.eval("foo == null", "<eval>").should be
+    end
+
+    it "converts boolean values properly" do
+      cxt[:foo] = true
+      cxt[:bar] = false
+      cxt.eval("foo == true", "<eval>").should be
+      cxt.eval("bar == false", "<eval>").should be
+    end
+
+    it "converts strings properly" do
+      cxt[:foo] = "bar"
+      cxt.eval("foo == 'bar'", "<eval>").should be
+    end
+
+    it "converts integers properly" do
+      cxt[:foo] = 1
+      cxt[:bar] = -1
+      cxt.eval("foo == 1", "<eval>").should be
+      cxt.eval("bar == -1", "<eval>").should be
+    end
+
+    it "converts numbers properly" do
+      cxt[:foo] = 1.5
+      cxt.eval("foo == 1.5", "<eval>").should be
+    end
+
+    it "converts arrays properly" do
+      cxt[:foo] = [1,2,3] 
+      cxt.eval("foo[0] == 1", "<eval>").should be
+      cxt.eval("foo[1] == 2", "<eval>").should be
+      cxt.eval("foo[2] == 3", "<eval>").should be
+    end
+
+    it "converts procs and lambdas properly" do
+      cxt[:foo] = proc {|foo| "foo#{foo}" }
+      cxt[:bar] = lambda {|foo| "foo#{foo}" }
+      cxt.eval("foo('bar')", "<eval>").should == "foobar"
+      cxt.eval("bar('foo')", "<eval>").should == "foofoo"
+    end
+
+    it "converts hashes properly" do
+      cxt[:foo] = {:a => 1, :b => 2}
+      cxt.eval("foo.a == 1", "<eval>").should be
+      cxt.eval("foo.b == 2", "<eval>").should be
+    end
+
+    it "converts ranges properly" do
+      cxt[:foo] = 1..2
+      cxt.eval("foo[0] == 1", "<eval>").should be
+      cxt.eval("foo[1] == 2", "<eval>").should be
+    end
+
+    it "converts regexps properly" do
+      cxt[:foo] = /foo(bar)?/i
+      cxt.eval("'Foo'.match(foo);", "<eval>").should be
+      cxt.eval("'FooBAR'.match(foo);", "<eval>").should be
+      cxt.eval("'FoaaoBARaa'.match(foo);", "<eval>").should be_null
+    end
+    
+    it "converts time properly" do
+      cxt[:foo] = now = Time.now
+      cxt.eval("foo == #{Time.now.to_s}", "<eval>").should be
+    end
+
+    it "converts objects properly" do
+      class Obj
+        attr_accessor :bar
+        def foo(a); a+bar; end
+      end
+
+      cxt[:foo] = foo = Obj.new
+      cxt[:foo].bar.should be_null
+      cxt.eval("foo.bar()", "<eval>").should be_null
+      foo.bar = 1
+      cxt.eval("foo.bar()", "<eval>").should == 1
+      cxt.eval("foo.set_bar(2)", "<eval>");
+      foo.bar.should == 2
+      cxt.eval("foo.foo(2)", "<eval>").should == 4
+    end
+  end
+end

data/spec/v8/context_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Context do
+  describe "#evaluate" do
+    it "evaluates given javascript source" do
+      subject.evaluate("var a = 'foo'; a;", "<eval>").should == 'foo'
+    end
+
+    it "returns result converted to ruby object" do
+      result = subject.evaluate("'foo'", "<eval>")
+      result.should be_kind_of(V8::String)
+      result.to_s.should == 'foo'
+    end
+
+    it "is aliased by #eval" do
+      subject.eval("'foo'", "<eval>").should == 'foo'
+    end
+  end
+
+  describe "#[]" do
+    it "gets value of specified variable from the global prototype" do
+      subject.evaluate("var foo='bar'", "<eval>")
+      subject['foo'].should == 'bar'
+    end
+
+    it "is aliased by #get" do
+      subject.evaluate("var foo='bar'", "<eval>")
+      subject.get('foo').should == 'bar'
+    end
+  end
+
+  describe "#[]=" do
+    it "stores given variable within the global prototype" do
+      subject["foo"] = "bar"
+      subject.evaluate("foo", "<eval>").should == "bar"
+      subject[:spam] = :eggs
+      subject.evaluate("spam", "<eval>").should == "eggs"
+    end
+
+    it "is aliased by #set" do
+      subject.set(:foo, "bar")
+      subject.evaluate("foo", "<eval>").should == "bar"
+    end
+  end
+
+  describe "#global" do
+    it "returns the global object for current context" do
+      subject.global.should be_kind_of(V8::Object)
+    end
+  end
+
+  describe "#enter" do
+    subject { V8::Context.new }
+
+    context "when block given" do
+      it "enters to context evaluates passed block, and exits after execution" do
+        entered = false
+        subject.enter { |cxt| entered = cxt.entered? }
+        entered.should be_true
+        subject.should_not be_entered
+      end
+    end
+
+    context "when no block given" do
+      it "enters to context" do
+        subject.enter.should be_true
+        subject.should be_entered
+      end
+    end
+  end
+
+  describe "#exit" do
+    it "exits from context" do
+      subject.exit.should_not be
+      subject.should_not be_entered
+    end
+  end
+end