opal 0.3.16 → 0.3.17

data/{core_spec → spec}/language/block_spec.rb

@@ -1,5 +1,22 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/block', __FILE__)
+module BlockSpecs
+  class Yielder
+    def z
+      yield
+    end
+
+    def m(*a)
+      yield(*a)
+    end
+
+    def s(a)
+      yield(a)
+    end
+
+    def r(a)
+      yield(*a)
+    end
+  end
+end
 
 describe "A block" do
   before :each do
@@ -102,4 +119,4 @@ describe "A block" do
       @y.m(1, 2, 3) { |a, *b| [a, b] }.should == [1, [2, 3]]
     end
   end
-end
+end

data/{core_spec → spec}/language/break_spec.rb

@@ -1,5 +1,42 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/break', __FILE__)
+module BreakSpecs
+  class Driver
+    def initialize(ensures=false)
+      @ensures = ensures
+    end
+
+    def note(value)
+      ScratchPad << value
+    end
+  end
+
+  class Block < Driver
+    def break_nil
+      note :a
+      note yielding {
+        note :b
+        break
+        note :c
+      }
+      note :d
+    end
+
+    def break_value
+      note :a
+      note yielding {
+        note :b
+        break :break
+        note :c
+      }
+      note :d
+    end
+
+    def yielding
+      note :aa
+      note yield
+      note :bb
+    end
+  end
+end
 
 describe "The break statement in a block" do
   before :each do
@@ -46,4 +83,4 @@ describe "Break inside a while loop" do
     end.should == 2
     at.should == 2
   end
-end
+end

data/{core_spec → spec}/language/case_spec.rb

@@ -1,5 +1,3 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
 describe "The 'case'-construct" do
   it "evaluates the body of the when clause matching the case target expression" do
     case 1
@@ -161,5 +159,4 @@ describe "The 'case'-construct" do
         "foo"
     end.should == nil
   end
-end
-
+end

data/{core_spec → spec}/language/defined_spec.rb

@@ -1,5 +1,11 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/defined', __FILE__)
+module DefinedSpecs
+  class Basic
+    A = 42
+
+    def a_defined_method
+    end
+  end
+end
 
 describe "The defined? keyword for literals" do
   it "returns 'self' for self" do
@@ -77,4 +83,4 @@ describe "The defined? keyword when called with a method name" do
       defined?(@defined_specs_obj.an_undefined_method).should be_nil
     end
   end
-end
+end

data/{core_spec → spec}/language/ensure_spec.rb

@@ -1,5 +1,40 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/ensure', __FILE__)
+module EnsureSpec
+  class Container
+    attr_reader :executed
+
+    def initialize
+      @executed = []
+    end
+
+    def raise_in_method_with_ensure
+      @executed << :method
+      raise "An Exception"
+    ensure
+      @executed << :ensure
+    end
+
+    def raise_and_rescue_in_method_with_ensure
+      @executed << :method
+      raise "An Exception"
+    rescue
+      @executed << :rescue
+    ensure
+      @executed << :ensure
+    end
+
+    def implicit_return_in_method_with_ensure
+      :method
+    ensure
+      :ensure
+    end
+
+    def explicit_return_in_method_with_ensure
+      return :method
+    ensure
+      return :ensure
+    end
+  end
+end
 
 describe "An ensure block inside a begin block" do
   before :each do
@@ -79,4 +114,4 @@ describe "An ensure block inside a method" do
   it "has an impact on the method's explicit return value" do
     @obj.explicit_return_in_method_with_ensure.should == :ensure
   end
-end
+end

data/{core_spec → spec}/language/hash_spec.rb

@@ -1,5 +1,3 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
 describe "Hash literal" do
   it "{} should return an empty hash" do
     {}.size.should == 0
@@ -40,4 +38,4 @@ describe "Hash literal" do
     h.size.should == 2
     h.should == {:a => 1, :b => 2}
   end
-end
+end

data/{core_spec → spec}/language/if_spec.rb

@@ -1,5 +1,3 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
 describe "The if expression" do
   it "evaluates body if expression is true" do
     a = []
@@ -274,5 +272,4 @@ describe "The postfix if form" do
     end
     b.should == 126
   end
-end
-
+end

data/{core_spec → spec}/language/loop_spec.rb

@@ -1,5 +1,3 @@
-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
@@ -29,4 +27,4 @@ describe "The loop expression" do
       break
     end.should == nil
   end
-end
+end

data/spec/language/metaclass_spec.rb

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

data/{core_spec → spec}/language/next_spec.rb

@@ -1,5 +1,49 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/next', __FILE__)
+class NextSpecs
+  def self.yielding_method(expected)
+    yield.should == expected
+    :method_return_value
+  end
+
+  def self.yielding
+    yield
+  end
+
+  def self.while_next(arg)
+    x = true
+    while x
+      begin
+        ScratchPad << :begin
+        x = false
+        if arg
+          next 42
+        else
+          next
+        end
+      ensure
+        ScratchPad << :ensure
+      end
+    end
+  end
+
+  def self.while_within_iter(arg)
+    yielding do
+      x = true
+      while x
+        begin
+          ScratchPad << :begin
+          x = false
+          if arg
+            next 42
+          else
+            next
+          end
+        ensure
+          ScratchPad << :ensure
+        end
+      end
+    end
+  end
+end
 
 describe "The next statement from within the block" do
   before :each do
@@ -125,4 +169,4 @@ describe "The next statement" do
       end
     end
   end
-end
+end

data/{core_spec → spec}/language/or_spec.rb

@@ -1,5 +1,3 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
 describe "The || operator" do
   it "evaluates to true if any of its operands are true" do
     if false || true || nil
@@ -61,5 +59,4 @@ describe "The or operator" do
     (false or ()).should be_nil
     (() or ()).should be_nil
   end
-end
-
+end

data/{core_spec → spec}/language/predefined_spec.rb

@@ -1,5 +1,3 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
 describe "Predefined global $~" do
   it "is set to contain the MatchData object of the last match if successful" do
     md = /foo/.match 'foo'
@@ -18,4 +16,4 @@ describe "Predefined global $~" do
     /foo/ =~ 'bar'
     $~.nil?.should == true
   end
-end
+end

data/{core_spec/language/regexp/interpolation_spec.rb → spec/language/regexp_spec.rb}

@@ -1,7 +1,10 @@
-require File.expand_path('../../../spec_helper', __FILE__)
+describe "Literal Regexps" do
+  it "yields a Regexp" do
+    /Hello/.should be_kind_of(Regexp)
+  end
+end
 
 describe "Regexps with interpolation" do
-
   it "allows interpolation of strings" do
     str = "foo|bar"
     /#{str}/.should == /foo|bar/
@@ -14,4 +17,4 @@ describe "Regexps with interpolation" do
     str = "a"
     /[#{str}-z]/.should == /[a-z]/
   end
-end
+end

data/{core_spec → spec}/language/send_spec.rb

@@ -1,5 +1,39 @@
-require File.expand_path('../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/send', __FILE__)
+module LangSendSpecs
+
+  def self.fooM0; 100; end
+  def self.fooM1(a); [a]; end
+  def self.fooM2(a,b); [a,b]; end
+  def self.fooM3(a,b,c); [a,b,c]; end
+  def self.fooM4(a,b,c,d); [a,b,c,d]; end
+  def self.fooM5(a,b,c,d,e); [a,b,c,d,e]; end
+  def self.fooM0O1(a=1); [a]; end
+  def self.fooM1O1(a,b=1); [a,b]; end
+  def self.fooM2O1(a,b,c=1); [a,b,c]; end
+  def self.fooM3O1(a,b,c,d=1); [a,b,c,d]; end
+  def self.fooM4O1(a,b,c,d,e=1); [a,b,c,d,e]; end
+  def self.fooM0O2(a=1,b=2); [a,b]; end
+  def self.fooM0R(*r); r; end
+  def self.fooM1R(a, *r); [a, r]; end
+  def self.fooM0O1R(a=1, *r); [a, r]; end
+  def self.fooM1O1R(a, b=1, *r); [a, b, r]; end
+
+  def self.one(a); a; end
+  def self.oneb(a,&b); [a,yield(b)]; end
+
+  def self.makeproc(&b) b end
+
+  def self.yield_now; yield; end
+
+  class ToProc
+    def initialize(val)
+      @val = val
+    end
+
+    def to_proc
+      Proc.new { @val }
+    end
+  end
+end
 
 specs = LangSendSpecs
 
@@ -58,7 +92,7 @@ describe "Invoking a method" do
     specs.oneb(10) { 200 }.should == [10,200]
   end
 
-  it "wwith a block converts the block to a Proc" do
+  it "with a block converts the block to a Proc" do
     prc = specs.makeproc { "hello" }
     prc.should be_kind_of(Proc)
     prc.call.should == "hello"
@@ -102,4 +136,4 @@ describe "Invoking a method" do
     specs.fooM1(:rbx => :cool, :specs => :fail_sometimes).should == [{ :rbx => :cool, :specs => :fail_sometimes }]
     (specs.fooM1 :rbx => :cool, :specs => :fail_sometimes).should == [{ :rbx => :cool, :specs => :fail_sometimes }]
   end
-end
+end

data/spec/language/singleton_class_spec.rb

@@ -0,0 +1,31 @@
+describe "A singleton class" do
+  it "is TrueClass for true" do
+    true.singleton_class.should == TrueClass
+  end
+
+  it "is FalseClass for false" do
+    false.singleton_class.should == FalseClass
+  end
+
+  it "is NilClass for nil" do
+    nil.singleton_class.should == NilClass
+  end
+
+  it "raises a TypeError for Fixnum's" do
+    lambda { 1.singleton_class }.should raise_error(TypeError)
+  end
+
+  it "raises a TypeError for synbols" do
+    lambda { :symbol.singleton_class }.should raise_error(TypeError)
+  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)
+  end
+
+  it "is a Class for classes" do
+    ClassSpecs::A::singleton_class.should be_kind_of(Class)
+  end
+end

data/spec/language/super_spec.rb

@@ -0,0 +1,188 @@
+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 "calls the superclass method when in a block" do
+    Super::S6.new.here.should == :good
+  end
+
+  it "calls the superclass when initial method is define_method'd" do
+    Super::S7.new.here.should == :good
+  end
+end
+
+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
+
+  class S5
+    def here
+      :good
+    end
+  end
+
+  class S6 < S5
+    def under
+      yield
+    end
+
+    def here
+      under {
+        super
+      }
+    end
+  end
+
+  class S7 < S5
+    define_method(:here) { super() }
+  end
+
+  module MS1
+    module ModA
+      def foo(a)
+        a << "ModA#foo"
+        bar(a)
+      end
+      def bar(a)
+        a << "ModA#bar"
+      end
+    end
+    class A
+      include ModA
+    end
+    module ModB
+      def bar(a)
+        a << "ModB#bar"
+        super(a)
+      end
+    end
+    class B < A
+      def foo(a)
+        a << "B#foo"
+        super(a)
+      end
+      include ModB
+    end
+  end
+
+  module MS2
+    class A
+      def baz(a)
+        a << "A#baz"
+      end
+    end
+    module ModB
+      def foo(a)
+        a << "ModB#foo"
+        baz(a)
+      end
+    end
+    class B < A
+      include ModB
+    end
+    class C < B
+      def baz(a)
+        a << "C#baz"
+        super(a)
+      end
+    end
+  end
+end