hamster 0.4.3 → 1.0.0

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

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

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

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

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

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

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

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "hamster/sorted_set"
+
+describe Hamster::SortedSet do
+  [:difference, :subtract, :-].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], []],
+        [["A"], [], ["A"]],
+        [["A"], ["A"], []],
+        [%w[A B C], ["B"], %w[A C]],
+        [%w[A B C], %w[A C], ["B"]],
+        [%w[A B C D E F], %w[B E F G M X], %w[A C D]]
+      ].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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "hamster/sorted_set"
+
+describe Hamster::SortedSet do
+  describe "#disjoint?" do
+    [
+      [[], [], true],
+      [["A"], [], true],
+      [[], ["A"], true],
+      [["A"], ["A"], false],
+      [%w[A B C], ["B"], false],
+      [["B"], %w[A B C], false],
+      [%w[A B C], %w[D E], true],
+      [%w[F G H I], %w[A B C], true],
+      [%w[A B C], %w[A B C], false],
+      [%w[A B C], %w[A B C D], false],
+      [%w[D E F G], %w[A B C], true],
+    ].each do |a, b, expected|
+      context "for #{a.inspect} and #{b.inspect}" do
+        it "returns #{expected}" do
+          Hamster.sorted_set(*a).disjoint?(Hamster.sorted_set(*b)).should be(expected)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require "spec_helper"
+require "hamster/sorted_set"
+
+describe Hamster::SortedSet do
+  describe "#drop" do
+    [
+      [[], 0, []],
+      [[], 10, []],
+      [["A"], 10, []],
+      [%w[A B C], 0, %w[A B C]],
+      [%w[A B C], 1, %w[B C]],
+      [%w[A B C], 2, ["C"]],
+      [%w[A B C], 3, []]
+    ].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.drop(number)
+          sorted_set.should eql(Hamster.sorted_set(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          sorted_set.drop(number).should eql(Hamster.sorted_set(*expected))
+        end
+      end
+    end
+
+    context "when argument is zero" do
+      let(:sorted_set) { Hamster.sorted_set(6, 7, 8, 9) }
+      it "returns self" do
+        sorted_set.drop(0).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.drop(1).to_a.should == [2, 1]
+        sorted_set.drop(2).to_a.should == [1]
+      end
+
+      it "keeps the comparator even when set is cleared" do
+        s = sorted_set.drop(3)
+        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]).drop(1).class.should be(subclass)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+require "hamster/sorted_set"
+
+describe Hamster::SortedSet do
+  describe "#each" do
+    context "with no block" do
+      let(:sorted_set) { Hamster.sorted_set("A", "B", "C") }
+
+      it "returns an Enumerator" do
+        sorted_set.each.class.should be(Enumerator)
+        sorted_set.each.to_a.should eql(sorted_set.to_a)
+      end
+    end
+
+    context "with a block" do
+      let(:sorted_set) { Hamster::SortedSet.new((1..1025).to_a.reverse) }
+
+      it "returns self" do
+        sorted_set.each {}.should be(sorted_set)
+      end
+
+      it "iterates over the items in order" do
+        items = []
+        sorted_set.each { |item| items << item }
+        items.should == (1..1025).to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "spec_helper"
+require "hamster/sorted_set"
+
+describe Hamster::SortedSet do
+  describe "#empty?" do
+    [
+      [[], true],
+      [["A"], false],
+      [%w[A B C], false],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:sorted_set) { Hamster.sorted_set(*values) }
+
+        it "returns #{expected.inspect}" do
+          sorted_set.empty?.should == expected
+        end
+      end
+    end
+  end
+
+  describe ".empty" do
+    it "returns the canonical empty set" do
+      Hamster::SortedSet.empty.size.should be(0)
+      Hamster::SortedSet.empty.object_id.should be(Hamster::SortedSet.empty.object_id)
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Hamster::SortedSet)
+        subclass.empty.class.should be(subclass)
+        subclass.empty.should be_empty
+      end
+    end
+  end
+end