immutable-ruby 0.0.1

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

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Immutable::Set 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 G H], [], %w[A B C D E F G H]],
+        [%w[A B C M X Y Z], %w[B C D E F G H I J X], %w[A M Y Z]]
+      ].each do |a, b, expected|
+        context "for #{a.inspect} and #{b.inspect}" do
+          let(:set_a) { S[*a] }
+          let(:set_b) { S[*b] }
+          let(:result) { set_a.send(method, set_b) }
+
+          it "doesn't modify the original Sets" do
+            result
+            set_a.should eql(S.new(a))
+            set_b.should eql(S.new(b))
+          end
+
+          it "returns #{expected.inspect}"  do
+            result.should eql(S[*expected])
+          end
+        end
+
+        context "when passed a Ruby Array" do
+          it "returns the expected Set" do
+            S[*a].difference(b.freeze).should eql(S[*expected])
+          end
+        end
+      end
+
+      it "works on a wide variety of inputs" do
+        items = ('aa'..'zz').to_a
+        50.times do
+          array1 = items.sample(200)
+          array2 = items.sample(200)
+          result = S.new(array1).send(method, S.new(array2))
+          result.to_a.sort.should eql((array1 - array2).sort)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Immutable::Set 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|
+      describe "for #{a.inspect} and #{b.inspect}" do
+        it "returns #{expected}" do
+          S[*a].disjoint?(S[*b]).should be(expected)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require "spec_helper"
+require "set"
+
+describe Immutable::Set do
+  let(:set) { S["A", "B", "C"] }
+
+  describe "#each" do
+    let(:each) { set.each(&block) }
+
+    context "without a block" do
+      let(:block) { nil }
+
+      it "returns an Enumerator" do
+        expect(each.class).to be(Enumerator)
+        expect(each.to_a).to eq(set.to_a)
+      end
+    end
+
+    context "with an empty block" do
+      let(:block) { ->(item) {} }
+
+      it "returns self" do
+        expect(each).to be(set)
+      end
+    end
+
+    context "with a block" do
+      let(:items)  { ::Set.new }
+      let(:values) { ::Set.new(%w[A B C]) }
+      let(:block)  { ->(item) { items << item } }
+      before(:each) { each }
+
+      it "yields all values" do
+        expect(items).to eq(values)
+      end
+    end
+
+    it "yields both of a pair of colliding keys" do
+      set = S[DeterministicHash.new('a', 1010), DeterministicHash.new('b', 1010)]
+      yielded = []
+      set.each { |obj| yielded << obj }
+      yielded.map(&:value).sort.should == ['a', 'b']
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#empty?" do
+    [
+      [[], true],
+      [["A"], false],
+      [%w[A B C], false],
+      [[nil], false],
+      [[false], false]
+    ].each do |values, expected|
+      describe "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          S[*values].empty?.should == expected
+        end
+      end
+    end
+  end
+
+  describe ".empty" do
+    it "returns the canonical empty set" do
+      S.empty.should be_empty
+      S.empty.object_id.should be(S[].object_id)
+      S.empty.should be(Immutable::EmptySet)
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Immutable::Set)
+        subclass.empty.class.should be(subclass)
+        subclass.empty.should be_empty
+      end
+
+      it "calls overridden #initialize when creating empty Set" do
+        subclass = Class.new(Immutable::Set) do
+          def initialize
+            @variable = 'value'
+          end
+        end
+        subclass.empty.instance_variable_get(:@variable).should == 'value'
+      end
+    end
+  end
+end

data/spec/lib/immutable/set/eqeq_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+require "set"
+
+describe Immutable::Set do
+  let(:set) { S[*values] }
+  let(:comparison) { S[*comparison_values] }
+
+  describe "#==" do
+    let(:eqeq) { set == comparison }
+
+    shared_examples "comparing non-sets" do
+      let(:values) { %w[A B C] }
+
+      it "returns false" do
+        expect(eqeq).to eq(false)
+      end
+    end
+
+    context "when comparing to a standard set" do
+      let(:comparison) { ::Set.new(%w[A B C]) }
+
+      include_examples "comparing non-sets"
+    end
+
+    context "when comparing to a arbitrary object" do
+      let(:comparison) { Object.new }
+
+      include_examples "comparing non-sets"
+    end
+
+    context "with an empty set for each comparison" do
+      let(:values) { [] }
+      let(:comparison_values) { [] }
+
+      it "returns true" do
+        expect(eqeq).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(eqeq).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(eqeq).to eq(false)
+      end
+    end
+
+    context "with matching single item array" do
+      let(:values) { ["A"] }
+      let(:comparison_values) { ["A"] }
+
+      it "returns true" do
+        expect(eqeq).to eq(true)
+      end
+    end
+
+    context "with mismatching single item array" do
+      let(:values) { ["A"] }
+      let(:comparison_values) { ["B"] }
+
+      it "returns false" do
+        expect(eqeq).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(eqeq).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(eqeq).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(eqeq).to eq(true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+require "spec_helper"
+require "set"
+
+describe Immutable::Set do
+  let(:set) { S[*values] }
+  let(:comparison) { S[*comparison_values] }
+
+  describe "#eql?" do
+    let(:eql?) { set.eql?(comparison) }
+
+    shared_examples "comparing non-sets" 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 non-sets"
+    end
+
+    context "when comparing to a arbitrary object" do
+      let(:comparison) { Object.new }
+
+      include_examples "comparing non-sets"
+    end
+
+    context "when comparing with a subclass of Immutable::Set" do
+      let(:comparison) { Class.new(Immutable::Set).new(%w[A B C]) }
+
+      include_examples "comparing non-sets"
+    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
+  end
+end

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

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe Immutable::Set 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
+          let(:set_a) { S[*a] }
+          let(:set_b) { S[*b] }
+          let(:result) { set_a.send(method, set_b) }
+
+          it "doesn't modify the original Sets" do
+            result
+            set_a.should eql(S.new(a))
+            set_b.should eql(S.new(b))
+          end
+
+          it "returns #{expected.inspect}"  do
+            result.should eql(S[*expected])
+          end
+        end
+
+        context "when passed a Ruby Array" do
+          it "returns the expected Set" do
+            S[*a].exclusion(b.freeze).should eql(S[*expected])
+          end
+        end
+      end
+
+      it "works for a wide variety of inputs" do
+        50.times do
+          array1 = (1..400).to_a.sample(100)
+          array2 = (1..400).to_a.sample(100)
+          result = S.new(array1) ^ S.new(array2)
+          result.to_a.sort.should eql(((array1 | array2) - (array1 & array2)).sort)
+        end
+      end
+    end
+  end
+end

data/spec/lib/immutable/set/find_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  [:find, :detect].each do |method|
+    describe "##{method}" do
+      [
+        [[], "A", nil],
+        [[], nil, nil],
+        [["A"], "A", "A"],
+        [["A"], "B", nil],
+        [["A"], nil, nil],
+        [["A", "B", nil], "A", "A"],
+        [["A", "B", nil], "B", "B"],
+        [["A", "B", nil], nil, nil],
+        [["A", "B", nil], "C", nil],
+      ].each do |values, item, expected|
+        describe "on #{values.inspect}" do
+          context "with a block" do
+            it "returns #{expected.inspect}" do
+              S[*values].send(method) { |x| x == item }.should == expected
+            end
+          end
+
+          context "without a block" do
+            it "returns an Enumerator" do
+              result = S[*values].send(method)
+              result.class.should be(Enumerator)
+              result.each { |x| x == item}.should == expected
+            end
+          end
+        end
+      end
+    end
+  end
+end