hamster 1.0.0 → 1.0.1.pre.rc.1

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

@@ -1,64 +0,0 @@
-require "spec_helper"
-require "hamster/set"
-
-describe Hamster::Set do
-  [:union, :|, :+, :merge].each do |method|
-    describe "##{method}" do
-      [
-        [[], [], []],
-        [["A"], [], ["A"]],
-        [["A"], ["A"], ["A"]],
-        [[], ["A"], ["A"]],
-        [%w[A B C], [], %w[A B C]],
-        [%w[A B C], %w[A B C], %w[A B C]],
-        [%w[A B C], %w[X Y Z], %w[A B C X Y Z]]
-      ].each do |a, b, expected|
-        context "for #{a.inspect} and #{b.inspect}" do
-          let(:set_a) { Hamster.set(*a) }
-          let(:set_b) { Hamster.set(*b) }
-
-          it "returns #{expected.inspect}, without changing the original Sets" do
-            set_a.send(method, set_b).should eql(Hamster.set(*expected))
-            set_a.should eql(Hamster::Set.new(a))
-            set_b.should eql(Hamster::Set.new(b))
-          end
-        end
-
-        context "for #{b.inspect} and #{a.inspect}" do
-          let(:set_a) { Hamster.set(*a) }
-          let(:set_b) { Hamster.set(*b) }
-
-          it "returns #{expected.inspect}, without changing the original Sets" do
-            set_b.send(method, set_a).should eql(Hamster.set(*expected))
-            set_a.should eql(Hamster::Set.new(a))
-            set_b.should eql(Hamster::Set.new(b))
-          end
-        end
-
-        context "when passed a Ruby Array" do
-          it "returns the expected Set" do
-            Hamster.set(*a).send(method, b.freeze).should eql(Hamster.set(*expected))
-            Hamster.set(*b).send(method, a.freeze).should eql(Hamster.set(*expected))
-          end
-        end
-
-        context "from a subclass" do
-          it "returns an instance of the subclass" do
-            subclass = Class.new(Hamster::Set)
-            subclass.new(a).send(method, Hamster::Set.new(b)).class.should be(subclass)
-            subclass.new(b).send(method, Hamster::Set.new(a)).class.should be(subclass)
-          end
-        end
-      end
-
-      context "when receiving a subset" do
-        let(:set_a) { Hamster.set(*(1..300).to_a) }
-        let(:set_b) { Hamster.set(*(1..200).to_a) }
-
-        it "returns self" do
-          set_a.send(method, set_b).should be(set_a)
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe "#above" do
-    context "when called without a block" do
-      it "returns a sorted set of all items higher than the argument" do
-        100.times do
-          items = rand(100).times.collect { rand(1000) }
-          set   = Hamster::SortedSet.new(items)
-          threshold = rand(1000)
-          result = set.above(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 higher than the argument" do
-        100.times do
-          items = rand(100).times.collect { rand(1000) }
-          set   = Hamster::SortedSet.new(items)
-          threshold = rand(1000)
-          result = []
-          set.above(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.above(1).should be_empty
-        Hamster::SortedSet.empty.above('abc').should be_empty
-        Hamster::SortedSet.empty.above(:symbol).should be_empty
-      end
-    end
-
-    context "with an argument higher than all the values in the set" do
-      it "returns an empty set" do
-        result = Hamster.sorted_set(*(1..100)).above(100)
-        result.class.should be(Hamster::SortedSet)
-        result.should be_empty
-      end
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  let(:sorted_set) { Hamster.sorted_set("B", "C", "D") }
-
-  [:add, :<<].each do |method|
-    describe "##{method}" do
-      context "with a unique value" do
-        it "preserves the original" do
-          sorted_set.send(method, "A")
-          sorted_set.should eql(Hamster.sorted_set("B", "C", "D"))
-        end
-
-        it "returns a copy with the superset of values (in order)" do
-          sorted_set.send(method, "A").should eql(Hamster.sorted_set("A", "B", "C", "D"))
-        end
-      end
-
-      context "with a duplicate value" do
-        it "preserves the original values" do
-          sorted_set.send(method, "C")
-          sorted_set.should eql(Hamster.sorted_set("B", "C", "D"))
-        end
-
-        it "returns self" do
-          sorted_set.send(method, "C").should equal(sorted_set)
-        end
-      end
-
-      context "on a set ordered by a comparator" do
-        it "inserts the new item in the correct place" do
-          s = Hamster.sorted_set('tick', 'pig', 'hippopotamus') { |str| str.length }
-          s.add('giraffe').to_a.should == ['pig', 'tick', 'giraffe', 'hippopotamus']
-        end
-      end
-    end
-  end
-
-  describe "#add?" do
-    context "with a unique value" do
-      it "preserves the original" do
-        sorted_set.add?("A")
-        sorted_set.should eql(Hamster.sorted_set("B", "C", "D"))
-      end
-
-      it "returns a copy with the superset of values" do
-        sorted_set.add?("A").should eql(Hamster.sorted_set("A", "B", "C", "D"))
-      end
-    end
-
-    context "with a duplicate value" do
-      it "preserves the original values" do
-        sorted_set.add?("C")
-        sorted_set.should eql(Hamster.sorted_set("B", "C", "D"))
-      end
-
-      it "returns false" do
-        sorted_set.add?("C").should equal(false)
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe "#at" do
-    [
-      [[], 10, nil],
-      [["A"], 10, nil],
-      [%w[A B C], 0, "A"],
-      [%w[A B C], 1, "B"],
-      [%w[A B C], 2, "C"],
-      [%w[A B C], 3, nil],
-      [%w[A B C], -1, "C"],
-      [%w[A B C], -2, "B"],
-      [%w[A B C], -3, "A"],
-      [%w[A B C], -4, nil]
-    ].each do |values, number, expected|
-      describe "#{values.inspect} with #{number}" do
-        it "returns #{expected.inspect}" do
-          Hamster.sorted_set(*values).at(number).should == expected
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe "#below" do
-    context "when called without a block" do
-      it "returns a sorted set of all items lower than the argument" do
-        100.times do
-          items = rand(100).times.collect { rand(1000) }
-          set   = Hamster::SortedSet.new(items)
-          threshold = rand(1000)
-          result = set.below(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 lower than the argument" do
-        100.times do
-          items = rand(100).times.collect { rand(1000) }
-          set   = Hamster::SortedSet.new(items)
-          threshold = rand(1000)
-          result = []
-          set.below(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.below(1).should be_empty
-        Hamster::SortedSet.empty.below('abc').should be_empty
-        Hamster::SortedSet.empty.below(:symbol).should be_empty
-      end
-    end
-
-    context "with an argument lower than all the values in the set" do
-      it "returns an empty set" do
-        result = Hamster.sorted_set(*(1..100)).below(1)
-        result.class.should be(Hamster::SortedSet)
-        result.should be_empty
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe "#between" do
-    context "when called without a block" do
-      it "returns a sorted set of all items from the first argument to the second" do
-        100.times do
-          items = rand(100).times.collect { rand(1000) }
-          set   = Hamster::SortedSet.new(items)
-          from,to = [rand(1000),rand(1000)].sort
-          result = set.between(from, to)
-          array  = items.select { |x| x >= from && x <= to }.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 lower than the argument" do
-        100.times do
-          items = rand(100).times.collect { rand(1000) }
-          set   = Hamster::SortedSet.new(items)
-          from,to = [rand(1000),rand(1000)].sort
-          result = []
-          set.between(from, to) { |x| result << x }
-          array  = items.select { |x| x >= from && x <= to }.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.between(1, 2).should be_empty
-        Hamster::SortedSet.empty.between('abc', 'def').should be_empty
-        Hamster::SortedSet.empty.between(:symbol, :another).should be_empty
-      end
-    end
-
-    context "with a 'to' argument lower than the 'from' argument" do
-      it "returns an empty set" do
-        result = Hamster.sorted_set(*(1..100)).between(6, 5)
-        result.class.should be(Hamster::SortedSet)
-        result.should be_empty
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe "#clear" do
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      context "on #{values}" do
-        let(:sorted_set) { Hamster.sorted_set(*values) }
-
-        it "preserves the original" do
-          sorted_set.clear
-          sorted_set.should eql(Hamster.sorted_set(*values))
-        end
-
-        it "returns an empty set" do
-          sorted_set.clear.should equal(Hamster::EmptySortedSet)
-          sorted_set.clear.should be_empty
-        end
-      end
-    end
-
-    context "from a subclass" do
-      it "returns an empty instance of the subclass" do
-        subclass = Class.new(Hamster::SortedSet)
-        instance = subclass.new([:a, :b, :c, :d])
-        instance.clear.class.should be(subclass)
-        instance.clear.should be_empty
-      end
-    end
-
-    context "with a comparator" do
-      let(:sorted_set) { Hamster::SortedSet.new([1, 2, 3]) { |x| -x } }
-      it "returns an empty instance with same comparator" do
-        e = sorted_set.clear
-        e.should be_empty
-        e.add(4).add(5).add(6).to_a.should == [6, 5, 4]
-      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/sorted_set/delete_at_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  describe "#delete_at" do
-    let(:sorted_set) { Hamster.sorted_set(1,2,3,4,5) }
-
-    it "removes the element at the specified index" do
-      sorted_set.delete_at(0).should eql(Hamster.sorted_set(2,3,4,5))
-      sorted_set.delete_at(2).should eql(Hamster.sorted_set(1,2,4,5))
-      sorted_set.delete_at(-1).should eql(Hamster.sorted_set(1,2,3,4))
-    end
-
-    it "makes no modification if the index is out of range" do
-      sorted_set.delete_at(5).should eql(sorted_set)
-      sorted_set.delete_at(-6).should eql(sorted_set)
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-require "spec_helper"
-require "hamster/sorted_set"
-
-describe Hamster::SortedSet do
-  let(:sorted_set) { Hamster.sorted_set("A", "B", "C") }
-
-  describe "#delete" do
-    context "on an empty set" do
-      it "returns an empty set" do
-        Hamster::EmptySortedSet.delete(0).should be(Hamster::EmptySortedSet)
-      end
-    end
-
-    context "with an existing value" do
-      it "preserves the original" do
-        sorted_set.delete("B")
-        sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
-      end
-
-      it "returns a copy with the remaining of values" do
-        sorted_set.delete("B").should eql(Hamster.sorted_set("A", "C"))
-      end
-    end
-
-    context "with a non-existing value" do
-      it "preserves the original values" do
-        sorted_set.delete("D")
-        sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
-      end
-
-      it "returns self" do
-        sorted_set.delete("D").should equal(sorted_set)
-      end
-    end
-
-    context "when removing the last value in a sorted set" do
-      it "maintains the set order" do
-        ss = Hamster.sorted_set("peanuts", "jam", "milk") { |word| word.length }
-        ss = ss.delete("jam").delete("peanuts").delete("milk")
-        ss = ss.add("banana").add("sugar").add("spam")
-        ss.to_a.should == ['spam', 'sugar', 'banana']
-      end
-
-      context "when the set is in natural order" do
-        it "returns the canonical empty set" do
-          sorted_set.delete("B").delete("C").delete("A").should be(Hamster::EmptySortedSet)
-        end
-      end
-    end
-
-    1.upto(10) do |n|
-      values = (1..n).to_a
-      values.combination(3) do |to_delete|
-        expected = to_delete.reduce(values.dup) { |ary,val| ary.delete(val); ary }
-        describe "on #{values.inspect}, when deleting #{to_delete.inspect}" do
-          it "returns #{expected.inspect}" do
-            set = Hamster::SortedSet.new(values)
-            result = to_delete.reduce(set) { |s,val| s.delete(val) }
-            result.should eql(Hamster::SortedSet.new(expected))
-            result.to_a.should eql(expected)
-          end
-        end
-      end
-    end
-  end
-
-  describe "#delete?" do
-    context "with an existing value" do
-      it "preserves the original" do
-        sorted_set.delete?("B")
-        sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
-      end
-
-      it "returns a copy with the remaining values" do
-        sorted_set.delete?("B").should eql(Hamster.sorted_set("A", "C"))
-      end
-    end
-
-    context "with a non-existing value" do
-      it "preserves the original values" do
-        sorted_set.delete?("D")
-        sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
-      end
-
-      it "returns false" do
-        sorted_set.delete?("D").should be(false)
-      end
-    end
-  end
-end