opal 0.4.4 → 0.5.0

data/spec/rubyspec/language/singleton_class_spec.rb

@@ -1,32 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../../fixtures/class', __FILE__)
-
-describe "A singleton class" do
-  it "is NilClass for nil" do
-    nil.singleton_class.should == NilClass
-  end
-
-  it "is a singleton Class instance" do
-    o = mock('x')
-    o.singleton_class.should be_kind_of(Class)
-    o.singleton_class.should_not equal(Object)
-    o.should_not be_kind_of(o.singleton_class)
-  end
-
-  it "is a Class for classes" do
-    ClassSpecs::A::singleton_class.should be_kind_of(Class)
-  end
-end
-
-describe "Defining instance methods on a singleton class" do
-  before do
-    @object = Object.new
-    class << @object
-      def singleton_method; 1 end
-    end
-  end
-
-  it "defines public methods" do
-    @object.singleton_method.should == 1
-  end
-end

data/spec/rubyspec/language/super_spec.rb

@@ -1,284 +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"]
-    Super::MS1::A.new.bar([]).should == ["ModA#bar"]
-    Super::MS1::B.new.foo([]).should == ["B#foo","ModA#foo","ModB#bar","ModA#bar"]
-    Super::MS1::B.new.bar([]).should == ["ModB#bar","ModA#bar"]
-  end
-
-  it "searches the full inheritence chain including modules" do
-    Super::MS2::B.new.foo([]).should == ["ModB#foo","A#baz"]
-    Super::MS2::B.new.baz([]).should == ["A#baz"]
-    Super::MS2::C.new.baz([]).should == ["C#baz","A#baz"]
-    Super::MS2::C.new.foo([]).should == ["ModB#foo","C#baz","A#baz"]
-  end
-
-  it "searches class methods including modules" do
-    Super::MS3::A.new.foo([]).should == ["A#foo"]
-    Super::MS3::A.foo([]).should == ["ModA#foo"]
-    Super::MS3::A.bar([]).should == ["ModA#bar","ModA#foo"]
-    Super::MS3::B.new.foo([]).should == ["A#foo"]
-    Super::MS3::B.foo([]).should == ["B::foo","ModA#foo"]
-    Super::MS3::B.bar([]).should == ["B::bar","ModA#bar","B::foo","ModA#foo"]
-  end
-
-  it "calls the correct method when the method visibility is modified" do
-    Super::MS4::A.new.example.should == 5
-  end
-
-  it "calls the correct method when the superclass argument list is different from the subclass" do
-    Super::S4::A.new.foo([]).should == ["A#foo"]
-    Super::S4::B.new.foo([],"test").should == ["B#foo(a,test)", "A#foo"]
-  end
-
-  ruby_bug "#1151 [ruby-core:22040]", "1.8.7.174" do
-    it "raises an error error when super method does not exist" do
-      sup = Class.new
-      sub_normal = Class.new(sup) do
-        def foo
-          super()
-        end
-      end
-      sub_zsuper = Class.new(sup) do
-        def foo
-          super
-        end
-      end
-
-      lambda {sub_normal.new.foo}.should raise_error(NoMethodError, /super/)
-      lambda {sub_zsuper.new.foo}.should raise_error(NoMethodError, /super/)
-    end
-  end
-
-  it "calls the superclass method when in a block" do
-    Super::S6.new.here.should == :good
-  end
-
-  it "calls the superclass method when initial method is defined_method'd" do
-    Super::S7.new.here.should == :good
-  end
-
-  it "can call through a define_method multiple times (caching check)" do
-    obj = Super::S7.new
-
-    2.times do
-      obj.here.should == :good
-    end
-  end
-
-  it "supers up appropriate name even if used for multiple method names" do
-    sup = Class.new do
-      def a; "a"; end
-      def b; "b"; end
-    end
-
-    sub = Class.new(sup) do
-      [:a, :b].each do |name|
-        define_method name do
-          super()
-        end
-      end
-    end
-
-    sub.new.a.should == "a"
-    sub.new.b.should == "b"
-    sub.new.a.should == "a"
-  end
-
-  ruby_version_is ""..."1.9" do
-    it "can be used with zero implicit arguments from a method defined with define_method" do
-      sup = Class.new do
-        def a; "a"; end
-      end
-
-      sub = Class.new(sup) do
-        define_method :a do
-          super
-        end
-      end
-
-      sub.new.a.should == "a"
-    end
-
-    it "can be used with non-zero implicit arguments from a method defined with define_method" do
-      sup = Class.new do
-        def a(n1, n2); n1 + n2; end
-      end
-
-      sub = Class.new(sup) do
-        define_method :a do |*args|
-          super
-        end
-      end
-
-      sub.new.a(30,12).should == 42
-    end
-
-    it "passes along optional args in all cases" do
-      sup = Class.new do
-        def a(n1, n2); n1 + n2; end
-      end
-
-      sub = Class.new(sup) do
-        def a(n1, n2=2)
-          super
-        end
-      end
-
-      sub.new.a(39, 3).should == 42
-      sub.new.a(40).should == 42
-    end
-
-    describe "passes along unnamed rest args" do
-      before(:each) do
-        @sup = Class.new do
-          def a(n1, *n2); return n1 + n2[0]; end
-        end
-      end
-
-      it "" do
-        sub = Class.new(@sup) do
-          def a(n, *)
-            super
-          end
-        end
-
-        sub.new.a(30, 12).should == 42
-      end
-
-      it "even when nested within a block" do
-        sub = Class.new(@sup) do
-          def yieldit; yield; end
-
-          def a(n, *)
-            yieldit { super }
-          end
-        end
-
-        sub.new.a(30, 12).should == 42
-      end
-    end
-
-    describe "passes along the incoming block to the super method" do
-      before(:each) do
-        @sup = Class.new do
-          def a(*n); yield n; end
-        end
-      end
-
-      it "" do
-        sub = Class.new(@sup) do
-          def a(*n); super; end
-        end
-
-        sub.new.a { 42 }.should == 42
-      end
-
-      it "even when the method has args" do
-        sub = Class.new(@sup) do
-          def a(*n); super; end
-        end
-
-        sub.new.a(42) {|i| i}.should == [42]
-      end
-
-      it "even when incoming args are explicitly passed in" do
-        sub = Class.new(@sup) do
-          def a(*n); super(*n); end
-        end
-
-        sub.new.a(42) {|i| i}.should == [42]
-      end
-    end
-  end
-
-  ruby_version_is "1.9"..."2.0" do
-    it "can't be used with implicit arguments from a method defined with define_method" do
-      Class.new do
-        define_method :a do
-          super
-        end.should raise_error(RuntimeError)
-      end
-    end
-  end
-
-  ruby_bug "#6907", "2.0" do
-    it "can be used with implicit arguments from a method defined with define_method" do
-      super_class = Class.new do
-        def a(arg)
-          arg
-        end
-      end
-
-      klass = Class.new super_class do
-        define_method :a do |arg|
-          super
-        end
-      end
-
-      klass.new.a(:a_called).should == :a_called
-    end
-  end
-
-  # Rubinius ticket github#157
-  it "calls method_missing when a superclass method is not found" do
-    lambda {
-      Super::MM_B.new.is_a?(Hash).should == false
-    }.should_not raise_error(NoMethodError)
-  end
-
-  # Rubinius ticket github#180
-  it "respects the original module a method is aliased from" do
-    lambda {
-      Super::Alias3.new.name3.should == [:alias2, :alias1]
-    }.should_not raise_error(RuntimeError)
-  end
-
-  it "sees the included version of a module a method is alias from" do
-    lambda {
-      Super::AliasWithSuper::Trigger.foo.should == [:b, :a]
-    }.should_not raise_error(NoMethodError)
-  end
-
-  it "passes along modified rest args when they weren't originally empty" do
-    Super::RestArgsWithSuper::B.new.a("bar").should == ["bar", "foo"]
-  end
-
-  ruby_version_is ""..."1.9" do
-    it "passes empty args instead of modified rest args when they were originally empty" do
-      Super::RestArgsWithSuper::B.new.a.should == []
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "passes along modified rest args when they were originally empty" do
-      Super::RestArgsWithSuper::B.new.a.should == ["foo"]
-    end
-  end
-end

data/spec/rubyspec/language/undef_spec.rb

@@ -1,16 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-class UndefSpecClass
-  def meth(other);other;end
-end
-
-describe "The undef keyword" do
-  it "undefines 'meth='" do
-    obj = ::UndefSpecClass.new
-    (obj.meth 5).should == 5
-    class ::UndefSpecClass
-      undef meth
-    end
-    lambda { obj.meth 5 }.should raise_error(NoMethodError)
-  end
-end

data/spec/rubyspec/language/unless_spec.rb

@@ -1,45 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe "The unless expression" do
-  it "evaluates the unless body when the expression is false" do
-    unless false
-      a = true
-    else
-      a = false
-    end
-
-    a.should == true
-  end
-
-  it "returns the last statement in the body" do
-    unless false
-      'foo'
-      'bar'
-      'baz'
-    end.should == 'baz'
-  end
-
-  it "evaluates the else body when the expression is true" do
-    unless true
-      'foo'
-    else
-      'bar'
-    end.should == 'bar'
-  end
-
-  it "takes an optional then after the expression" do
-    unless false then
-      'baz'
-    end.should == 'baz'
-  end
-
-  it "does not return a value when the expression is true" do
-    unless true; end.should == nil
-  end
-
-  it "allows expression and body to be on one line (using 'then')" do
-    unless false then 'foo'; else 'bar'; end.should == 'foo'
-  end
-end
-
-# language_version __FILE__, "unless"

data/spec/rubyspec/language/until_spec.rb

@@ -1,234 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-# until bool-expr [do]
-#   body
-# end
-#
-# begin
-#   body
-# end until bool-expr
-#
-# expr until bool-expr
-describe "The until expression" do
-  it "runs while the expression is false" do
-    i = 0
-    until i > 9
-      i += 1
-    end
-
-    i.should == 10
-  end
-
-  it "optionally takes a 'do' after the expression" do
-    i = 0
-    until i > 9 do
-      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 += 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 += 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 += 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+=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+=1)>=3
-      a << i
-      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 += 1 until i > 9
-    i.should == 10
-  end
-
-  it "evaluates condition before statement execution" do
-    a = []
-    i = 0
-    a << i until (i+=1) >= 3
-    a.should == [1, 2]
-  end
-
-  it "does not run preceding statement if the condition is true" do
-    i = 0
-    i += 1 until true
-    i.should == 0
-  end
-
-  it "returns nil if ended when condition became true" do
-    i = 0
-    (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+=1) == 3 ? next : 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+=1) == 4 ? redo : j+=i until (i+=1) > 10
-    j.should == 34
-  end
-end
-
-describe "The until modifier with begin .. end block" do
-  it "runs block while the expression is false" do
-    i = 0
-    begin
-      i += 1
-    end until i > 9
-
-    i.should == 10
-  end
-
-  it "stops running block if interrupted by break" do
-    i = 0
-    begin
-      i += 1
-      break if i > 5
-    end until i > 9
-
-    i.should == 6
-  end
-
-  it "returns value passed to break if interrupted by break" do
-    (begin; break 123; end until false).should == 123
-  end
-
-  it "returns nil if interrupted by break with no arguments" do
-    (begin; break; end until false).should == nil
-  end
-
-  it "runs block at least once (even if the expression is true)" do
-    i = 0
-    begin
-      i += 1
-    end until true
-
-    i.should == 1
-  end
-
-  it "evaluates condition after block execution" do
-    a = []
-    i = 0
-    begin
-      a << i
-    end until (i+=1)>=5
-    a.should == [0, 1, 2, 3, 4]
-  end
-
-  it "skips to end of body with next" do
-    a = []
-    i = 0
-    begin
-      next if i==3
-      a << i
-    end until (i+=1)>=5
-    a.should == [0, 1, 2, 4]
-  end
-
-  it "restart the current iteration without reevaluting condition with redo" do
-    a = []
-    i = 0
-    j = 0
-    begin
-      a << i
-      j+=1
-      redo if j<3
-    end until (i+=1)>=3
-    a.should == [0, 0, 0, 1, 2]
-  end
-end