hamster 1.0.1.pre.rc3 → 2.0.0

data/spec/lib/hamster/deque/head_spec.rb

@@ -1,20 +0,0 @@
-require "spec_helper"
-require "hamster/deque"
-
-describe Hamster::Deque do
-  [:head, :first, :front].each do |method|
-    describe "##{method}" do
-      [
-        [[], nil],
-        [["A"], "A"],
-        [%w[A B C], "A"],
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.deque(*values).send(method).should == expected
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/hamster/hash/uniq_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
-
-  [:uniq, :nub, :remove_duplicates].each do |method|
-    describe "##{method}" do
-      it "returns self" do
-        hash.send(method).should equal(hash)
-      end
-    end
-  end
-end

data/spec/lib/hamster/list/elem_index_spec.rb

@@ -1,36 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  [:elem_index, :index].each do |method|
-    describe "##{method}" do
-      context "on a really big list" do
-        it "doesn't run out of stack" do
-          -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).send(method, nil) }.should_not raise_error
-        end
-      end
-
-      [
-        [[], "A", nil],
-        [[], nil, nil],
-        [["A"], "A", 0],
-        [["A"], "B", nil],
-        [["A"], nil, nil],
-        [["A", "B", nil], "A", 0],
-        [["A", "B", nil], "B", 1],
-        [["A", "B", nil], nil, 2],
-        [["A", "B", nil], "C", nil],
-        [[2], 2, 0],
-        [[2], 2.0, 0],
-        [[2.0], 2.0, 0],
-        [[2.0], 2, 0],
-      ].each do |values, item, expected|
-        context "looking for #{item.inspect} in #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.list(*values).send(method, item).should == expected
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/hamster/list/elem_indices_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  [:elem_indices, :indices].each do |method|
-    describe "##{method}" do
-      it "is lazy" do
-        count = 0
-        Hamster.stream { count += 1 }.send(method, nil)
-        count.should <= 1
-      end
-
-      [
-        [[], "A", []],
-        [["A"], "B", []],
-        [%w[A B A], "B", [1]],
-        [%w[A B A], "A", [0, 2]],
-        [[2], 2, [0]],
-        [[2], 2.0, [0]],
-        [[2.0], 2.0, [0]],
-        [[2.0], 2, [0]],
-      ].each do |values, item, expected|
-        context "looking for #{item.inspect} in #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.list(*values).send(method, item).should eql(Hamster.list(*expected))
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/hamster/list/filter_spec.rb

@@ -1,71 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  let(:list) { Hamster.list(*values) }
-  let(:filtered_list) { Hamster.list(*filtered_values) }
-
-  describe "#filter" do
-    it "is lazy" do
-      expect { Hamster.stream { fail }.filter { |item| false } }.to_not raise_error
-    end
-
-    shared_examples "checking values" do
-      context "with a block" do
-        let(:filter) { list.filter { |item| item == item.upcase } }
-
-        it "preserves the original" do
-          expect(list).to eq(Hamster.list(*values))
-        end
-
-        it "returns the filtered list" do
-          expect(filter).to eq(filtered_list)
-        end
-      end
-
-      context "without a block" do
-        let(:filter) { list.filter }
-
-        it "returns an Enumerator" do
-          expect(filter.class).to be(Enumerator)
-          expect(filter.each { |item| item == item.upcase}).to eq(filtered_list)
-        end
-      end
-    end
-
-    context "with an empty array" do
-      let(:values) { [] }
-      let(:filtered_values) { [] }
-
-      include_examples "checking values"
-    end
-
-    context "with a single item array" do
-      let(:values) { ["A"] }
-      let(:filtered_values) { ["A"] }
-
-      include_examples "checking values"
-    end
-
-    context "with a multi-item array" do
-      let(:values) { %w[A B] }
-      let(:filtered_values) { %w[A B] }
-
-      include_examples "checking values"
-    end
-
-    context "with a multi-item single filterable array" do
-      let(:values) { %w[A b] }
-      let(:filtered_values) { ["A"] }
-
-      include_examples "checking values"
-    end
-
-    context "with a multi-item multi-filterable array" do
-      let(:values) { %w[a b] }
-      let(:filtered_values) { [] }
-
-      include_examples "checking values"
-    end
-  end
-end

data/spec/lib/hamster/list/find_indices_spec.rb

@@ -1,37 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  [:find_indices, :indices].each do |method|
-    describe "##{method}" do
-      it "is lazy" do
-        count = 0
-        Hamster.stream { count += 1 }.send(method) { |item| true }
-        count.should <= 1
-      end
-
-      context "on a large list which doesn't contain desired item" do
-        it "doesn't blow the stack" do
-          -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).find_indices { |x| x < 0 }.size }.should_not raise_error
-        end
-      end
-
-      [
-        [[], "A", []],
-        [["A"], "B", []],
-        [%w[A B A], "B", [1]],
-        [%w[A B A], "A", [0, 2]],
-        [[2], 2, [0]],
-        [[2], 2.0, [0]],
-        [[2.0], 2.0, [0]],
-        [[2.0], 2, [0]],
-      ].each do |values, item, expected|
-        context "looking for #{item.inspect} in #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.list(*values).send(method) { |x| x == item }.should eql(Hamster.list(*expected))
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/hamster/set/foreach_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-require "set"
-require "hamster/set"
-
-describe Hamster::Set do
-  let(:set) { Hamster.set("A", "B", "C") }
-
-  describe "#foreach" do
-    let(:foreach) { set.foreach(&block) }
-
-    context "without a block" do
-      let(:block) { nil }
-
-      it "returns an Enumerator" do
-        expect(foreach.class).to be(Enumerator)
-        expect(foreach.to_a).to eq(set.to_a)
-      end
-    end
-
-    context "with an empty block" do
-      let(:block) { ->(item) {} }
-
-      it "returns self" do
-        expect(foreach).to be(set)
-      end
-    end
-
-    context "with a block" do
-      let(:items) { ::Set.new }
-      let(:values) { ::Set.new(%w[A B C]) }
-      let(:block) { ->(item) { items << item } }
-
-      before(:each) { foreach }
-
-      it "yields all values" do
-        expect(items).to eq(values)
-      end
-    end
-  end
-end

data/spec/lib/hamster/set/head_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-require "hamster/set"
-
-describe Hamster::Set do
-  [:head, :first].each do |method|
-    describe "##{method}" do
-      context "on an empty set" do
-        it "returns nil" do
-          Hamster.set.send(method).should be_nil
-        end
-      end
-
-      context "on a non-empty set" do
-        it "returns an arbitrary value from the set" do
-          %w[A B C].include?(Hamster.set("A", "B", "C").send(method)).should == true
-        end
-      end
-
-      it "returns nil if only member of set is nil" do
-        Hamster.set(nil).send(method).should be(nil)
-      end
-
-      it "returns the first item yielded by #each" do
-        10.times do
-          set = Hamster::Set.new((rand(10)+1).times.collect { rand(10000 )})
-          set.each { |item| break item }.should be(set.send(method))
-        end
-      end
-    end
-  end
-end

data/spec/lib/hamster/set/uniq_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-require "hamster/set"
-
-describe Hamster::Set do
-  let(:set) { Hamster.set("A", "B", "C") }
-
-  [:uniq, :nub, :remove_duplicates].each do |method|
-    describe "##{method}" do
-      it "returns self" do
-        set.send(method).should equal(set)
-      end
-    end
-  end
-end

data/spec/lib/hamster/sorted_set/construction_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe ".sorted_set" do
-    context "with no values" do
-      it "returns the empty set" do
-        Hamster.sorted_set.should equal(Hamster::EmptySortedSet)
-        Hamster.sorted_set.should be_empty
-      end
-    end
-
-    context "with a list of values" do
-      let(:sorted_set) { Hamster.sorted_set("A", "B", "C") }
-
-      it "is equivalent to repeatedly using #add" do
-        sorted_set.size.should be(3)
-        sorted_set.should eql(Hamster.sorted_set.add("A").add("B").add("C"))
-      end
-    end
-
-    context "with a block" do
-      it "returns a set sorted using the given block" do
-        set = Hamster.sorted_set('fling', 'chalk', 'whip', 'papaya') { |str| str.reverse }
-        set.to_a.should == ['papaya', 'fling', 'chalk', 'whip']
-      end
-    end
-  end
-end

data/spec/lib/hamster/vector/exist_spec.rb

@@ -1,70 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  let(:vector) { Hamster.vector(*values) }
-
-  describe "#exist?" do
-    let(:exist?) { vector.exist?(&block) }
-
-    context "when created with no values" do
-      let(:values) { [] }
-
-      context "with a block" do
-        let(:block) { ->(item) { item + 1 }}
-
-        it "returns false" do
-          expect(exist?).to be(false)
-        end
-      end
-
-      context "without a block" do
-        let(:block) { nil }
-
-        it "returns false" do
-          expect(exist?).to be(false)
-        end
-      end
-    end
-
-    context "when created with values" do
-      let(:values) { ["A", "B", 3, nil] }
-
-      context "with a block that returns true" do
-        let(:block) { ->(item) { item == 3 }}
-
-        it "returns true" do
-          expect(exist?).to be(true)
-        end
-      end
-
-      context "with a block that doesn't return true" do
-        let(:block) { ->(item) { item == "D" }}
-
-        it "returns false" do
-          expect(exist?).to be(false)
-        end
-      end
-
-      context "without a block" do
-        let(:block) { nil }
-
-        context "with some values that are truthy" do
-          let(:values) { [nil, false, "B"] }
-
-          it "returns true" do
-            expect(exist?).to be(true)
-          end
-        end
-
-        context "with all values that are falsey" do
-          let(:values) { [nil, false] }
-
-          it "returns false" do
-            expect(exist?).to be(false)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/hamster/vector/exists_spec.rb

@@ -1,70 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  let(:vector) { Hamster.vector(*values) }
-
-  describe "#exists?" do
-    let(:exists?) { vector.exists?(&block) }
-
-    context "when created with no values" do
-      let(:values) { [] }
-
-      context "with a block" do
-        let(:block) { ->(item) { item + 1 }}
-
-        it "returns false" do
-          expect(exists?).to be(false)
-        end
-      end
-
-      context "without a block" do
-        let(:block) { nil }
-
-        it "returns false" do
-          expect(exists?).to be(false)
-        end
-      end
-    end
-
-    context "when created with values" do
-      let(:values) { ["A", "B", 3, nil] }
-
-      context "with a block that returns true" do
-        let(:block) { ->(item) { item == 3 }}
-
-        it "returns true" do
-          expect(exists?).to be(true)
-        end
-      end
-
-      context "with a block that doesn't return true" do
-        let(:block) { ->(item) { item == "D" }}
-
-        it "returns false" do
-          expect(exists?).to be(false)
-        end
-      end
-
-      context "without a block" do
-        let(:block) { nil }
-
-        context "with some values that are truthy" do
-          let(:values) { [nil, false, "B"] }
-
-          it "returns true" do
-            expect(exists?).to be(true)
-          end
-        end
-
-        context "with all values that are falsey" do
-          let(:values) { [nil, false] }
-
-          it "returns false" do
-            expect(exists?).to be(false)
-          end
-        end
-      end
-    end
-  end
-end