opal 0.3.16 → 0.3.17

data/core_spec/core/enumerable/find_spec.rb

@@ -1,3 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-require File.expand_path('../shared/find', __FILE__)

data/core_spec/core/enumerable/first_spec.rb

@@ -1,3 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-require File.expand_path('../shared/take', __FILE__)

data/core_spec/core/enumerable/shared/entries.rb

@@ -1,7 +0,0 @@
-#describe :enumerable_entries, :shared => true do
-describe :enumerable_entires do
-  it "returns an array containing the elements" do
-    numerous = EnumerableSpecs::Numerous.new(1, nil, 'a', 2, false, true)
-    numerous.to_a.should == [1, nil, "a", 2, false, true]
-  end
-end

data/core_spec/core/enumerable/shared/find.rb

@@ -1,49 +0,0 @@
-describe "Enumerable#find" do
-  # #detect and #find are aliases, so we only need one function
-  before :each do
-    ScratchPad.record []
-    @elements = [2, 4, 6, 8, 10]
-    @numerous = EnumerableSpecs::Numerous.new(*@elements)
-    @empty = []
-  end
-
-  it "passes each entry in enum to block while block when block is false" do
-    visited_elements = []
-    @numerous.find do |element|
-      visited_elements << element
-      false
-    end
-    visited_elements.should == @elements
-  end
-
-  it "returns nil when the block is false and there is no ifnore proc given" do
-    @numerous.find {|e| false }.should == nil
-  end
-
-  it "returns the first element for which the block is not false" do
-    @elements.each do |element|
-      @numerous.find {|e| e > element - 1 }.should == element
-    end
-  end
-
-  it "returns the value of the ifnone proc if the block is false" do
-    fail_proc = lambda { "cheeseburgers" }
-    @numerous.find(fail_proc) { |e| false }.should == "cheeseburgers"
-  end
-
-  it "doesn't call the ifnone proc if an element is found" do
-    fail_proc = lambda { raise "This shouldn't have been called" }
-    @numerous.find(fail_proc) {|e| e == @elements.first }.should == 2
-  end
-
-  it "calls the ifnone proc only once when the block is false" do
-    times = 0
-    fail_proc = lambda { times += 1; raise if times > 1; "cheeseburgers" }
-    @numerous.find(fail_proc) {|e| false }.should == "cheeseburgers"
-  end
-
-  it "calls the ifnone proc when there are no elements" do
-    fail_proc = lambda { "yay" }
-    @empty.find(fail_proc) {|e| true }.should == "yay"
-  end
-end

data/core_spec/core/enumerable/shared/take.rb

@@ -1,31 +0,0 @@
-describe :enumerable_take, :shared => true do
-  before :each do
-    @values = [4,3,2,1,0,-1]
-    @enum = EnumerableSpecs::Numerous.new(*@values)
-  end
-
-  it "returns the first count elements if given a count" do
-    @enum.first(2).should == [4, 3]
-    @enum.first(4).should == [4, 3, 2, 1]
-  end
-
-  it "returns an empty array when passed count on an empty array" do
-    empty = EnumerableSpecs::Empty.new
-    empty.first(0).should == []
-    empty.first(1).should == []
-    empty.first(2).should == []
-  end
-
-  it "returns an empty array when passed count == 0" do
-    @enum.first(0).should == []
-  end
-
-  it "returns an array containing the first element when passed count == 1" do
-    @enum.first(1).should == [4]
-  end
-
-  it "returns the entire array when count > length" do
-    @enum.first(100).should == @values
-    @enum.first(8).should == @values
-  end
-end

data/core_spec/core/enumerable/to_a_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-require File.expand_path('../shared/entries', __FILE__)
-
-describe "Enumerable#to_a" do
-  it_behaves_like(:enumerable_entries, :to_a)
-end

data/core_spec/core/hash/assoc_spec.rb

@@ -1,29 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-#ruby_version_is "1.9" do
-  describe "Hash#assoc" do
-    before(:each) do
-      @h = {:apple => :green, :orange => :orange, :grape => :green, :banana => :yellow}
-    end
-
-    it "returns an Array is the argument is == to a key of the Hash" do
-      @h.assoc(:apple).should be_kind_of(Array)
-    end
-
-    it "returns a 2-element Array if the argument is == to a key of the Hash" do
-      @h.assoc(:grape).size.should == 2
-    end
-
-    it "sets the first element of the Array to the located key" do
-      @h.assoc(:banana).first.should == :banana
-    end
-
-    it "sets the last element of the Array to the value of the located key" do
-      @h.assoc(:banana).last.should == :yellow
-    end
-
-    it "returns nil if the argument if not a key of the Hash" do
-      @h.assoc(:green).should be_nil
-    end
-  end
-#end

data/core_spec/core/object/is_a_spec.rb

@@ -1,2 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../shared/kind_of', __FILE__)

data/core_spec/core/regexp/shared/match.rb

@@ -1,11 +0,0 @@
-require File.expand_path('../../../../spec_helper', __FILE__)
-
-describe :regexp_match do
-  it "returns nil if there is no match" do
-    /xyz/.match("abxyc").should be_nil
-  end
-
-  it "returns nil if the object is nil" do
-    /xyz/.match(nil).should be_nil
-  end
-end

data/core_spec/language/fixtures/block.rb

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

data/core_spec/language/fixtures/break.rb

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

data/core_spec/language/fixtures/defined.rb

@@ -1,9 +0,0 @@
-module DefinedSpecs
-
-  class Basic
-    A = 42
-
-    def a_defined_method
-    end
-  end
-end

data/core_spec/language/fixtures/ensure.rb

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

data/core_spec/language/fixtures/next.rb

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

data/core_spec/language/fixtures/send.rb

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

data/core_spec/language/fixtures/super.rb

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

data/core_spec/language/regexp_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe "Literal Regexps" do
-  it "yields a Regexp" do
-    /Hello/.should be_kind_of(Regexp)
-  end
-end

data/core_spec/language/string_spec.rb

@@ -1,4 +0,0 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-describe "Ruby character strings" do
-end

data/core_spec/language/super_spec.rb

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

data/core_spec/language/versions/hash_1.9.rb

@@ -1,20 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "Hash literal" do
-  describe "new-style hash syntax" do
-    it "constructs a new hash with the given elements" do
-      {foo: 123}.should == {:foo => 123}
-      {rbx: :cool, specs: 'fail_sometimes'}.should == {:rbx => :cool, :specs => 'fail_sometimes'}
-    end
-
-    it "ignores a hanging comma" do
-      {foo: 123,}.should == {:foo => 123}
-      {rbx: :cool, specs: 'fail_sometimes',}.should == {:rbx => :cool, :specs => 'fail_sometimes'}
-    end
-
-    it "can mix and match syntax styles" do
-      {rbx: :cool, :specs => 'fail_sometimes'}.should == {:rbx => :cool, :specs => 'fail_sometimes'}
-      {'rbx' => :cool, specs: 'fail_sometimes'}.should == {'rbx' => :cool, :specs => 'fail_sometimes'}
-    end
-  end
-end