opal-wedge 0.9.0.dev

data/spec/opal/core/numeric/multiply_spec.rb

@@ -0,0 +1,9 @@
+describe "Numeric#*" do
+  it "returns self multiplied by the given Integer" do
+    (4923 * 2).should == 9846
+    (1342177 * 800).should == 1073741600
+    (65536 * 65536).should == 4294967296
+
+    (6712 * 0.25).should == 1678.0
+  end
+end

data/spec/opal/core/numeric/next_spec.rb

@@ -0,0 +1,9 @@
+describe "Numeric#next" do
+  it "returns the next larger positive Fixnum" do
+    2.next.should == 3
+  end
+
+  it "returns the next larger negative Fixnum" do
+    (-2).next.should == -1
+  end
+end

data/spec/opal/core/numeric/ord_spec.rb

@@ -0,0 +1,9 @@
+describe "Numeric#ord" do
+  it "returns self" do
+    20.ord.should == 20
+    40.ord.should == 40
+
+    0.ord.should == 0
+    (-10).ord.should == -10
+  end
+end

data/spec/opal/core/numeric/plus_spec.rb

@@ -0,0 +1,8 @@
+describe "Numeric#+" do
+  it "returns self plus the given Integer" do
+    (491 + 2).should == 493
+    (90210 + 10).should == 90220
+
+    (1001 + 5.219).should == 1006.219
+  end
+end

data/spec/opal/core/numeric/pred_spec.rb

@@ -0,0 +1,7 @@
+describe "Numeric#pred" do
+  it "returns the Integer equal to self - 1" do
+    0.pred.should == -1
+    (-1).pred.should == -2
+    20.pred.should == 19
+  end
+end

data/spec/opal/core/numeric/right_shift_spec.rb

@@ -0,0 +1,25 @@
+describe "Numeric#>> with n >> m" do
+  it "returns n shifted right m bits when n > 0, m > 0" do
+    (2 >> 1).should == 1
+  end
+
+  it "returns n shifted right m bits when n < 0, m > 0" do
+    (-2 >> 1).should == -1
+  end
+
+  it "returns 0 when n == 0" do
+    (0 >> 1).should == 0
+  end
+
+  it "returns n when n > 0, m == 0" do
+    (1 >> 0).should == 1
+  end
+
+  it "returns n when n < 0, m == 0" do
+    (-1 >> 0).should == -1
+  end
+
+  it "returns 0 when m > 0 and m == p where 2**p > n >= 2**(p-1)" do
+    (4 >> 3).should == 0
+  end
+end

data/spec/opal/core/numeric/step_spec.rb

@@ -0,0 +1,11 @@
+describe "Numeric#step" do
+  before :each do
+    ScratchPad.record []
+    @prc = lambda { |x| ScratchPad << x }
+  end
+
+  it "defaults to step = 1" do
+    1.step(5, &@prc)
+    ScratchPad.recorded.should == [1, 2, 3, 4, 5]
+  end
+end

data/spec/opal/core/numeric/succ_spec.rb

@@ -0,0 +1,9 @@
+describe "Numeric#succ" do
+  it "returns the next larger positive Fixnum" do
+    2.succ.should == 3
+  end
+
+  it "returns the next larger negative Fixnum" do
+    (-2).succ.should == -1
+  end
+end

data/spec/opal/core/numeric/times_spec.rb

@@ -0,0 +1,36 @@
+describe "Numeric#times" do
+  it "returns self" do
+    5.times {}.should == 5
+    9.times {}.should == 9
+    9.times { |n| n - 2 }.should == 9
+  end
+
+  it "yields each value from 0 to self - 1" do
+    a = []
+    9.times { |i| a << i }
+    (-2).times { |i| a << i }
+    a.should == [0, 1, 2, 3, 4, 5, 6, 7, 8]
+  end
+
+  it "skips the current iteration when encountering 'next'" do
+    a = []
+    3.times do |i|
+      next if i == 1
+      a << i
+    end
+    a.should == [0, 2]
+  end
+
+  it "skips all iterations when encountering 'break'" do
+    a = []
+    5.times do |i|
+      break if i == 3
+      a << i
+    end
+    a.should == [0, 1, 2]
+  end
+
+  it "skips all iterations when encountering break with an argument and returns that argument" do
+    9.times { break 2 }.should == 2
+  end
+end

data/spec/opal/core/numeric/to_f_spec.rb

@@ -0,0 +1,7 @@
+describe "Numeric#to_f" do
+  it "returns self converted to a Float" do
+    0.to_f.should == 0.0
+    (-500).to_f.should == -500.0
+    9_641_278.to_f.should == 9641278.0
+  end
+end

data/spec/opal/core/numeric/to_i_spec.rb

@@ -0,0 +1,7 @@
+describe "Numeric#to_i" do
+  it "returns self as an integer" do
+    10.to_i.should == 10
+    (-15).to_i.should == -15
+    3.142.to_i.should == 3
+  end
+end

data/spec/opal/core/numeric/to_json_spec.rb

@@ -0,0 +1,8 @@
+require 'json'
+
+describe "Numeric#to_json" do
+  it "returns a string representing the number" do
+    42.to_json.should == "42"
+    3.142.to_json.should == "3.142"
+  end
+end

data/spec/opal/core/numeric/to_s_spec.rb

@@ -0,0 +1,26 @@
+describe "Fixnum#to_s when given a base" do
+  it "returns self converted to a String in the given base" do
+    12345.to_s(2).should == "11000000111001"
+    12345.to_s(8).should == "30071"
+    12345.to_s(10).should == "12345"
+    12345.to_s(16).should == "3039"
+    95.to_s(16).should == "5f"
+    12345.to_s(36).should == "9ix"
+  end
+
+  it "raises an ArgumentError if the base is less than 2 or higher than 36" do
+    lambda { 123.to_s(-1) }.should raise_error(ArgumentError)
+    lambda { 123.to_s(0)  }.should raise_error(ArgumentError)
+    lambda { 123.to_s(1)  }.should raise_error(ArgumentError)
+    lambda { 123.to_s(37) }.should raise_error(ArgumentError)
+  end
+end
+
+describe "Numeric#to_s when no base given" do
+  it "returns self converted to a String using base 10" do
+    255.to_s.should == '255'
+    3.to_s.should == '3'
+    0.to_s.should == '0'
+    (-9002).to_s.should == '-9002'
+  end
+end

data/spec/opal/core/numeric/uminus_spec.rb

@@ -0,0 +1,9 @@
+describe "Numeric#-@" do
+  it "returns self as a negative value" do
+    2.send(:-@).should == -2
+    (-2).should == -2
+    (-268435455).should == -268435455
+    (--5).should == 5
+    (-8).send(:-@).should == 8
+  end
+end

data/spec/opal/core/numeric/upto_spec.rb

@@ -0,0 +1,19 @@
+describe "Numeric#upto [stop] when self and stop are Fixnums" do
+  it "does not yield when stop is less than self" do
+    result = []
+    5.upto(4) { |x| result << x }
+    result.should == []
+  end
+
+  it "yields once when stop equals self" do
+    result = []
+    5.upto(5) { |x| result << x }
+    result.should == [5]
+  end
+
+  it "yields while increasing self until it is less than stop" do
+    result = []
+    2.upto(5) { |x| result << x }
+    result.should == [2, 3, 4, 5]
+  end
+end

data/spec/opal/core/numeric/zero_spec.rb

@@ -0,0 +1,7 @@
+describe "Numeric#zero?" do
+  it "returns true if self is 0" do
+    0.zero?.should == true
+    (-1).zero?.should == false
+    1.zero?.should == false
+  end
+end

data/spec/opal/core/object_id_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "Opal.uid()" do
+  it "returns even sequential numbers in increments of 2" do
+    %x{
+      var id0 = Opal.uid(),
+          id1 = Opal.uid(),
+          id2 = Opal.uid(),
+          id3 = Opal.uid(),
+          id4 = Opal.uid();
+    }
+
+    modulo = `id0` % 2
+    modulo.should == 0
+
+    `id1`.should == `id0` + 2
+    `id2`.should == `id0` + 4
+    `id3`.should == `id0` + 6
+    `id4`.should == `id0` + 8
+  end
+end
+
+describe "FalseClass#object_id" do
+  it "returns 0" do
+    false.object_id.should == 0
+  end
+end
+
+describe "TrueClass#object_id" do
+  it "returns 2" do
+    true.object_id.should == 2
+  end
+end
+
+describe "NilClass#object_id" do
+  it "returns 4" do
+    nil.object_id.should == 4
+  end
+end
+
+describe "Numeric#object_id" do
+  it "returns (self * 2) + 1" do
+    0.object_id.should == 1
+    1.object_id.should == 3
+    2.object_id.should == 5
+    420.object_id.should == 841
+    -2.object_id.should == -3
+    -1.object_id.should == -1
+  end
+end
+
+describe "String#object_id" do
+  it "returns the primitive string version of self" do
+    `#{"hello".object_id} === "hello".toString()`.should be_true
+  end
+end

data/spec/opal/core/proc/call_spec.rb

@@ -0,0 +1,21 @@
+describe "Proc#call" do
+  it "invokes self" do
+    Proc.new { "test!" }.call.should == "test!"
+    lambda { "test!" }.call.should == "test!"
+    proc { "test!" }.call.should == "test!"
+  end
+
+  it "sets self's parameters to the given values" do
+    Proc.new { |a, b| a + b }.call(1, 2).should == 3
+    Proc.new { |*args| args }.call(1, 2, 3, 4).should == [1, 2, 3, 4]
+    Proc.new { |_, *args| args }.call(1, 2, 3).should == [2, 3]
+
+    lambda { |a, b| a + b }.call(1, 2).should == 3
+    lambda { |*args| args }.call(1, 2, 3, 4).should == [1, 2, 3, 4]
+    lambda { |_, *args| args }.call(1, 2, 3).should == [2, 3]
+
+    proc { |a, b| a + b }.call(1, 2).should == 3
+    proc { |*args| args }.call(1, 2, 3, 4).should == [1, 2, 3, 4]
+    proc { |_, *args| args }.call(1, 2, 3).should == [2, 3]
+  end
+end

data/spec/opal/core/proc/element_reference_spec.rb

@@ -0,0 +1,21 @@
+describe "Proc#[]" do
+  it "invokes self" do
+    Proc.new { "test!" }[].should == "test!"
+    lambda { "test!" }[].should == "test!"
+    proc { "test!" }[].should == "test!"
+  end
+
+  it "sets self's parameters to the given values" do
+    Proc.new { |a, b| a + b }[1, 2].should == 3
+    Proc.new { |*args| args }[1, 2, 3, 4].should == [1, 2, 3, 4]
+    Proc.new { |_, *args| args }[1, 2, 3].should == [2, 3]
+
+    lambda { |a, b| a + b }[1, 2].should == 3
+    lambda { |*args| args }[1, 2, 3, 4].should == [1, 2, 3, 4]
+    lambda { |_, *args| args }[1, 2, 3].should == [2, 3]
+
+    proc { |a, b| a + b }[1, 2].should == 3
+    proc { |*args| args }[1, 2, 3, 4].should == [1, 2, 3, 4]
+    proc { |_, *args| args }[1, 2, 3].should == [2, 3]
+  end
+end

data/spec/opal/core/proc/proc_tricks_spec.rb

@@ -0,0 +1,7 @@
+describe 'Proc' do
+  describe '#new' do
+    it 'is not a lambda' do
+      Proc.new {}.lambda?.should == false
+    end
+  end
+end

data/spec/opal/core/runtime/begin_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe "Begin block" do
+  it "can be used as an expression" do
+    foo = begin
+            self.class
+            200
+          end
+
+    foo.should == 200
+
+    begin
+      self.class
+      42
+    end.should == 42
+
+    begin
+      3.142
+    end.should == 3.142
+  end
+
+  it "can be used as part of an optional assignment" do
+    count = 0
+    foo = nil
+
+    runner = proc do
+      foo ||= begin
+                count += 1
+                count
+              end
+    end
+
+    runner.call
+    foo.should == 1
+
+    runner.call
+    foo.should == 1
+  end
+end

data/spec/opal/core/runtime/block_send_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+class RuntimeOpalBlockSendSpec
+  def simple
+    42
+  end
+
+  def yielder(&block)
+    yield 3.142
+  end
+end
+
+describe "Opal.block_send()" do
+  before do
+    @obj = RuntimeOpalBlockSendSpec.new
+  end
+
+  it "calls receiver with given method" do
+    `Opal.block_send(#{@obj}, 'simple')`.should == 42
+  end
+
+  it "calls method with given block" do
+    val = nil
+    p = proc { |a| val = a }
+    `Opal.block_send(#{@obj}, 'yielder', p)`
+    val.should == 3.142
+  end
+end

data/spec/opal/core/runtime/block_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "Blocks" do
+  it "accept default arguments" do
+    proc { |a, b = 100| [a, b] }.call(:foo, :bar).should == [:foo, :bar]
+    proc { |a, b = 100| [a, b] }.call(:foo).should == [:foo, 100]
+  end
+
+  it "the block variable can be optionally overwritten without destroying original block reference" do
+    klass = Class.new { def foo(&block); block = 100 if false; block; end }
+    klass.new.foo {}.should be_kind_of(Proc)
+  end
+
+  it "can accept a block" do
+    proc { |&b| b }.call(&:to_s).should be_kind_of(Proc)
+  end
+
+  it "does not cache block between invocations" do
+    p = proc { |&b| b }
+    p.call(&:to_s).should be_kind_of(Proc)
+    p.call.should be_nil
+  end
+end

data/spec/opal/core/runtime/bridged_classes_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+%x{
+  var bridge_class_demo = function(){};
+  bridge_class_demo.prototype.$foo = function() { return "bar" };
+}
+class TopBridgedClassDemo < `bridge_class_demo`
+  def some_bridged_method
+    [1, 2, 3]
+  end
+end
+
+describe "Bridged Classes" do
+  describe "Passing native constructor to class keyword" do
+    before do
+      @bridged = ::TopBridgedClassDemo
+      @instance = `new bridge_class_demo()`
+    end
+
+    it "should expose the given class at the top level scope" do
+      @bridged.should be_kind_of(Class)
+    end
+
+    it "gives the class the correct name" do
+      @bridged.name.should == "TopBridgedClassDemo"
+    end
+
+    it "should have all BasicObject methods defined" do
+      @instance.should respond_to(:instance_eval)
+      @bridged.new.should respond_to(:==)
+    end
+
+    it "should have all Object methods defined" do
+      @instance.should respond_to(:class)
+      @bridged.new.should respond_to(:singleton_class)
+    end
+
+    it "instances of class should be able to call native ruby methods" do
+      @instance.foo.should == "bar"
+      @bridged.new.foo.should == "bar"
+    end
+
+    it "allows new methods to be defined on the bridged prototype" do
+      @instance.some_bridged_method.should == [1, 2, 3]
+      @bridged.new.some_bridged_method.should == [1, 2, 3]
+    end
+  end
+
+  describe ".instance_methdods" do
+    it "should report methods for class" do
+      Array.instance_methods(false).should include(:shift)
+    end
+
+    it "should not include methods donated from Object/Kernel" do
+      Array.instance_methods(false).should_not include(:class)
+    end
+
+    it "should not include methods donated from BasicObject" do
+      Array.instance_methods(false).should_not include(:__send__)
+      Array.instance_methods(false).should_not include(:send)
+    end
+  end
+end
+
+class ModularizedBridgeClass
+  def something
+    'different module'
+  end
+end
+
+%x{
+  var bridge_class_demo_module = function(){};
+  bridge_class_demo_module.prototype.$foo = function() { return "foobar" };
+}
+
+module BridgeModule
+  class ModularizedBridgeClass < `bridge_class_demo_module`
+    def some_bridged_method
+      [4, 5, 6]
+    end
+  end
+end
+
+describe 'Bridged classes in different modules' do
+  before do
+    @bridged = BridgeModule::ModularizedBridgeClass
+    @instance = `new bridge_class_demo_module()`
+  end
+  
+  it "should expose the given class not at the top level scope" do
+    @bridged.should be_kind_of(Class)
+  end
+  
+  it 'should not disturb an existing class at the top level scope' do
+    ModularizedBridgeClass.new.something.should == 'different module'
+  end
+
+  it "gives the class the correct name" do
+    @bridged.name.should == "BridgeModule::ModularizedBridgeClass"
+  end
+
+  it "instances of class should be able to call native ruby methods" do
+    @instance.foo.should == "foobar"
+    @bridged.new.foo.should == "foobar"
+  end
+
+  it "allows new methods to be defined on the bridged prototype" do
+    @instance.some_bridged_method.should == [4, 5, 6]
+    @bridged.new.some_bridged_method.should == [4, 5, 6]
+  end
+end