immutable-ruby 0.0.1 → 0.0.2

data/spec/lib/immutable/hash/superset_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "immutable/hash"
+
+describe Immutable::Hash do
+  describe "#>=" do
+    [
+      [{}, {}, true],
+      [{"A" => 1}, {}, true],
+      [{}, {"A" => 1}, false],
+      [{"A" => 1}, {"A" => 1}, true],
+      [{"A" => 1}, {"A" => 2}, false],
+      [{"A" => 1, "B" => 2, "C" => 3}, {"B" => 2}, true],
+      [{"B" => 2}, {"A" => 1, "B" => 2, "C" => 3}, false],
+      [{"A" => 1, "B" => 2, "C" => 3}, {"B" => 0}, false],
+    ].each do |a, b, expected|
+      describe "for #{a.inspect} and #{b.inspect}" do
+        it "returns #{expected}"  do
+          expect(H[a] >= H[b]).to eq(expected)
+        end
+      end
+    end
+  end
+
+  describe "#>" do
+    [
+      [{}, {}, false],
+      [{"A" => 1}, {}, true],
+      [{}, {"A" => 1}, false],
+      [{"A" => 1}, {"A" => 1}, false],
+      [{"A" => 1}, {"A" => 2}, false],
+      [{"A" => 1, "B" => 2, "C" => 3}, {"B" => 2}, true],
+      [{"B" => 2}, {"A" => 1, "B" => 2, "C" => 3}, false],
+      [{"A" => 1, "B" => 2, "C" => 3}, {"B" => 0}, false],
+    ].each do |a, b, expected|
+      describe "for #{a.inspect} and #{b.inspect}" do
+        it "returns #{expected}"  do
+          expect(H[a] > H[b]).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/spec/lib/immutable/hash/to_proc_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+require "immutable/hash"
+
+describe Immutable::Hash do
+  describe "#to_proc" do
+    context "on Hash without default proc" do
+      let(:hash) { H.new("A" => "aye") }
+
+      it "returns a Proc instance" do
+        hash.to_proc.should be_kind_of(Proc)
+      end
+
+      it "returns a Proc that returns the value of an existing key" do
+        hash.to_proc.call("A").should == "aye"
+      end
+
+      it "returns a Proc that returns nil for a missing key" do
+        hash.to_proc.call("B").should be_nil
+      end
+    end
+
+    context "on Hash with a default proc" do
+      let(:hash) { H.new("A" => "aye") { |key| "#{key}-VAL" } }
+
+      it "returns a Proc instance" do
+        hash.to_proc.should be_kind_of(Proc)
+      end
+
+      it "returns a Proc that returns the value of an existing key" do
+        hash.to_proc.call("A").should == "aye"
+      end
+
+      it "returns a Proc that returns the result of the hash's default proc for a missing key" do
+        hash.to_proc.call("B").should == "B-VAL"
+        hash.should == H.new("A" => "aye")
+      end
+    end
+  end
+end

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

@@ -2,12 +2,32 @@ require "spec_helper"
 
 describe Immutable::Hash do
   describe "#values_at" do
-    it "returns a vector of values for the given keys" do
-      h = H[:a => 9, :b => 'a', :c => -10, :d => nil]
-      h.values_at.should be_kind_of(Immutable::Vector)
-      h.values_at.should eql(V.empty)
-      h.values_at(:a, :d, :b).should be_kind_of(Immutable::Vector)
-      h.values_at(:a, :d, :b).should eql(V[9, nil, 'a'])
+    context "on Hash without default proc" do
+      let(:hash) { H[:a => 9, :b => 'a', :c => -10, :d => nil] }
+
+      it "returns an empty vector when no keys are given" do
+        hash.values_at.should be_kind_of(Immutable::Vector)
+        hash.values_at.should eql(V.empty)
+      end
+
+      it "returns a vector of values for the given keys" do
+        hash.values_at(:a, :d, :b).should be_kind_of(Immutable::Vector)
+        hash.values_at(:a, :d, :b).should eql(V[9, nil, 'a'])
+      end
+
+      it "fills nil when keys are missing" do
+        hash.values_at(:x, :a, :y, :b).should be_kind_of(Immutable::Vector)
+        hash.values_at(:x, :a, :y, :b).should eql(V[nil, 9, nil, 'a'])
+      end
+    end
+
+    context "on Hash with default proc" do
+      let(:hash) { Immutable::Hash.new(:a => 9) { |key| "#{key}-VAL" } }
+
+      it "fills the result of the default proc when keys are missing" do
+        hash.values_at(:x, :a, :y).should be_kind_of(Immutable::Vector)
+        hash.values_at(:x, :a, :y).should eql(V['x-VAL', 9, 'y-VAL'])
+      end
     end
   end
 end

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

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Immutable::List do
   describe "#all?" do
     context "on a really big list" do
-      let(:list) { Immutable.interval(0, STACK_OVERFLOW_DEPTH) }
+      let(:list) { BigList }
 
       it "doesn't run out of stack" do
         -> { list.all? }.should_not raise_error

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

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Immutable::List do
   describe "#any?" do
     context "on a really big list" do
-      let(:list) { Immutable.interval(0, STACK_OVERFLOW_DEPTH) }
+      let(:list) { BigList }
 
       it "doesn't run out of stack" do
         -> { list.any? { false } }.should_not raise_error

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

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Immutable::List do
   describe "#at" do
     context "on a really big list" do
-      let(:list) { Immutable.interval(0, STACK_OVERFLOW_DEPTH) }
+      let(:list) { BigList }
 
       it "doesn't run out of stack" do
         -> { list.at(STACK_OVERFLOW_DEPTH) }.should_not raise_error

data/spec/lib/immutable/list/construction_spec.rb

@@ -90,7 +90,7 @@ describe Immutable do
     it "realizes values as they are needed" do
       # this example shows that Lists are not as lazy as they could be
       # if Lists were fully lazy, you would have to take(4) to hit the exception
-      expect { list.take(3).to_a }.to raise_exception
+      expect { list.take(3).to_a }.to raise_exception(RuntimeError)
     end
   end
 

data/spec/lib/immutable/list/count_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#count" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).count }.should_not raise_error
+        -> { BigList.count }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/each_slice_spec.rb

@@ -5,7 +5,7 @@ describe Immutable::List do
     describe "##{method}" do
       context "on a really big list" do
         it "doesn't run out of stack" do
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).send(method, 1) { |item| } }.should_not raise_error
+          -> { BigList.send(method, 1) { |item| } }.should_not raise_error
         end
       end
 

data/spec/lib/immutable/list/each_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#each" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).each { |item| } }.should_not raise_error
+        -> { BigList.each { |item| } }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/empty_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#empty?" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).select(&:nil?).empty? }.should_not raise_error
+        -> { BigList.select(&:nil?).empty? }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/eql_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#eql?" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).eql?(Immutable.interval(0, STACK_OVERFLOW_DEPTH)) }.should_not raise_error
+        -> { BigList.eql?(Immutable.interval(0, STACK_OVERFLOW_DEPTH)) }.should_not raise_error
       end
     end
   end

data/spec/lib/immutable/list/find_index_spec.rb

@@ -5,7 +5,7 @@ describe Immutable::List do
     describe "##{method}" do
       context "on a really big list" do
         it "doesn't run out of stack" do
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).send(method) { |item| false } }.should_not raise_error
+          -> { BigList.send(method) { |item| false } }.should_not raise_error
         end
       end
 

data/spec/lib/immutable/list/find_spec.rb

@@ -5,7 +5,7 @@ describe Immutable::List do
     describe "##{method}" do
       context "on a really big list" do
         it "doesn't run out of stack" do
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).send(method) { false } }.should_not raise_error
+          -> { BigList.send(method) { false } }.should_not raise_error
         end
       end
 

data/spec/lib/immutable/list/group_by_spec.rb

@@ -5,7 +5,7 @@ describe Immutable::List do
     describe "##{method}" do
       context "on a really big list" do
         it "doesn't run out of stack" do
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).send(method) }.should_not raise_error
+          -> { BigList.send(method) }.should_not raise_error
         end
       end
 

data/spec/lib/immutable/list/hash_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#hash" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).hash }.should_not raise_error
+        -> { BigList.hash }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/include_spec.rb

@@ -5,7 +5,7 @@ describe Immutable::List do
     describe "##{method}" do
       context "on a really big list" do
         it "doesn't run out of stack" do
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).send(method, nil) }.should_not raise_error
+          -> { BigList.send(method, nil) }.should_not raise_error
         end
       end
 

data/spec/lib/immutable/list/index_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#index" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).index(nil) }.should_not raise_error
+        -> { BigList.index(nil) }.should_not raise_error
       end
     end
 
@@ -25,7 +25,11 @@ describe Immutable::List do
     ].each do |values, item, expected|
       context "looking for #{item.inspect} in #{values.inspect}" do
         it "returns #{expected.inspect}" do
-          L[*values].index(item).should == expected
+          if RUBY_ENGINE == 'jruby' && RUBY_VERSION <= '2.2.2' && values[0].is_a?(Fixnum) && item.is_a?(Float)
+            skip "On JRuby, Enumerable#find_index doesn't test equality properly"
+          else
+            L[*values].index(item).should == expected
+          end
         end
       end
     end

data/spec/lib/immutable/list/indices_spec.rb

@@ -11,7 +11,7 @@ describe Immutable::List do
 
       context "on a large list which doesn't contain desired item" do
         it "doesn't blow the stack" do
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).indices { |x| x < 0 }.size }.should_not raise_error
+          -> { BigList.indices { |x| x < 0 }.size }.should_not raise_error
         end
       end
 

data/spec/lib/immutable/list/inspect_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#inspect" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).inspect }.should_not raise_error
+        -> { BigList.inspect }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/join_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#join" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).join }.should_not raise_error
+        -> { BigList.join }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/last_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#last" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).last }.should_not raise_error
+        -> { BigList.last }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/maximum_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#max" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).max }.should_not raise_error
+        -> { BigList.max }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/minimum_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#min" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).min }.should_not raise_error
+        -> { BigList.min }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/multithreading_spec.rb

@@ -3,8 +3,8 @@ require "concurrent/atomics"
 
 describe Immutable::List do
   it "ensures each node of a lazy list will only be realized on ONE thread, even when accessed by multiple threads" do
-    counter = Concurrent::Atomic.new(0)
-    list = (1..10000).to_list.map { |x| counter.update { |count| count + 1 }; x * 2 }
+    counter = Concurrent::Atom.new(0)
+    list = (1..10000).to_list.map { |x| counter.swap { |count| count + 1 }; x * 2 }
 
     threads = 10.times.collect do
       Thread.new do
@@ -14,7 +14,7 @@ describe Immutable::List do
     end
     threads.each(&:join)
 
-    counter.get.should == 10000
+    counter.value.should == 10000
     list.sum.should == 100010000
   end
 
@@ -44,4 +44,4 @@ describe Immutable::List do
     elapsed = Time.now - start
     elapsed.should_not > 0.3
   end
-end
+end

data/spec/lib/immutable/list/none_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#none?" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).none? { false } }.should_not raise_error
+        -> { BigList.none? { false } }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/one_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#one?" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).one? { false } }.should_not raise_error
+        -> { BigList.one? { false } }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/product_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#product" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).product }.should_not raise_error
+        -> { BigList.product }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/reduce_spec.rb

@@ -5,7 +5,7 @@ describe Immutable::List do
     describe "##{method}" do
       context "on a really big list" do
         it "doesn't run out of stack" do
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).send(method, &:+) }.should_not raise_error
+          -> { BigList.send(method, &:+) }.should_not raise_error
         end
       end
 

data/spec/lib/immutable/list/reverse_spec.rb

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#reverse" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).reverse }.should_not raise_error
+        -> { BigList.reverse }.should_not raise_error
       end
     end
 

data/spec/lib/immutable/list/size_spec.rb

@@ -5,7 +5,7 @@ describe Immutable::List do
     describe "##{method}" do
       context "on a really big list" do
         it "doesn't run out of stack" do
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).size }.should_not raise_error
+          -> { BigList.size }.should_not raise_error
         end
       end
 

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

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#sum" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).sum }.should_not raise_error
+        -> { BigList.sum }.should_not raise_error
       end
     end
 

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

@@ -4,7 +4,7 @@ describe Immutable::List do
   describe "#tail" do
     context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).select(&:nil?).tail }.should_not raise_error
+        -> { BigList.select(&:nil?).tail }.should_not raise_error
       end
     end