immutable-ruby 0.0.1

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

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  [:difference, :subtract, :-].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], []],
+        [["A"], [], ["A"]],
+        [["A"], ["A"], []],
+        [%w[A B C], ["B"], %w[A C]],
+        [%w[A B C], %w[A C], ["B"]],
+        [%w[A B C D E F], %w[B E F G M X], %w[A C D]]
+      ].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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#disjoint?" do
+    [
+      [[], [], true],
+      [["A"], [], true],
+      [[], ["A"], true],
+      [["A"], ["A"], false],
+      [%w[A B C], ["B"], false],
+      [["B"], %w[A B C], false],
+      [%w[A B C], %w[D E], true],
+      [%w[F G H I], %w[A B C], true],
+      [%w[A B C], %w[A B C], false],
+      [%w[A B C], %w[A B C D], false],
+      [%w[D E F G], %w[A B C], true],
+    ].each do |a, b, expected|
+      context "for #{a.inspect} and #{b.inspect}" do
+        it "returns #{expected}" do
+          SS[*a].disjoint?(SS[*b]).should be(expected)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#drop" do
+    [
+      [[], 0, []],
+      [[], 10, []],
+      [["A"], 10, []],
+      [%w[A B C], 0, %w[A B C]],
+      [%w[A B C], 1, %w[B C]],
+      [%w[A B C], 2, ["C"]],
+      [%w[A B C], 3, []]
+    ].each do |values, number, expected|
+      context "#{number} from #{values.inspect}" do
+        let(:sorted_set) { SS[*values] }
+
+        it "preserves the original" do
+          sorted_set.drop(number)
+          sorted_set.should eql(SS[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          sorted_set.drop(number).should eql(SS[*expected])
+        end
+      end
+    end
+
+    context "when argument is zero" do
+      let(:sorted_set) { SS[6, 7, 8, 9] }
+      it "returns self" do
+        sorted_set.drop(0).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.drop(1).to_a.should == [2, 1]
+        sorted_set.drop(2).to_a.should == [1]
+      end
+
+      it "keeps the comparator even when set is cleared" do
+        s = sorted_set.drop(3)
+        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]).drop(1).class.should be(subclass)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#each" do
+    context "with no block" do
+      let(:sorted_set) { SS["A", "B", "C"] }
+
+      it "returns an Enumerator" do
+        sorted_set.each.class.should be(Enumerator)
+        sorted_set.each.to_a.should eql(sorted_set.to_a)
+      end
+    end
+
+    context "with a block" do
+      let(:sorted_set) { SS.new((1..1025).to_a.reverse) }
+
+      it "returns self" do
+        sorted_set.each {}.should be(sorted_set)
+      end
+
+      it "iterates over the items in order" do
+        items = []
+        sorted_set.each { |item| items << item }
+        items.should == (1..1025).to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#empty?" do
+    [
+      [[], true],
+      [["A"], false],
+      [%w[A B C], false],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:sorted_set) { SS[*values] }
+
+        it "returns #{expected.inspect}" do
+          sorted_set.empty?.should == expected
+        end
+      end
+    end
+  end
+
+  describe ".empty" do
+    it "returns the canonical empty set" do
+      SS.empty.size.should be(0)
+      SS.empty.object_id.should be(SS.empty.object_id)
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Immutable::SortedSet)
+        subclass.empty.class.should be(subclass)
+        subclass.empty.should be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+require "spec_helper"
+require "set"
+
+describe Immutable::SortedSet do
+  let(:set) { SS[*values] }
+  let(:comparison) { SS[*comparison_values] }
+
+  describe "#eql?" do
+    let(:eql?) { set.eql?(comparison) }
+
+    shared_examples "comparing something which is not a sorted set" do
+      let(:values) { %w[A B C] }
+
+      it "returns false" do
+        expect(eql?).to eq(false)
+      end
+    end
+
+    context "when comparing to a standard set" do
+      let(:comparison) { ::Set.new(%w[A B C]) }
+      include_examples "comparing something which is not a sorted set"
+    end
+
+    context "when comparing to a arbitrary object" do
+      let(:comparison) { Object.new }
+      include_examples "comparing something which is not a sorted set"
+    end
+
+    context "when comparing to an Immutable::Set" do
+      let(:comparison) { Immutable::Set.new(%w[A B C]) }
+      include_examples "comparing something which is not a sorted set"
+    end
+
+    context "when comparing with a subclass of Immutable::SortedSet" do
+      let(:comparison) { Class.new(Immutable::SortedSet).new(%w[A B C]) }
+      include_examples "comparing something which is not a sorted set"
+    end
+
+    context "with an empty set for each comparison" do
+      let(:values) { [] }
+      let(:comparison_values) { [] }
+
+      it "returns true" do
+        expect(eql?).to eq(true)
+      end
+    end
+
+    context "with an empty set and a set with nil" do
+      let(:values) { [] }
+      let(:comparison_values) { [nil] }
+
+      it "returns false" do
+        expect(eql?).to eq(false)
+      end
+    end
+
+    context "with a single item array and empty array" do
+      let(:values) { ["A"] }
+      let(:comparison_values) { [] }
+
+      it "returns false" do
+        expect(eql?).to eq(false)
+      end
+    end
+
+    context "with matching single item array" do
+      let(:values) { ["A"] }
+      let(:comparison_values) { ["A"] }
+
+      it "returns true" do
+        expect(eql?).to eq(true)
+      end
+    end
+
+    context "with mismatching single item array" do
+      let(:values) { ["A"] }
+      let(:comparison_values) { ["B"] }
+
+      it "returns false" do
+        expect(eql?).to eq(false)
+      end
+    end
+
+    context "with a multi-item array and single item array" do
+      let(:values) { %w[A B] }
+      let(:comparison_values) { ["A"] }
+
+      it "returns false" do
+        expect(eql?).to eq(false)
+      end
+    end
+
+    context "with matching multi-item array" do
+      let(:values) { %w[A B] }
+      let(:comparison_values) { %w[A B] }
+
+      it "returns true" do
+        expect(eql?).to eq(true)
+      end
+    end
+
+    context "with a mismatching multi-item array" do
+      let(:values) { %w[A B] }
+      let(:comparison_values) { %w[B A] }
+
+      it "returns true" do
+        expect(eql?).to eq(true)
+      end
+    end
+
+    context "with the same values, but a different sort order" do
+      let(:set) { SS[1, 2, 3] }
+      let(:comparison) { SS.new([1, 2, 3]) { |n| -n }}
+
+      it "returns false" do
+        expect(eql?).to eq(false)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  [:exclusion, :^].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], []],
+        [["A"], [], ["A"]],
+        [["A"], ["A"], []],
+        [%w[A B C], ["B"], %w[A C]],
+        [%w[A B C], %w[B C D], %w[A D]],
+        [%w[A B C], %w[D E F], %w[A B C D E F]],
+      ].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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#fetch" do
+    let(:sorted_set) { SS['a', 'b', 'c'] }
+
+    context "with no default provided" do
+      context "when the index exists" do
+        it "returns the value at the index" do
+          sorted_set.fetch(0).should == "a"
+          sorted_set.fetch(1).should == "b"
+          sorted_set.fetch(2).should == "c"
+        end
+      end
+
+      context "when the key does not exist" do
+        it "raises an IndexError" do
+          -> { sorted_set.fetch(3) }.should raise_error(IndexError)
+          -> { sorted_set.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
+          sorted_set.fetch(0, "default").should == "a"
+          sorted_set.fetch(1, "default").should == "b"
+          sorted_set.fetch(2, "default").should == "c"
+        end
+      end
+
+      context "when the index does not exist" do
+        it "returns the default value" do
+          sorted_set.fetch(3, "default").should == "default"
+          sorted_set.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
+          sorted_set.fetch(0) { "default".upcase }.should == "a"
+          sorted_set.fetch(1) { "default".upcase }.should == "b"
+          sorted_set.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
+          sorted_set.fetch(3) { |index| index.should == 3 }
+          sorted_set.fetch(-4) { |index| index.should == -4 }
+          sorted_set.fetch(3) { "default".upcase }.should == "DEFAULT"
+          sorted_set.fetch(-4) { "default".upcase }.should == "DEFAULT"
+        end
+      end
+    end
+
+    it "gives precedence to default block over default argument if passed both" do
+      sorted_set.fetch(3, 'one') { 'two' }.should == 'two'
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  [:find_index, :index].each do |method|
+    describe "##{method}" do
+      [
+        [[], "A", nil],
+        [[], nil, nil],
+        [["A"], "A", 0],
+        [["A"], "B", nil],
+        [["A"], nil, nil],
+        [["A", "B", "C"], "A", 0],
+        [["A", "B", "C"], "B", 1],
+        [["A", "B", "C"], "C", 2],
+        [["A", "B", "C"], "D", nil],
+        [0..1, 1, 1],
+        [0..10, 5, 5],
+        [0..10, 10, 10],
+        [[2], 2, 0],
+        [[2], 2.0, 0],
+        [[2.0], 2.0, 0],
+        [[2.0], 2, 0],
+      ].each do |values, item, expected|
+        unless item.nil? # test breaks otherwise
+          context "looking for #{item.inspect} in #{values.inspect} without block" do
+            it "returns #{expected.inspect}" do
+              SS[*values].send(method, item).should == expected
+            end
+          end
+        end
+
+        context "looking for #{item.inspect} in #{values.inspect} with block" do
+          it "returns #{expected.inspect}" do
+            SS[*values].send(method) { |x| x == item }.should == expected
+          end
+        end
+      end
+    end
+  end
+end