hamster 0.4.3 → 1.0.0

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

@@ -0,0 +1,45 @@
+require "spec_helper"
+require "hamster/sorted_set"
+
+describe Hamster::SortedSet do
+  [
+    [:sort, ->(left, right) { left.length <=> right.length }],
+    [:sort_by, ->(item) { item.length }],
+  ].each do |method, comparator|
+    describe "##{method}" do
+      [
+        [[], []],
+        [["A"], ["A"]],
+        [%w[Ichi Ni San], %w[Ni San Ichi]],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          let(:sorted_set) { Hamster.sorted_set(*values) { |item| item.reverse }}
+
+          context "with a block" do
+            it "preserves the original" do
+              sorted_set.send(method, &comparator)
+              sorted_set.to_a.should == Hamster.sorted_set(*values) { |item| item.reverse }
+            end
+
+            it "returns #{expected.inspect}" do
+              sorted_set.send(method, &comparator).class.should be(Hamster::SortedSet)
+              sorted_set.send(method, &comparator).to_a.should == expected
+            end
+          end
+
+          context "without a block" do
+            it "preserves the original" do
+              sorted_set.send(method)
+              sorted_set.to_a.should == Hamster.sorted_set(*values) { |item| item.reverse }
+            end
+
+            it "returns #{expected.sort.inspect}" do
+              sorted_set.send(method).class.should be(Hamster::SortedSet)
+              sorted_set.send(method).to_a.should == expected.sort
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,48 @@
+require "spec_helper"
+require "hamster/sorted_set"
+
+describe Hamster::SortedSet do
+  describe "#superset?" do
+    [
+      [[], [], true],
+      [["A"], [], true],
+      [[], ["A"], false],
+      [["A"], ["A"], true],
+      [%w[A B C], ["B"], true],
+      [["B"], %w[A B C], false],
+      [%w[A B C], %w[A C], true],
+      [%w[A C], %w[A B C], false],
+      [%w[A B C], %w[A B C], true],
+      [%w[A B C], %w[A B C D], false],
+      [%w[A B C D], %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).superset?(Hamster.sorted_set(*b)).should == expected
+        end
+      end
+    end
+  end
+
+  describe "#proper_superset?" do
+    [
+      [[], [], false],
+      [["A"], [], true],
+      [[], ["A"], false],
+      [["A"], ["A"], false],
+      [%w[A B C], ["B"], true],
+      [["B"], %w[A B C], false],
+      [%w[A B C], %w[A C], true],
+      [%w[A C], %w[A B C], false],
+      [%w[A B C], %w[A B C], false],
+      [%w[A B C], %w[A B C D], false],
+      [%w[A B C D], %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).proper_superset?(Hamster.sorted_set(*b)).should == expected
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

@@ -0,0 +1,68 @@
+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/any_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+require "hamster/vector"
+
+describe Hamster::Vector do
+  let(:vector) { Hamster.vector(*values) }
+
+  describe "#any?" do
+    let(:any?) { vector.any?(&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(any?).to be(false)
+        end
+      end
+
+      context "with a block" do
+        let(:block) { nil }
+
+        it "returns false" do
+          expect(any?).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(any?).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(any?).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(any?).to be(true)
+          end
+        end
+
+        context "with all values that are falsey" do
+          let(:values) { [nil, false] }
+
+          it "returns false" do
+            expect(any?).to be(false)
+          end
+        end
+      end
+    end
+  end
+end