immutable-ruby 0.0.1 → 0.1.0

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

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-describe Immutable::SortedSet do
-  describe "#take" do
-    [
-      [[], 10, []],
-      [["A"], 10, ["A"]],
-      [%w[A B C], 0, []],
-      [%w[A B C], 2, %w[A B]],
-    ].each do |values, number, expected|
-      context "#{number} from #{values.inspect}" do
-        let(:sorted_set) { SS[*values] }
-
-        it "preserves the original" do
-          sorted_set.take(number)
-          sorted_set.should eql(SS[*values])
-        end
-
-        it "returns #{expected.inspect}" do
-          sorted_set.take(number).should eql(SS[*expected])
-        end
-      end
-    end
-
-    context "when argument is at least size of receiver" do
-      let(:sorted_set) { SS[6, 7, 8, 9] }
-      it "returns self" do
-        sorted_set.take(sorted_set.size).should be(sorted_set)
-        sorted_set.take(sorted_set.size + 1).should be(sorted_set)
-      end
-    end
-
-    context "when the set has a custom order" do
-      let(:sorted_set) { SS.new([1, 2, 3]) { |x| -x }}
-      it "maintains the custom order" do
-        sorted_set.take(1).to_a.should == [3]
-        sorted_set.take(2).to_a.should == [3, 2]
-        sorted_set.take(3).to_a.should == [3, 2, 1]
-      end
-
-      it "keeps the comparator even when set is cleared" do
-        s = sorted_set.take(0)
-        s.add(4).add(5).add(6).to_a.should == [6, 5, 4]
-      end
-    end
-
-    context "when called on a subclass" do
-      it "should return an instance of the subclass" do
-        subclass = Class.new(Immutable::SortedSet)
-        subclass.new([1,2,3]).take(1).class.should be(subclass)
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-describe Immutable::SortedSet do
-  describe "#take_while" do
-    [
-      [[], []],
-      [["A"], ["A"]],
-      [%w[A B C], %w[A B]],
-    ].each do |values, expected|
-      context "on #{values.inspect}" do
-        let(:sorted_set) { SS[*values] }
-
-        context "with a block" do
-          it "returns #{expected.inspect}" do
-            sorted_set.take_while { |item| item < "C" }.should eql(SS[*expected])
-          end
-
-          it "preserves the original" do
-            sorted_set.take_while { |item| item < "C" }
-            sorted_set.should eql(SS[*values])
-          end
-        end
-
-        context "without a block" do
-          it "returns an Enumerator" do
-            sorted_set.take_while.class.should be(Enumerator)
-            sorted_set.take_while.each { |item| item < "C" }.should eql(SS[*expected])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-describe Immutable::SortedSet do
-  describe "#to_set" do
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      context "on #{values.inspect}" do
-        it "returns a set with the same values" do
-          SS[*values].to_set.should eql(S[*values])
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-require "spec_helper"
-
-describe Immutable::SortedSet do
-  [:union, :|, :+, :merge].each do |method|
-    describe "##{method}" do
-      [
-        [[], [], []],
-        [["A"], [], ["A"]],
-        [["A"], ["A"], ["A"]],
-        [%w[A B C], [], %w[A B C]],
-        [%w[A C E G X], %w[B C D E H M], %w[A B C D E G H M X]]
-      ].each do |a, b, expected|
-        context "for #{a.inspect} and #{b.inspect}" do
-          it "returns #{expected.inspect}" do
-            SS[*a].send(method, SS[*b]).should eql(SS[*expected])
-          end
-        end
-
-        context "for #{b.inspect} and #{a.inspect}" do
-          it "returns #{expected.inspect}" do
-            SS[*b].send(method, SS[*a]).should eql(SS[*expected])
-          end
-        end
-      end
-    end
-  end
-end

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) }
-          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) }
-          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/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