hamster 0.4.3 → 1.0.0

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

@@ -0,0 +1,20 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#to_list" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        it "returns self" do
+          list.to_list.should equal(list)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "spec_helper"
+require "hamster/list"
+require "hamster/set"
+
+describe Hamster::List 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.list(*values).to_set.should eql(Hamster.set(*values))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#transpose" do
+    it "takes a list of lists and returns a list of all the first elements, all the 2nd elements, and so on" do
+      L[L[1, 'a'], L[2, 'b'], L[3, 'c']].transpose.should eql(L[L[1, 2, 3], L["a", "b", "c"]])
+      L[L[1, 2, 3], L["a", "b", "c"]].transpose.should eql(L[L[1, 'a'], L[2, 'b'], L[3, 'c']])
+      L[].transpose.should eql(L[])
+      L[L[]].transpose.should eql(L[])
+      L[L[], L[]].transpose.should eql(L[])
+      L[L[0]].transpose.should eql(L[L[0]])
+      L[L[0], L[1]].transpose.should eql(L[L[0, 1]])
+    end
+
+    it "only goes as far as the shortest list" do
+      L[L[1,2,3], L[2]].transpose.should eql(L[L[1,2]])
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  [:union, :|].each do |method|
+    describe "##{method}" do
+      it "is lazy" do
+        -> { Hamster.stream { fail }.union(Hamster.stream { fail }) }.should_not raise_error
+      end
+
+      [
+        [[], [], []],
+        [["A"], [], ["A"]],
+        [%w[A B C], [], %w[A B C]],
+        [%w[A A], ["A"], ["A"]],
+      ].each do |a, b, expected|
+        context "returns #{expected.inspect}" do
+          let(:list_a) { Hamster.list(*a) }
+          let(:list_b) { Hamster.list(*b) }
+
+          it "for #{a.inspect} and #{b.inspect}"  do
+            list_a.send(method, list_b).should eql(Hamster.list(*expected))
+          end
+
+          it "for #{b.inspect} and #{a.inspect}"  do
+            list_b.send(method, list_a).should eql(Hamster.list(*expected))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#uniq" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.uniq }.should_not raise_error
+    end
+
+    [
+      [[], []],
+      [["A"], ["A"]],
+      [%w[A B C], %w[A B C]],
+      [%w[A B A C C], %w[A B C]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        it "preserves the original" do
+          list.uniq
+          list.should eql(Hamster.list(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          list.uniq.should eql(Hamster.list(*expected))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#zip" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.zip(Hamster.stream { fail }) }.should_not raise_error
+    end
+
+    [
+      [[], [], []],
+      [["A"], ["aye"], [Hamster.list("A", "aye")]],
+      [["A"], [], [Hamster.list("A", nil)]],
+      [[], ["A"], [Hamster.list(nil, "A")]],
+      [%w[A B C], %w[aye bee see], [Hamster.list("A", "aye"), Hamster.list("B", "bee"), Hamster.list("C", "see")]],
+    ].each do |left, right, expected|
+      context "on #{left.inspect} and #{right.inspect}" do
+        it "returns #{expected.inspect}" do
+          Hamster.list(*left).zip(Hamster.list(*right)).should eql(Hamster.list(*expected))
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/nested/construction_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "hamster/nested"
+require "set"
+
+describe Hamster do
+  describe ".from" do
+    context "with deep Ruby structure" do
+      let(:ruby_obj) {
+        { "a" => 1,
+          "b" => [2, {"c" => 3}, 4],
+          "d" => ::Set.new([5, 6, 7]),
+          "e" => {"f" => 8, "g" => 9},
+          "h" => Regexp.new("ijk") }
+      }
+
+      it "creates nested hamster objects" do
+        result = Hamster.from(ruby_obj)
+        result.should eql(Hamster::Hash["a" => 1,
+                                        "b" => Hamster::Vector[2, Hamster::Hash["c" => 3], 4],
+                                        "d" => Hamster::Set[5, 6, 7],
+                                        "e" => Hamster::Hash["f" => 8, "g" => 9],
+                                        "h" => Regexp.new("ijk")])
+      end
+    end
+
+    [
+      # [input, expected_result]
+      [ {}, Hamster::Hash[] ],
+      [ {"a" => 1, "b" => 2, "c" => 3}, Hamster::Hash["a" => 1, "b" => 2, "c" => 3] ],
+      [ [], Hamster::Vector[] ],
+      [ [1, 2, 3], Hamster::Vector[1, 2, 3] ],
+      [ ::Set.new, Hamster::Set[] ],
+      [ ::Set.new([1, 2, 3]), Hamster::Set[1, 2, 3] ],
+      [ 42, 42 ],
+      [ STDOUT, STDOUT ]
+    ].each do |input, expected_result|
+      context "with #{input.inspect} as input" do
+        it "should return #{expected_result.inspect}" do
+          Hamster.from(input).should eql(expected_result)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  let(:original) { Hamster.set("A", "B", "C") }
+
+  [:add, :<<].each do |method|
+    describe "##{method}" do
+      context "with a unique value" do
+        let(:result) { original.send(method, "D") }
+
+        it "preserves the original" do
+          result
+          original.should eql(Hamster.set("A", "B", "C"))
+        end
+
+        it "returns a copy with the superset of values" do
+          result.should eql(Hamster.set("A", "B", "C", "D"))
+        end
+      end
+
+      context "with a duplicate value" do
+        let(:result) { original.send(method, "C") }
+
+        it "preserves the original values" do
+          result
+          original.should eql(Hamster.set("A", "B", "C"))
+        end
+
+        it "returns self" do
+          result.should equal(original)
+        end
+      end
+
+      it "can add nil to a set" do
+        original.add(nil).should eql(Hamster.set("A", "B", "C", nil))
+      end
+
+      it "works on large sets, with many combinations of input" do
+        50.times do
+          array = (1..500).to_a.sample(100)
+          set = Hamster::Set.new(array)
+          to_add = 1000 + rand(1000)
+          set.add(to_add).size.should == 101
+          set.add(to_add).include?(to_add).should == true
+        end
+      end
+    end
+  end
+
+  describe "#add?" do
+    context "with a unique value" do
+      let(:result) { original.add?("D") }
+
+      it "preserves the original" do
+        original.should eql(Hamster.set("A", "B", "C"))
+      end
+
+      it "returns a copy with the superset of values" do
+        result.should eql(Hamster.set("A", "B", "C", "D"))
+      end
+    end
+
+    context "with a duplicate value" do
+      let(:result) { original.add?("C") }
+
+      it "preserves the original values" do
+        original.should eql(Hamster.set("A", "B", "C"))
+      end
+
+      it "returns false" do
+        result.should equal(false)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#all?" do
+    context "when empty" do
+      it "with a block returns true" do
+        Hamster.set.all? {}.should == true
+      end
+
+      it "with no block returns true" do
+        Hamster.set.all?.should == true
+      end
+    end
+
+    context "when not empty" do
+      context "with a block" do
+        let(:set) { Hamster.set("A", "B", "C") }
+
+        it "returns true if the block always returns true" do
+          set.all? { |item| true }.should == true
+        end
+
+        it "returns false if the block ever returns false" do
+          set.all? { |item| item == "D" }.should == false
+        end
+
+        it "propagates an exception from the block" do
+          -> { set.all? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+        end
+
+        it "stops iterating as soon as the block returns false" do
+          yielded = []
+          set.all? { |k,v| yielded << k; false }
+          yielded.size.should == 1
+        end
+      end
+
+      describe "with no block" do
+        it "returns true if all values are truthy" do
+          Hamster.set(true, "A").all?.should == true
+        end
+
+        [nil, false].each do |value|
+          it "returns false if any value is #{value.inspect}" do
+            Hamster.set(value, true, "A").all?.should == false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#any?" do
+    context "when empty" do
+      it "with a block returns false" do
+        Hamster.set.any? {}.should == false
+      end
+
+      it "with no block returns false" do
+        Hamster.set.any?.should == false
+      end
+    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 true if the block ever returns true (#{value.inspect})" do
+            set.any? { |item| item == value }.should == true
+          end
+        end
+
+        it "returns false if the block always returns false" do
+          set.any? { |item| item == "D" }.should == false
+        end
+
+        it "propagates exceptions raised in the block" do
+          -> { set.any? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+        end
+
+        it "stops iterating as soon as the block returns true" do
+          yielded = []
+          set.any? { |k,v| yielded << k; true }
+          yielded.size.should == 1
+        end
+      end
+
+      context "with no block" do
+        it "returns true if any value is truthy" do
+          Hamster.set(nil, false, true, "A").any?.should == true
+        end
+
+        it "returns false if all values are falsey" do
+          Hamster.set(nil, false).any?.should == false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#clear" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      describe "on #{values}" do
+        let(:set) { Hamster.set(*values) }
+
+        it "preserves the original" do
+          set.clear
+          set.should eql(Hamster.set(*values))
+        end
+
+        it "returns an empty set" do
+          set.clear.should equal(Hamster.set)
+        end
+      end
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Hamster::Set)
+        instance = subclass.new([:a, :b, :c, :d])
+        instance.clear.class.should be(subclass)
+        instance.clear.should be_empty
+      end
+    end
+  end
+end

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

@@ -1,42 +1,31 @@
-require 'spec_helper'
-
-require 'hamster/set'
+require "spec_helper"
+require "hamster/set"
 
 describe Hamster::Set do
-
   describe "#compact" do
-
     [
       [[], []],
       [["A"], ["A"]],
-      [["A", "B", "C"], ["A", "B", "C"]],
+      [%w[A B C], %w[A B C]],
       [[nil], []],
       [[nil, "B"], ["B"]],
       [["A", nil], ["A"]],
       [[nil, nil], []],
-      [["A", nil, "C"], ["A", "C"]],
+      [["A", nil, "C"], %w[A C]],
       [[nil, "B", nil], ["B"]],
     ].each do |values, expected|
-
       describe "on #{values.inspect}" do
-
-        before do
-          @original = Hamster.set(*values)
-          @result = @original.compact
-        end
+        let(:set) { Hamster.set(*values) }
 
         it "preserves the original" do
-          @original.should == Hamster.set(*values)
+          set.compact
+          set.should eql(Hamster.set(*values))
         end
 
         it "returns #{expected.inspect}" do
-          @result.should == Hamster.set(*expected)
+          set.compact.should eql(Hamster.set(*expected))
         end
-
       end
-
     end
-
   end
-
-end
+end