immutable-ruby 0.0.1 → 0.1.0

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

@@ -1,45 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H["a" => 3, "b" => 2, "c" => 1] }
-
-  describe "#min" do
-    it "returns the smallest key/val pair" do
-      hash.min.should == ["a", 3]
-    end
-  end
-
-  describe "#max" do
-    it "returns the largest key/val pair" do
-      hash.max.should == ["c", 1]
-    end
-  end
-
-  describe "#min_by" do
-    it "returns the smallest key/val pair (after passing it through a key function)" do
-      hash.min_by { |k,v| v }.should == ["c", 1]
-    end
-
-    it "returns the first key/val pair yielded by #each in case of a tie" do
-      hash.min_by { 0 }.should == hash.each.first
-    end
-
-    it "returns nil if the hash is empty" do
-      H.empty.min_by { |k,v| v }.should be_nil
-    end
-  end
-
-  describe "#max_by" do
-    it "returns the largest key/val pair (after passing it through a key function)" do
-      hash.max_by { |k,v| v }.should == ["a", 3]
-    end
-
-    it "returns the first key/val pair yielded by #each in case of a tie" do
-      hash.max_by { 0 }.should == hash.each.first
-    end
-
-    it "returns nil if the hash is empty" do
-      H.empty.max_by { |k,v| v }.should be_nil
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe ".new" do
-    it "is amenable to overriding of #initialize" do
-      class SnazzyHash < Immutable::Hash
-        def initialize
-          super({'snazzy?' => 'oh yeah'})
-        end
-      end
-
-      SnazzyHash.new['snazzy?'].should == 'oh yeah'
-    end
-
-    context "from a subclass" do
-      it "returns a frozen instance of the subclass" do
-        subclass = Class.new(Immutable::Hash)
-        instance = subclass.new("some" => "values")
-        instance.class.should be(subclass)
-        instance.frozen?.should be true
-      end
-    end
-
-    it "accepts an array as initializer" do
-      H.new([['a', 'b'], ['c', 'd']]).should eql(H['a' => 'b', 'c' => 'd'])
-    end
-
-    it "returns a Hash which doesn't change even if initializer is mutated" do
-      rbhash = {a: 1, b: 2}
-      hash = H.new(rbhash)
-      rbhash[:a] = 'BAD'
-      hash.should eql(H[a: 1, b: 2])
-    end
-  end
-
-  describe ".[]" do
-    it "accepts a Ruby Hash as initializer" do
-      hash = H[a: 1, b: 2]
-      hash.class.should be(Immutable::Hash)
-      hash.size.should == 2
-      hash.key?(:a).should == true
-      hash.key?(:b).should == true
-    end
-
-    it "accepts a Immutable::Hash as initializer" do
-      hash = H[H.new(a: 1, b: 2)]
-      hash.class.should be(Immutable::Hash)
-      hash.size.should == 2
-      hash.key?(:a).should == true
-      hash.key?(:b).should == true
-    end
-
-    it "accepts an array as initializer" do
-      hash = H[[[:a, 1], [:b, 2]]]
-      hash.class.should be(Immutable::Hash)
-      hash.size.should == 2
-      hash.key?(:a).should == true
-      hash.key?(:b).should == true
-    end
-
-    it "can be used with a subclass of Immutable::Hash" do
-      subclass = Class.new(Immutable::Hash)
-      instance = subclass[a: 1, b: 2]
-      instance.class.should be(subclass)
-      instance.size.should == 2
-      instance.key?(:a).should == true
-      instance.key?(:b).should == true
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#none?" do
-    context "when empty" do
-      it "with a block returns true" do
-        H.empty.none? {}.should == true
-      end
-
-      it "with no block returns true" do
-        H.empty.none?.should == true
-      end
-    end
-
-    context "when not empty" do
-      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"] }
-
-      context "with a block" do
-        [
-          %w[A aye],
-          %w[B bee],
-          %w[C see],
-          [nil, "NIL"],
-        ].each do |pair|
-          it "returns false if the block ever returns true (#{pair.inspect})" do
-            hash.none? { |key, value| key == pair.first && value == pair.last }.should == false
-          end
-
-          it "returns true if the block always returns false" do
-            hash.none? { |key, value| key == "D" && value == "dee" }.should == true
-          end
-
-          it "stops iterating as soon as the block returns true" do
-            yielded = []
-            hash.none? { |k,v| yielded << k; true }
-            yielded.size.should == 1
-          end
-        end
-      end
-
-      context "with no block" do
-        it "returns false" do
-          hash.none?.should == false
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H["a" => 1, "b" => 2, "c" => 3, "d" => 4] }
-  let(:partition) { hash.partition { |k,v| v % 2 == 0 }}
-
-  describe "#partition" do
-    it "returns a pair of Immutable::Hashes" do
-      partition.each { |h| h.class.should be(Immutable::Hash) }
-      partition.should be_frozen
-    end
-
-    it "returns key/val pairs for which predicate is true in first Hash" do
-      partition[0].should == {"b" => 2, "d" => 4}
-    end
-
-    it "returns key/val pairs for which predicate is false in second Hash" do
-      partition[1].should == {"a" => 1, "c" => 3}
-    end
-
-    it "doesn't modify the original Hash" do
-      partition
-      hash.should eql(H["a" => 1, "b" => 2, "c" => 3, "d" => 4])
-    end
-
-    context "from a subclass" do
-      it "should return instances of the subclass" do
-        subclass  = Class.new(Immutable::Hash)
-        instance  = subclass.new("a" => 1, "b" => 2, "c" => 3, "d" => 4)
-        partition = instance.partition { |k,v| v % 2 == 0 }
-        partition.each { |h| h.class.should be(subclass) }
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require "spec_helper"
-require "pp"
-require "stringio"
-
-describe Immutable::Hash do
-  describe "#pretty_print" do
-    let(:hash) { Immutable::Hash.new(DeterministicHash.new(1,1) => "tin", DeterministicHash.new(2,2) => "earwax", DeterministicHash.new(3,3) => "neanderthal") }
-    let(:stringio) { StringIO.new }
-
-
-    it "prints the whole Hash on one line if it fits" do
-      PP.pp(hash, stringio, 80)
-      stringio.string.chomp.should == 'Immutable::Hash[1 => "tin", 2 => "earwax", 3 => "neanderthal"]'
-    end
-
-    it "prints each key/val pair on its own line, if not" do
-      PP.pp(hash, stringio, 20)
-      stringio.string.chomp.should == 'Immutable::Hash[
- 1 => "tin",
- 2 => "earwax",
- 3 => "neanderthal"]'
-    end
-
-    it "prints keys and vals on separate lines, if space is very tight" do
-      PP.pp(hash, stringio, 15)
-      # the trailing space after "3 =>" below is needed, don't remove it
-      stringio.string.chomp.should == 'Immutable::Hash[
- 1 => "tin",
- 2 => "earwax",
- 3 => 
-  "neanderthal"]'
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#put" do
-    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-    context "with a block" do
-      it "passes the value to the block" do
-        hash.put("A") { |value| value.should == "aye" }
-      end
-
-      it "replaces the value with the result of the block" do
-        result = hash.put("A") { |value| "FLIBBLE" }
-        result.get("A").should == "FLIBBLE"
-      end
-
-      it "supports to_proc methods" do
-        result = hash.put("A", &:upcase)
-        result.get("A").should == "AYE"
-      end
-
-      context "if there is no existing association" do
-        it "passes nil to the block" do
-          hash.put("D") { |value| value.should be_nil }
-        end
-
-        it "stores the result of the block as the new value" do
-          result = hash.put("D") { |value| "FLIBBLE" }
-          result.get("D").should == "FLIBBLE"
-        end
-      end
-    end
-
-    context "with a unique key" do
-      let(:result) { hash.put("D", "dee") }
-
-      it "preserves the original" do
-        result
-        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
-      end
-
-      it "returns a copy with the superset of key/value pairs" do
-        result.should eql(H["A" => "aye", "B" => "bee", "C" => "see", "D" => "dee"])
-      end
-    end
-
-    context "with a duplicate key" do
-      let(:result) { hash.put("C", "sea") }
-
-      it "preserves the original" do
-        result
-        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
-      end
-
-      it "returns a copy with the superset of key/value pairs" do
-        result.should eql(H["A" => "aye", "B" => "bee", "C" => "sea"])
-      end
-    end
-
-    context "with duplicate key and identical value" do
-      let(:hash) { H["X" => 1, "Y" => 2] }
-      let(:result) { hash.put("X", 1) }
-
-      it "returns the original hash unmodified" do
-        result.should be(hash)
-      end
-
-      context "with big hash (force nested tries)" do
-        let(:keys) { (0..99).map(&:to_s) }
-        let(:values) { (100..199).to_a }
-        let(:hash) { H[keys.zip(values)] }
-
-        it "returns the original hash unmodified for all changes" do
-          keys.each_with_index do |key, index|
-            result = hash.put(key, values[index])
-            result.should be(hash)
-          end
-        end
-      end
-    end
-
-    context "with unequal keys which hash to the same value" do
-      let(:hash) { H[DeterministicHash.new('a', 1) => 'aye'] }
-
-      it "stores and can retrieve both" do
-        result = hash.put(DeterministicHash.new('b', 1), 'bee')
-        result.get(DeterministicHash.new('a', 1)).should eql('aye')
-        result.get(DeterministicHash.new('b', 1)).should eql('bee')
-      end
-    end
-
-    context "when a String is inserted as key and then mutated" do
-      it "is not affected" do
-        string = "a string!"
-        hash = H.empty.put(string, 'a value!')
-        string.upcase!
-        hash['a string!'].should == 'a value!'
-        hash['A STRING!'].should be_nil
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  [:reduce, :inject].each do |method|
-    describe "##{method}" do
-      context "when empty" do
-        it "returns the memo" do
-          H.empty.send(method, "ABC") {}.should == "ABC"
-        end
-      end
-
-      context "when not empty" do
-        let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-        context "with a block" do
-          it "returns the final memo" do
-            hash.send(method, 0) { |memo, key, value| memo + 1 }.should == 3
-          end
-        end
-
-        context "with no block" do
-          let(:hash) { H[a: 1, b: 2] }
-
-          it "uses a passed string as the name of a method to use instead" do
-            [[:a, 1, :b, 2], [:b, 2, :a, 1]].include?(hash.send(method, "+")).should == true
-          end
-
-          it "uses a passed symbol as the name of a method to use instead" do
-            [[:a, 1, :b, 2], [:b, 2, :a, 1]].include?(hash.send(method, :+)).should == true
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  [:reject, :delete_if].each do |method|
-    describe "##{method}" do
-      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-      context "when nothing matches" do
-        it "returns self" do
-          hash.send(method) { |key, value| false }.should equal(hash)
-        end
-      end
-
-      context "when only some things match" do
-        context "with a block" do
-          let(:result) { hash.send(method) { |key, value| key == "A" && value == "aye" }}
-
-          it "preserves the original" do
-            result
-            hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
-          end
-
-          it "returns a set with the matching values" do
-            result.should eql(H["B" => "bee", "C" => "see"])
-          end
-
-          it "yields entries in the same order as #each" do
-            each_pairs = []
-            remove_pairs = []
-            hash.each_pair { |k,v| each_pairs << [k,v] }
-            hash.send(method) { |k,v| remove_pairs << [k,v] }
-            each_pairs.should == remove_pairs
-          end
-        end
-
-        context "with no block" do
-          it "returns an Enumerator" do
-            hash.send(method).class.should be(Enumerator)
-            hash.send(method).to_a.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
-            hash.send(method).each { true }.should eql(H.empty)
-          end
-        end
-
-        context "on a large hash, with many combinations of input" do
-          it "still works" do
-            array = 1000.times.collect { |n| [n, n] }
-            hash  = H.new(array)
-            [0, 10, 100, 200, 500, 800, 900, 999, 1000].each do |threshold|
-              result = hash.send(method) { |k,v| k >= threshold}
-              result.size.should == threshold
-              0.upto(threshold-1) { |n| result.key?(n).should == true }
-              threshold.upto(1000) { |n| result.key?(n).should == false }
-            end
-            # shouldn't have changed
-            hash.should eql(H.new(1000.times.collect { |n| [n, n] }))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-  describe "#reverse_each" do
-    context "with a block" do
-      it "returns self" do
-        hash.reverse_each {}.should be(hash)
-      end
-
-      it "yields all key/value pairs in the opposite order as #each" do
-        result = []
-        hash.reverse_each { |entry| result << entry }
-        result.should eql(hash.to_a.reverse)
-      end
-    end
-
-    context "with no block" do
-      it "returns an Enumerator" do
-        result = hash.reverse_each
-        result.class.should be(Enumerator)
-        result.to_a.should eql(hash.to_a.reverse)
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#sample" do
-    let(:hash) { Immutable::Hash.new((:a..:z).zip(1..26)) }
-
-    it "returns a randomly chosen item" do
-      chosen = 250.times.map { hash.sample }.sort.uniq
-      chosen.each { |item| hash.include?(item[0]).should == true }
-      hash.each { |item| chosen.include?(item).should == true }
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  [:select, :find_all, :keep_if].each do |method|
-    describe "##{method}" do
-      let(:original) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-      context "when everything matches" do
-        it "returns self" do
-          original.send(method) { |key, value| true }.should equal(original)
-        end
-      end
-
-      context "when only some things match" do
-        context "with a block" do
-          let(:result) { original.send(method) { |key, value| key == "A" && value == "aye" }}
-
-          it "preserves the original" do
-            original.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
-          end
-
-          it "returns a set with the matching values" do
-            result.should eql(H["A" => "aye"])
-          end
-        end
-
-        it "yields entries as [key, value] pairs" do
-          original.send(method) do |e|
-            e.should be_kind_of(Array)
-            ["A", "B", "C"].include?(e[0]).should == true
-            ["aye", "bee", "see"].include?(e[1]).should == true
-          end
-        end
-
-        context "with no block" do
-          it "returns an Enumerator" do
-            original.send(method).class.should be(Enumerator)
-            original.send(method).to_a.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
-          end
-        end
-      end
-
-      it "works on a large hash, with many combinations of input" do
-        keys = (1..1000).to_a
-        original = H.new(keys.zip(2..1001))
-        25.times do
-          threshold = rand(1000)
-          result    = original.send(method) { |k,v| k <= threshold }
-          result.size.should == threshold
-          result.each_key { |k| k.should <= threshold }
-          (threshold+1).upto(1000) { |k| result.key?(k).should == false }
-        end
-        original.should eql(H.new(keys.zip(2..1001))) # shouldn't have changed
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  [:size, :length].each do |method|
-    describe "##{method}" do
-      [
-        [[], 0],
-        [["A" => "aye"], 1],
-        [["A" => "bee", "B" => "bee", "C" => "see"], 3],
-      ].each do |values, result|
-
-        it "returns #{result} for #{values.inspect}" do
-          H[*values].send(method).should == result
-        end
-      end
-
-      lots = (1..10_842).to_a
-      srand 89_533_474
-      random_things = (lots + lots).sort_by { |x|rand }
-
-      it "has the correct size after adding lots of things with colliding keys and such" do
-        h = H.empty
-        random_things.each do |thing|
-          h = h.put(thing, thing * 2)
-        end
-        h.size.should == 10_842
-      end
-
-      random_actions = (lots.map { |x|[:add, x] } + lots.map { |x|[:add, x] } + lots.map { |x|[:remove, x] }).sort_by { |x|rand }
-      ending_size = random_actions.reduce({}) do |h, (act, ob)|
-        if act == :add
-          h[ob] = 1
-        else
-          h.delete(ob)
-        end
-        h
-      end.size
-      it "has the correct size after lots of addings and removings" do
-        h = H.empty
-        random_actions.each do |(act, ob)|
-          if act == :add
-            h = h.put(ob, ob * 3)
-          else
-            h = h.delete(ob)
-          end
-        end
-        h.size.should == ending_size
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
-
-  describe "#slice" do
-    let(:slice) { hash.slice(*values) }
-
-    context "with all keys present in the Hash" do
-      let(:values) { ["B", nil] }
-
-      it "returns the sliced values" do
-        expect(slice).to eq(described_class.new("B" => "bee", nil => "NIL"))
-      end
-
-      it "doesn't modify the original Hash" do
-        slice
-        hash.should eql(H.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"))
-      end
-    end
-
-    context "with keys aren't present in the Hash" do
-      let(:values) { ["B", "A", 3] }
-
-      it "returns the sliced values of the matching keys" do
-        expect(slice).to eq(described_class.new("A" => "aye", "B" => "bee"))
-      end
-
-      it "doesn't modify the original Hash" do
-        slice
-        hash.should eql(H.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"))
-      end
-    end
-
-    context "on a Hash with a default block" do
-      let(:hash) { H.new('A' => 'aye', 'B' => 'bee') { 'nothing' }}
-      let(:values) { ["B", nil] }
-
-      it "maintains the default block" do
-        expect(slice['C']).to eq('nothing')
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H[a: 3, b: 2, c: 1] }
-
-  describe "#sort" do
-    it "returns a Vector of sorted key/val pairs" do
-      hash.sort.should eql(V[[:a, 3], [:b, 2], [:c, 1]])
-    end
-
-    it "works on large hashes" do
-      array = (1..1000).map { |n| [n,n] }
-      H.new(array.shuffle).sort.should eql(V.new(array))
-    end
-
-    it "uses block as comparator to sort if passed a block" do
-      hash.sort { |a,b| b <=> a }.should eql(V[[:c, 1], [:b, 2], [:a, 3]])
-    end
-  end
-
-  describe "#sort_by" do
-    it "returns a Vector of key/val pairs, sorted using the block as a key function" do
-      hash.sort_by { |k,v| v }.should eql(V[[:c, 1], [:b, 2], [:a, 3]])
-    end
-  end
-end