opal 0.4.4 → 0.5.0

data/spec/rubyspec/language/if_spec.rb

@@ -1,356 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-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
-    if true
-      123
-    end.should == 123
-  end
-
-  it "returns result of last statement in then-body if expression is true" do
-    if true
-      'foo'
-      'bar'
-      'baz'
-    end.should == 'baz'
-  end
-
-  it "returns result of then-body evaluation if expression is true and else part is present" do
-    if true
-      123
-    else
-      456
-    end.should == 123
-  end
-
-  it "returns result of else-body evaluation if expression is false" do
-    if false
-      123
-    else
-      456
-    end.should == 456
-  end
-
-  it "returns nil if then-body is empty and expression is true" do
-    if true
-    end.should == nil
-  end
-
-  it "returns nil if then-body is empty, expression is true and else part is present" do
-    if true
-    else
-      456
-    end.should == nil
-  end
-
-  it "returns nil if then-body is empty, expression is true and else part is empty" do
-    if true
-    else
-    end.should == nil
-  end
-
-  it "returns nil if else-body is empty and expression is false" do
-    if false
-      123
-    else
-    end.should == nil
-  end
-
-  it "returns nil if else-body is empty, expression is false and then-body is empty" do
-    if false
-    else
-    end.should == nil
-  end
-
-  it "considers an expression with nil result as false" do
-    if nil
-      123
-    else
-      456
-    end.should == 456
-  end
-
-  it "considers a non-nil and non-boolean object in expression result as true" do
-    if mock('x')
-      123
-    else
-      456
-    end.should == 123
-  end
-
-  it "considers a zero integer in expression result as true" do
-    if 0
-      123
-    else
-      456
-    end.should == 123
-  end
-
-  it "allows starting else-body on the same line" do
-    if false
-      123
-    else 456
-    end.should == 456
-  end
-
-  it "evaluates subsequent elsif statements and execute body of first matching" do
-    if false
-      123
-    elsif false
-      234
-    elsif true
-      345
-    elsif true
-      456
-    end.should == 345
-  end
-
-  it "evaluates else-body if no if/elsif statements match" do
-    if false
-      123
-    elsif false
-      234
-    elsif false
-      345
-    else
-      456
-    end.should == 456
-  end
-
-  it "allows 'then' after expression when then-body is on the next line" do
-    if true then
-      123
-    end.should == 123
-
-    if true then ; 123; end.should == 123
-  end
-
-  it "allows then-body on the same line separated with 'then'" do
-    if true then 123
-    end.should == 123
-
-    if true then 123; end.should == 123
-  end
-
-  it "returns nil when then-body on the same line separated with 'then' and expression is false" do
-    if false then 123
-    end.should == nil
-
-    if false then 123; end.should == nil
-  end
-
-  it "returns nil when then-body separated by 'then' is empty and expression is true" do
-    if true then
-    end.should == nil
-
-    if true then ; end.should == nil
-  end
-
-  it "returns nil when then-body separated by 'then', expression is false and no else part" do
-    if false then
-    end.should == nil
-
-    if false then ; end.should == nil
-  end
-
-  it "evaluates then-body when then-body separated by 'then', expression is true and else part is present" do
-    if true then 123
-    else 456
-    end.should == 123
-
-    if true then 123; else 456; end.should == 123
-  end
-
-  it "evaluates else-body when then-body separated by 'then' and expression is false" do
-    if false then 123
-    else 456
-    end.should == 456
-
-    if false then 123; else 456; end.should == 456
-  end
-
-  describe "with a boolean range ('flip-flop' operator)" do
-    before :each do
-      ScratchPad.record []
-    end
-
-    after :each do
-      ScratchPad.clear
-    end
-
-    it "mimics an awk conditional with a single-element inclusive-end range" do
-      10.times { |i| ScratchPad << i if (i == 4)..(i == 4) }
-      ScratchPad.recorded.should == [4]
-    end
-
-    it "mimics an awk conditional with a many-element inclusive-end range" do
-      10.times { |i| ScratchPad << i if (i == 4)..(i == 7) }
-      ScratchPad.recorded.should == [4, 5, 6, 7]
-    end
-
-    it "mimics a sed conditional with a zero-element exclusive-end range" do
-      10.times { |i| ScratchPad << i if (i == 4)...(i == 4) }
-      ScratchPad.recorded.should == [4, 5, 6, 7, 8, 9]
-    end
-
-    it "mimics a sed conditional with a many-element exclusive-end range" do
-      10.times { |i| ScratchPad << i if (i == 4)...(i == 5) }
-      ScratchPad.recorded.should == [4, 5]
-    end
-
-    it "allows combining two flip-flops" do
-      10.times { |i| ScratchPad << i if (i == 4)...(i == 5) or (i == 7)...(i == 8) }
-      ScratchPad.recorded.should == [4, 5, 7, 8]
-    end
-
-    it "evaluates the first conditions lazily with inclusive-end range" do
-      collector = proc { |i| ScratchPad << i }
-      10.times { |i| i if collector[i]...false }
-      ScratchPad.recorded.should == [0]
-    end
-
-    it "evaluates the first conditions lazily with exclusive-end range" do
-      collector = proc { |i| ScratchPad << i }
-      10.times { |i| i if collector[i]..false }
-      ScratchPad.recorded.should == [0]
-    end
-
-    it "evaluates the second conditions lazily with inclusive-end range" do
-      collector = proc { |i| ScratchPad << i }
-      10.times { |i| i if (i == 4)...collector[i] }
-      ScratchPad.recorded.should == [5]
-    end
-
-    it "evaluates the second conditions lazily with exclusive-end range" do
-      collector = proc { |i| ScratchPad << i }
-      10.times { |i| i if (i == 4)..collector[i] }
-      ScratchPad.recorded.should == [4]
-    end
-
-    it "scopes state by flip-flop" do
-      store_me = proc { |i| ScratchPad << i if (i == 4)..(i == 7) }
-      store_me[1]
-      store_me[4]
-      proc { store_me[1] }.call
-      store_me[7]
-      store_me[5]
-      ScratchPad.recorded.should == [4, 1, 7]
-    end
-
-    it "keeps flip-flops from interfering" do
-      a = proc { |i| ScratchPad << i if (i == 4)..(i == 7) }
-      b = proc { |i| ScratchPad << i if (i == 4)..(i == 7) }
-      6.times(&a)
-      6.times(&b)
-      ScratchPad.recorded.should == [4, 5, 4, 5]
-    end
-  end
-end
-
-describe "The postfix if form" do
-  it "evaluates statement if expression is true" do
-    a = []
-    a << 123 if true
-    a.should == [123]
-  end
-
-  it "does not evaluate statement if expression is false" do
-    a = []
-    a << 123 if false
-    a.should == []
-  end
-
-  it "returns result of expression if value is true" do
-    (123 if true).should == 123
-  end
-
-  it "returns nil if expression is false" do
-    (123 if false).should == nil
-  end
-
-  it "considers a nil expression as false" do
-    (123 if nil).should == nil
-  end
-
-  it "considers a non-nil object as true" do
-    (123 if mock('x')).should == 123
-  end
-
-  it "evaluates then-body in containing scope" do
-    a = 123
-    if true
-      b = a+1
-    end
-    b.should == 124
-  end
-
-  it "evaluates else-body in containing scope" do
-    a = 123
-    if false
-      b = a+1
-    else
-      b = a+2
-    end
-    b.should == 125
-  end
-
-  it "evaluates elsif-body in containing scope" do
-    a = 123
-    if false
-      b = a+1
-    elsif false
-      b = a+2
-    elsif true
-      b = a+3
-    else
-      b = a+4
-    end
-    b.should == 126
-  end
-end
-
-# language_version __FILE__, "if"

data/spec/rubyspec/language/literal_lambda_spec.rb

@@ -1 +0,0 @@
-# language_version __FILE__, "literal_lambda"

data/spec/rubyspec/language/loop_spec.rb

@@ -1,67 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe "The loop expression" do
-  it "repeats the given block until a break is called" do
-    outer_loop = 0
-    loop do
-      outer_loop += 1
-      break if outer_loop == 10
-    end
-    outer_loop.should == 10
-  end
-
-  it "executes code in its own scope" do
-    loop do
-      inner_loop = 123
-      break
-    end
-    lambda { inner_loop }.should raise_error(NameError)
-  end
-
-  it "returns the value passed to break if interrupted by break" do
-    loop do
-      break 123
-    end.should == 123
-  end
-
-  it "returns nil if interrupted by break with no arguments" do
-    loop do
-      break
-    end.should == nil
-  end
-
-  it "skips to end of body with next" do
-    a = []
-    i = 0
-    loop do
-      break if (i+=1) >= 5
-      next if i == 3
-      a << i
-    end
-    a.should == [1, 2, 4]
-  end
-
-  it "restarts the current iteration with redo" do
-    a = []
-    loop do
-      a << 1
-      redo if a.size < 2
-      a << 2
-      break if a.size == 3
-    end
-    a.should == [1, 1, 2]
-  end
-
-  it "uses a spaghetti nightmare of redo, next and break" do
-    a = []
-    loop do
-      a << 1
-      redo if a.size == 1
-      a << 2
-      next if a.size == 3
-      a << 3
-      break if a.size > 6
-    end
-    a.should == [1, 1, 2, 1, 2, 3, 1, 2, 3]
-  end
-end

data/spec/rubyspec/language/metaclass_spec.rb

@@ -1,159 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../../fixtures/class', __FILE__)
-require File.expand_path('../fixtures/metaclass', __FILE__)
-
-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" do
-    lambda { class << 1; self; end }.should raise_error(TypeError)
-  end
-
-  it "raises a TypeError for symbols" do
-    lambda { class << :symbol; self; end }.should raise_error(TypeError)
-  end
-
-  it "is a singleton Class instance" do
-    cls = class << mock('x'); self; end
-    cls.is_a?(Class).should == true
-    cls.should_not equal(Object)
-  end
-end
-
-describe "A constant on a metaclass" do
-  before(:each) do
-    @object = Object.new
-    class << @object
-      CONST = self
-    end
-  end
-
-  it "can be accessed after the metaclass body is reopened" do
-    class << @object
-      CONST.should == self
-    end
-  end
-
-  it "can be accessed via self::CONST" do
-    class << @object
-      self::CONST.should == self
-    end
-  end
-
-  it "can be accessed via const_get" do
-    class << @object
-      const_get(:CONST).should == self
-    end
-  end
-
-  it "is not defined on the object's class" do
-    @object.class.const_defined?(:CONST).should be_false
-  end
-
-  it "is not defined in the metaclass opener's scope" do
-    class << @object
-      CONST
-    end
-    lambda { CONST }.should raise_error(NameError)
-  end
-
-  it "cannot be accessed via object::CONST" do
-    lambda do
-      @object::CONST
-    end.should raise_error(TypeError)
-  end
-
-  it "raises a NameError for anonymous_module::CONST" do
-    @object = Class.new
-    class << @object
-      CONST = 100
-    end
-
-    lambda do
-      @object::CONST
-    end.should raise_error(NameError)
-  end
-
-  ruby_version_is ""..."1.9" do
-    it "appears in the metaclass constant list" do
-      constants = class << @object; constants; end
-      constants.should include("CONST")
-    end
-
-    it "does not appear in the object's class constant list" do
-      @object.class.constants.should_not include("CONST")
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "appears in the metaclass constant list" do
-      constants = class << @object; constants; end
-      constants.should include(:CONST)
-    end
-
-  it "does not appear in the object's class constant list" do
-      @object.class.constants.should_not include(:CONST)
-    end
-  end
-
-  it "is not preserved when the object is duped" do
-    @object = @object.dup
-
-    lambda do
-      class << @object; CONST; end
-    end.should raise_error(NameError)
-  end
-
-  it "is preserved when the object is cloned" do
-    @object = @object.clone
-
-    class << @object
-      CONST.should_not be_nil
-    end
-  end
-end
-
-describe "calling methods on the metaclass" do
-
-  it "calls a method on the metaclass" do
-    MetaClassSpecs::A.cheese.should == 'edam'
-    MetaClassSpecs::B.cheese.should == 'stilton'
-  end
-
-  it "calls a method on the instance's metaclass" do
-    b = MetaClassSpecs::B.new
-    b_meta = MetaClassSpecs.metaclass_of b
-    b_meta.send(:define_method, :cheese) {'cheshire'}
-    b.cheese.should == 'cheshire'
-  end
-
-  it "calls a method in deeper chains of metaclasses" do
-    b = MetaClassSpecs::B.new
-    b_meta = MetaClassSpecs.metaclass_of b
-    b_meta_meta = MetaClassSpecs.metaclass_of b_meta
-    b_meta_meta.send(:define_method, :cheese) {'gouda'}
-    b_meta.cheese.should == 'gouda'
-
-    b_meta_meta_meta = MetaClassSpecs.metaclass_of b_meta_meta
-    b_meta_meta_meta.send(:define_method, :cheese) {'wensleydale'}
-    b_meta_meta.cheese.should == 'wensleydale'
-  end
-
-  ruby_version_is "1.9" do
-    it "calls a method defined on the metaclass of the metaclass" do
-      d_meta = MetaClassSpecs::D.singleton_class
-      d_meta.ham.should == 'iberico'
-    end
-  end
-
-end