immutable-ruby 0.0.1

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

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#superset?" do
+    [
+      [[], [], true],
+      [["A"], [], true],
+      [[], ["A"], false],
+      [["A"], ["A"], true],
+      [%w[A B C], ["B"], true],
+      [["B"], %w[A B C], false],
+      [%w[A B C], %w[A C], true],
+      [%w[A C], %w[A B C], false],
+      [%w[A B C], %w[A B C], true],
+      [%w[A B C], %w[A B C D], false],
+      [%w[A B C D], %w[A B C], true],
+    ].each do |a, b, expected|
+      context "for #{a.inspect} and #{b.inspect}" do
+        it "returns #{expected}"  do
+          SS[*a].superset?(SS[*b]).should == expected
+        end
+      end
+    end
+  end
+
+  describe "#proper_superset?" do
+    [
+      [[], [], false],
+      [["A"], [], true],
+      [[], ["A"], false],
+      [["A"], ["A"], false],
+      [%w[A B C], ["B"], true],
+      [["B"], %w[A B C], false],
+      [%w[A B C], %w[A C], true],
+      [%w[A C], %w[A B C], false],
+      [%w[A B C], %w[A B C], false],
+      [%w[A B C], %w[A B C D], false],
+      [%w[A B C D], %w[A B C], true],
+    ].each do |a, b, expected|
+      context "for #{a.inspect} and #{b.inspect}" do
+        it "returns #{expected}"  do
+          SS[*a].proper_superset?(SS[*b]).should == expected
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,45 @@
+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