hamster 1.0.1.pre.rc3 → 2.0.0

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

@@ -17,27 +17,27 @@ describe Hamster::List do
         [%w[Ichi Ni San], %w[Ni San Ichi]],
       ].each do |values, expected|
         context "on #{values.inspect}" do
-          let(:list) { Hamster.list(*values) }
+          let(:list) { L[*values] }
 
           context "with a block" do
             it "preserves the original" do
               list.send(method, &comparator)
-              list.should == Hamster.list(*values)
+              list.should == L[*values]
             end
 
             it "returns #{expected.inspect}" do
-              list.send(method, &comparator).should == Hamster.list(*expected)
+              list.send(method, &comparator).should == L[*expected]
             end
           end
 
           context "without a block" do
             it "preserves the original" do
               list.send(method)
-              list.should eql(Hamster.list(*values))
+              list.should eql(L[*values])
             end
 
             it "returns #{expected.sort.inspect}" do
-              list.send(method).should == Hamster.list(*expected.sort)
+              list.send(method).should == L[*expected.sort]
             end
           end
         end

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

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "hamster/list"
 
-describe "Hamster.list#span" do
+describe "Hamster::list#span" do
   it "is lazy" do
     -> { Hamster.stream { |item| fail }.span { true } }.should_not raise_error
   end
@@ -25,7 +25,7 @@ DESC
       [[4], [], [4]],
     ].each do |values, expected_prefix, expected_remainder|
       context "given the list #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         context "and a predicate that returns true for values <= 2" do
           let(:result) { list.span { |item| item <= 2 }}
@@ -34,15 +34,15 @@ DESC
 
           it "preserves the original" do
             result
-            list.should eql(Hamster.list(*values))
+            list.should eql(L[*values])
           end
 
           it "returns the prefix as #{expected_prefix.inspect}" do
-            prefix.should eql(Hamster.list(*expected_prefix))
+            prefix.should eql(L[*expected_prefix])
           end
 
           it "returns the remainder as #{expected_remainder.inspect}" do
-            remainder.should eql(Hamster.list(*expected_remainder))
+            remainder.should eql(L[*expected_remainder])
           end
 
           it "calls the block only once for each element" do

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

@@ -15,14 +15,14 @@ describe Hamster::List do
       [[1, 2, 3, 4], [1, 2], [3, 4]],
     ].each do |values, expected_prefix, expected_remainder|
       context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
         let(:result) { list.split_at(2) }
         let(:prefix) { result.first }
         let(:remainder) { result.last }
 
         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
@@ -32,11 +32,11 @@ describe Hamster::List do
         end
 
         it "correctly identifies the matches" 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
     end

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

@@ -3,7 +3,7 @@ require "hamster/list"
 
 describe Hamster::List do
   describe "#subsequences" do
-    let(:list) { Hamster.list(1,2,3,4,5) }
+    let(:list) { L[1,2,3,4,5] }
 
     it "yields all sublists with 1 or more consecutive items" do
       result = []

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

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

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

@@ -5,7 +5,7 @@ describe Hamster::List do
   describe "#tail" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).filter(&:nil?).tail }.should_not raise_error
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).select(&:nil?).tail }.should_not raise_error
       end
     end
 
@@ -15,15 +15,15 @@ describe Hamster::List do
       [%w[A B C], %w[B 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.tail
-          list.should eql(Hamster.list(*values))
+          list.should eql(L[*values])
         end
 
         it "returns #{expected.inspect}" do
-          list.tail.should eql(Hamster.list(*expected))
+          list.tail.should eql(L[*expected])
         end
       end
     end

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

@@ -13,15 +13,15 @@ describe Hamster::List do
       [%w[A B C], [L["A", "B", "C"], L["B", "C"], 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.tails
-          list.should eql(Hamster.list(*values))
+          list.should eql(L[*values])
         end
 
         it "returns #{expected.inspect}" do
-          list.tails.should eql(Hamster.list(*expected))
+          list.tails.should eql(L[*expected])
         end
       end
     end

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

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

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

@@ -13,16 +13,16 @@ describe Hamster::List do
       [%w[A B C], %w[A B]],
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         context "with a block" do
           it "returns #{expected.inspect}" do
-            list.take_while { |item| item < "C" }.should eql(Hamster.list(*expected))
+            list.take_while { |item| item < "C" }.should eql(L[*expected])
           end
 
           it "preserves the original" do
             list.take_while { |item| item < "C" }
-            list.should eql(Hamster.list(*values))
+            list.should eql(L[*values])
           end
 
           it "is lazy" do
@@ -38,7 +38,7 @@ describe Hamster::List do
         context "without a block" do
           it "returns an Enumerator" do
             list.take_while.class.should be(Enumerator)
-            list.take_while.each { |item| item < "C" }.should eql(Hamster.list(*expected))
+            list.take_while.each { |item| item < "C" }.should eql(L[*expected])
           end
         end
       end

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

@@ -16,7 +16,7 @@ describe Hamster::List do
         %w[A B C],
       ].each do |values|
         context "on #{values.inspect}" do
-          let(:list) { Hamster.list(*values) }
+          let(:list) { L[*values] }
 
           it "returns #{values.inspect}" do
             list.send(method).should == values
@@ -24,7 +24,7 @@ describe Hamster::List do
 
           it "leaves the original unchanged" do
             list.send(method)
-            list.should eql(Hamster.list(*values))
+            list.should eql(L[*values])
           end
 
           it "returns a mutable array" do

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  let(:list) { Hamster.list("A", "B", "C", "D") }
+  let(:list) { L["A", "B", "C", "D"] }
 
   describe "#to_ary" do
     context "on a really big list" do

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

@@ -9,7 +9,7 @@ describe Hamster::List do
       %w[A B C],
     ].each do |values|
       context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         it "returns self" do
           list.to_list.should equal(list)

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

@@ -11,7 +11,7 @@ describe Hamster::List do
     ].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))
+          L[*values].to_set.should eql(S[*values])
         end
       end
     end

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

@@ -15,15 +15,15 @@ describe Hamster::List do
         [%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) }
+          let(:list_a) { L[*a] }
+          let(:list_b) { L[*b] }
 
           it "for #{a.inspect} and #{b.inspect}"  do
-            list_a.send(method, list_b).should eql(Hamster.list(*expected))
+            list_a.send(method, list_b).should eql(L[*expected])
           end
 
           it "for #{b.inspect} and #{a.inspect}"  do
-            list_b.send(method, list_a).should eql(Hamster.list(*expected))
+            list_b.send(method, list_a).should eql(L[*expected])
           end
         end
       end

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

@@ -2,29 +2,33 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  [:uniq, :nub, :remove_duplicates].each do |method|
-    describe "##{method}" do
-      it "is lazy" do
-        -> { Hamster.stream { fail }.uniq }.should_not raise_error
+  describe "#uniq" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.uniq }.should_not raise_error
+    end
+
+    context "when passed a block" do
+      it "uses the block to identify duplicates" do
+        L["a", "A", "b"].uniq(&:upcase).should eql(Hamster::List["a", "b"])
       end
+    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) }
+    [
+      [[], []],
+      [["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) { L[*values] }
 
-          it "preserves the original" do
-            list.send(method)
-            list.should eql(Hamster.list(*values))
-          end
+        it "preserves the original" do
+          list.uniq
+          list.should eql(L[*values])
+        end
 
-          it "returns #{expected.inspect}" do
-            list.send(method).should eql(Hamster.list(*expected))
-          end
+        it "returns #{expected.inspect}" do
+          list.uniq.should eql(L[*expected])
         end
       end
     end

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

@@ -9,14 +9,14 @@ describe Hamster::List do
 
     [
       [[], [], []],
-      [["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")]],
+      [["A"], ["aye"], [L["A", "aye"]]],
+      [["A"], [], [L["A", nil]]],
+      [[], ["A"], [L[nil, "A"]]],
+      [%w[A B C], %w[aye bee see], [L["A", "aye"], L["B", "bee"], L["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))
+          L[*left].zip(L[*right]).should eql(L[*expected])
         end
       end
     end

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

@@ -0,0 +1,103 @@
+require "spec_helper"
+require "hamster/nested"
+require "hamster/deque"
+require "set"
+
+describe Hamster do
+  expectations = [
+    # [Ruby, Hamster]
+    [ { "a" => 1,
+        "b" => [2, {"c" => 3}, 4],
+        "d" => ::Set.new([5, 6, 7]),
+        "e" => {"f" => 8, "g" => 9},
+        "h" => Regexp.new("ijk"),
+        "l" => ::SortedSet.new([1, 2, 3]) },
+      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"),
+        "l" => Hamster::SortedSet.new([1, 2, 3])] ],
+    [ {}, 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] ],
+    [ ::SortedSet.new, Hamster::SortedSet[] ],
+    [ ::SortedSet.new([1, 2, 3]), Hamster::SortedSet[1, 2, 3] ],
+    [ 42, 42 ],
+    [ STDOUT, STDOUT ],
+
+    # Struct conversion is one-way (from Ruby core Struct to Hamster::Hash), not back again!
+    [ Struct::Customer.new, Hamster::Hash[name: nil, address: nil], true ],
+    [ Struct::Customer.new('Dave', '123 Main'), Hamster::Hash[name: 'Dave', address: '123 Main'], true ]
+  ]
+
+  describe ".from" do
+    expectations.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
+
+    context "with mixed object" do
+      it "should return Hamster data" do
+        input = {
+          "a" => "b",
+          "c" => {"d" => "e"},
+          "f" => Hamster::Vector["g", "h", []],
+          "i" => Hamster::Hash["j" => {}, "k" => Hamster::Set[[], {}]] }
+        expected_result = Hamster::Hash[
+          "a" => "b",
+          "c" => Hamster::Hash["d" => "e"],
+          "f" => Hamster::Vector["g", "h", Hamster::EmptyVector],
+          "i" => Hamster::Hash["j" => Hamster::EmptyHash, "k" => Hamster::Set[Hamster::EmptyVector, Hamster::EmptyHash]] ]
+        Hamster.from(input).should eql(expected_result)
+      end
+    end
+  end
+
+  describe ".to_ruby" do
+    expectations.each do |expected_result, input, one_way|
+      unless one_way
+        context "with #{input.inspect} as input" do
+          it "should return #{expected_result.inspect}" do
+            Hamster.to_ruby(input).should eql(expected_result)
+          end
+        end
+      end
+    end
+
+    context "with Hamster::Deque[] as input" do
+      it "should return []" do
+        Hamster.to_ruby(Hamster::Deque[]).should eql([])
+      end
+    end
+
+    context "with Hamster::Deque[Hamster::Hash[\"a\" => 1]] as input" do
+      it "should return [{\"a\" => 1}]" do
+        Hamster.to_ruby(Hamster::Deque[Hamster::Hash["a" => 1]]).should eql([{"a" => 1}])
+      end
+    end
+
+    context "with mixed object" do
+      it "should return Ruby data structures" do
+        input = Hamster::Hash[
+          "a" => "b",
+          "c" => {"d" => "e"},
+          "f" => Hamster::Vector["g", "h"],
+          "i" => {"j" => Hamster::EmptyHash, "k" => Set.new([Hamster::EmptyVector, Hamster::EmptyHash])}]
+        expected_result = {
+          "a" => "b",
+          "c" => {"d" => "e"},
+          "f" => ["g", "h"],
+          "i" => {"j" => {}, "k" => Set.new([[], {}])} }
+        Hamster.to_ruby(input).should eql(expected_result)
+      end
+    end
+  end
+end