hamster 1.0.1.pre.rc3 → 2.0.0

data/spec/lib/hamster/hash/to_a_spec.rb

@@ -4,7 +4,7 @@ require "hamster/hash"
 describe Hamster::Hash do
   describe "#to_a" do
     it "returns an Array of [key, value] pairs in same order as #each" do
-      hash = Hamster.hash(:a => 1, 1 => :a, 3 => :b, :b => 5)
+      hash = H[:a => 1, 1 => :a, 3 => :b, :b => 5]
       pairs = []
       hash.each_pair { |k,v| pairs << [k,v] }
       hash.to_a.should be_kind_of(Array)

data/spec/lib/hamster/hash/to_hash_spec.rb

@@ -5,17 +5,17 @@ describe Hamster::Hash do
   [:to_hash, :to_h].each do |method|
     describe "##{method}" do
       it "converts an empty Hamster::Hash to an empty Ruby Hash" do
-        Hamster.hash.send(method).should eql({})
+        H.empty.send(method).should eql({})
       end
 
       it "converts a non-empty Hamster::Hash to a Hash with the same keys and values" do
-        Hamster.hash(a: 1, b: 2).send(method).should eql({a: 1, b: 2})
+        H[a: 1, b: 2].send(method).should eql({a: 1, b: 2})
       end
 
       it "doesn't modify the receiver" do
-        hash = Hamster.hash(a: 1, b: 2)
+        hash = H[a: 1, b: 2]
         hash.send(method)
-        hash.should eql(Hamster.hash(a: 1, b: 2))
+        hash.should eql(H[a: 1, b: 2])
       end
     end
   end

data/spec/lib/hamster/hash/values_at_spec.rb

@@ -4,11 +4,11 @@ require "hamster/hash"
 describe Hamster::Hash do
   describe "#values_at" do
     it "returns a vector of values for the given keys" do
-      h = Hamster.hash(:a => 9, :b => 'a', :c => -10, :d => nil)
+      h = H[:a => 9, :b => 'a', :c => -10, :d => nil]
       h.values_at.should be_kind_of(Hamster::Vector)
-      h.values_at.should eql(Hamster.vector)
+      h.values_at.should eql(V.empty)
       h.values_at(:a, :d, :b).should be_kind_of(Hamster::Vector)
-      h.values_at(:a, :d, :b).should eql(Hamster::Vector[9, nil, 'a'])
+      h.values_at(:a, :d, :b).should eql(V[9, nil, 'a'])
     end
   end
 end

data/spec/lib/hamster/hash/values_spec.rb

@@ -4,7 +4,7 @@ require "hamster/set"
 
 describe Hamster::Hash do
   describe "#values" do
-    let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
     let(:result) { hash.values }
 
     it "returns the keys as a Vector" do
@@ -13,7 +13,7 @@ describe Hamster::Hash do
     end
 
     context "with duplicates" do
-      let(:hash) { Hamster.hash(:A => 15, :B => 19, :C => 15) }
+      let(:hash) { H[:A => 15, :B => 19, :C => 15] }
       let(:result) { hash.values }
 
       it "returns the keys as a Vector" do

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

@@ -11,4 +11,18 @@ describe Hamster::Immutable do
   it "freezes the instance" do
     expect(immutable).to be_frozen
   end
+
+  context "subclass hides all public methods" do
+    it "freezes the instance" do
+      my_class = Class.new do
+        include Hamster::Immutable
+
+        (public_instance_methods - Object.public_instance_methods).each do |m|
+          protected m
+        end
+      end
+      immutable = my_class.new
+      expect(immutable).to be_frozen
+    end
+  end
 end

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

@@ -3,17 +3,23 @@ require "hamster/list"
 
 describe Hamster::List do
   describe "#add" do
-    it "adds an item onto the end of a list" do
-      list = Hamster.list("a", "b")
-      list.add("c").should eql(Hamster.list("a", "b", "c"))
-      list.should eql(Hamster.list("a", "b"))
-    end
+    [
+      [[], "A", ["A"]],
+      [["A"], "B", %w[B A]],
+      [["A"], "A", %w[A A]],
+      [%w[A B C], "D", %w[D A B C]],
+    ].each do |values, new_value, expected|
+      context "on #{values.inspect} with #{new_value.inspect}" do
+        let(:list) { L[*values] }
+
+        it "preserves the original" do
+          list.add(new_value)
+          list.should eql(L[*values])
+        end
 
-    context "on an empty list" do
-      it "returns a list with one item" do
-        list = Hamster.list
-        list.add("c").should eql(Hamster.list("c"))
-        list.should eql(Hamster.list)
+        it "returns #{expected.inspect}" do
+          list.add(new_value).should eql(L[*expected])
+        end
       end
     end
   end

data/spec/lib/hamster/list/all_spec.rb

@@ -2,55 +2,53 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  [:all?, :forall?].each do |method|
-    describe "##{method}" do
-      context "on a really big list" do
-        let(:list) { Hamster.interval(0, STACK_OVERFLOW_DEPTH) }
+  describe "#all?" do
+    context "on a really big list" do
+      let(:list) { Hamster.interval(0, STACK_OVERFLOW_DEPTH) }
 
-        it "doesn't run out of stack" do
-          -> { list.send(method) }.should_not raise_error
-        end
+      it "doesn't run out of stack" do
+        -> { list.all? }.should_not raise_error
       end
+    end
 
-      context "when empty" do
-        it "with a block returns true" do
-          Hamster.list.send(method) {}.should == true
-        end
+    context "when empty" do
+      it "with a block returns true" do
+        L.empty.all? {}.should == true
+      end
 
-        it "with no block returns true" do
-          Hamster.list.send(method).should == true
-        end
+      it "with no block returns true" do
+        L.empty.all?.should == true
       end
+    end
 
-      context "when not empty" do
-        context "with a block" do
-          let(:list) { Hamster.list("A", "B", "C") }
+    context "when not empty" do
+      context "with a block" do
+        let(:list) { L["A", "B", "C"] }
 
-          context "if the block always returns true" do
-            it "returns true" do
-              list.send(method) { |item| true }.should == true
-            end
+        context "if the block always returns true" do
+          it "returns true" do
+            list.all? { |item| true }.should == true
           end
+        end
 
-          context "if the block ever returns false" do
-            it "returns false" do
-              list.send(method) { |item| item == "D" }.should == false
-            end
+        context "if the block ever returns false" do
+          it "returns false" do
+            list.all? { |item| item == "D" }.should == false
           end
         end
+      end
 
-        context "with no block" do
-          context "if all values are truthy" do
-            it "returns true" do
-              Hamster.list(true, "A").send(method).should == true
-            end
+      context "with no block" do
+        context "if all values are truthy" do
+          it "returns true" do
+            L[true, "A"].all?.should == true
           end
+        end
 
-          [nil, false].each do |value|
-            context "if any value is #{value.inspect}" do
-              it "returns false" do
-                Hamster.list(value, true, "A").send(method).should == false
-              end
+        [nil, false].each do |value|
+          context "if any value is #{value.inspect}" do
+            it "returns false" do
+              L[value, true, "A"].all?.should == false
             end
           end
         end

data/spec/lib/hamster/list/any_spec.rb

@@ -2,49 +2,47 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  [:any?, :exist?, :exists?].each do |method|
-    describe "##{method}" do
-      context "on a really big list" do
-        let(:list) { Hamster.interval(0, STACK_OVERFLOW_DEPTH) }
+  describe "#any?" do
+    context "on a really big list" do
+      let(:list) { Hamster.interval(0, STACK_OVERFLOW_DEPTH) }
 
-        it "doesn't run out of stack" do
-          -> { list.send(method) { false } }.should_not raise_error
-        end
+      it "doesn't run out of stack" do
+        -> { list.any? { false } }.should_not raise_error
       end
+    end
 
-      context "when empty" do
-        it "with a block returns false" do
-         Hamster.list.send(method) {}.should == false
-        end
+    context "when empty" do
+      it "with a block returns false" do
+       L.empty.any? {}.should == false
+      end
 
-        it "with no block returns false" do
-          Hamster.list.send(method).should == false
-        end
+      it "with no block returns false" do
+        L.empty.any?.should == false
       end
+    end
 
-      context "when not empty" do
-        context "with a block" do
-          let(:list) { Hamster.list("A", "B", "C", nil) }
+    context "when not empty" do
+      context "with a block" do
+        let(:list) { L["A", "B", "C", nil] }
 
-          ["A", "B", "C", nil].each do |value|
-            it "returns true if the block ever returns true (#{value.inspect})" do
-              list.send(method) { |item| item == value }.should == true
-            end
+        ["A", "B", "C", nil].each do |value|
+          it "returns true if the block ever returns true (#{value.inspect})" do
+            list.any? { |item| item == value }.should == true
           end
+        end
 
-          it "returns false if the block always returns false" do
-            list.send(method) { |item| item == "D" }.should == false
-          end
+        it "returns false if the block always returns false" do
+          list.any? { |item| item == "D" }.should == false
         end
+      end
 
-        context "with no block" do
-          it "returns true if any value is truthy" do
-            Hamster.list(nil, false, "A", true).send(method).should == true
-          end
+      context "with no block" do
+        it "returns true if any value is truthy" do
+          L[nil, false, "A", true].any?.should == true
+        end
 
-          it "returns false if all values are falsey" do
-            Hamster.list(nil, false).send(method).should == false
-          end
+        it "returns false if all values are falsey" do
+          L[nil, false].any?.should == false
         end
       end
     end

data/spec/lib/hamster/list/append_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  [:append, :concat, :cat, :+].each do |method|
+  [:append, :concat, :+].each do |method|
     describe "##{method}" do
       it "is lazy" do
         -> { Hamster.stream { fail }.append(Hamster.stream { fail }) }.should_not raise_error
@@ -15,22 +15,22 @@ describe Hamster::List do
         [%w[A B], %w[C D], %w[A B C D]],
       ].each do |left_values, right_values, expected|
         context "on #{left_values.inspect} and #{right_values.inspect}" do
-          let(:left) { Hamster.list(*left_values) }
-          let(:right) { Hamster.list(*right_values) }
+          let(:left) { L[*left_values] }
+          let(:right) { L[*right_values] }
           let(:result) { left.append(right) }
 
           it "preserves the left" do
             result
-            left.should eql(Hamster.list(*left_values))
+            left.should eql(L[*left_values])
           end
 
           it "preserves the right" do
             result
-            right.should eql(Hamster.list(*right_values))
+            right.should eql(L[*right_values])
           end
 
           it "returns #{expected.inspect}" do
-            result.should eql(Hamster.list(*expected))
+            result.should eql(L[*expected])
           end
         end
       end

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

@@ -22,7 +22,7 @@ describe Hamster::List do
     ].each do |values, number, expected|
       describe "#{values.inspect} with #{number}" do
         it "returns #{expected.inspect}" do
-          Hamster.list(*values).at(number).should == expected
+          L[*values].at(number).should == expected
         end
       end
     end

data/spec/lib/hamster/list/break_spec.rb

@@ -18,7 +18,7 @@ describe Hamster::List do
       [[4], [], [4]],
     ].each do |values, expected_prefix, expected_remainder|
       context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         context "with a block" do
           let(:result) { list.break { |item| item > 2 }}
@@ -27,7 +27,7 @@ describe Hamster::List do
 
           it "preserves the original" do
             result
-            list.should eql(Hamster.list(*values))
+            list.should eql(L[*values])
           end
 
           it "returns a frozen array with two items" do
@@ -37,11 +37,11 @@ describe Hamster::List do
           end
 
           it "correctly identifies the prefix" do
-            prefix.should eql(Hamster.list(*expected_prefix))
+            prefix.should eql(L[*expected_prefix])
           end
 
           it "correctly identifies the remainder" do
-            remainder.should eql(Hamster.list(*expected_remainder))
+            remainder.should eql(L[*expected_remainder])
           end
         end
 

data/spec/lib/hamster/list/cadr_spec.rb

@@ -10,24 +10,24 @@ describe Hamster::List do
     [%w[A B C], :caddr, "C"],
     [%w[A B C], :cadddr, nil],
     [%w[A B C], :caddddr, nil],
-    [[], :cdr, Hamster.list],
-    [["A"], :cdr, Hamster.list],
-    [%w[A B C], :cdr, Hamster.list("B", "C")],
-    [%w[A B C], :cddr, Hamster.list("C")],
-    [%w[A B C], :cdddr, Hamster.list],
-    [%w[A B C], :cddddr, Hamster.list],
+    [[], :cdr, L.empty],
+    [["A"], :cdr, L.empty],
+    [%w[A B C], :cdr, L["B", "C"]],
+    [%w[A B C], :cddr, L["C"]],
+    [%w[A B C], :cdddr, L.empty],
+    [%w[A B C], :cddddr, L.empty],
   ].each do |values, method, expected|
     describe "##{method}" do
       it "is responded to" do
-        Hamster.list.respond_to?(method).should == true
+        L.empty.respond_to?(method).should == true
       end
 
       context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         it "preserves the original" do
           list.send(method)
-          list.should eql(Hamster.list(*values))
+          list.should eql(L[*values])
         end
 
         it "returns #{expected.inspect}" do

data/spec/lib/hamster/list/chunk_spec.rb

@@ -9,19 +9,19 @@ describe Hamster::List do
 
     [
       [[], []],
-      [["A"], [Hamster.list("A")]],
-      [%w[A B C], [Hamster.list("A", "B"), Hamster.list("C")]],
+      [["A"], [L["A"]]],
+      [%w[A B C], [L["A", "B"], L["C"]]],
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         it "preserves the original" do
           list.chunk(2)
-          list.should eql(Hamster.list(*values))
+          list.should eql(L[*values])
         end
 
         it "returns #{expected.inspect}" do
-          list.chunk(2).should eql(Hamster.list(*expected))
+          list.chunk(2).should eql(L[*expected])
         end
       end
     end

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

@@ -9,15 +9,15 @@ describe Hamster::List do
       %w[A B C],
     ].each do |values|
       describe "on #{values}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         it "preserves the original" do
           list.clear
-          list.should eql(Hamster.list(*values))
+          list.should eql(L[*values])
         end
 
         it "returns an empty list" do
-          list.clear.should equal(Hamster.list)
+          list.clear.should equal(L.empty)
         end
       end
     end

data/spec/lib/hamster/list/combination_spec.rb

@@ -18,15 +18,15 @@ describe Hamster::List do
       [[], 1, []],
     ].each do |values, number, expected|
       context "on #{values.inspect} in groups of #{number}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         it "preserves the original" do
           list.combination(number)
-          list.should eql(Hamster.list(*values))
+          list.should eql(L[*values])
         end
 
         it "returns #{expected.inspect}" do
-          list.combination(number).should eql(Hamster.list(*expected))
+          list.combination(number).should eql(L[*expected])
         end
       end
     end