immutable-ruby 0.0.1

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

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#to_set" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      describe "on #{values.inspect}" do
+        let(:set) { S[*values] }
+
+        it "returns self" do
+          set.to_set.should equal(set)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  [:union, :|, :+, :merge].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], []],
+        [["A"], [], ["A"]],
+        [["A"], ["A"], ["A"]],
+        [[], ["A"], ["A"]],
+        [%w[A B C], [], %w[A B C]],
+        [%w[A B C], %w[A B C], %w[A B C]],
+        [%w[A B C], %w[X Y Z], %w[A B C X 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] }
+
+          it "returns #{expected.inspect}, without changing the original Sets" do
+            set_a.send(method, set_b).should eql(S[*expected])
+            set_a.should eql(S.new(a))
+            set_b.should eql(S.new(b))
+          end
+        end
+
+        context "for #{b.inspect} and #{a.inspect}" do
+          let(:set_a) { S[*a] }
+          let(:set_b) { S[*b] }
+
+          it "returns #{expected.inspect}, without changing the original Sets" do
+            set_b.send(method, set_a).should eql(S[*expected])
+            set_a.should eql(S.new(a))
+            set_b.should eql(S.new(b))
+          end
+        end
+
+        context "when passed a Ruby Array" do
+          it "returns the expected Set" do
+            S[*a].send(method, b.freeze).should eql(S[*expected])
+            S[*b].send(method, a.freeze).should eql(S[*expected])
+          end
+        end
+
+        context "from a subclass" do
+          it "returns an instance of the subclass" do
+            subclass = Class.new(Immutable::Set)
+            subclass.new(a).send(method, S.new(b)).class.should be(subclass)
+            subclass.new(b).send(method, S.new(a)).class.should be(subclass)
+          end
+        end
+      end
+
+      context "when receiving a subset" do
+        let(:set_a) { S.new(1..300) }
+        let(:set_b) { S.new(1..200) }
+
+        it "returns self" do
+          set_a.send(method, set_b).should be(set_a)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#above" do
+    context "when called without a block" do
+      it "returns a sorted set of all items higher than the argument" do
+        100.times do
+          items     = rand(100).times.collect { rand(1000) }
+          set       = SS.new(items)
+          threshold = rand(1000)
+          result    = set.above(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 higher than the argument" do
+        100.times do
+          items     = rand(100).times.collect { rand(1000) }
+          set       = SS.new(items)
+          threshold = rand(1000)
+          result    = []
+          set.above(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.above(1).should be_empty
+        SS.empty.above('abc').should be_empty
+        SS.empty.above(:symbol).should be_empty
+      end
+    end
+
+    context "with an argument higher than all the values in the set" do
+      it "returns an empty set" do
+        result = SS.new(1..100).above(100)
+        result.class.should be(Immutable::SortedSet)
+        result.should be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  let(:sorted_set) { SS["B", "C", "D"] }
+
+  [:add, :<<].each do |method|
+    describe "##{method}" do
+      context "with a unique value" do
+        it "preserves the original" do
+          sorted_set.send(method, "A")
+          sorted_set.should eql(SS["B", "C", "D"])
+        end
+
+        it "returns a copy with the superset of values (in order)" do
+          sorted_set.send(method, "A").should eql(SS["A", "B", "C", "D"])
+        end
+      end
+
+      context "with a duplicate value" do
+        it "preserves the original values" do
+          sorted_set.send(method, "C")
+          sorted_set.should eql(SS["B", "C", "D"])
+        end
+
+        it "returns self" do
+          sorted_set.send(method, "C").should equal(sorted_set)
+        end
+      end
+
+      context "on a set ordered by a comparator" do
+        it "inserts the new item in the correct place" do
+          s = SS.new(['tick', 'pig', 'hippopotamus']) { |str| str.length }
+          s.add('giraffe').to_a.should == ['pig', 'tick', 'giraffe', 'hippopotamus']
+        end
+      end
+    end
+  end
+
+  describe "#add?" do
+    context "with a unique value" do
+      it "preserves the original" do
+        sorted_set.add?("A")
+        sorted_set.should eql(SS["B", "C", "D"])
+      end
+
+      it "returns a copy with the superset of values" do
+        sorted_set.add?("A").should eql(SS["A", "B", "C", "D"])
+      end
+    end
+
+    context "with a duplicate value" do
+      it "preserves the original values" do
+        sorted_set.add?("C")
+        sorted_set.should eql(SS["B", "C", "D"])
+      end
+
+      it "returns false" do
+        sorted_set.add?("C").should equal(false)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#at" do
+    [
+      [[], 10, nil],
+      [["A"], 10, nil],
+      [%w[A B C], 0, "A"],
+      [%w[A B C], 1, "B"],
+      [%w[A B C], 2, "C"],
+      [%w[A B C], 3, nil],
+      [%w[A B C], -1, "C"],
+      [%w[A B C], -2, "B"],
+      [%w[A B C], -3, "A"],
+      [%w[A B C], -4, nil]
+    ].each do |values, number, expected|
+      describe "#{values.inspect} with #{number}" do
+        it "returns #{expected.inspect}" do
+          SS[*values].at(number).should == expected
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#below" do
+    context "when called without a block" do
+      it "returns a sorted set of all items lower than the argument" do
+        100.times do
+          items     = rand(100).times.collect { rand(1000) }
+          set       = SS.new(items)
+          threshold = rand(1000)
+          result    = set.below(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 lower than the argument" do
+        100.times do
+          items     = rand(100).times.collect { rand(1000) }
+          set       = SS.new(items)
+          threshold = rand(1000)
+          result    = []
+          set.below(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.below(1).should be_empty
+        SS.empty.below('abc').should be_empty
+        SS.empty.below(:symbol).should be_empty
+      end
+    end
+
+    context "with an argument lower than all the values in the set" do
+      it "returns an empty set" do
+        result = SS.new(1..100).below(1)
+        result.class.should be(Immutable::SortedSet)
+        result.should be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#between" do
+    context "when called without a block" do
+      it "returns a sorted set of all items from the first argument to the second" do
+        100.times do
+          items   = rand(100).times.collect { rand(1000) }
+          set     = SS.new(items)
+          from,to = [rand(1000),rand(1000)].sort
+          result  = set.between(from, to)
+          array   = items.select { |x| x >= from && x <= to }.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 lower than the argument" do
+        100.times do
+          items   = rand(100).times.collect { rand(1000) }
+          set     = SS.new(items)
+          from,to = [rand(1000),rand(1000)].sort
+          result  = []
+          set.between(from, to) { |x| result << x }
+          array  = items.select { |x| x >= from && x <= to }.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.between(1, 2).should be_empty
+        SS.empty.between('abc', 'def').should be_empty
+        SS.empty.between(:symbol, :another).should be_empty
+      end
+    end
+
+    context "with a 'to' argument lower than the 'from' argument" do
+      it "returns an empty set" do
+        result = SS.new(1..100).between(6, 5)
+        result.class.should be(Immutable::SortedSet)
+        result.should be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#clear" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      context "on #{values}" do
+        let(:sorted_set) { SS[*values] }
+
+        it "preserves the original" do
+          sorted_set.clear
+          sorted_set.should eql(SS[*values])
+        end
+
+        it "returns an empty set" do
+          sorted_set.clear.should equal(Immutable::EmptySortedSet)
+          sorted_set.clear.should be_empty
+        end
+      end
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Immutable::SortedSet)
+        instance = subclass.new([:a, :b, :c, :d])
+        instance.clear.class.should be(subclass)
+        instance.clear.should be_empty
+      end
+    end
+
+    context "with a comparator" do
+      let(:sorted_set) { SS.new([1, 2, 3]) { |x| -x } }
+      it "returns an empty instance with same comparator" do
+        e = sorted_set.clear
+        e.should be_empty
+        e.add(4).add(5).add(6).to_a.should == [6, 5, 4]
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#delete_at" do
+    let(:sorted_set) { SS[1,2,3,4,5] }
+
+    it "removes the element at the specified index" do
+      sorted_set.delete_at(0).should  eql(SS[2,3,4,5])
+      sorted_set.delete_at(2).should  eql(SS[1,2,4,5])
+      sorted_set.delete_at(-1).should eql(SS[1,2,3,4])
+    end
+
+    it "makes no modification if the index is out of range" do
+      sorted_set.delete_at(5).should eql(sorted_set)
+      sorted_set.delete_at(-6).should eql(sorted_set)
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  let(:sorted_set) { SS["A", "B", "C"] }
+
+  describe "#delete" do
+    context "on an empty set" do
+      it "returns an empty set" do
+        SS.empty.delete(0).should be(SS.empty)
+      end
+    end
+
+    context "with an existing value" do
+      it "preserves the original" do
+        sorted_set.delete("B")
+        sorted_set.should eql(SS["A", "B", "C"])
+      end
+
+      it "returns a copy with the remaining of values" do
+        sorted_set.delete("B").should eql(SS["A", "C"])
+      end
+    end
+
+    context "with a non-existing value" do
+      it "preserves the original values" do
+        sorted_set.delete("D")
+        sorted_set.should eql(SS["A", "B", "C"])
+      end
+
+      it "returns self" do
+        sorted_set.delete("D").should equal(sorted_set)
+      end
+    end
+
+    context "when removing the last value in a sorted set" do
+      it "maintains the set order" do
+        ss = SS.new(["peanuts", "jam", "milk"]) { |word| word.length }
+        ss = ss.delete("jam").delete("peanuts").delete("milk")
+        ss = ss.add("banana").add("sugar").add("spam")
+        ss.to_a.should == ['spam', 'sugar', 'banana']
+      end
+
+      context "when the set is in natural order" do
+        it "returns the canonical empty set" do
+          sorted_set.delete("B").delete("C").delete("A").should be(Immutable::EmptySortedSet)
+        end
+      end
+    end
+
+    1.upto(10) do |n|
+      values = (1..n).to_a
+      values.combination(3) do |to_delete|
+        expected = to_delete.reduce(values.dup) { |ary,val| ary.delete(val); ary }
+        describe "on #{values.inspect}, when deleting #{to_delete.inspect}" do
+          it "returns #{expected.inspect}" do
+            set    = SS.new(values)
+            result = to_delete.reduce(set) { |s,val| s.delete(val) }
+            result.should eql(SS.new(expected))
+            result.to_a.should eql(expected)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#delete?" do
+    context "with an existing value" do
+      it "preserves the original" do
+        sorted_set.delete?("B")
+        sorted_set.should eql(SS["A", "B", "C"])
+      end
+
+      it "returns a copy with the remaining values" do
+        sorted_set.delete?("B").should eql(SS["A", "C"])
+      end
+    end
+
+    context "with a non-existing value" do
+      it "preserves the original values" do
+        sorted_set.delete?("D")
+        sorted_set.should eql(SS["A", "B", "C"])
+      end
+
+      it "returns false" do
+        sorted_set.delete?("D").should be(false)
+      end
+    end
+  end
+end