immutable-ruby 0.0.4 → 0.2.0

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

@@ -1,60 +0,0 @@
-require "spec_helper"
-require 'set'
-
-describe Immutable::Set do
-  [:include?, :member?].each do |method|
-    describe "##{method}" do
-      let(:set) { S["A", "B", "C", 2.0, nil] }
-
-      ["A", "B", "C", 2.0, nil].each do |value|
-        it "returns true for an existing value (#{value.inspect})" do
-          set.send(method, value).should == true
-        end
-      end
-
-      it "returns false for a non-existing value" do
-        set.send(method, "D").should == false
-      end
-
-      it "returns true even if existing value is nil" do
-        S[nil].include?(nil).should == true
-      end
-
-      it "returns true even if existing value is false" do
-        S[false].include?(false).should == true
-      end
-
-      it "returns false for a mutable item which is mutated after adding" do
-        item = ['mutable']
-        item = [rand(1000000)] while (item.hash.abs & 31 == [item[0], 'HOSED!'].hash.abs & 31)
-        set  = S[item]
-        item.push('HOSED!')
-        set.include?(item).should == false
-      end
-
-      it "uses #eql? for equality" do
-        set.send(method, 2).should == false
-      end
-
-      it "returns the right answers after a lot of addings and removings" do
-        array, set, rb_set = [], S.new, ::Set.new
-
-        1000.times do
-          if rand(2) == 0
-            array << (item = rand(10000))
-            rb_set.add(item)
-            set = set.add(item)
-            set.include?(item).should == true
-          else
-            item = array.sample
-            rb_set.delete(item)
-            set = set.delete(item)
-            set.include?(item).should == false
-          end
-        end
-
-        array.each { |item| set.include?(item).should == rb_set.include?(item) }
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  describe "#inspect" do
-    [
-      [[], "Immutable::Set[]"],
-      [["A"], 'Immutable::Set["A"]'],
-    ].each do |values, expected|
-      describe "on #{values.inspect}" do
-        let(:set) { S[*values] }
-
-        it "returns #{expected.inspect}" do
-          set.inspect.should == expected
-        end
-
-        it "returns a string which can be eval'd to get an equivalent set" do
-          eval(set.inspect).should eql(set)
-        end
-      end
-    end
-
-    describe 'on ["A", "B", "C"]' do
-      let(:set) { S["A", "B", "C"] }
-
-      it "returns a programmer-readable representation of the set contents" do
-        set.inspect.should match(/^Immutable::Set\["[A-C]", "[A-C]", "[A-C]"\]$/)
-      end
-
-      it "returns a string which can be eval'd to get an equivalent set" do
-        eval(set.inspect).should eql(set)
-      end
-    end
-
-    context "from a subclass" do
-      MySet = Class.new(Immutable::Set)
-      let(:set) { MySet[1, 2] }
-
-      it "returns a programmer-readable representation of the set contents" do
-        set.inspect.should match(/^MySet\[[1-2], [1-2]\]$/)
-      end
-
-      it "returns a string which can be eval'd to get an equivalent set" do
-        eval(set.inspect).should eql(set)
-      end
-    end
-  end
-end

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

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

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

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  [:intersection, :&].each do |method|
-    describe "##{method}" do
-      [
-        [[], [], []],
-        [["A"], [], []],
-        [["A"], ["A"], ["A"]],
-        [%w[A B C], ["B"], ["B"]],
-        [%w[A B C], %w[A C], %w[A C]],
-      ].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])
-          end
-        end
-      end
-
-      it "returns results consistent with Array#&" do
-        50.times do
-          array1 = rand(100).times.map { rand(1000000).to_s(16) }
-          array2 = rand(100).times.map { rand(1000000).to_s(16) }
-          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/join_spec.rb

@@ -1,64 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  describe "#join" do
-    context "with a separator" do
-      [
-        [[], ""],
-        [["A"], "A"],
-        [[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)], "A|B|C"]
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          let(:set) { S[*values] }
-
-          it "preserves the original" do
-            set.join("|")
-            set.should eql(S[*values])
-          end
-
-          it "returns #{expected.inspect}" do
-            set.join("|").should eql(expected)
-          end
-        end
-      end
-    end
-
-    context "without a separator" do
-      [
-        [[], ""],
-        [["A"], "A"],
-        [[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)], "ABC"]
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          let(:set) { S[*values] }
-
-          it "preserves the original" do
-            set.join
-            set.should eql(S[*values])
-          end
-
-          it "returns #{expected.inspect}" do
-            set.join.should eql(expected)
-          end
-        end
-      end
-    end
-
-    context "without a separator (with global default separator set)" do
-      before { $, = '**' }
-      let(:set) { S[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)] }
-      after  { $, = nil }
-
-      context "on ['A', 'B', 'C']" do
-        it "preserves the original" do
-          set.join
-          set.should eql(S[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)])
-        end
-
-        it "returns #{@expected.inspect}" do
-          set.join.should == "A**B**C"
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  [:map, :collect].each do |method|
-    describe "##{method}" do
-      context "when empty" do
-        it "returns self" do
-          S.empty.send(method) {}.should equal(S.empty)
-        end
-      end
-
-      context "when not empty" do
-        let(:set) { S["A", "B", "C"] }
-
-        context "with a block" do
-          it "preserves the original values" do
-            set.send(method, &:downcase)
-            set.should eql(S["A", "B", "C"])
-          end
-
-          it "returns a new set with the mapped values" do
-            set.send(method, &:downcase).should eql(S["a", "b", "c"])
-          end
-        end
-
-        context "with no block" do
-          it "returns an Enumerator" do
-            set.send(method).class.should be(Enumerator)
-            set.send(method).each(&:downcase).should == S['a', 'b', 'c']
-          end
-        end
-      end
-
-      context "from a subclass" do
-        it "returns an instance of the subclass" do
-          subclass = Class.new(Immutable::Set)
-          instance = subclass['a', 'b']
-          instance.map { |item| item.upcase }.class.should be(subclass)
-        end
-      end
-
-      context "when multiple items map to the same value" do
-        it "filters out the duplicates" do
-          set = S.new('aa'..'zz')
-          result = set.map { |s| s[0] }
-          result.should eql(Immutable::Set.new('a'..'z'))
-          result.size.should == 26
-        end
-      end
-
-      it "works on large sets" do
-        set = S.new(1..1000)
-        result = set.map { |x| x * 10 }
-        result.size.should == 1000
-        1.upto(1000) { |n| result.include?(n * 10).should == true }
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  describe "#marshal_dump/#marshal_load" do
-    let(:ruby) { File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"]) }
-
-    let(:child_cmd) do
-      %Q|#{ruby} -I lib -r immutable -e 'set = Immutable::Set[:one, :two]; $stdout.write(Marshal.dump(set))'|
-    end
-
-    let(:reloaded_hash) do
-      IO.popen(child_cmd, "r+") do |child|
-        reloaded_hash = Marshal.load(child)
-        child.close
-        reloaded_hash
-      end
-    end
-
-    it "can survive dumping and loading into a new process" do
-      reloaded_hash.should eql(S[:one, :two])
-    end
-
-    it "is still possible to test items by key after loading" do
-      reloaded_hash.should include :one
-      reloaded_hash.should include :two
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  describe "#max" do
-    context "with a block" do
-      [
-        [[], nil],
-        [["A"], "A"],
-        [%w[Ichi Ni San], "Ichi"],
-      ].each do |values, expected|
-        describe "on #{values.inspect}" do
-          let(:set) { S[*values] }
-          let(:result) { set.max { |maximum, item| maximum.length <=> item.length }}
-
-          it "returns #{expected.inspect}" do
-            result.should == expected
-          end
-        end
-      end
-    end
-
-    context "without a block" do
-      [
-        [[], nil],
-        [["A"], "A"],
-        [%w[Ichi Ni San], "San"],
-      ].each do |values, expected|
-        describe "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            S[*values].max.should == expected
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  describe "#min" do
-    context "with a block" do
-      [
-        [[], nil],
-        [["A"], "A"],
-        [%w[Ichi Ni San], "Ni"],
-      ].each do |values, expected|
-        describe "on #{values.inspect}" do
-          let(:set) { S[*values] }
-          let(:result) { set.min { |minimum, item| minimum.length <=> item.length }}
-
-          it "returns #{expected.inspect}" do
-            result.should == expected
-          end
-        end
-      end
-    end
-
-    context "without a block" do
-      [
-        [[], nil],
-        [["A"], "A"],
-        [%w[Ichi Ni San], "Ichi"],
-      ].each do |values, expected|
-        describe "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            S[*values].min.should == expected
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  describe ".new" do
-    it "initializes a new set" do
-      set = S.new([1,2,3])
-      set.size.should be(3)
-      [1,2,3].each { |n| set.include?(n).should == true }
-    end
-
-    it "accepts a Range" do
-      set = S.new(1..3)
-      set.size.should be(3)
-      [1,2,3].each { |n| set.include?(n).should == true }
-    end
-
-    it "returns a Set which doesn't change even if the initializer is mutated" do
-      array = [1,2,3]
-      set = S.new([1,2,3])
-      array.push('BAD')
-      set.should eql(S[1,2,3])
-    end
-
-    context "from a subclass" do
-      it "returns a frozen instance of the subclass" do
-        subclass = Class.new(Immutable::Set)
-        instance = subclass.new(["some", "values"])
-        instance.class.should be subclass
-        instance.should be_frozen
-      end
-    end
-
-    it "is amenable to overriding of #initialize" do
-      class SnazzySet < Immutable::Set
-        def initialize
-          super(['SNAZZY!!!'])
-        end
-      end
-
-      set = SnazzySet.new
-      set.size.should be(1)
-      set.include?('SNAZZY!!!').should == true
-    end
-  end
-
-  describe "[]" do
-    it "accepts any number of arguments and initializes a new set" do
-      set = S[1,2,3,4]
-      set.size.should be(4)
-      [1,2,3,4].each { |n| set.include?(n).should == true }
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  describe "#none?" do
-    context "when empty" do
-      it "with a block returns true" do
-        S.empty.none? {}.should == true
-      end
-
-      it "with no block returns true" do
-        S.empty.none?.should == true
-      end
-    end
-
-    context "when not empty" do
-      context "with a block" do
-        let(:set) { S["A", "B", "C", nil] }
-
-        ["A", "B", "C", nil].each do |value|
-          it "returns false if the block ever returns true (#{value.inspect})" do
-            set.none? { |item| item == value }.should == false
-          end
-        end
-
-        it "returns true if the block always returns false" do
-          set.none? { |item| item == "D" }.should == true
-        end
-
-        it "stops iterating as soon as the block returns true" do
-          yielded = []
-          set.none? { |item| yielded << item; true }
-          yielded.size.should == 1
-        end
-      end
-
-      context "with no block" do
-        it "returns false if any value is truthy" do
-          S[nil, false, true, "A"].none?.should == false
-        end
-
-        it "returns true if all values are falsey" do
-          S[nil, false].none?.should == true
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  describe "#one?" do
-    context "when empty" do
-      it "with a block returns false" do
-        S.empty.one? {}.should == false
-      end
-
-      it "with no block returns false" do
-        S.empty.one?.should == false
-      end
-    end
-
-    context "when not empty" do
-      context "with a block" do
-        let(:set) { S["A", "B", "C"] }
-
-        it "returns false if the block returns true more than once" do
-          set.one? { |item| true }.should == false
-        end
-
-        it "returns false if the block never returns true" do
-          set.one? { |item| false }.should == false
-        end
-
-        it "returns true if the block only returns true once" do
-          set.one? { |item| item == "A" }.should == true
-        end
-      end
-
-      context "with no block" do
-        it "returns false if more than one value is truthy" do
-          S[nil, true, "A"].one?.should == false
-        end
-
-        it "returns true if only one value is truthy" do
-          S[nil, true, false].one?.should == true
-        end
-
-        it "returns false if no values are truthy" do
-          S[nil, false].one?.should == false
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  describe "#partition" do
-    [
-      [[], [], []],
-      [[1], [1], []],
-      [[1, 2], [1], [2]],
-      [[1, 2, 3], [1, 3], [2]],
-      [[1, 2, 3, 4], [1, 3], [2, 4]],
-      [[2, 3, 4], [3], [2, 4]],
-      [[3, 4], [3], [4]],
-      [[4], [], [4]],
-    ].each do |values, expected_matches, expected_remainder|
-      context "on #{values.inspect}" do
-        let(:set) { S[*values] }
-
-        context "with a block" do
-          let(:result)  { set.partition(&:odd?) }
-          let(:matches) { result.first }
-          let(:remainder) { result.last }
-
-          it "preserves the original" do
-            result
-            set.should eql(S[*values])
-          end
-
-          it "returns a frozen array with two items" do
-            result.class.should be(Array)
-            result.should be_frozen
-            result.size.should be(2)
-          end
-
-          it "correctly identifies the matches" do
-            matches.should eql(S[*expected_matches])
-          end
-
-          it "correctly identifies the remainder" do
-            remainder.should eql(S[*expected_remainder])
-          end
-        end
-
-        describe "without a block" do
-          it "returns an Enumerator" do
-            set.partition.class.should be(Enumerator)
-            set.partition.each(&:odd?).should eql([S.new(expected_matches), S.new(expected_remainder)])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  describe "#product" do
-    [
-      [[], 1],
-      [[2], 2],
-      [[1, 3, 5, 7, 11], 1155],
-    ].each do |values, expected|
-      context "on #{values.inspect}" do
-        let(:set) { S[*values] }
-
-        it "returns #{expected.inspect}" do
-          set.product.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/reduce_spec.rb

@@ -1,55 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  [:reduce, :inject].each do |method|
-    describe "##{method}" do
-      [
-        [[], 10, 10],
-        [[1], 10, 9],
-        [[1, 2, 3], 10, 4],
-      ].each do |values, initial, expected|
-        describe "on #{values.inspect}" do
-          let(:set) { S[*values] }
-
-          context "with an initial value of #{initial}" do
-            context "and a block" do
-              it "returns #{expected.inspect}" do
-                set.send(method, initial) { |memo, item| memo - item }.should == expected
-              end
-            end
-          end
-        end
-      end
-
-      [
-        [[], nil],
-        [[1], 1],
-        [[1, 2, 3], 6],
-      ].each do |values, expected|
-        describe "on #{values.inspect}" do
-          let(:set) { S[*values] }
-
-          context "with no initial value" do
-            context "and a block" do
-              it "returns #{expected.inspect}" do
-                set.send(method) { |memo, item| memo + item }.should == expected
-              end
-            end
-          end
-        end
-      end
-
-      describe "with no block and a symbol argument" do
-        it "uses the symbol as the name of a method to reduce with" do
-          S[1, 2, 3].reduce(:+).should == 6
-        end
-      end
-
-      describe "with no block and a string argument" do
-        it "uses the string as the name of a method to reduce with" do
-          S[1, 2, 3].reduce('+').should == 6
-        end
-      end
-    end
-  end
-end