opal 0.3.18 → 0.3.19

data/test/core/string/swapcase_spec.rb

@@ -0,0 +1,18 @@
+describe "String#swapcase" do
+  it "returns a new string with all uppercase chars from self converted to lowercase and vice versa" do
+    "Hello".swapcase.should == "hELLO"
+    "cYbEr_PuNk11".swapcase.should == "CyBeR_pUnK11"
+    "+++---111222???".swapcase.should == "+++---111222???"
+  end
+
+  it "is locale insensitive (only upcases a-z and only downcases A-Z" do
+    "ÄÖÜ".swapcase.should == "ÄÖÜ"
+    "ärger".swapcase.should == "äRGER"
+    "BÄR".swapcase.should == "bÄr"
+  end
+
+  it "returns subclass instances when called on a subclass" do
+    StringSpecs::MyString.new("").swapcase.should be_kind_of(StringSpecs::MyString)
+    StringSpecs::MyString.new("hello").swapcase.should be_kind_of(StringSpecs::MyString)
+  end
+end

data/test/core/string/to_a_spec.rb

@@ -0,0 +1,9 @@
+describe "String#to_a" do
+  it "returns an empty array for empty strings" do
+    "".to_a.should == []
+  end
+
+  it "returns an array containing the string for non-empty strings" do
+    "hello".to_a.should == ["hello"]
+  end
+end

data/test/core/string/to_f_spec.rb

@@ -0,0 +1,14 @@
+describe "String#to_f" do
+  it "treats leading characters of self as a floating point number" do
+    "45.67 degress".to_f.should == 45.67
+    "0".to_f.should == 0.0
+
+    ".5".to_f.should == 0.5
+    "5e".to_f.should == 5.0
+    "5E".to_f.should == 5.0
+  end
+
+  it "treats special float value strings as characters" do
+    "NaN".to_f.should == 0
+  end
+end

data/test/core/string/to_i_spec.rb

@@ -0,0 +1,25 @@
+describe "String#to_i" do
+  it "returns 0 for strings with leading underscores" do
+    "_123".to_i.should == 0
+  end
+
+  it "ignores subsequent invalid characters" do
+    "123asdf".to_i.should == 123
+    "123#123".to_i.should == 123
+    "123 456".to_i.should == 123
+  end
+
+  it "interprets leading characters as a number in the given base" do
+    "10110010010".to_i(2).should == 1426
+    "100110201001".to_i(3).should == 186409
+    "103110201001".to_i(4).should == 5064769
+    "103110241001".to_i(5).should == 55165126
+    "153110241001".to_i(6).should == 697341529
+    "153160241001".to_i(7).should == 3521513430
+    "153160241701".to_i(8).should == 14390739905
+    "853160241701".to_i(9).should == 269716550518
+    "853160241791".to_i(10).should == 853160241791
+
+    "5e10".to_i.should == 5
+  end
+end

data/test/core/string/to_s_spec.rb

@@ -0,0 +1,13 @@
+describe "String#to_s" do
+  it "returns self when self.class == String" do
+    a = "a string"
+    a.should equal(a.to_s)
+  end
+
+  it "returns a new instance of String when called on a subclass" do
+    a = StringSpecs::MyString.new("a string")
+    s = a.to_s
+    s.should == "a string"
+    s.should be_kind_of(String)
+  end
+end

data/test/core/string/to_str_spec.rb

@@ -0,0 +1,13 @@
+describe "String#to_str" do
+  it "returns self when self.class == String" do
+    a = "a string"
+    a.should equal(a.to_str)
+  end
+
+  it "returns a new instance of String when called on a subclass" do
+    a = StringSpecs::MyString.new("a string")
+    s = a.to_str
+    s.should == "a string"
+    s.should be_kind_of(String)
+  end
+end

data/test/core/string/to_sym_spec.rb

@@ -0,0 +1,9 @@
+describe "String#to_sym" do
+  it "returns the symbol corresponding to self" do
+    "Koala".to_sym.should == :Koala
+    'cat'.to_sym.should == :cat
+    '@cat'.to_sym.should == :@cat
+    'cat and dog'.to_sym.should == :"cat and dog"
+    "abc=".to_sym.should == :abc=
+  end
+end

data/test/core/string/upcase_spec.rb

@@ -0,0 +1,6 @@
+describe "String#upcase" do
+  it "returns a copy of self with all lowercase letters upcased" do
+    "Hello".upcase.should == "HELLO"
+    "hello".upcase.should == "HELLO"
+  end
+end

data/test/core/symbol/to_proc_spec.rb

@@ -0,0 +1,12 @@
+describe "Symbol#to_proc" do
+  it "returns a new Proc" do
+    proc = :to_s.to_proc
+    proc.should be_kind_of(Proc)
+  end
+
+  it "sends self to arguments passed when calling #call on the proc" do
+    obj = Object.new
+    def obj.to_s; "Received #to_s"; end
+    :to_s.to_proc.call(obj).should == "Received #to_s"
+  end
+end

data/test/index.html

@@ -0,0 +1,11 @@
+<!doctype html>
+<html>
+<head>
+  <title></title>
+</head>
+<body>
+  <script type="text/javascript" src="../build/opal.js"></script>
+  <script type="text/javascript" src="../build/opal-spec.js"></script>
+  <script type="text/javascript" src="../build/opal.specs.js"></script>
+</body>
+</html>

data/{core/spec → test}/language/alias_spec.rb

@@ -20,4 +20,8 @@ describe "The alias keyword" do
     end
     @obj.__value.should == 5
   end
+
+  it "FIXME" do
+    raise Exception, "remaining examples should be added once bug in alias for blocks is fixed"
+  end
 end

data/test/language/fixtures/yield.rb

@@ -0,0 +1,23 @@
+module YieldSpecs
+  class Yielder
+    def z
+      yield
+    end
+
+    def s(a)
+      yield(a)
+    end
+
+    def m(a, b, c)
+      yield(a, b, c)
+    end
+
+    def r(a)
+      yield(*a)
+    end
+
+    def rs(a, b, c)
+      yield(a, b, *c)
+    end
+  end
+end

data/test/language/literal_lambda_spec.rb

@@ -0,0 +1,47 @@
+describe "->(){}" do
+  it "can be specified as a literal" do
+    lambda { ->(){} }.call
+  end
+
+  it "returns a Proc object" do
+    ->(){}.should be_kind_of(Proc)
+  end
+
+  it "returns a lambda" do
+    ->(){}.lambda?.should be_true
+  end
+
+  it "can be assigned to a variable" do
+    var = ->(){}
+    var.lambda?.should be_true
+  end
+
+  it "understands a do/end block in place of {}" do
+    lambda do
+      ->() do
+      end
+    end.call
+  end
+
+  it "can be interpolated into a String" do
+    "1+2=#{->{ 1 + 2 }.call}".should == "1+2=3"
+  end
+
+  it "can be used as a Hash key" do
+    h = {}
+    h[->(){ 1 + 2 }.call] = :value
+    h.key?(3).should be_true
+  end
+
+  it "can be used in method parameter lists" do
+    def glark7654(a=-> { :foo })
+      a.call
+    end
+    glark7654.should == :foo
+  end
+
+  it "accepts an paramter list between the paranthesis" do
+    lambda { ->(a) {} }.call
+    lambda { ->(a,b) {} }.call
+  end
+end

data/test/language/yield_spec.rb

@@ -0,0 +1,100 @@
+describe "The yield call" do
+  before :each do
+    @y = YieldSpecs::Yielder.new
+  end
+
+  describe "taking no arguments" do
+    it "raises a LocalJumpError when the method is not passed a block" do
+      lambda { @y.z }.should raise_error(LocalJumpError)
+    end
+  end
+
+  describe "taking a single argument" do
+    it "raises a LocalJumpError when the method is not passed a block" do
+      lambda { @y.s(1) }.should raise_error(LocalJumpError)
+    end
+
+    it "passes an empty Array when the argument is an empty Array" do
+      @y.s([]) { |*a| a }.should == [[]]
+    end
+
+    it "passes nil as a value" do
+      @y.s(nil) { |*a| a }.should == [nil]
+    end
+
+    it "passes a single value" do
+      @y.s(1) { |*a| a }.should == [1]
+    end
+
+    it "passes a single, multi-value Array" do
+      @y.s([1, 2, 3]) { |*a| a }.should == [[1, 2, 3]]
+    end
+  end
+
+  describe "taking multiple arguments" do
+    it "raises a LocalJumpError when the method is not passed a block" do
+      lambda { @y.m(1, 2, 3) }.should raise_error(LocalJumpError)
+    end
+
+    it "passes the arguments to the block" do
+      @y.m(1, 2, 3) { |*a| a }.should == [1, 2, 3]
+    end
+  end
+
+  describe "taking a single splatted argument" do
+    it "raises a LocalJumpError when the method is not passed a block" do
+      lambda { @y.r(0) }.should raise_error(LocalJumpError)
+    end
+
+    it "passes a single value" do
+      @y.r(1) { |*a| a }.should == [1]
+    end
+
+    it "passes no arguments when the argument is an empty array" do
+      @y.r([]) { |*a| a }.should == []
+    end
+
+    it "passes the value when the argument is an Array containing a single value" do
+      @y.r([1]) { |*a| a }.should == [1]
+    end
+
+    it "passes the values of the Array as individual arguments" do
+      @y.r([1, 2, 3]) { |*a| a }.should == [1, 2, 3]
+    end
+
+    it "passes the element of a single element Array" do
+      @y.r([[1, 2]]) { |*a| a }.should == [[1, 2]]
+      @y.r([nil]) { |*a| a }.should == [nil]
+      @y.r([[]]) { |*a| a }.should == [[]]
+    end
+
+    it "passes nil as a value" do
+      @y.r(nil) { |*a| a }.should == [nil]
+    end
+  end
+
+  describe "taking multiple arguments with a splat" do
+    it "raises a LocalJumpError when the method is not passed a block" do
+      lambda { @y.rs(1, 2, [3, 4]) }.should raise_error(LocalJumpError)
+    end
+
+    it "passes the arguments to the block" do
+      @y.rs(1, 2, 3) { |*a| a }.should == [1, 2, 3]
+    end
+
+    it "does not pass an argument value if the splatted argument is an empty Array" do
+      @y.rs(1, 2, []) { |*a| a }.should == [1, 2]
+    end
+
+    it "passes the Array elements as arguments if the splatted argument is a non-empty Array" do
+      @y.rs(1, 2, [3]) { |*a| a }.should == [1, 2, 3]
+      @y.rs(1, 2, [nil]) { |*a| a }.should == [1, 2, nil]
+      @y.rs(1, 2, [[]]) { |*a| a }.should == [1, 2, []]
+      @y.rs(1, 2, [3, 4, 5]) { |*a| a }.should == [1, 2, 3, 4, 5]
+    end
+
+    it "passes nil as the argument value if the splatted argument is nil" do
+      @y.rs(1, 2, nil) { |*a| a }.should == [1, 2, nil]
+    end
+  end
+end

data/test/opal/array/subclassing_spec.rb

@@ -0,0 +1,32 @@
+class ArraySubclassSpec < Array
+  def add_val(val)
+    `this.push(val)`
+    self
+  end
+
+  def foo
+    :bar
+  end
+end
+
+describe "Array subclasses" do
+  it "should have their defined methods present on instances" do
+    ArraySubclassSpec.new.foo.should == :bar
+  end
+
+  it "should correctly keep their length" do
+    arr = ArraySubclassSpec.new
+    arr.add_val :foo
+    arr.length.should == 1
+  end
+
+  it "should have the correct class" do
+    ArraySubclassSpec.new.class.should == ArraySubclassSpec
+    Array.new.class.should == Array
+  end
+
+  it "is just an instance of the bridged constructor" do
+    arr = ArraySubclassSpec.new
+    `(arr.constructor === Array)`.should == true
+  end
+end

data/test/opal/class/bridge_class_spec.rb

@@ -0,0 +1,37 @@
+%x{
+  var BridgeClassProto = function() {
+    this.foo = 200;
+  };
+
+  BridgeClassProto.prototype = {
+    bar: 300,
+    baz: 400
+  };
+}
+
+class BridgeClassSpec < `BridgeClassProto`
+  def get_foo
+    `this.foo`
+  end
+
+  def say_it
+    "hello world"
+  end
+end
+
+describe "Bridging native prototypes to a class" do
+  it "should have a superclass of Object" do
+    BridgeClassSpec.superclass.should == Object
+  end
+
+  it "should report instances as kind of bridged class" do
+    obj = `new BridgeClassProto()`
+    obj.should be_kind_of(BridgeClassSpec)
+  end
+
+  it "should have defined instance methods present on prototype" do
+    obj = `new BridgeClassProto()`
+    obj.get_foo.should == 200
+    obj.say_it.should == "hello world"
+  end
+end