hamster 1.0.0 → 1.0.1.pre.rc.1

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

@@ -1,55 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe "#take" do
-    [
-      [[], 10, []],
-      [["A"], 10, ["A"]],
-      [%w[A B C], 0, []],
-      [%w[A B C], 2, %w[A B]],
-    ].each do |values, number, expected|
-      context "#{number} from #{values.inspect}" do
-        let(:sorted_set) { Hamster.sorted_set(*values) }
-
-        it "preserves the original" do
-          sorted_set.take(number)
-          sorted_set.should eql(Hamster.sorted_set(*values))
-        end
-
-        it "returns #{expected.inspect}" do
-          sorted_set.take(number).should eql(Hamster.sorted_set(*expected))
-        end
-      end
-    end
-
-    context "when argument is at least size of receiver" do
-      let(:sorted_set) { Hamster.sorted_set(6, 7, 8, 9) }
-      it "returns self" do
-        sorted_set.take(sorted_set.size).should be(sorted_set)
-        sorted_set.take(sorted_set.size + 1).should be(sorted_set)
-      end
-    end
-
-    context "when the set has a custom order" do
-      let(:sorted_set) { Hamster.sorted_set(1, 2, 3) { |x| -x }}
-      it "maintains the custom order" do
-        sorted_set.take(1).to_a.should == [3]
-        sorted_set.take(2).to_a.should == [3, 2]
-        sorted_set.take(3).to_a.should == [3, 2, 1]
-      end
-
-      it "keeps the comparator even when set is cleared" do
-        s = sorted_set.take(0)
-        s.add(4).add(5).add(6).to_a.should == [6, 5, 4]
-      end
-    end
-
-    context "when called on a subclass" do
-      it "should return an instance of the subclass" do
-        subclass = Class.new(Hamster::SortedSet)
-        subclass.new([1,2,3]).take(1).class.should be(subclass)
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe "#take_while" do
-    [
-      [[], []],
-      [["A"], ["A"]],
-      [%w[A B C], %w[A B]],
-    ].each do |values, expected|
-      context "on #{values.inspect}" do
-        let(:sorted_set) { Hamster.sorted_set(*values) }
-
-        context "with a block" do
-          it "returns #{expected.inspect}" do
-            sorted_set.take_while { |item| item < "C" }.should eql(Hamster.sorted_set(*expected))
-          end
-
-          it "preserves the original" do
-            sorted_set.take_while { |item| item < "C" }
-            sorted_set.should eql(Hamster.sorted_set(*values))
-          end
-        end
-
-        context "without a block" do
-          it "returns an Enumerator" do
-            sorted_set.take_while.class.should be(Enumerator)
-            sorted_set.take_while.each { |item| item < "C" }.should eql(Hamster.sorted_set(*expected))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-require "hamster/set"
-
-describe Hamster::SortedSet do
-  describe "#to_set" do
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      context "on #{values.inspect}" do
-        it "returns a set with the same values" do
-          Hamster.sorted_set(*values).to_set.should eql(Hamster.set(*values))
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  [:union, :|, :+, :merge].each do |method|
-    describe "##{method}" do
-      [
-        [[], [], []],
-        [["A"], [], ["A"]],
-        [["A"], ["A"], ["A"]],
-        [%w[A B C], [], %w[A B C]],
-        [%w[A C E G X], %w[B C D E H M], %w[A B C D E G H M X]]
-      ].each do |a, b, expected|
-        context "for #{a.inspect} and #{b.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.sorted_set(*a).send(method, Hamster.sorted_set(*b)).should eql(Hamster.sorted_set(*expected))
-          end
-        end
-
-        context "for #{b.inspect} and #{a.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.sorted_set(*b).send(method, Hamster.sorted_set(*a)).should eql(Hamster.sorted_set(*expected))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe "#up_to" do
-    context "when called without a block" do
-      it "returns a sorted set of all items equal to or less than the argument" do
-        100.times do
-          items = rand(100).times.collect { rand(1000) }
-          set   = Hamster::SortedSet.new(items)
-          threshold = rand(1000)
-          result = set.up_to(threshold)
-          array  = items.select { |x| x <= threshold }.sort
-          result.class.should be(Hamster::SortedSet)
-          result.size.should == array.size
-          result.to_a.should == array
-        end
-      end
-    end
-
-    context "when called with a block" do
-      it "yields all the items equal to or less than than the argument" do
-        100.times do
-          items = rand(100).times.collect { rand(1000) }
-          set   = Hamster::SortedSet.new(items)
-          threshold = rand(1000)
-          result = []
-          set.up_to(threshold) { |x| result << x }
-          array  = items.select { |x| x <= threshold }.sort
-          result.size.should == array.size
-          result.should == array
-        end
-      end
-    end
-
-    context "on an empty set" do
-      it "returns an empty set" do
-        Hamster::SortedSet.empty.up_to(1).should be_empty
-        Hamster::SortedSet.empty.up_to('abc').should be_empty
-        Hamster::SortedSet.empty.up_to(:symbol).should be_empty
-      end
-    end
-
-    context "with an argument less than all the values in the set" do
-      it "returns an empty set" do
-        result = Hamster.sorted_set(*(1..100)).up_to(0)
-        result.class.should be(Hamster::SortedSet)
-        result.should be_empty
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe "#values_at" do
-    let(:sorted_set) { Hamster.sorted_set('a', 'b', 'c') }
-
-    it "accepts any number of indices, and returns a sorted_set of items at those indices" do
-      sorted_set.values_at(0).should eql(Hamster.sorted_set('a'))
-      sorted_set.values_at(1,2).should eql(Hamster.sorted_set('b', 'c'))
-    end
-
-    context "when passed invalid indices" do
-      it "filters them out" do
-        sorted_set.values_at(1,2,3).should eql(Hamster.sorted_set('b', 'c'))
-        sorted_set.values_at(-10,10).should eql(Hamster.sorted_set)
-      end
-    end
-
-    context "when passed no arguments" do
-      it "returns an empty sorted_set" do
-        sorted_set.values_at.should eql(Hamster.sorted_set)
-      end
-    end
-
-    context "from a subclass" do
-      it "returns an instance of the subclass" do
-        subclass = Class.new(Hamster::SortedSet)
-        instance = subclass.new([1,2,3])
-        instance.values_at(1,2).class.should be(subclass)
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  let(:vector) { Hamster.vector(*values) }
-
-  [:add, :<<, :push].each do |method|
-    describe "##{method}" do
-      shared_examples "checking adding values" do
-        let(:added_vector) { Hamster.vector(*added_values) }
-
-        it "preserves the original" do
-          original = vector
-          vector.send(method, added_value)
-          expect(original).to eq(vector)
-        end
-
-        it "adds the item to the vector" do
-          result = vector.send(method, added_value)
-          expect(result).to eq(added_vector)
-          expect(result.size).to eq(vector.size + 1)
-        end
-      end
-
-      context "with a empty vector adding a single item" do
-        let(:values) { [] }
-        let(:added_value) { "A" }
-        let(:added_values) { ["A"] }
-
-        include_examples "checking adding values"
-      end
-
-      context "with a single-item vector adding a different item" do
-        let(:values) { ["A"] }
-        let(:added_value) { "B" }
-        let(:added_values) { %w[A B] }
-
-        include_examples "checking adding values"
-      end
-
-      context "with a single-item vector adding a duplicate item" do
-        let(:values) { ["A"] }
-        let(:added_value) { "A" }
-        let(:added_values) { %w[A A] }
-
-        include_examples "checking adding values"
-      end
-
-      [31, 32, 33, 1023, 1024, 1025].each do |size|
-        context "with a #{size}-item vector adding a different item" do
-          let(:values) { (1..size).to_a }
-          let(:added_value) { size+1 }
-          let(:added_values) { (1..(size+1)).to_a }
-
-          include_examples "checking adding values"
-        end
-      end
-
-      context "from a subclass" do
-        it "returns an instance of the subclass" do
-          subclass = Class.new(Hamster::Vector)
-          instance = subclass[1,2,3]
-          instance.add(4).class.should be(subclass)
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  let(:vector) { Hamster.vector([:a, 3], [:b, 2], [:c, 1]) }
-
-  describe "#assoc" do
-    it "searches for a 2-element array with a given 1st item" do
-      vector.assoc(:b).should == [:b, 2]
-    end
-
-    it "returns nil if a matching 1st item is not found" do
-      vector.assoc(:d).should be_nil
-    end
-
-    it "uses #== to compare 1st items with provided object" do
-      vector.assoc(EqualNotEql.new).should_not be_nil
-      vector.assoc(EqlNotEqual.new).should be_nil
-    end
-  end
-
-  describe "#rassoc" do
-    it "searches for a 2-element array with a given 2nd item" do
-      vector.rassoc(1).should == [:c, 1]
-    end
-
-    it "returns nil if a matching 2nd item is not found" do
-      vector.rassoc(4).should be_nil
-    end
-
-    it "uses #== to compare 2nd items with provided object" do
-      vector.rassoc(EqualNotEql.new).should_not be_nil
-      vector.rassoc(EqlNotEqual.new).should be_nil
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  describe "#bsearch" do
-    let(:vector) { Hamster.vector(5,10,20,30) }
-
-    context "with a block which returns false for elements below desired position, and true for those at/above" do
-      it "returns the first element for which the predicate is true" do
-        vector.bsearch { |x| x > 10 }.should be(20)
-        vector.bsearch { |x| x > 1 }.should be(5)
-        vector.bsearch { |x| x > 25 }.should be(30)
-      end
-
-      context "if the block always returns false" do
-        it "returns nil" do
-          vector.bsearch { false }.should be_nil
-        end
-      end
-
-      context "if the block always returns true" do
-        it "returns the first element" do
-          vector.bsearch { true }.should be(5)
-        end
-      end
-    end
-
-    context "with a block which returns a negative number for elements below desired position, zero for the right element, and positive for those above" do
-      it "returns the element for which the block returns zero" do
-        vector.bsearch { |x| x <=> 10 }.should be(10)
-      end
-
-      context "if the block always returns positive" do
-        it "returns nil" do
-          vector.bsearch { 1 }.should be_nil
-        end
-      end
-
-      context "if the block always returns negative" do
-        it "returns nil" do
-          vector.bsearch { -1 }.should be_nil
-        end
-      end
-
-      context "if the block returns sometimes positive, sometimes negative, but never zero" do
-        it "returns nil" do
-          vector.bsearch { |x| x <=> 11 }.should be_nil
-        end
-      end
-    end
-
-    context "on an empty vector" do
-      it "returns nil" do
-        Hamster.vector.bsearch { |x| x > 5 }.should be_nil
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  describe "#clear" do
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      describe "on #{values}" do
-        let(:vector) { Hamster.vector(*values) }
-
-        it "preserves the original" do
-          vector.clear
-          vector.should eql(Hamster.vector(*values))
-        end
-
-        it "returns an empty vector" do
-          vector.clear.should equal(Hamster.vector)
-        end
-      end
-
-      context "from a subclass" do
-        it "returns an instance of the subclass" do
-          subclass = Class.new(Hamster::Vector)
-          instance = subclass.new(%w{a b c})
-          instance.clear.class.should be(subclass)
-          instance.clear.should be_empty
-        end
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  describe "#combination" do
-    let(:vector) { Hamster.vector(1,2,3,4) }
-
-    context "with a block" do
-      it "returns self" do
-        vector.combination(2) {}.should be(vector)
-      end
-    end
-
-    context "with no block" do
-      it "returns an Enumerator" do
-        vector.combination(2).class.should be(Enumerator)
-        vector.combination(2).to_a.should == vector.to_a.combination(2).to_a
-      end
-    end
-
-    context "when passed an argument which is out of bounds" do
-      it "yields nothing and returns self" do
-        vector.combination(5) { fail }.should be(vector)
-        vector.combination(-1) { fail }.should be(vector)
-      end
-    end
-
-    context "when passed an argument zero" do
-      it "yields an empty array" do
-        result = []
-        vector.combination(0) { |obj| result << obj }
-        result.should eql([[]])
-      end
-    end
-
-    context "when passed an argument equal to the vector's length" do
-      it "yields self as an array" do
-        result = []
-        vector.combination(4) { |obj| result << obj }
-        result.should eql([vector.to_a])
-      end
-    end
-
-    context "when passed an argument 1" do
-      it "yields each item in the vector, as single-item vectors" do
-        result = []
-        vector.combination(1) { |obj| result << obj }
-        result.should eql([[1], [2], [3], [4]])
-      end
-    end
-
-    context "when passed another integral argument" do
-      it "yields all combinations of the given length" do
-        result = []
-        vector.combination(3) { |obj| result << obj }
-        result.should eql([[1,2,3], [1,2,4], [1,3,4], [2,3,4]])
-      end
-    end
-
-    context "on an empty vector" do
-      it "works the same" do
-        Hamster.vector.combination(0).to_a.should == [[]]
-        Hamster.vector.combination(1).to_a.should == []
-      end
-    end
-
-    it "works on many combinations of input" do
-      0.upto(5) do |comb_size|
-        array = 12.times.map { rand(1000) }
-        V.new(array).combination(comb_size).to_a.should == array.combination(comb_size).to_a
-      end
-
-      array = 20.times.map { rand(1000) }
-      V.new(array).combination(2).to_a.should == array.combination(2).to_a
-    end
-
-    it "leaves the original unmodified" do
-      vector.combination(2) {}
-      vector.should eql(Hamster.vector(1,2,3,4))
-    end
-  end
-end