immutable-ruby 0.0.4 → 0.1.0

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

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

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

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

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

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

@@ -1,65 +0,0 @@
-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
-    # originally this test checked that #sort_by only called the block once
-    #   for each item
-    # however, when initializing a SortedSet, we need to make sure that it
-    #   does not include any duplicates, and we use the block when checking that
-    # the real point here is that the block should not be called an excessive
-    #   number of times, degrading performance
-    it "calls the passed block no more than twice 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 * 2)
-    end
-  end
-end

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

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

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

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

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

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

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

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

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

@@ -1,51 +0,0 @@
-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) }.uniq
-          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) }.uniq
-          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

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

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