hamster 0.4.3 → 1.0.0

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

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

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

@@ -0,0 +1,53 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:intersection, :&].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], []],
+        [["A"], [], []],
+        [["A"], ["A"], ["A"]],
+        [%w[A B C], ["B"], ["B"]],
+        [%w[A B C], %w[A C], %w[A C]],
+      ].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))
+          end
+        end
+      end
+
+      it "returns results consistent with Array#&" do
+        50.times do
+          array1 = rand(100).times.map { rand(1000000).to_s(16) }
+          array2 = rand(100).times.map { rand(1000000).to_s(16) }
+          result = Hamster::Set.new(array1).send(method, Hamster::Set.new(array2))
+          result.to_a.sort.should eql((array1 & array2).sort)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#join" do
+    context "with a separator" do
+      [
+        [[], ""],
+        [["A"], "A"],
+        [[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)], "A|B|C"]
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          let(:set) { Hamster.set(*values) }
+
+          it "preserves the original" do
+            set.join("|")
+            set.should eql(Hamster.set(*values))
+          end
+
+          it "returns #{expected.inspect}" do
+            set.join("|").should eql(expected)
+          end
+        end
+      end
+    end
+
+    context "without a separator" do
+      [
+        [[], ""],
+        [["A"], "A"],
+        [[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)], "ABC"]
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          let(:set) { Hamster.set(*values) }
+
+          it "preserves the original" do
+            set.join
+            set.should eql(Hamster.set(*values))
+          end
+
+          it "returns #{expected.inspect}" do
+            set.join.should eql(expected)
+          end
+        end
+      end
+    end
+
+    context "without a separator (with global default separator set)" do
+      before { $, = '**' }
+      let(:set) { Hamster::Set[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)] }
+      after  { $, = nil }
+
+      context "on ['A', 'B', 'C']" do
+        it "preserves the original" do
+          set.join
+          set.should eql(Hamster::Set[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)])
+        end
+
+        it "returns #{@expected.inspect}" do
+          set.join.should == "A**B**C"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:map, :collect].each do |method|
+    describe "##{method}" do
+      context "when empty" do
+        it "returns self" do
+          Hamster.set.send(method) {}.should equal(Hamster.set)
+        end
+      end
+
+      context "when not empty" do
+        let(:set) { Hamster.set("A", "B", "C") }
+
+        context "with a block" do
+          it "preserves the original values" do
+            set.send(method, &:downcase)
+            set.should eql(Hamster.set("A", "B", "C"))
+          end
+
+          it "returns a new set with the mapped values" do
+            set.send(method, &:downcase).should eql(Hamster.set("a", "b", "c"))
+          end
+        end
+
+        context "with no block" do
+          it "returns an Enumerator" do
+            set.send(method).class.should be(Enumerator)
+            set.send(method).each(&:downcase).should == Hamster.set('a', 'b', 'c')
+          end
+        end
+      end
+
+      context "from a subclass" do
+        it "returns an instance of the subclass" do
+          subclass = Class.new(Hamster::Set)
+          instance = subclass['a', 'b']
+          instance.map { |item| item.upcase }.class.should be(subclass)
+        end
+      end
+
+      context "when multiple items map to the same value" do
+        it "filters out the duplicates" do
+          set = Hamster::Set.new('aa'..'zz')
+          result = set.map { |s| s[0] }
+          result.should eql(Hamster::Set.new('a'..'z'))
+          result.size.should == 26
+        end
+      end
+
+      it "works on large sets" do
+        set = Hamster::Set.new(1..1000)
+        result = set.map { |x| x * 10 }
+        result.size.should == 1000
+        1.upto(1000) { |n| result.include?(n * 10).should == true }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#marshal_dump/#marshal_load" do
+    let(:ruby) { File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"]) }
+
+    let(:child_cmd) do
+      %Q|#{ruby} -I lib -r hamster -e 'set = Hamster.set :one, :two; $stdout.write(Marshal.dump(set))'|
+    end
+
+    let(:reloaded_hash) do
+      IO.popen(child_cmd, "r+") do |child|
+        reloaded_hash = Marshal.load(child)
+        child.close
+        reloaded_hash
+      end
+    end
+
+    it "can survive dumping and loading into a new process" do
+      reloaded_hash.should eql(Hamster.set(:one, :two))
+    end
+
+    it "is still possible to test items by key after loading" do
+      reloaded_hash.should include :one
+      reloaded_hash.should include :two
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#max" do
+    context "with a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "Ichi"],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          let(:set) { Hamster.set(*values) }
+          let(:result) { set.max { |maximum, item| maximum.length <=> item.length }}
+
+          it "returns #{expected.inspect}" do
+            result.should == expected
+          end
+        end
+      end
+    end
+
+    context "without a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "San"],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            Hamster.set(*values).max.should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#min" do
+    context "with a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "Ni"],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          let(:set) { Hamster.set(*values) }
+          let(:result) { set.min { |minimum, item| minimum.length <=> item.length }}
+
+          it "returns #{expected.inspect}" do
+            result.should == expected
+          end
+        end
+      end
+    end
+
+    context "without a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "Ichi"],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            Hamster.set(*values).min.should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe ".new" do
+    it "initializes a new set" do
+      set = Hamster::Set.new([1,2,3])
+      set.size.should be(3)
+      [1,2,3].each { |n| set.include?(n).should == true }
+    end
+
+    it "accepts a Range" do
+      set = Hamster::Set.new(1..3)
+      set.size.should be(3)
+      [1,2,3].each { |n| set.include?(n).should == true }
+    end
+
+    it "returns a Set which doesn't change even if the initializer is mutated" do
+      array = [1,2,3]
+      set = Hamster::Set.new([1,2,3])
+      array.push('BAD')
+      set.should eql(Hamster.set(1,2,3))
+    end
+
+    context "from a subclass" do
+      it "returns a frozen instance of the subclass" do
+        subclass = Class.new(Hamster::Set)
+        instance = subclass.new(["some", "values"])
+        instance.class.should be subclass
+        instance.should be_frozen
+      end
+    end
+
+    it "is amenable to overriding of #initialize" do
+      class SnazzySet < Hamster::Set
+        def initialize
+          super(['SNAZZY!!!'])
+        end
+      end
+
+      set = SnazzySet.new
+      set.size.should be(1)
+      set.include?('SNAZZY!!!').should == true
+    end
+  end
+
+  describe "[]" do
+    it "accepts any number of arguments and initializes a new set" do
+      set = Hamster::Set[1,2,3,4]
+      set.size.should be(4)
+      [1,2,3,4].each { |n| set.include?(n).should == true }
+    end
+  end
+end

data/spec/{hamster → lib/hamster}/set/none_spec.rb

@@ -1,51 +1,40 @@
-require 'spec_helper'
-
-require 'hamster/set'
+require "spec_helper"
+require "hamster/set"
 
 describe Hamster::Set do
-
   describe "#none?" do
-
-    describe "when empty" do
-
-      before do
-        @set = Hamster.set
-      end
-
+    context "when empty" do
       it "with a block returns true" do
-        @set.none? {}.should == true
+        Hamster.set.none? {}.should == true
       end
 
       it "with no block returns true" do
-        @set.none?.should == true
+        Hamster.set.none?.should == true
       end
-
     end
 
-    describe "when not empty" do
-
-      describe "with a block" do
-
-        before do
-          @set = Hamster.set("A", "B", "C", nil)
-        end
+    context "when not empty" do
+      context "with a block" do
+        let(:set) { Hamster.set("A", "B", "C", nil) }
 
         ["A", "B", "C", nil].each do |value|
-
           it "returns false if the block ever returns true (#{value.inspect})" do
-            @set.none? { |item| item == value }.should == false
+            set.none? { |item| item == value }.should == false
           end
-
         end
 
         it "returns true if the block always returns false" do
-          @set.none? { |item| item == "D" }.should == true
+          set.none? { |item| item == "D" }.should == true
         end
 
+        it "stops iterating as soon as the block returns true" do
+          yielded = []
+          set.none? { |item| yielded << item; true }
+          yielded.size.should == 1
+        end
       end
 
-      describe "with no block" do
-
+      context "with no block" do
         it "returns false if any value is truthy" do
           Hamster.set(nil, false, true, "A").none?.should == false
         end
@@ -53,11 +42,7 @@ describe Hamster::Set do
         it "returns true if all values are falsey" do
           Hamster.set(nil, false).none?.should == true
         end
-
       end
-
     end
-
   end
-
-end
+end