opal 0.0.1 → 0.1.0

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

@@ -0,0 +1,11 @@
+
+describe "Redefining a method" do
+  
+  it "replaces the original method" do
+    def barFoo; 100; end
+    barFoo.should == 100
+    
+    def barFoo; 200; end
+    barFoo.should == 200
+  end
+end

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

@@ -0,0 +1,60 @@
+
+# describe "self in an eigenclass body (class << obj)" do
+#   it "is TrueClass for true" do
+#     class << true; self; end.should == TrueClass
+#   end
+#   
+#   it "is FalseClass for false" do
+#     class << false; self; end.should == FalseClass
+#   end
+#   
+#   it "is NilClass for nil" do
+#     class << nil; self; end.should == NilClass
+#   end
+#   
+#   it "is a singleton Class instance" do
+#     mock = Object.new
+#     cls = class << mock; self; end
+#     cls.is_a?(Class).should == true
+#     # puts cls
+#     # `console.log(#{cls});`
+#   end
+#   
+#   it "is a Class for classes"
+#   
+#   it "inherits from Class for classes" do
+#     temp = []
+#     cls = class << Object; self; end
+#     sc = cls
+#     until sc.nil? || sc.superclass == sc
+#       temp << sc
+#       sc = sc.superclass
+#     end
+#     temp.should include(Class)
+#   end
+# end
+
+
+# puts "testing eigenclass etc"
+# 
+# class EigenclassSpecTest
+#   
+#   def something=(something)
+#     puts "setting something to #{something}"
+#   end
+# end
+# 
+# a = EigenclassSpecTest.new
+# a.something = 100
+# 
+# a_class = class << a; self; end
+# 
+# a_class.define_method(:something=) do |value|
+#   puts "setting something.."
+#   super value
+#   puts "did set something"
+# end
+# 
+# # `console.log(#{a}['$something=']);`
+# 
+# a.something = 200

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

@@ -0,0 +1,29 @@
+
+describe "Hash literal" do
+  it "{} should return an empty hash" do
+    {}.size.should == 0
+    {}.should == {}
+  end
+  
+  it "{} should return a new hash populated with the given elements" do
+    h = { :a => 'a', 'b' => 3, 44 => 2.3 }
+    h.size.should == 3
+    h.should == { :a => 'a', 'b' => 3, 44 => 2.3 }
+  end
+  
+  it "treats empty expressions as nils" do
+    h = {() => ()}
+    h.keys.should == [nil]
+    h.values.should == [nil]
+    
+    h = {() => :value}
+    h.keys.should == [nil]
+    h.values.should == [:value]
+    h[nil].should == :value
+    
+    h = {:key => ()}
+    h.keys.should == [:key]
+    h.values.should == [nil]
+    h[:key].should == nil
+  end
+end

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

@@ -0,0 +1,54 @@
+# 
+# describe "The if expression" do
+#   it "evaluates body if expression is true" do
+#     a = []
+#     if true
+#       a << 123
+#     end
+#     a.should == [123]
+#   end
+#   
+#   it "does not evaluate body if expression is false" do
+#     a = []
+#     if false
+#       a << 123
+#     end
+#     a.should == []
+#   end
+#   
+#   it "does not evaluate body if expression is empty" do
+#     a = []
+#     if ()
+#       a << 123
+#     end
+#     a.should == []
+#   end
+#   
+#   it "does not evaluate else body if expression is true" do
+#     a = []
+#     if true
+#       a << 123
+#     else
+#       a << 456
+#     end
+#     a.should == [123]
+#   end
+#   
+#   it "evaluates only else-body if expression is false" do
+#     a = []
+#     if false
+#       a << 123
+#     else
+#       a << 456
+#     end
+#     a.should == [456]
+#   end
+#   
+#   it "returns result of then-body evaluation if expression is true" do
+#     # raise "this causes error: return is injected before if = javascript error"
+#     # if true
+#       # 123
+#     # end.should == 456
+#   end
+# end
+

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

@@ -0,0 +1,11 @@
+
+describe "The loop expression" do
+  it "repeats the given block until a break is called" do
+    outer_loop = 0
+    loop do
+      outer_loop = outer_loop + 1
+      break if outer_loop == 10
+    end
+    outer_loop.should == 10
+  end
+end

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

@@ -0,0 +1,21 @@
+
+describe "self in a metaclass body (class << obj)" do
+  it "is TrueClass for true" do
+    class << true; self; end.should == TrueClass
+  end
+  
+  it "is FalseClass for false" do
+    class << false; self; end.should == FalseClass
+  end
+  
+  it "is NilClass for nil" do
+    class << nil; self; end.should == NilClass
+  end
+  
+  it "raises a TypeError for numbers"
+  
+  it "raises a TypeError for symbols"
+  
+  it "is a singleton Class instance"
+  
+end

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

@@ -0,0 +1,64 @@
+
+describe "Calling a method" do
+  it "with no arguments is ok" do
+    def fooP0; 100; end
+    
+    fooP0.should == 100
+  end
+  
+  it "with simple required arguments works" do
+    def fooP1(a); [a]; end
+    fooP1(1).should == [1]
+    
+    def fooP2(a, b); [a, b]; end
+    fooP2(1, 2).should == [1, 2]
+    
+    def fooP3(a,b,c); [a,b,c]; end
+    fooP3(1,2,3).should == [1,2,3]
+
+    def fooP4(a,b,c,d); [a,b,c,d]; end
+    fooP4(1,2,3,4).should == [1,2,3,4]
+
+    def fooP5(a,b,c,d,e); [a,b,c,d,e]; end
+    fooP5(1,2,3,4,5).should == [1,2,3,4,5]
+  end
+  
+  it "works with optional arguments" do
+    def fooP0O1(a=1); [a]; end
+    fooP0O1().should == [1]
+    
+    def fooP1O1(a, b=1); [a, b]; end
+    fooP1O1(1).should == [1, 1]
+    
+    def fooP2O1(a, b, c=1); [a, b, c]; end
+    fooP2O1(1, 2).should == [1, 2, 1]
+    
+    def fooP3O1(a, b, c, d=1); [a, b, c, d]; end
+    fooP3O1(1, 2, 3).should == [1, 2, 3, 1]
+    
+    def fooP4O1(a, b, c, d, e=1); [a, b, c, d, e]; end
+    fooP4O1(1, 2, 3, 4).should == [1, 2, 3, 4, 1]
+    
+    def fooP0O2(a=1, b=2); [a, b]; end
+    fooP0O2.should == [1, 2]
+  end
+  
+  it "works with rest arguments" do
+    def fooP0R(*r); r; end
+    fooP0R().should == []
+    fooP0R(1).should == [1]
+    fooP0R(1, 2).should == [1, 2]
+    
+    def fooP1R(a, *r); [a, r]; end
+    fooP1R(1).should == [1, []]
+    fooP1R(1, 2).should == [1, [2]]
+    
+    # def fooP0O1R(a=1, *r); [a, r]; end
+    # fooP0O1R().should == [1, []]
+  end
+  
+  it "with an empty expression is like calling with nil argument" do
+    def foo(a); a; end
+    foo(()).should == nil
+  end
+end

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

@@ -0,0 +1,25 @@
+
+describe "The next statement from within the block" do
+  it "ends block execution" do
+    a = []
+    lambda {
+      a << 1
+      next
+      a << 2
+    }.call
+    a.should == [1]
+  end
+  
+  it "causes block to return nil if invoked without arguments" do
+    lambda { 123; next; 456 }.call.should == nil
+  end
+  
+  it "causes block to return nil if invoked with an empty expression" do
+    lambda { next (); 456 }.call.should == nil
+  end
+  
+  it "returns the argument passed" do
+    lambda { 123; next 234; 345 }.call.should == 234
+  end
+end
+

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

@@ -0,0 +1,34 @@
+
+describe "The || operator" do
+  it "evaluates to true if any of its operands are true" do
+    if false || true || nil
+      x = true
+    end
+    x.should == true
+  end
+  
+  it "evaluates to false if all of its operands are false" do
+    if false || nil
+      x = true
+    end
+    x.should == nil
+  end
+  
+  it "is evaluated before assignment operators" do
+    x = nil || true
+    x.should == true
+  end
+  
+  it "has a lower precedence than the && operator" do
+    x = 1 || false && x = 2
+    x.should == 1
+  end
+  
+  it "treats empty expressions as nil" do
+    (() || true).should == true
+    (() || false).should == false
+    (true || ()).should == true
+    (false || ()).should == nil
+    (() || ()).should == nil
+  end
+end

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

@@ -0,0 +1,24 @@
+
+describe "The redo statement" do
+  it "restarts block execution if used within block" do
+    a = []
+    lambda {
+      a << 1
+      redo if a.size < 2
+      a << 2
+    }.call
+    a.should == [1, 1, 2]
+  end
+  
+  it "re-executes the closest loop"
+  
+  it "re-executes the last step in enumeration" do
+    list = []
+    [1,2,3].each do |x|
+      list << x
+      break if list.size == 6
+      redo if x == 3
+    end
+    list.should == [1,2,3,3,3,3]
+  end
+end

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

@@ -0,0 +1,20 @@
+
+class SpecificExampleException < StandardError; end
+
+class OtherCustomException < StandardError; end
+
+def exception_list
+  [SpecificExampleException, OtherCustomException]
+end
+
+describe "The rescue keyword" do
+  it "can be used to handle a specific exception"
+  
+  it "can capture the raised exception in a local variable" do
+    begin
+      raise SpecificExampleException, "some text"
+    rescue SpecificExampleException => e
+      e.message.should == "some text"
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+
+describe "The return keyword" do
+  it "returns any object directly" do
+    def r; return 1; end
+    r().should == 1
+  end
+  
+  it "returns an single element array directly" do
+    def r; return[1]; end
+    r().should == [1]
+  end
+  
+  it "returns an multi element array directly" do
+    def r; return [1, 2]; end
+    r().should == [1, 2]
+  end
+  
+  it "returns nil be default" do
+    def r; return; end
+    r().should == nil
+  end
+  
+  # describe "within a begin" do
+    # it "executes ensure before re"
+  # end
+  
+  describe "within a block" do
+    it "raises a LocalJumpError if there is no lexicaly enclosing method" #do
+      # def f; yield; end
+      # lambda { f { return 5 } }
+    # end
+    
+    it "causes lambda to return nil if invoked without any arguments" do
+      lambda { return; 456 }.call.should == nil
+    end
+  
+  end
+  
+  describe "within two blocks" do
+    it "causes the method that lexically encloses the block to return" do
+      def f
+        1.times { 1.times { return true }; false }; false
+      end
+      f.should == true
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+
+describe "Ruby character strings" do
+  it "don't get interpolated when put in single quotes" do
+    @ip = 'xxx'
+    '#{@ip}'.should == '#{@ip}'
+  end
+  
+  it 'get interpolated with #{} when put in double quotes' do
+    @ip = 'xxx'
+    "#{@ip}".should == "xxx"
+  end
+  
+  it "interpolate instance variables just with the # character" #do
+    # @ip = "xxx"
+    # "#@ip".should == "xxx"
+  # end
+  
+  it "interpolate global variables just with the # character"
+  
+  it "interpolate class variables with just the # character"
+  
+  it "allow underscore as part of a variable name in a simple interpolation"
+  
+  it "have characters [.(=?!# end simple # interpolation"
+end