hamster 1.0.0 → 1.0.1.pre.rc.1

data/spec/lib/hamster/vector/eql_spec.rb

@@ -1,77 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  describe "#eql" do
-    let(:vector) { Hamster.vector("A", "B", "C") }
-
-    it "returns false when comparing with an array with the same contents" do
-      vector.eql?(%w[A B C]).should == false
-    end
-
-    it "returns false when comparing with an arbitrary object" do
-      vector.eql?(Object.new).should == false
-    end
-
-    it "returns false when comparing an empty vector with an empty array" do
-      Hamster.vector.eql?([]).should == false
-    end
-
-    it "returns false when comparing with a subclass of Hamster::Vector" do
-      vector.eql?(Class.new(Hamster::Vector).new(%w[A B C])).should == false
-    end
-  end
-
-  describe "#==" do
-    let(:vector) { Hamster.vector("A", "B", "C") }
-
-    it "returns true when comparing with an array with the same contents" do
-      (vector == %w[A B C]).should == true
-    end
-
-    it "returns false when comparing with an arbitrary object" do
-      (vector == Object.new).should == false
-    end
-
-    it "returns true when comparing an empty vector with an empty array" do
-      (Hamster.vector == []).should == true
-    end
-
-    it "returns true when comparing with a subclass of Hamster::Vector" do
-      (vector == Class.new(Hamster::Vector).new(%w[A B C])).should == true
-    end
-
-    it "works on larger vectors" do
-      array = 2000.times.map { rand(10000) }
-      (V.new(array.dup) == array).should == true
-    end
-  end
-
-  [:eql?, :==].each do |method|
-    describe "##{method}" do
-      [
-        [[], [], true],
-        [[], [nil], false],
-        [["A"], [], false],
-        [["A"], ["A"], true],
-        [["A"], ["B"], false],
-        [%w[A B], ["A"], false],
-        [%w[A B C], %w[A B C], true],
-        [%w[C A B], %w[A B C], false],
-      ].each do |a, b, expected|
-        describe "returns #{expected.inspect}" do
-          let(:vector_a) { Hamster.vector(*a) }
-          let(:vector_b) { Hamster.vector(*b) }
-
-          it "for vectors #{a.inspect} and #{b.inspect}" do
-            vector_a.send(method, vector_b).should == expected
-          end
-
-          it "for vectors #{b.inspect} and #{a.inspect}" do
-            vector_b.send(method, vector_a).should == expected
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/hamster/vector/fetch_spec.rb

@@ -1,65 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  describe "#fetch" do
-    let(:vector) { Hamster.vector('a', 'b', 'c') }
-
-    context "with no default provided" do
-      context "when the index exists" do
-        it "returns the value at the index" do
-          vector.fetch(0).should == "a"
-          vector.fetch(1).should == "b"
-          vector.fetch(2).should == "c"
-        end
-      end
-
-      context "when the key does not exist" do
-        it "raises an IndexError" do
-          -> { vector.fetch(3) }.should raise_error(IndexError)
-          -> { vector.fetch(-4) }.should raise_error(IndexError)
-        end
-      end
-    end
-
-    context "with a default value" do
-      context "when the index exists" do
-        it "returns the value at the index" do
-          vector.fetch(0, "default").should == "a"
-          vector.fetch(1, "default").should == "b"
-          vector.fetch(2, "default").should == "c"
-        end
-      end
-
-      context "when the index does not exist" do
-        it "returns the default value" do
-          vector.fetch(3, "default").should == "default"
-          vector.fetch(-4, "default").should == "default"
-        end
-      end
-    end
-
-    context "with a default block" do
-      context "when the index exists" do
-        it "returns the value at the index" do
-          vector.fetch(0) { "default".upcase }.should == "a"
-          vector.fetch(1) { "default".upcase }.should == "b"
-          vector.fetch(2) { "default".upcase }.should == "c"
-        end
-      end
-
-      context "when the index does not exist" do
-        it "invokes the block with the missing index as parameter" do
-          vector.fetch(3) { |index| index.should == 3}
-          vector.fetch(-4) { |index| index.should == -4 }
-          vector.fetch(3) { "default".upcase }.should == "DEFAULT"
-          vector.fetch(-4) { "default".upcase }.should == "DEFAULT"
-        end
-      end
-    end
-
-    it "gives precedence to default block over default argument if passed both" do
-      vector.fetch(3, 'one') { 'two' }.should == 'two'
-    end
-  end
-end

data/spec/lib/hamster/vector/fill_spec.rb

@@ -1,89 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  describe "#fill" do
-    let(:vector) { Hamster.vector(1, 2, 3, 4, 5, 6) }
-
-    it "can replace a range of items at the beginning of a vector" do
-      vector.fill(:a, 0, 3).should eql(Hamster.vector(:a, :a, :a, 4, 5, 6))
-    end
-
-    it "can replace a range of items in the middle of a vector" do
-      vector.fill(:a, 3, 2).should eql(Hamster.vector(1, 2, 3, :a, :a, 6))
-    end
-
-    it "can replace a range of items at the end of a vector" do
-      vector.fill(:a, 4, 2).should eql(Hamster.vector(1, 2, 3, 4, :a, :a))
-    end
-
-    it "can replace all the items in a vector" do
-      vector.fill(:a, 0, 6).should eql(Hamster.vector(:a, :a, :a, :a, :a, :a))
-    end
-
-    it "can fill past the end of the vector" do
-      vector.fill(:a, 3, 6).should eql(Hamster.vector(1, 2, 3, :a, :a, :a, :a, :a, :a))
-    end
-
-    context "with 1 argument" do
-      it "replaces all the items in the vector by default" do
-        vector.fill(:a).should eql(Hamster.vector(:a, :a, :a, :a, :a, :a))
-      end
-    end
-
-    context "with 2 arguments" do
-      it "replaces up to the end of the vector by default" do
-        vector.fill(:a, 4).should eql(Hamster.vector(1, 2, 3, 4, :a, :a))
-      end
-    end
-
-    context "when index and length are 0" do
-      it "leaves the vector unmodified" do
-        vector.fill(:a, 0, 0).should eql(vector)
-      end
-    end
-
-    context "when expanding a vector past boundary where vector trie needs to deepen" do
-      it "works the same" do
-        vector.fill(:a, 32, 3).size.should == 35
-        vector.fill(:a, 32, 3).to_a.size.should == 35
-      end
-    end
-
-    [1000, 1023, 1024, 1025, 2000].each do |size|
-      context "on a #{size}-item vector" do
-        it "works the same" do
-          array = (0..size).to_a
-          vector = Hamster::Vector.new(array)
-          [[:a, 0, 5], [:b, 31, 2], [:c, 32, 60], [:d, 1000, 20], [:e, 1024, 33], [:f, 1200, 35]].each do |obj, index, length|
-            next if index > size
-            vector = vector.fill(obj, index, length)
-            array.fill(obj, index, length)
-            vector.size.should == array.size
-            ary = vector.to_a
-            ary.size.should == vector.size
-            ary.should eql(array)
-          end
-        end
-      end
-    end
-
-    it "behaves like Array#fill, on a variety of inputs" do
-      50.times do
-        array = rand(100).times.map { rand(1000) }
-        index = rand(array.size)
-        length = rand(50)
-        V.new(array).fill(:a, index, length).should == array.fill(:a, index, length)
-      end
-      10.times do
-        array = rand(100).times.map { rand(10000) }
-        length = rand(100)
-        V.new(array).fill(:a, array.size, length).should == array.fill(:a, array.size, length)
-      end
-      10.times do
-        array = rand(100).times.map { rand(10000) }
-        V.new(array).fill(:a).should == array.fill(:a)
-      end
-    end
-  end
-end

data/spec/lib/hamster/vector/first_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  describe "#first" do
-    [
-      [[], nil],
-      [["A"], "A"],
-      [%w[A B C], "A"],
-      [(1..32), 1],
-    ].each do |values, expected|
-      describe "on #{values.inspect}" do
-        it "returns #{expected.inspect}" do
-          Hamster.vector(*values).first.should == expected
-        end
-      end
-    end
-  end
-end

data/spec/lib/hamster/vector/flat_map_spec.rb

@@ -1,51 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  let(:vector) { Hamster.vector(*values) }
-
-  describe "#flat_map" do
-    let(:block) { ->(item) { [item, item + 1, item * item] } }
-    let(:flat_map) { vector.flat_map(&block) }
-    let(:flattened_vector) { Hamster.vector(*flattened_values) }
-
-    shared_examples "checking flattened result" do
-      it "returns the flattened values as a Hamster::Vector" do
-        expect(flat_map).to eq(flattened_vector)
-      end
-
-      it "returns a Hamster::Vector" do
-        expect(flat_map).to be_a(Hamster::Vector)
-      end
-    end
-
-    context "with an empty vector" do
-      let(:values) { [] }
-      let(:flattened_values) { [] }
-
-      include_examples "checking flattened result"
-    end
-
-    context "with a block that returns an empty vector" do
-      let(:block) { ->(item) { [] } }
-      let(:values) { [1, 2, 3] }
-      let(:flattened_values) { [] }
-
-      include_examples "checking flattened result"
-    end
-
-    context "with a vector of one item" do
-      let(:values) { [7] }
-      let(:flattened_values) { [7, 8, 49] }
-
-      include_examples "checking flattened result"
-    end
-
-    context "with a vector of multiple items" do
-      let(:values) { [1, 2, 3] }
-      let(:flattened_values) { [1, 2, 1, 2, 3, 4, 3, 4, 9] }
-
-      include_examples "checking flattened result"
-    end
-  end
-end

data/spec/lib/hamster/vector/flatten_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  describe "#flatten" do
-    it "recursively flattens nested vectors into containing vector" do
-      V[V[1], V[2]].flatten.should eql(V[1,2])
-      V[V[V[V[V[V[1,2,3]]]]]].flatten.should eql(V[1,2,3])
-      V[V[V[1]], V[V[V[2]]]].flatten.should eql(V[1,2])
-    end
-
-    it "flattens nested arrays as well" do
-      V[[1,2,3],[[4],[5,6]]].flatten.should eql(V[1,2,3,4,5,6])
-    end
-
-    context "with an integral argument" do
-      it "only flattens down to the specified depth" do
-        V[V[V[1,2]]].flatten(1).should eql(V[V[1,2]])
-        V[V[V[V[1]], V[2], V[3]]].flatten(2).should eql(V[V[1], 2, 3])
-      end
-    end
-
-    context "with an argument of zero" do
-      it "returns self" do
-        vector = V[1,2,3]
-        vector.flatten(0).should be(vector)
-      end
-    end
-
-    context "on a subclass" do
-      it "returns an instance of the subclass" do
-        subclass = Class.new(Hamster::Vector)
-        instance = subclass.new([1,2])
-        instance.flatten.class.should be(subclass)
-      end
-    end
-
-    it "leaves the original unmodified" do
-      vector = V[1,2,3]
-      vector.flatten
-      vector.should eql(V[1,2,3])
-    end
-  end
-end

data/spec/lib/hamster/vector/get_spec.rb

@@ -1,75 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  [:get, :at].each do |method|
-    describe "##{method}" do
-      context "when empty" do
-        it "always returns nil" do
-          (-1..1).each do |i|
-            Hamster.vector.send(method, i).should be_nil
-          end
-        end
-      end
-
-      context "when not empty" do
-        let(:vector) { Hamster.vector(*(1..1025)) }
-
-        context "with a positive index" do
-          context "within the absolute bounds of the vector" do
-            it "returns the value at the specified index from the head" do
-              (0..(vector.size - 1)).each do |i|
-                vector.send(method, i).should == i + 1
-              end
-            end
-          end
-
-          context "outside the absolute bounds of the vector" do
-            it "returns nil" do
-              vector.send(method, vector.size).should be_nil
-            end
-          end
-        end
-
-        context "with a negative index" do
-          context "within the absolute bounds of the vector" do
-            it "returns the value at the specified index from the tail" do
-              (-vector.size..-1).each do |i|
-                vector.send(method, i).should == vector.size + i + 1
-              end
-            end
-          end
-
-          context "outside the absolute bounds of the vector" do
-            it "returns nil" do
-              vector.send(method, -vector.size.next).should be_nil
-            end
-          end
-        end
-      end
-
-      [1, 10, 31, 32, 33, 1024, 1025, 2000].each do |size|
-        context "on a #{size}-item vector" do
-          it "works correctly, even after various addings and removings" do
-            array = size.times.map { rand(10000) }
-            vector = V.new(array)
-            100.times do
-              if rand(2) == 0
-                value, index = rand(10000), rand(size)
-                array[index] = value
-                vector = vector.set(index, value)
-              else
-                index = rand(array.size)
-                array.delete_at(index)
-                vector = vector.delete_at(index)
-              end
-            end
-            0.upto(array.size) do |i|
-              array[i].should == vector.send(method, i)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/hamster/vector/group_by_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-require "hamster/vector"
-
-describe Hamster::Vector do
-  describe "#group_by" do
-    context "with a block" do
-      [
-        [[], []],
-        [[1], [true => Hamster.vector(1)]],
-        [[1, 2, 3, 4], [true => Hamster.vector(1, 3), false => Hamster.vector(2, 4)]],
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          let(:vector) { Hamster.vector(*values) }
-
-          it "returns #{expected.inspect}" do
-            vector.group_by(&:odd?).should eql(Hamster.hash(*expected))
-            vector.should eql(Hamster::Vector.new(values)) # make sure it hasn't changed
-          end
-        end
-      end
-    end
-
-    context "without a block" do
-      [
-        [[], []],
-        [[1], [1 => Hamster.vector(1)]],
-        [[1, 2, 3, 4], [1 => Hamster.vector(1), 2 => Hamster.vector(2), 3 => Hamster.vector(3), 4 => Hamster.vector(4)]],
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          let(:vector) { Hamster.vector(*values) }
-
-          it "returns #{expected.inspect}" do
-            vector.group_by.should eql(Hamster.hash(*expected))
-            vector.should eql(Hamster::Vector.new(values)) # make sure it hasn't changed
-          end
-        end
-      end
-    end
-
-    context "on an empty vector" do
-      it "returns an empty hash" do
-        Hamster.vector.group_by { |x| x }.should eql(Hamster.hash)
-      end
-    end
-
-    it "returns a hash without default proc" do
-      Hamster.vector(1,2,3).group_by { |x| x }.default_proc.should be_nil
-    end
-
-    context "from a subclass" do
-      it "returns an Hash whose values are instances of the subclass" do
-        subclass = Class.new(Hamster::Vector)
-        instance = subclass.new([1, 'string', :symbol])
-        instance.group_by { |x| x.class }.values.each { |v| v.class.should be(subclass) }
-      end
-    end
-  end
-end