opal 0.3.2 → 0.3.6

data/gems/core/spec/language/loop_spec.rb

@@ -1,11 +0,0 @@
-
-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/gems/core/spec/language/metaclass_spec.rb

@@ -1,21 +0,0 @@
-# 
-# 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/gems/core/spec/language/method_spec.rb

@@ -1,124 +0,0 @@
-
-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
-  
-  it "with block as block argument is ok" do
-    def foo(a, &b); [a, yield(b)] end
-    
-    foo(10) do 200 end.should == [10, 200]
-    foo(10) { 200 }.should == [10, 200]
-  end
-  
-  it "with block argument converts the block to proc" do
-    def makeproc(&b) b end
-      makeproc { "hello" }.call.should == "hello"
-      makeproc { "hello" }.class.should == Proc
-      
-      def proc_caller(&b) b.call end
-      def enclosing_method
-        proc_caller { return :break_return_value }
-        :method_return_value
-      end
-      
-      enclosing_method.should == :break_return_value
-  end
-  
-  it "with same names as existing variables is ok" do
-    foobar = 100
-    
-    def foobar; 200; end
-    
-    foobar.should == 100
-    foobar().should == 200
-  end
-  
-  it "with splat operator * and literal array unpacks params" do
-    def fooP3(a, b, c); [a, b, c]; end
-    
-    fooP3(*[1, 2, 3]).should == [1, 2, 3]
-  end
-  
-  it "with splat operator * and references array unpacks params" do
-    def fooP3(a,b,c); [a,b,c] end
-    
-    a = [1,2,3]
-    fooP3(*a).should == [1,2,3]
-  end
-  
-  it "without parentheses works" do
-    def fooP3(a,b,c); [a,b,c] end
-    
-    (fooP3 1,2,3).should == [1,2,3]
-  end
-  
-  it "with a space separating method name and parenthesis treats expression in parenthesis as first argument" do
-    def myfoo(x); x * 2 end
-    def mybar
-      # means myfoo((5).to_s)
-      # NOT   (myfoo(5)).to_s
-      # myfoo (5).to_s
-    end
-    
-    # mybar().should == "55"
-  end
-end

data/gems/core/spec/language/next_spec.rb

@@ -1,25 +0,0 @@
-
-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/gems/core/spec/language/or_spec.rb

@@ -1,34 +0,0 @@
-
-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/gems/core/spec/language/redo_spec.rb

@@ -1,24 +0,0 @@
-
-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/gems/core/spec/language/regexp_spec.rb

@@ -1,26 +0,0 @@
-
-describe "Regexp literals" do
-  
-  # ===========================================================================
-  # = Back-refs                                                               =
-  # ===========================================================================
-  
-  it "saves match data in the $~ pseudo-global variable" do
-    "hello" =~ /l+/
-    $~.to_a.should == ["ll"]
-  end
-  
-  it "saves captures in numbered $[1-9] variables" do
-    "1234567890" =~ /(1)(2)(3)(4)(5)(6)(7)(8)(9)(0)/
-    $~.to_a.should == ["1234567890", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
-    $1.should == "1"
-    $2.should == "2"
-    $3.should == "3"
-    $4.should == "4"
-    $5.should == "5"
-    $6.should == "6"
-    $7.should == "7"
-    $8.should == "8"
-    $9.should == "9"
-  end
-end

data/gems/core/spec/language/rescue_spec.rb

@@ -1,20 +0,0 @@
-
-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/gems/core/spec/language/return_spec.rb

@@ -1,47 +0,0 @@
-
-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/gems/core/spec/language/string_spec.rb

@@ -1,25 +0,0 @@
-
-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

data/gems/core/spec/language/super_spec.rb

@@ -1,32 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/super', __FILE__)
-
-describe "The super keyword" do
-  
-  it "calls the method on the calling class" do
-    Super::S1::A.new.foo([]).should == ["A#foo", "A#bar"]
-    Super::S1::A.new.bar([]).should == ["A#bar"]
-    Super::S1::B.new.foo([]).should == ["B#foo","A#foo","B#bar","A#bar"]
-    Super::S1::B.new.bar([]).should == ["B#bar", "A#bar"]
-  end
-  
-  it "searches the full inheritence chain" do
-    Super::S2::B.new.foo([]).should == ["B#foo", "A#baz"]
-    Super::S2::B.new.baz([]).should == ["A#baz"]
-    Super::S2::C.new.foo([]).should == ["B#foo","C#baz","A#baz"]
-    Super::S2::C.new.baz([]).should == ["C#baz","A#baz"]
-  end
-  
-  it "searches class methods" do
-    Super::S3::A.new.foo([]).should == ["A#foo"]
-    Super::S3::A.foo([]).should == ["A::foo"]
-    Super::S3::A.bar([]).should == ["A::bar","A::foo"]
-    Super::S3::B.new.foo([]).should == ["A#foo"]
-    Super::S3::B.foo([]).should == ["B::foo","A::foo"]
-    Super::S3::B.bar([]).should == ["B::bar","A::bar","B::foo","A::foo"]
-  end
-  
-  it "calls the method on the calling class including modules" do
-    Super::MS1::A.new.foo([]).should == ["ModA#foo", "ModA#bar"]
-  end
-end

data/gems/core/spec/language/until_spec.rb

@@ -1,157 +0,0 @@
-
-describe "The until expression" do
-  it "runs while the expression is false" do
-    i = 0
-    until i > 9
-      i = i + 1
-    end
-    
-    i.should == 10
-  end
-  
-  it "optionally takes a 'do' after the expression" do
-    i = 0
-    until i > 9 do
-      i = i + 1
-    end
-    
-    i.should == 10
-  end
-  
-  it "allows body begin on the same line if do is used" do
-    i = 0
-    until i > 9 do i = i + 1
-    end
-    
-    i.should == 10
-  end
-  
-  it "executes code in containing variable scope" do
-    i = 0
-    until i == 1
-      a = 123
-      i = 1
-    end
-    
-    a.should == 123
-  end
-  
-  it "executes code in containing variable scope with 'do'" do
-    i = 0
-    until i == 1 do
-      a = 123
-      i = 1
-    end
-    
-    a.should == 123
-  end
-  
-  it "returns nil if ended when condition became true" do
-    i = 0
-    until i > 9
-      i = i + 1
-    end.should == nil
-  end
-  
-  it "evaluates the body if expression is empty" do
-    a = []
-    until ()
-      a << :body_evaluated
-      break
-    end
-    a.should == [:body_evaluated]
-  end
-  
-  it "stops running body if interrupted by break" do
-    i = 0
-    until i > 9
-      i = i + 1
-      break if i > 5
-    end
-    i.should == 6
-  end
-  
-  it "returns value passed to break if interrupted by break" do
-    until false
-      break 123
-    end.should == 123
-  end
-  
-  it "returns nil if interrupted by break with no arguments" do
-    until false
-      break
-    end.should == nil
-  end
-  
-  it "skips to end of body with next" do
-    a = []
-    i = 0
-    until (i = i + 1) >= 5
-      next if i == 3
-      a << i
-    end
-    
-    a.should == [1, 2, 4]
-  end
-  
-  it "restarts the current iteration without reevaluating condition with redo" do
-    a = []
-    i = 0
-    j = 0
-    until (i = i + 1) >= 3
-      a << i
-      j = j + 1
-      redo if j < 3
-    end
-    a.should == [1, 1, 1, 2]
-  end
-end
-
-# describe "The until modifier" do
-#   it "runs preceding statement while the condition is false" do
-#     i = 0
-#     i = i + 1 until i > 9
-#     i.should == 10
-#   end
-#   
-#   it "evaluates condition before statement execution" do
-#     a = []
-#     i = 0
-#     a << i until (i = i + 1) >= 3
-#     a.should == [1, 2]
-#   end
-#   
-#   it "does not run preceding statement if the condition is true" do
-#     i = 0
-#     i = i + 1 until true
-#     i.should == 0
-#   end
-#   
-#   it "returns nil if ended when condition became true" do
-#     i = 0
-#     (i = i + 1 until i > 9).should == nil
-#   end
-#   
-#   it "returns value passed to break if interrupted by break" do
-#     (break 123 until false).should == 123
-#   end
-#   
-#   it "returns nil if interrupted by break with no arguments" do
-#     (break until false).should == nil
-#   end
-#   
-#   it "skips to end of body with next" do
-#     i = 0
-#     j = 0
-#     (i = i + 1) == 3 ? next : j = j + i until i > 10
-#     j.should == 63
-#   end
-#   
-#   it "restarts the current iteration without reevaluating condition with redo" do
-#     i = 0
-#     j = 0
-#     (i = i + 1) == 4 ? redo : j = j + i until (i = i + 1) > 10
-#     j.should == 34
-#   end
-# end
-