hamster 1.0.0 → 1.0.1.pre.rc.1

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

@@ -1,28 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  let(:hash) { Hamster.hash("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/hamster/hash/sample_spec.rb

@@ -1,14 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "#sample" do
-    let(:hash) { Hamster::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/hamster/hash/select_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:select, :find_all, :keep_if].each do |method|
-    describe "##{method}" do
-      let(:original) { Hamster.hash("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(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
-          end
-
-          it "returns a set with the matching values" do
-            result.should eql(Hamster.hash("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 = Hamster::Hash.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(Hamster::Hash.new(keys.zip(2..1001))) # shouldn't have changed
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  let(:hash) { Hamster::Hash.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(Hamster::Hash.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(Hamster::Hash.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"))
-      end
-    end
-
-    context "on a Hash with a default block" do
-      let(:hash) { Hamster.hash('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/hamster/hash/sort_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  let(:hash) { Hamster.hash(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] }
-      Hamster::Hash.new(array.shuffle).sort.should eql(Hamster::Vector.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

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

@@ -1,76 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "#store" do
-    let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
-
-    context "with a unique key" do
-      let(:result) { hash.store("D", "dee") }
-
-      it "preserves the original" do
-        result
-        hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
-      end
-
-      it "returns a copy with the superset of key/value pairs" do
-        result.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", "D" => "dee"))
-      end
-    end
-
-    context "with a duplicate key" do
-      let(:result) { hash.store("C", "sea") }
-
-      it "preserves the original" do
-        result
-        hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
-      end
-
-      it "returns a copy with the superset of key/value pairs" do
-        result.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "sea"))
-      end
-    end
-
-    context "with duplicate key and identical value" do
-      let(:hash) { Hamster::Hash["X" => 1, "Y" => 2] }
-      let(:result) { hash.store("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) { Hamster::Hash[keys.zip(values)] }
-
-        it "returns the original hash unmodified for all changes" do
-          keys.each_with_index do |key, index|
-            result = hash.store(key, values[index])
-            result.should be(hash)
-          end
-        end
-      end
-    end
-
-    context "with unequal keys which hash to the same value" do
-      let(:hash) { Hamster.hash(DeterministicHash.new('a', 1) => 'aye') }
-
-      it "stores and can retrieve both" do
-        result = hash.store(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 = Hamster.hash.store(string, 'a value!')
-        string.upcase!
-        hash['a string!'].should == 'a value!'
-        hash['A STRING!'].should be_nil
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
-
-  describe "#take" do
-    it "returns the first N key/val pairs from hash" do
-      hash.take(0).should == []
-      [[['A', 'aye']], [['B', 'bee']], [['C', 'see']]].include?(hash.take(1)).should == true
-      [['A', 'aye'], ['B', 'bee'], ['C', 'see']].combination(2).include?(hash.take(2).sort).should == true
-      hash.take(3).sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
-      hash.take(4).sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
-    end
-  end
-
-  describe "#take_while" do
-    it "passes elements to the block until the block returns nil/false" do
-      passed = nil
-      hash.take_while { |k,v| passed = k; false }
-      ['A', 'B', 'C'].include?(passed).should == true
-    end
-
-    it "returns an array of all elements before the one which returned nil/false" do
-      count = 0
-      result = hash.take_while { count += 1; count < 3 }
-      [['A', 'aye'], ['B', 'bee'], ['C', 'see']].combination(2).include?(result.sort).should == true
-    end
-
-    it "passes all elements if the block never returns nil/false" do
-      passed = []
-      hash.take_while { |pair| passed << pair; true }.should == hash.to_a
-      passed.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-require "spec_helper"
-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)
-      pairs = []
-      hash.each_pair { |k,v| pairs << [k,v] }
-      hash.to_a.should be_kind_of(Array)
-      hash.to_a.should == pairs
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-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({})
-      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})
-      end
-
-      it "doesn't modify the receiver" do
-        hash = Hamster.hash(a: 1, b: 2)
-        hash.send(method)
-        hash.should eql(Hamster.hash(a: 1, b: 2))
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "#update_in" do
-    let(:hash) {
-      Hamster::Hash[
-        "A" => "aye",
-        "B" => Hamster::Hash["C" => "see", "D" => Hamster::Hash["E" => "eee"]],
-        "F" => Hamster::Vector["G", Hamster::Hash["H" => "eitch"], "I"]
-      ]
-    }
-
-    context "with one level on existing key" do
-      it "passes the value to the block" do
-        hash.update_in("A") { |value| value.should == "aye" }
-      end
-
-      it "replaces the value with the result of the block" do
-        result = hash.update_in("A") { |value| "FLIBBLE" }
-        result.get("A").should == "FLIBBLE"
-      end
-
-      it "should preserve the original" do
-        result = hash.update_in("A") { |value| "FLIBBLE" }
-        hash.get("A").should == "aye"
-      end
-    end
-
-    context "with multi-level on existing keys" do
-      it "passes the value to the block" do
-        hash.update_in("B", "D", "E") { |value| value.should == "eee" }
-      end
-
-      it "replaces the value with the result of the block" do
-        result = hash.update_in("B", "D", "E") { |value| "FLIBBLE" }
-        result["B"]["D"]["E"].should == "FLIBBLE"
-      end
-
-      it "should preserve the original" do
-        result = hash.update_in("B", "D", "E") { |value| "FLIBBLE" }
-        hash["B"]["D"]["E"].should == "eee"
-      end
-    end
-
-    context "with multi-level creating sub-hashes when keys don't exist" do
-      it "passes nil to the block" do
-        hash.update_in("B", "X", "Y") { |value| value.should be_nil }
-      end
-
-      it "creates subhashes on the way to set the value" do
-        result = hash.update_in("B", "X", "Y") { |value| "NEWVALUE" }
-        result["B"]["X"]["Y"].should == "NEWVALUE"
-        result["B"]["D"]["E"].should == "eee"
-      end
-    end
-
-    context "with multi-level including vector with existing keys" do
-      it "passes the value to the block" do
-        hash.update_in("F", 1, "H") { |value| value.should == "eitch" }
-      end
-
-      it "replaces the value with the result of the block" do
-        result = hash.update_in("F", 1, "H") { |value| "FLIBBLE" }
-        result["F"][1]["H"].should == "FLIBBLE"
-      end
-
-      it "should preserve the original" do
-        result = hash.update_in("F", 1, "H") { |value| "FLIBBLE" }
-        hash["F"][1]["H"].should == "eitch"
-      end
-    end
-
-    context "with empty key_path" do
-      it "raises ArguemntError" do
-        expect { hash.update_in() { |v| 42 } }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-require "spec_helper"
-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.values_at.should be_kind_of(Hamster::Vector)
-      h.values_at.should eql(Hamster.vector)
-      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'])
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-require "hamster/set"
-
-describe Hamster::Hash do
-  describe "#values" do
-    let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
-    let(:result) { hash.values }
-
-    it "returns the keys as a Vector" do
-      result.should be_a Hamster::Vector
-      result.to_a.sort.should == %w(aye bee see)
-    end
-
-    context "with duplicates" do
-      let(:hash) { Hamster.hash(:A => 15, :B => 19, :C => 15) }
-      let(:result) { hash.values }
-
-      it "returns the keys as a Vector" do
-        result.class.should be(Hamster::Vector)
-        result.to_a.sort.should == [15, 15, 19]
-      end
-    end
-  end
-end