opal 0.0.1 → 0.1.0

data/opals/opal/spec/core/false/to_s_spec.rb

@@ -0,0 +1,6 @@
+
+describe "FalseClass#to_s" do
+  it "returns the string 'false'" do
+    false.to_s.should == "false"
+  end
+end

data/opals/opal/spec/core/false/xor_spec.rb

@@ -0,0 +1,10 @@
+
+describe "FalseClass#^" do
+  it "returns false if other is nil or false, otherwise true" do
+    (false ^ false).should == false
+    (false ^ true).should == true
+    (false ^ nil).should == false
+    (false ^ "").should == true
+    (false ^ 'x').should == true
+  end
+end

data/opals/opal/spec/core/file/join_spec.rb

@@ -0,0 +1,19 @@
+
+describe "File.join" do
+  it "returns an empty string when given no arguments" do
+    File.join.should == ""
+  end
+  
+  it "when given a single argument returns an equal string" do
+    File.join("").should == ""
+    File.join("usr").should == "usr"
+  end
+  
+  it "joins parts using File::SEPARATOR" do
+    File.join('usr', 'bin').should == 'usr/bin'
+  end
+  
+  it "supports any number of arguments" do
+    File.join("a", "b", "c", "d").should == "a/b/c/d"
+  end
+end

data/opals/opal/spec/core/kernel/loop_spec.rb

@@ -0,0 +1,24 @@
+
+describe "Kernel.loop" do
+  it "calls block until it is terminated by a break" do
+    i = 0
+    loop do
+      i = i + 1
+      break if i == 10
+    end
+    
+    i.should == 10
+  end
+  
+  it "returns value passed to break" do
+    loop do
+      break 123
+    end.should == 123
+  end
+  
+  it "returns nil if no value passed to break" do
+    loop do
+      break
+    end.should == nil
+  end
+end

data/opals/opal/spec/core/module/attr_accessor_spec.rb

@@ -0,0 +1,28 @@
+
+# describe "Module#attr_accessor" do
+#   it "creates a getter and setter for each given attribute name" do
+#     class AttrAccessorSpec
+#       attr_accessor :a, 'b'
+#     end
+#     
+#     o = AttrAccessorSpec.new
+#     
+#     ['a', 'b'].each do |x|
+#       o.respond_to?(x).should == true
+#       o.respond_to?("#{x}=").should == true
+#     end
+#     
+#     o.a = "a"
+#     o.a.should == "a"
+#     
+#     o.b = "b"
+#     o.b.should == "b"
+#     o.a = o.b = nil
+#     
+#     o.__send__(:a=, "a")
+#     o.__send__(:a).should == "a"
+#     
+#     o.__send__(:b=, "b")
+#     o.__send__(:b).should == "b"
+#   end
+# end

data/opals/opal/spec/core/number/lt_spec.rb

@@ -0,0 +1,12 @@
+
+describe "Fixnum#<" do
+  it "returns true if self is less than the given argument" do
+    (2 < 13).should == true
+    (-600 < -500).should == true
+    
+    (5 < 1).should == false
+    (5 < 5).should == false
+    
+    (5 < 4.999).should == false
+  end
+end

data/opals/opal/spec/core/true/and_spec.rb

@@ -0,0 +1,10 @@
+
+describe "TrueClass#&" do
+  it "returns false if other is nil or false, otherwise true" do
+    (true & true).should == true
+    (true & false).should == false
+    (true & nil).should == false
+    (true & "").should == true
+    (true & 'x').should == true
+  end
+end

data/opals/opal/spec/core/true/inspect_spec.rb

@@ -0,0 +1,6 @@
+
+describe "TrueClass#inspect" do
+  it "returns the string 'true'" do
+    true.inspect.should == "true"
+  end
+end

data/opals/opal/spec/core/true/or_spec.rb

@@ -0,0 +1,10 @@
+
+describe "TrueClass#|" do
+  it "returns true" do
+    (true | true).should == true
+    (true | false).should == true
+    (true | nil).should == true
+    (true | '').should == true
+    (true | 'x').should == true
+  end
+end

data/opals/opal/spec/core/true/to_s_spec.rb

@@ -0,0 +1,6 @@
+
+describe "TrueClass#to_s" do
+  it "returns the string 'true'" do
+    true.to_s.should == "true"
+  end
+end

data/opals/opal/spec/core/true/xor_spec.rb

@@ -0,0 +1,10 @@
+
+describe "TrueClass#^" do
+  it "returns true if other is nil or false, otherwise false" do
+    (true ^ true).should == false
+    (true ^ false).should == true
+    (true ^ nil).should == true
+    (true ^ '').should == false
+    (true ^ 'x').should == false
+  end
+end

data/opals/opal/spec/fixtures/super.rb

@@ -0,0 +1,70 @@
+module Super
+  module S1
+    class A
+      def foo(a)
+        a << "A#foo"
+        bar(a)
+      end
+      def bar(a)
+        a << "A#bar"
+      end
+    end
+    class B < A
+      def foo(a)
+        a << "B#foo"
+        super(a)
+      end
+      def bar(a)
+        a << "B#bar"
+        super(a)
+      end
+    end
+  end
+  
+  module S2
+    class A
+      def baz(a)
+        a << "A#baz"
+      end
+    end
+    class B < A
+      def foo(a)
+        a << "B#foo"
+        baz(a)
+      end
+    end
+    class C < B
+      def baz(a)
+        a << "C#baz"
+        super(a)
+      end
+    end
+  end
+  
+  module S3
+    class A
+      def foo(a)
+        a << "A#foo"
+      end
+      def self.foo(a)
+        a << "A::foo"
+      end
+      def self.bar(a)
+        a << "A::bar"
+        foo(a)
+      end
+    end
+    class B < A
+      def self.foo(a)
+        a << "B::foo"
+        super(a)
+      end
+      def self.bar(a)
+        a << "B::bar"
+        super(a)
+      end
+    end
+  end
+  
+  
+end

data/opals/opal/spec/language/____temp_remove_this.rb

@@ -0,0 +1,12 @@
+# testing remove need for mid_to_jsid client side
+# adam = nil
+
+# adam.beynon
+# adam.beynon = 10
+
+def testing_super(a, b, c)
+  super
+  super()
+  super a, b
+  super a
+end

data/opals/opal/spec/language/and_spec.rb

@@ -0,0 +1,62 @@
+
+describe "The '&&' statement" do
+  it "short circuits evaluation at the first condition to be false" do
+    x = nil
+    true && false && x = 1
+    x.should == nil
+  end
+  
+  it "evaluates to the first condition not to be true" do
+    ("yes" && 1 && nil && true).should == nil
+    ("yes" && 1 && false && true).should == false
+  end
+  
+  it "evaluates to the last condition if all are true" do
+    ("yes" && 1).should == 1
+    (1 && "yes").should == "yes"
+  end
+  
+  it "evaluates the full set of chained conditions during assignment" do
+    x = nil
+    y = nil
+    x = 1 && y = 2
+    x.should == 2
+  end
+  
+  it "treats empty expressions as nil" do
+    (() && true).should == nil
+    (true && ()).should == nil
+    (() && ()).should == nil
+  end
+end
+
+describe "The 'and' statement" do
+  it "short-circuits evaluation at the first condition to be false" do
+    x = nil
+    true and false and x = 1
+    x.should == nil
+  end
+  
+  it "evaluates to the first condition not to be true" do
+    ("yes" and 1 and nil and true).should == nil
+    ("yes" and 1 and false and true).should == false
+  end
+  
+  it "evaluates to the last condition if all are true" do
+    ("yes" and 1).should == 1
+    (1 and "yes").should == "yes"
+  end
+  
+  it "when used in assignment, evaluates and assigns the expressions individually" do
+    x = nil
+    y = nil
+    x = 1 and y = 2
+    x.should == 1
+  end
+  
+  it "treats empty expressions as nil" do
+    (() and true).should == nil
+    (true and ()).should == nil
+    (() and ()).should == nil
+  end
+end

data/opals/opal/spec/language/array_spec.rb

@@ -0,0 +1,52 @@
+
+describe "Array literals" do
+  it "[] should return a new array populated with the given elements" do
+    array = [1, 'a', nil]
+    array.class.should == Array
+    array[0].should == 1
+    array[1].should == "a"
+    array[2].should == nil
+  end
+  
+  it "[] treats empty expressions as nil elements" do
+    array = [0, (), 2, (), 4]
+    array.class.should == Array
+    array[0].should == 0
+    array[1].should == nil
+    array[2].should == 2
+    array[3].should == nil
+    array[4].should == 4
+  end
+  
+  it "[] accepts a literal hash without curly braces as its only parameter" #do
+    # ["foo" => :bar, :baz => 42].should == nil
+ # end
+end
+
+describe "Bareword array literal" do
+  it "%w() transforms unquoted barewords into an array" #do
+    # a = 3
+    # %w(a #{3+a} 3).should
+#  end
+
+  it "%W() transforms unquoted barewords into an array, supporing interpolation" do
+    a = 3
+    %W(a #{3+a} 3).should == ["a", "6", "3"]
+  end
+  
+  it "%W() always treats interpolated expressions as a single word" do
+    a = "hello world"
+    %W(a b c #{a} d e).should == ["a", "b", "c", "hello world", "d", "e"]
+  end
+  
+  it "treats consecutive whitespace characters the same as one" do
+    %W(a  b c  d).should == ["a", "b", "c", "d"]
+    %W(hello
+       world).should == ["hello", "world"]
+  end
+  
+  it "treats whitespace as literals characters when escaped by a backslash" #do
+    # %W(a b\ c d e).should == ["a", "b c", "d", "e"]
+  # end
+  
+end

data/opals/opal/spec/language/block_spec.rb

@@ -0,0 +1,18 @@
+
+describe "Block parameters" do
+  it "does not override a shodowed variable from the outer scope" do
+    i = 0
+    a = [1, 2, 3]
+    a.each { |i| ;}
+    i.should == 0
+  end
+  
+  it "captures variables from the outer scope" do
+    a = [1, 2, 3]
+    sum = 0
+    vari = nil
+    a.each { |vari| sum = sum + vari }
+    sum.should == 6
+    vari.should == nil
+  end
+end

data/opals/opal/spec/language/break_spec.rb

@@ -0,0 +1,36 @@
+
+describe "The break statement" do
+  it "ends block execution if used within block" do
+    a = []
+    lambda {
+      a << 1
+      break
+      a << 2
+    }.call
+    a.should == [1]
+  end
+  
+  it "causes block to return value passed to break" do
+    lambda { break 123; 456 }.call.should == 123
+  end
+  
+  it "causes block to return nil if an empty expression passed to break" do
+    lambda { break (); 456 }.call.should == nil
+  end
+  
+  it "causes block to return nil if no value passed to break" do
+    lambda { break; 456 }.call.should == nil
+  end
+end
+
+# describe "Executing break from within a block" do
+#   
+#   it "returns from the invoking singleton method" do
+#     obj = Object.new
+#     def obj.meth_with_block
+#       yield
+#       raise "break didn't break from the singleton method"
+#     end
+#     obj.meth_with_block { break :value }.should == :value
+#   end
+# end

data/opals/opal/spec/language/case_spec.rb

@@ -0,0 +1,103 @@
+
+describe "The 'case'-construct" do
+  it "evaluates the body of the when clause matching the case target expression" do
+    case 1
+      when 2; false
+      when 1; true
+    end.should == true
+  end
+  
+  it "evaluates the body of the when clause whose array expression includes the case target expression" do
+    case 2
+    when 3, 4; false
+    when 1, 2; true
+    end.should == true
+  end
+  
+  it "evaluates the body of the when clause in left-to-right order if it's an array expression" do
+    @calls = []
+    def foo; @calls << :foo; end
+    def bar; @calls << :bar; end
+    
+    case true
+    when foo, bar;
+    end
+    
+    @calls.should == [:foo, :bar]
+  end
+  
+  it "evaluates the body of the when clause whose range expression includes the case target expression" do
+    case 5
+    when 21..30; false
+    when 1..20; true
+    end.should == true
+  end
+  
+  it "returns nil when no 'then'-bodies are given" do
+    case "a"
+    when "a"
+    when "b"
+    end.should == nil
+  end
+  
+  it "evaluates the 'else'-body when no other expression matches" do
+    case "c"
+    when "a"; 'foo'
+    when "b"; 'bar'
+    else 'zzz'
+    end.should == 'zzz'
+  end
+  
+  it "returns nil when no expression matches and 'else'-body is empty" do
+    case "c"
+    when "a"; "a"
+    when "b"; "b"
+    else
+    end.should == nil
+  end
+  
+  it "returns 2 when a then body is empty" do
+    case Object.new
+    when Number then
+      1
+    when String then
+      # ok
+    else
+      2
+    end.should == 2
+  end
+  
+  it "returns that statement following 'then'" do
+    case "a"
+    when "a" then 'foo'
+    when "b" then 'bar'
+    end.should == 'foo'
+  end
+  
+  it "tests classes with case equality" do
+    case "a"
+    when String
+      'foo'
+    when Symbol
+      'bar'
+    end.should == 'foo'
+  end
+  
+  it "tests with matching regexps" do
+    case "hello"
+    when /abc/; false
+    when /^hell/; true
+    end.should == true
+  end
+  
+  it "takes a list of values" do
+    case 'z'
+    when 'a', 'b', 'c', 'd'
+      "foo"
+    when 'x', 'y', 'z'
+      "bar"
+    end.should == "bar"
+  end
+  
+  it "takes an expanded array in addition to a list of values"
+end