immutable-ruby 0.0.4 → 0.1.0

data/spec/lib/immutable/sorted_set/up_to_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-describe Immutable::SortedSet do
-  describe "#up_to" do
-    context "when called without a block" do
-      it "returns a sorted set of all items equal to or less than the argument" do
-        100.times do
-          items     = rand(100).times.collect { rand(1000) }.uniq
-          set       = SS.new(items)
-          threshold = rand(1000)
-          result    = set.up_to(threshold)
-          array     = items.select { |x| x <= threshold }.sort
-          result.class.should be(Immutable::SortedSet)
-          result.size.should == array.size
-          result.to_a.should == array
-        end
-      end
-    end
-
-    context "when called with a block" do
-      it "yields all the items equal to or less than than the argument" do
-        100.times do
-          items     = rand(100).times.collect { rand(1000) }.uniq
-          set       = SS.new(items)
-          threshold = rand(1000)
-          result    = []
-          set.up_to(threshold) { |x| result << x }
-          array  = items.select { |x| x <= threshold }.sort
-          result.size.should == array.size
-          result.should == array
-        end
-      end
-    end
-
-    context "on an empty set" do
-      it "returns an empty set" do
-        SS.empty.up_to(1).should be_empty
-        SS.empty.up_to('abc').should be_empty
-        SS.empty.up_to(:symbol).should be_empty
-        SS.empty.up_to(nil).should be_empty
-      end
-    end
-
-    context "with an argument less than all the values in the set" do
-      it "returns an empty set" do
-        result = SS.new(1..100).up_to(0)
-        result.class.should be(Immutable::SortedSet)
-        result.should be_empty
-      end
-    end
-  end
-end

data/spec/lib/immutable/sorted_set/util_spec.rb

@@ -1,48 +0,0 @@
-require "spec_helper"
-
-describe Immutable::SortedSet do
-  # Utility method used for filtering out duplicate objects, with equality
-  #   determined by comparator
-  describe ".uniq_by_comparator!" do
-    it "can handle empty arrays" do
-      array = []
-      SS.uniq_by_comparator!(array, ->(x,y) { x <=> y })
-      expect(array).to be_empty
-    end
-
-    it "can handle arrays with 1 element" do
-      array = [1]
-      SS.uniq_by_comparator!(array, ->(x,y) { x <=> y })
-      expect(array).to eq([1])
-    end
-
-    it "can handle arrays with 2 elements and no dupes" do
-      array = [1, 2]
-      SS.uniq_by_comparator!(array, ->(x,y) { x <=> y })
-      expect(array).to eq([1, 2])
-    end
-
-    it "can handle arrays with 2 elements and dupes" do
-      array = [1, 1]
-      SS.uniq_by_comparator!(array, ->(x,y) { x <=> y })
-      expect(array).to eq([1])
-    end
-
-    it "can handle arrays with lots of elements" do
-      100.times do
-        array1 = rand(100).times.collect { rand(100) }.sort
-        array2 = array1.dup.uniq
-        SS.uniq_by_comparator!(array1, ->(x,y) { x <=> y })
-        expect(array1).to eq(array2)
-      end
-    end
-
-    it "works with funny comparators" do
-      # let's work in modulo arithmetic
-      comparator = ->(x,y) { (x % 7) <=> (y % 7) }
-      array = [21, 1, 8, 1, 9, 10, 3, 5, 6, 20] # this is "sorted" (modulo 7)
-      SS.uniq_by_comparator!(array, comparator)
-      expect(array).to eq([21, 1, 9, 10, 5, 6])
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-describe Immutable::SortedSet do
-  describe "#values_at" do
-    let(:sorted_set) { SS['a', 'b', 'c'] }
-
-    it "accepts any number of indices, and returns a sorted_set of items at those indices" do
-      sorted_set.values_at(0).should   eql(SS['a'])
-      sorted_set.values_at(1,2).should eql(SS['b', 'c'])
-    end
-
-    context "when passed invalid indices" do
-      it "filters them out" do
-        sorted_set.values_at(1,2,3).should  eql(SS['b', 'c'])
-        sorted_set.values_at(-10,10).should eql(SS.empty)
-      end
-    end
-
-    context "when passed no arguments" do
-      it "returns an empty sorted_set" do
-        sorted_set.values_at.should eql(SS.empty)
-      end
-    end
-
-    context "from a subclass" do
-      it "returns an instance of the subclass" do
-        subclass = Class.new(Immutable::SortedSet)
-        instance = subclass.new([1,2,3])
-        instance.values_at(1,2).class.should be(subclass)
-      end
-    end
-  end
-end

data/spec/lib/immutable/vector/add_spec.rb

@@ -1,67 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  let(:vector) { V[*values] }
-
-  [:add, :<<, :push].each do |method|
-    describe "##{method}" do
-      shared_examples "checking adding values" do
-        let(:added_vector) { V[*added_values] }
-
-        it "preserves the original" do
-          original = vector
-          vector.send(method, added_value)
-          expect(original).to eq(vector)
-        end
-
-        it "adds the item to the vector" do
-          result = vector.send(method, added_value)
-          expect(result).to eq(added_vector)
-          expect(result.size).to eq(vector.size + 1)
-        end
-      end
-
-      context "with a empty vector adding a single item" do
-        let(:values) { [] }
-        let(:added_value) { "A" }
-        let(:added_values) { ["A"] }
-
-        include_examples "checking adding values"
-      end
-
-      context "with a single-item vector adding a different item" do
-        let(:values) { ["A"] }
-        let(:added_value) { "B" }
-        let(:added_values) { %w[A B] }
-
-        include_examples "checking adding values"
-      end
-
-      context "with a single-item vector adding a duplicate item" do
-        let(:values) { ["A"] }
-        let(:added_value) { "A" }
-        let(:added_values) { %w[A A] }
-
-        include_examples "checking adding values"
-      end
-
-      [31, 32, 33, 1023, 1024, 1025].each do |size|
-        context "with a #{size}-item vector adding a different item" do
-          let(:values) { (1..size).to_a }
-          let(:added_value) { size+1 }
-          let(:added_values) { (1..(size+1)).to_a }
-
-          include_examples "checking adding values"
-        end
-      end
-
-      context "from a subclass" do
-        it "returns an instance of the subclass" do
-          subclass = Class.new(Immutable::Vector)
-          instance = subclass[1,2,3]
-          instance.add(4).class.should be(subclass)
-        end
-      end
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  let(:vector) { V[*values] }
-
-  describe "#any?" do
-    let(:any?) { vector.any?(&block) }
-
-    context "when created with no values" do
-      let(:values) { [] }
-
-      context "with a block" do
-        let(:block) { ->(item) { item + 1 } }
-
-        it "returns false" do
-          expect(any?).to be(false)
-        end
-      end
-
-      context "with a block" do
-        let(:block) { nil }
-
-        it "returns false" do
-          expect(any?).to be(false)
-        end
-      end
-    end
-
-    context "when created with values" do
-      let(:values) { ["A", "B", 3, nil] }
-
-      context "with a block that returns true" do
-        let(:block) { ->(item) { item == 3 } }
-
-        it "returns true" do
-          expect(any?).to be(true)
-        end
-      end
-
-      context "with a block that doesn't return true" do
-        let(:block) { ->(item) { item == "D" } }
-
-        it "returns false" do
-          expect(any?).to be(false)
-        end
-      end
-
-      context "without a block" do
-        let(:block) { nil }
-
-        context "with some values that are truthy" do
-          let(:values) { [nil, false, "B"] }
-
-          it "returns true" do
-            expect(any?).to be(true)
-          end
-        end
-
-        context "with all values that are falsey" do
-          let(:values) { [nil, false] }
-
-          it "returns false" do
-            expect(any?).to be(false)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/immutable/vector/assoc_spec.rb

@@ -1,45 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  let(:vector) { V[[:a, 3], [:b, 2], [:c, 1]] }
-
-  describe "#assoc" do
-    it "searches for a 2-element array with a given 1st item" do
-      vector.assoc(:b).should == [:b, 2]
-    end
-
-    it "returns nil if a matching 1st item is not found" do
-      vector.assoc(:d).should be_nil
-    end
-
-    it "uses #== to compare 1st items with provided object" do
-      vector.assoc(EqualNotEql.new).should_not be_nil
-      vector.assoc(EqlNotEqual.new).should be_nil
-    end
-
-    it "skips elements which are not indexable" do
-      V[false, true, nil].assoc(:b).should be_nil
-      V[[1,2], nil].assoc(3).should be_nil
-    end
-  end
-
-  describe "#rassoc" do
-    it "searches for a 2-element array with a given 2nd item" do
-      vector.rassoc(1).should == [:c, 1]
-    end
-
-    it "returns nil if a matching 2nd item is not found" do
-      vector.rassoc(4).should be_nil
-    end
-
-    it "uses #== to compare 2nd items with provided object" do
-      vector.rassoc(EqualNotEql.new).should_not be_nil
-      vector.rassoc(EqlNotEqual.new).should be_nil
-    end
-
-    it "skips elements which are not indexable" do
-      V[false, true, nil].rassoc(:b).should be_nil
-      V[[1,2], nil].rassoc(3).should be_nil
-    end
-  end
-end

data/spec/lib/immutable/vector/bsearch_spec.rb

@@ -1,65 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  describe "#bsearch" do
-    let(:vector) { V[5,10,20,30] }
-
-    context "with a block which returns false for elements below desired position, and true for those at/above" do
-      it "returns the first element for which the predicate is true" do
-        vector.bsearch { |x| x > 10 }.should be(20)
-        vector.bsearch { |x| x > 1 }.should be(5)
-        vector.bsearch { |x| x > 25 }.should be(30)
-      end
-
-      context "if the block always returns false" do
-        it "returns nil" do
-          vector.bsearch { false }.should be_nil
-        end
-      end
-
-      context "if the block always returns true" do
-        it "returns the first element" do
-          vector.bsearch { true }.should be(5)
-        end
-      end
-    end
-
-    context "with a block which returns a negative number for elements below desired position, zero for the right element, and positive for those above" do
-      it "returns the element for which the block returns zero" do
-        vector.bsearch { |x| x <=> 10 }.should be(10)
-      end
-
-      context "if the block always returns positive" do
-        it "returns nil" do
-          vector.bsearch { 1 }.should be_nil
-        end
-      end
-
-      context "if the block always returns negative" do
-        it "returns nil" do
-          vector.bsearch { -1 }.should be_nil
-        end
-      end
-
-      context "if the block returns sometimes positive, sometimes negative, but never zero" do
-        it "returns nil" do
-          vector.bsearch { |x| x <=> 11 }.should be_nil
-        end
-      end
-
-      context "if not passed a block" do
-        it "returns an Enumerator" do
-          enum = vector.bsearch
-          enum.should be_a(Enumerator)
-          enum.each { |x| x <=> 10 }.should == 10
-        end
-      end
-    end
-
-    context "on an empty vector" do
-      it "returns nil" do
-        V.empty.bsearch { |x| x > 5 }.should be_nil
-      end
-    end
-  end
-end

data/spec/lib/immutable/vector/clear_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  describe "#clear" do
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      describe "on #{values}" do
-        let(:vector) { V[*values] }
-
-        it "preserves the original" do
-          vector.clear
-          vector.should eql(V[*values])
-        end
-
-        it "returns an empty vector" do
-          vector.clear.should equal(V.empty)
-        end
-      end
-
-      context "from a subclass" do
-        it "returns an instance of the subclass" do
-          subclass = Class.new(Immutable::Vector)
-          instance = subclass.new(%w{a b c})
-          instance.clear.class.should be(subclass)
-          instance.clear.should be_empty
-        end
-      end
-    end
-  end
-end

data/spec/lib/immutable/vector/combination_spec.rb

@@ -1,81 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  describe "#combination" do
-    let(:vector) { V[1,2,3,4] }
-
-    context "with a block" do
-      it "returns self" do
-        vector.combination(2) {}.should be(vector)
-      end
-    end
-
-    context "with no block" do
-      it "returns an Enumerator" do
-        vector.combination(2).class.should be(Enumerator)
-        vector.combination(2).to_a.should == vector.to_a.combination(2).to_a
-      end
-    end
-
-    context "when passed an argument which is out of bounds" do
-      it "yields nothing and returns self" do
-        vector.combination(5) { fail }.should be(vector)
-        vector.combination(-1) { fail }.should be(vector)
-      end
-    end
-
-    context "when passed an argument zero" do
-      it "yields an empty array" do
-        result = []
-        vector.combination(0) { |obj| result << obj }
-        result.should eql([[]])
-      end
-    end
-
-    context "when passed an argument equal to the vector's length" do
-      it "yields self as an array" do
-        result = []
-        vector.combination(4) { |obj| result << obj }
-        result.should eql([vector.to_a])
-      end
-    end
-
-    context "when passed an argument 1" do
-      it "yields each item in the vector, as single-item vectors" do
-        result = []
-        vector.combination(1) { |obj| result << obj }
-        result.should eql([[1], [2], [3], [4]])
-      end
-    end
-
-    context "when passed another integral argument" do
-      it "yields all combinations of the given length" do
-        result = []
-        vector.combination(3) { |obj| result << obj }
-        result.should eql([[1,2,3], [1,2,4], [1,3,4], [2,3,4]])
-      end
-    end
-
-    context "on an empty vector" do
-      it "works the same" do
-        V.empty.combination(0).to_a.should == [[]]
-        V.empty.combination(1).to_a.should == []
-      end
-    end
-
-    it "works on many combinations of input" do
-      0.upto(5) do |comb_size|
-        array = 12.times.map { rand(1000) }
-        V.new(array).combination(comb_size).to_a.should == array.combination(comb_size).to_a
-      end
-
-      array = 20.times.map { rand(1000) }
-      V.new(array).combination(2).to_a.should == array.combination(2).to_a
-    end
-
-    it "leaves the original unmodified" do
-      vector.combination(2) {}
-      vector.should eql(V[1,2,3,4])
-    end
-  end
-end

data/spec/lib/immutable/vector/compact_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  describe "#compact" do
-    it "returns a new Vector with all nils removed" do
-      V[1, nil, 2, nil].compact.should eql(V[1, 2])
-      V[1, 2, 3].compact.should eql(V[1, 2, 3])
-      V[nil].compact.should eql(V.empty)
-    end
-
-    context "on an empty vector" do
-      it "returns self" do
-        V.empty.compact.should be(V.empty)
-      end
-    end
-
-    it "doesn't remove false" do
-      V[false].compact.should eql(V[false])
-    end
-
-    context "from a subclass" do
-      it "returns an instance of the subclass" do
-        subclass = Class.new(V)
-        instance = subclass[1, nil, 2]
-        instance.compact.class.should be(subclass)
-      end
-    end
-  end
-end

data/spec/lib/immutable/vector/compare_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  describe "#<=>" do
-    [
-      [[], [1]],
-      [[1], [2]],
-      [[1], [1, 2]],
-      [[2, 3, 4], [3, 4, 5]],
-      [[[0]], [[1]]]
-    ].each do |items1, items2|
-      describe "with #{items1} and #{items2}" do
-        it "returns -1" do
-          (V.new(items1) <=> V.new(items2)).should be(-1)
-        end
-      end
-
-      describe "with #{items2} and #{items1}" do
-        it "returns 1" do
-          (V.new(items2) <=> V.new(items1)).should be(1)
-        end
-      end
-
-      describe "with #{items1} and #{items1}" do
-        it "returns 0" do
-          (V.new(items1) <=> V.new(items1)).should be(0)
-        end
-      end
-    end
-  end
-end

data/spec/lib/immutable/vector/concat_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  [:+, :concat].each do |method|
-    describe "##{method}" do
-      let(:vector) { V.new(1..100) }
-
-      it "preserves the original" do
-        vector.concat([1,2,3])
-        vector.should eql(V.new(1..100))
-      end
-
-      it "appends the elements in the other enumerable" do
-        vector.concat([1,2,3]).should eql(V.new((1..100).to_a + [1,2,3]))
-        vector.concat(1..1000).should eql(V.new((1..100).to_a + (1..1000).to_a))
-        vector.concat(1..200).size.should == 300
-        vector.concat(vector).should eql(V.new((1..100).to_a * 2))
-        vector.concat(V.empty).should eql(vector)
-        V.empty.concat(vector).should eql(vector)
-      end
-
-      [1, 31, 32, 33, 1023, 1024, 1025].each do |size|
-        context "on a #{size}-item vector" do
-          it "works the same" do
-            vector = V.new(1..size)
-            result = vector.concat((size+1)..size+10)
-            result.size.should == size + 10
-            result.should eql(V.new(1..(size+10)))
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/immutable/vector/copying_spec.rb

@@ -1,20 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  [:dup, :clone].each do |method|
-    [
-      [],
-      ["A"],
-      %w[A B C],
-      (1..32),
-    ].each do |values|
-      describe "on #{values.inspect}" do
-        let(:vector) { V[*values] }
-
-        it "returns self" do
-          vector.send(method).should equal(vector)
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  describe "#count" do
-    it "returns the number of elements" do
-      V[:a, :b, :c].count.should == 3
-    end
-
-    it "returns the number of elements that equal the argument" do
-      V[:a, :b, :b, :c].count(:b).should == 2
-    end
-
-    it "returns the number of element for which the block evaluates to true" do
-      V[:a, :b, :c].count { |s| s != :b }.should == 2
-    end
-  end
-end

data/spec/lib/immutable/vector/delete_at_spec.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  describe "#delete_at" do
-    let(:vector) { V[1,2,3,4,5] }
-
-    it "removes the element at the specified index" do
-      vector.delete_at(0).should eql(V[2,3,4,5])
-      vector.delete_at(2).should eql(V[1,2,4,5])
-      vector.delete_at(-1).should eql(V[1,2,3,4])
-    end
-
-    it "makes no modification if the index is out of range" do
-      vector.delete_at(5).should eql(vector)
-      vector.delete_at(-6).should eql(vector)
-    end
-
-    it "works when deleting last item at boundary where vector trie needs to get shallower" do
-      vector = Immutable::Vector.new(1..33)
-      vector.delete_at(32).size.should == 32
-      vector.delete_at(32).to_a.should eql((1..32).to_a)
-    end
-
-    it "works on an empty vector" do
-      V.empty.delete_at(0).should be(V.empty)
-      V.empty.delete_at(1).should be(V.empty)
-    end
-
-    it "works on a vector with 1 item" do
-      V[10].delete_at(0).should eql(V.empty)
-      V[10].delete_at(1).should eql(V[10])
-    end
-
-    it "works on a vector with 32 items" do
-      V.new(1..32).delete_at(0).should eql(V.new(2..32))
-      V.new(1..32).delete_at(31).should eql(V.new(1..31))
-    end
-
-    it "has the right size and contents after many deletions" do
-      array  = (1..2000).to_a # we use an Array as standard of correctness
-      vector = Immutable::Vector.new(array)
-      500.times do
-        index = rand(vector.size)
-        vector = vector.delete_at(index)
-        array.delete_at(index)
-        vector.size.should == array.size
-        ary = vector.to_a
-        ary.size.should == vector.size
-        ary.should eql(array)
-      end
-    end
-  end
-end