hamster 1.0.1.pre.rc3 → 2.0.0

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

@@ -10,11 +10,11 @@ describe Hamster::Set do
         [[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) }
+          let(:set) { S[*values] }
 
           it "preserves the original" do
             set.join("|")
-            set.should eql(Hamster.set(*values))
+            set.should eql(S[*values])
           end
 
           it "returns #{expected.inspect}" do
@@ -31,11 +31,11 @@ describe Hamster::Set do
         [[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) }
+          let(:set) { S[*values] }
 
           it "preserves the original" do
             set.join
-            set.should eql(Hamster.set(*values))
+            set.should eql(S[*values])
           end
 
           it "returns #{expected.inspect}" do
@@ -47,13 +47,13 @@ describe Hamster::Set do
 
     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)] }
+      let(:set) { S[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)])
+          set.should eql(S[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)])
         end
 
         it "returns #{@expected.inspect}" do

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

@@ -6,28 +6,28 @@ describe Hamster::Set do
     describe "##{method}" do
       context "when empty" do
         it "returns self" do
-          Hamster.set.send(method) {}.should equal(Hamster.set)
+          S.empty.send(method) {}.should equal(S.empty)
         end
       end
 
       context "when not empty" do
-        let(:set) { Hamster.set("A", "B", "C") }
+        let(:set) { S["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"))
+            set.should eql(S["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"))
+            set.send(method, &:downcase).should eql(S["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')
+            set.send(method).each(&:downcase).should == S['a', 'b', 'c']
           end
         end
       end
@@ -42,7 +42,7 @@ describe Hamster::Set do
 
       context "when multiple items map to the same value" do
         it "filters out the duplicates" do
-          set = Hamster::Set.new('aa'..'zz')
+          set = S.new('aa'..'zz')
           result = set.map { |s| s[0] }
           result.should eql(Hamster::Set.new('a'..'z'))
           result.size.should == 26
@@ -50,7 +50,7 @@ describe Hamster::Set do
       end
 
       it "works on large sets" do
-        set = Hamster::Set.new(1..1000)
+        set = S.new(1..1000)
         result = set.map { |x| x * 10 }
         result.size.should == 1000
         1.upto(1000) { |n| result.include?(n * 10).should == true }

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

@@ -6,7 +6,7 @@ describe Hamster::Set 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))'|
+      %Q|#{ruby} -I lib -r hamster -e 'set = Hamster::Set[:one, :two]; $stdout.write(Marshal.dump(set))'|
     end
 
     let(:reloaded_hash) do
@@ -18,7 +18,7 @@ describe Hamster::Set do
     end
 
     it "can survive dumping and loading into a new process" do
-      reloaded_hash.should eql(Hamster.set(:one, :two))
+      reloaded_hash.should eql(S[:one, :two])
     end
 
     it "is still possible to test items by key after loading" do

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

@@ -2,35 +2,33 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  [:maximum, :max].each do |method|
-    describe "##{method}" 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.send(method) { |maximum, item| maximum.length <=> item.length }}
+  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) { S[*values] }
+          let(:result) { set.max { |maximum, item| maximum.length <=> item.length }}
 
-            it "returns #{expected.inspect}" do
-              result.should == expected
-            end
+          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).send(method).should == expected
-            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
+            S[*values].max.should == expected
           end
         end
       end

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

@@ -2,35 +2,33 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  [:minimum, :min].each do |method|
-    describe "##{method}" 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.send(method) { |minimum, item| minimum.length <=> item.length }}
+  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) { S[*values] }
+          let(:result) { set.min { |minimum, item| minimum.length <=> item.length }}
 
-            it "returns #{expected.inspect}" do
-              result.should == expected
-            end
+          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).send(method).should == expected
-            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
+            S[*values].min.should == expected
           end
         end
       end

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

@@ -4,22 +4,22 @@ require "hamster/set"
 describe Hamster::Set do
   describe ".new" do
     it "initializes a new set" do
-      set = Hamster::Set.new([1,2,3])
+      set = S.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 = S.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])
+      set = S.new([1,2,3])
       array.push('BAD')
-      set.should eql(Hamster.set(1,2,3))
+      set.should eql(S[1,2,3])
     end
 
     context "from a subclass" do
@@ -46,7 +46,7 @@ describe Hamster::Set do
 
   describe "[]" do
     it "accepts any number of arguments and initializes a new set" do
-      set = Hamster::Set[1,2,3,4]
+      set = S[1,2,3,4]
       set.size.should be(4)
       [1,2,3,4].each { |n| set.include?(n).should == true }
     end

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

@@ -5,17 +5,17 @@ describe Hamster::Set do
   describe "#none?" do
     context "when empty" do
       it "with a block returns true" do
-        Hamster.set.none? {}.should == true
+        S.empty.none? {}.should == true
       end
 
       it "with no block returns true" do
-        Hamster.set.none?.should == true
+        S.empty.none?.should == true
       end
     end
 
     context "when not empty" do
       context "with a block" do
-        let(:set) { Hamster.set("A", "B", "C", nil) }
+        let(:set) { S["A", "B", "C", nil] }
 
         ["A", "B", "C", nil].each do |value|
           it "returns false if the block ever returns true (#{value.inspect})" do
@@ -36,11 +36,11 @@ describe Hamster::Set do
 
       context "with no block" do
         it "returns false if any value is truthy" do
-          Hamster.set(nil, false, true, "A").none?.should == false
+          S[nil, false, true, "A"].none?.should == false
         end
 
         it "returns true if all values are falsey" do
-          Hamster.set(nil, false).none?.should == true
+          S[nil, false].none?.should == true
         end
       end
     end

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

@@ -5,17 +5,17 @@ describe Hamster::Set do
   describe "#one?" do
     context "when empty" do
       it "with a block returns false" do
-        Hamster.set.one? {}.should == false
+        S.empty.one? {}.should == false
       end
 
       it "with no block returns false" do
-        Hamster.set.one?.should == false
+        S.empty.one?.should == false
       end
     end
 
     context "when not empty" do
       context "with a block" do
-        let(:set) { Hamster.set("A", "B", "C") }
+        let(:set) { S["A", "B", "C"] }
 
         it "returns false if the block returns true more than once" do
           set.one? { |item| true }.should == false
@@ -32,15 +32,15 @@ describe Hamster::Set do
 
       context "with no block" do
         it "returns false if more than one value is truthy" do
-          Hamster.set(nil, true, "A").one?.should == false
+          S[nil, true, "A"].one?.should == false
         end
 
         it "returns true if only one value is truthy" do
-          Hamster.set(nil, true, false).one?.should == true
+          S[nil, true, false].one?.should == true
         end
 
         it "returns false if no values are truthy" do
-          Hamster.set(nil, false).one?.should == false
+          S[nil, false].one?.should == false
         end
       end
     end

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

@@ -14,7 +14,7 @@ describe Hamster::Set do
       [[4], [], [4]],
     ].each do |values, expected_matches, expected_remainder|
       context "on #{values.inspect}" do
-        let(:set) { Hamster.set(*values) }
+        let(:set) { S[*values] }
 
         context "with a block" do
           let(:result)  { set.partition(&:odd?) }
@@ -23,7 +23,7 @@ describe Hamster::Set do
 
           it "preserves the original" do
             result
-            set.should eql(Hamster.set(*values))
+            set.should eql(S[*values])
           end
 
           it "returns a frozen array with two items" do
@@ -33,18 +33,18 @@ describe Hamster::Set do
           end
 
           it "correctly identifies the matches" do
-            matches.should eql(Hamster.set(*expected_matches))
+            matches.should eql(S[*expected_matches])
           end
 
           it "correctly identifies the remainder" do
-            remainder.should eql(Hamster.set(*expected_remainder))
+            remainder.should eql(S[*expected_remainder])
           end
         end
 
         describe "without a block" do
           it "returns an Enumerator" do
             set.partition.class.should be(Enumerator)
-            set.partition.each(&:odd?).should eql([Hamster::Set.new(expected_matches), Hamster::Set.new(expected_remainder)])
+            set.partition.each(&:odd?).should eql([S.new(expected_matches), S.new(expected_remainder)])
           end
         end
       end

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

@@ -9,14 +9,14 @@ describe Hamster::Set do
       [[1, 3, 5, 7, 11], 1155],
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:set) { Hamster.set(*values) }
+        let(:set) { S[*values] }
 
         it "returns #{expected.inspect}" do
           set.product.should == expected
         end
 
         it "doesn't change the original Set" do
-          set.should eql(Hamster::Set.new(values))
+          set.should eql(S.new(values))
         end
       end
     end

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  [:reduce, :inject, :fold, :foldr].each do |method|
+  [:reduce, :inject].each do |method|
     describe "##{method}" do
       [
         [[], 10, 10],
@@ -10,7 +10,7 @@ describe Hamster::Set do
         [[1, 2, 3], 10, 4],
       ].each do |values, initial, expected|
         describe "on #{values.inspect}" do
-          let(:set) { Hamster.set(*values) }
+          let(:set) { S[*values] }
 
           context "with an initial value of #{initial}" do
             context "and a block" do
@@ -28,7 +28,7 @@ describe Hamster::Set do
         [[1, 2, 3], 6],
       ].each do |values, expected|
         describe "on #{values.inspect}" do
-          let(:set) { Hamster.set(*values) }
+          let(:set) { S[*values] }
 
           context "with no initial value" do
             context "and a block" do
@@ -42,13 +42,13 @@ describe Hamster::Set do
 
       describe "with no block and a symbol argument" do
         it "uses the symbol as the name of a method to reduce with" do
-          Hamster.set(1, 2, 3).reduce(:+).should == 6
+          S[1, 2, 3].reduce(:+).should == 6
         end
       end
 
       describe "with no block and a string argument" do
         it "uses the string as the name of a method to reduce with" do
-          Hamster.set(1, 2, 3).reduce('+').should == 6
+          S[1, 2, 3].reduce('+').should == 6
         end
       end
     end

data/spec/lib/hamster/set/{remove_spec.rb → reject_spec.rb}

@@ -2,9 +2,9 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  [:remove, :reject, :delete_if].each do |method|
+  [:reject, :delete_if].each do |method|
     describe "##{method}" do
-      let(:set) { Hamster.set("A", "B", "C") }
+      let(:set) { S["A", "B", "C"] }
 
       context "when nothing matches" do
         it "returns self" do
@@ -18,18 +18,18 @@ describe Hamster::Set do
 
           it "preserves the original" do
             result
-            set.should eql(Hamster.set("A", "B", "C"))
+            set.should eql(S["A", "B", "C"])
           end
 
           it "returns a set with the matching values" do
-            result.should eql(Hamster.set("B", "C"))
+            result.should eql(S["B", "C"])
           end
         end
 
         context "with no block" do
           it "returns self" do
             set.send(method).class.should be(Enumerator)
-            set.send(method).each { |item| item == "A" }.should == Hamster.set("B", "C")
+            set.send(method).each { |item| item == "A" }.should == S["B", "C"]
           end
         end
       end
@@ -37,7 +37,7 @@ describe Hamster::Set do
       context "on a large set, with many combinations of input" do
         it "still works" do
           array = (1..1000).to_a
-          set   = Hamster::Set.new(array)
+          set   = S.new(array)
           [0, 10, 100, 200, 500, 800, 900, 999, 1000].each do |threshold|
             result = set.send(method) { |item| item > threshold }
             result.size.should == threshold