immutable-ruby 0.0.1

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

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  [:reject, :delete_if].each do |method|
+    describe "##{method}" do
+      let(:set) { S["A", "B", "C"] }
+
+      context "when nothing matches" do
+        it "returns self" do
+          set.send(method) { |item| false }.should equal(set)
+        end
+      end
+
+      context "when only some things match" do
+        context "with a block" do
+          let(:result) { set.send(method) { |item| item == "A" }}
+
+          it "preserves the original" do
+            result
+            set.should eql(S["A", "B", "C"])
+          end
+
+          it "returns a set with the matching values" do
+            result.should eql(S["B", "C"])
+          end
+        end
+
+        context "with no block" do
+          it "returns self" do
+            set.send(method).class.should be(Enumerator)
+            set.send(method).each { |item| item == "A" }.should == S["B", "C"]
+          end
+        end
+      end
+
+      context "on a large set, with many combinations of input" do
+        it "still works" do
+          array = (1..1000).to_a
+          set   = S.new(array)
+          [0, 10, 100, 200, 500, 800, 900, 999, 1000].each do |threshold|
+            result = set.send(method) { |item| item > threshold }
+            result.size.should == threshold
+            1.upto(threshold)  { |n| result.include?(n).should == true }
+            (threshold+1).upto(1000) { |n| result.include?(n).should == false }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require "spec_helper"
+require "set"
+
+describe Immutable::Set do
+  let(:set) { S["A", "B", "C"] }
+
+  describe "#reverse_each" do
+    let(:reverse_each) { set.reverse_each(&block) }
+
+    context "without a block" do
+      let(:block) { nil }
+
+      it "returns an Enumerator" do
+        expect(reverse_each.class).to be(Enumerator)
+        expect(reverse_each.to_a).to eq(set.to_a.reverse)
+      end
+    end
+
+    context "with an empty block" do
+      let(:block) { ->(item) {} }
+
+      it "returns self" do
+        expect(reverse_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) { reverse_each }
+
+      it "yields all values" do
+        expect(items).to eq(values)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#sample" do
+    let(:set) { S.new(1..10) }
+
+    it "returns a randomly chosen item" do
+      chosen = 100.times.map { set.sample }
+      chosen.each { |item| set.include?(item).should == true }
+      set.each { |item| chosen.include?(item).should == true }
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  [:select, :find_all].each do |method|
+    describe "##{method}" do
+      let(:set) { S["A", "B", "C"] }
+
+      context "when everything matches" do
+        it "returns self" do
+          set.send(method) { |item| true }.should equal(set)
+        end
+      end
+
+      context "when only some things match" do
+        context "with a block" do
+          let(:result) { set.send(method) { |item| item == "A" }}
+
+          it "preserves the original" do
+            result
+            set.should eql(S["A", "B", "C"])
+          end
+
+          it "returns a set with the matching values" do
+            result.should eql(S["A"])
+          end
+        end
+
+        context "with no block" do
+          it "returns an Enumerator" do
+            set.send(method).class.should be(Enumerator)
+            set.send(method).each { |item| item == "A" }.should eql(S["A"])
+          end
+        end
+      end
+
+      context "when nothing matches" do
+        let(:result) { set.send(method) { |item| false }}
+
+        it "preserves the original" do
+          result
+          set.should eql(S["A", "B", "C"])
+        end
+
+        it "returns the canonical empty set" do
+          result.should equal(Immutable::EmptySet)
+        end
+      end
+
+      context "from a subclass" do
+        it "returns an instance of the same class" do
+          subclass = Class.new(Immutable::Set)
+          instance = subclass.new(['A', 'B', 'C'])
+          instance.send(method) { true }.class.should be(subclass)
+          instance.send(method) { false }.class.should be(subclass)
+          instance.send(method) { rand(2) == 0 }.class.should be(subclass)
+        end
+      end
+
+      it "works on a large set, with many combinations of input" do
+        items = (1..1000).to_a
+        original = S.new(items)
+        30.times do
+          threshold = rand(1000)
+          result    = original.send(method) { |item| item <= threshold }
+          result.size.should == threshold
+          result.each { |item| item.should <= threshold }
+          (threshold+1).upto(1000) { |item| result.include?(item).should == false }
+        end
+        original.should eql(S.new(items))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  [:size, :length].each do |method|
+    describe "##{method}" do
+      [
+        [[], 0],
+        [["A"], 1],
+        [%w[A B C], 3],
+      ].each do |values, result|
+        it "returns #{result} for #{values.inspect}" do
+          S[*values].send(method).should == result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  [
+    [:sort, ->(left, right) { left.length <=> right.length }],
+    [:sort_by, ->(item) { item.length }],
+  ].each do |method, comparator|
+    describe "##{method}" do
+      [
+        [[], []],
+        [["A"], ["A"]],
+        [%w[Ichi Ni San], %w[Ni San Ichi]],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          let(:set) { S[*values] }
+
+          describe "with a block" do
+            let(:result) { set.send(method, &comparator) }
+
+            it "returns #{expected.inspect}" do
+              result.should eql(SS.new(expected, &comparator))
+              result.to_a.should == expected
+            end
+
+            it "doesn't change the original Set" do
+              result
+              set.should eql(S.new(values))
+            end
+          end
+
+          describe "without a block" do
+            let(:result) { set.send(method) }
+
+            it "returns #{expected.sort.inspect}" do
+              result.should eql(SS[*expected])
+              result.to_a.should == expected.sort
+            end
+
+            it "doesn't change the original Set" do
+              result
+              set.should eql(S.new(values))
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#sort_by" do
+    it "only calls the passed block once for each item" do
+      count = 0
+      fn    = lambda { |x| count += 1; -x }
+      items = 100.times.collect { rand(10000) }.uniq
+
+      S[*items].sort_by(&fn).to_a.should == items.sort.reverse
+      count.should == items.length
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  [:subset?, :<=].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], true],
+        [["A"], [], false],
+        [[], ["A"], true],
+        [["A"], ["A"], true],
+        [%w[A B C], ["B"], false],
+        [["B"], %w[A B C], true],
+        [%w[A B C], %w[A C], false],
+        [%w[A C], %w[A B C], true],
+        [%w[A B C], %w[A B C], true],
+        [%w[A B C], %w[A B C D], true],
+        [%w[A B C D], %w[A B C], false],
+      ].each do |a, b, expected|
+        describe "for #{a.inspect} and #{b.inspect}" do
+          it "returns #{expected}"  do
+            S[*a].send(method, S[*b]).should == expected
+          end
+        end
+      end
+    end
+  end
+
+  [:proper_subset?, :<].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], false],
+        [["A"], [], false],
+        [[], ["A"], true],
+        [["A"], ["A"], false],
+        [%w[A B C], ["B"], false],
+        [["B"], %w[A B C], true],
+        [%w[A B C], %w[A C], false],
+        [%w[A C], %w[A B C], true],
+        [%w[A B C], %w[A B C], false],
+        [%w[A B C], %w[A B C D], true],
+        [%w[A B C D], %w[A B C], false],
+      ].each do |a, b, expected|
+        describe "for #{a.inspect} and #{b.inspect}" do
+          it "returns #{expected}"  do
+            S[*a].send(method, S[*b]).should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#sum" do
+    [
+      [[], 0],
+      [[2], 2],
+      [[1, 3, 5, 7, 11], 27],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:set) { S[*values] }
+
+        it "returns #{expected.inspect}" do
+          set.sum.should == expected
+        end
+
+        it "doesn't change the original Set" do
+          set.should eql(S.new(values))
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  [:to_a, :entries].each do |method|
+    describe "##{method}" do
+      ('a'..'z').each do |letter|
+        let(:values) { ('a'..letter).to_a }
+        let(:set) { S.new(values) }
+        let(:result) { set.send(method) }
+
+        context "on 'a'..'#{letter}'" do
+          it "returns an equivalent array" do
+            result.sort.should == values.sort
+          end
+
+          it "doesn't change the original Set" do
+            result
+            set.should eql(S[*values])
+          end
+
+          it "returns a mutable array" do
+            expect(result.last).to_not eq("The End")
+            result << "The End"
+            result.last.should == "The End"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#to_list" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      context "on #{values.inspect}" do
+        let(:set) { S[*values] }
+        let(:list) { set.to_list }
+
+        it "returns a list" do
+          list.is_a?(Immutable::List).should == true
+        end
+
+        it "doesn't change the original Set" do
+          list
+          set.should eql(S.new(values))
+        end
+
+        describe "the returned list" do
+          it "has the correct length" do
+            list.size.should == values.size
+          end
+
+          it "contains all values" do
+            list.to_a.sort.should == values.sort
+          end
+        end
+      end
+    end
+  end
+end