immutable-ruby 0.0.1

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

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#first" do
+    context "on an empty set" do
+      it "returns nil" do
+        S.empty.first.should be_nil
+      end
+    end
+
+    context "on a non-empty set" do
+      it "returns an arbitrary value from the set" do
+        %w[A B C].include?(S["A", "B", "C"].first).should == true
+      end
+    end
+
+    it "returns nil if only member of set is nil" do
+      S[nil].first.should be(nil)
+    end
+
+    it "returns the first item yielded by #each" do
+      10.times do
+        set = S.new((rand(10)+1).times.collect { rand(10000 )})
+        set.each { |item| break item }.should be(set.first)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe Immutable do
+  describe "#flatten" do
+    [
+      [["A"], ["A"]],
+      [%w[A B C], %w[A B C]],
+      [["A", S["B"], "C"], %w[A B C]],
+      [[S["A"], S["B"], S["C"]], %w[A B C]],
+    ].each do |values, expected|
+      describe "on #{values}" do
+        let(:set) { S[*values] }
+
+        it "preserves the original" do
+          set.flatten
+          set.should eql(S[*values])
+        end
+
+        it "returns the inlined values" do
+          set.flatten.should eql(S[*expected])
+        end
+      end
+    end
+
+    context "on an empty set" do
+      it "returns an empty set" do
+        S.empty.flatten.should equal(S.empty)
+      end
+    end
+
+    context "on a set with multiple levels of nesting" do
+      it "inlines lower levels of nesting" do
+        set = S[S[S[1]], S[S[2]]]
+        set.flatten.should eql(S[1, 2])
+      end
+    end
+
+    context "from a subclass" do
+      it "returns an instance of the subclass" do
+        subclass = Class.new(Immutable::Set)
+        subclass.new.flatten.class.should be(subclass)
+        subclass.new([S[1], S[2]]).flatten.class.should be(subclass)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  let(:set) { S[*values] }
+
+  describe "#grep" do
+    let(:grep) { set.grep(String, &block) }
+
+    shared_examples "check filtered values" do
+      it "returns the filtered values" do
+        expect(grep).to eq(filtered)
+      end
+    end
+
+    shared_examples "check different types of inputs" do
+      context "with an empty array" do
+        let(:values) { [] }
+        let(:filtered) { [] }
+
+        shared_examples "check filtered values"
+      end
+
+      context "with a single item array" do
+        let(:values) { ["A"] }
+        let(:filtered) { ["A"] }
+
+        shared_examples "check filtered values"
+      end
+
+      context "with a single item array that doesn't contain match" do
+        let(:values) { [1] }
+        let(:filtered) { [] }
+
+        shared_examples "check filtered values"
+      end
+
+      context "with a multi-item array where one isn't a match" do
+        let(:values) { ["A", 2, "C"] }
+        let(:filtered) { %w[A C] }
+
+        shared_examples "check filtered values"
+      end
+    end
+
+    context "without a block" do
+      let(:block) { nil }
+
+      include_examples "check different types of inputs"
+    end
+
+    describe "with a block" do
+      let(:block) { ->(item) { item.downcase }}
+
+      include_examples "check different types of inputs"
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  [:group_by, :group, :classify].each do |method|
+    describe "##{method}" do
+      context "with a block" do
+        [
+          [[], []],
+          [[1], [true => S[1]]],
+          [[1, 2, 3, 4], [true => S[3, 1], false => S[4, 2]]],
+        ].each do |values, expected|
+          context "on #{values.inspect}" do
+            let(:set) { S[*values] }
+
+            it "returns #{expected.inspect}" do
+              set.send(method, &:odd?).should eql(H[*expected])
+              set.should eql(S.new(values)) # make sure it hasn't changed
+            end
+          end
+        end
+      end
+
+      context "without a block" do
+        [
+          [[], []],
+          [[1], [1 => S[1]]],
+          [[1, 2, 3, 4], [1 => S[1], 2 => S[2], 3 => S[3], 4 => S[4]]],
+        ].each do |values, expected|
+          context "on #{values.inspect}" do
+            let(:set) { S[*values] }
+
+            it "returns #{expected.inspect}" do
+              set.group_by.should eql(H[*expected])
+              set.should eql(S.new(values)) # make sure it hasn't changed
+            end
+          end
+        end
+      end
+
+      context "on an empty set" do
+        it "returns an empty hash" do
+          S.empty.group_by { |x| x }.should eql(H.empty)
+        end
+      end
+
+      it "returns a hash without default proc" do
+        S[1,2,3].group_by { |x| x }.default_proc.should be_nil
+      end
+
+      context "from a subclass" do
+        it "returns an Hash whose values are instances of the subclass" do
+          subclass = Class.new(Immutable::Set)
+          instance = subclass.new([1, 'string', :symbol])
+          instance.group_by { |x| x.class }.values.each { |v| v.class.should be(subclass) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#hash" do
+    context "on an empty set" do
+      it "returns 0" do
+        S.empty.hash.should == 0
+      end
+    end
+
+    it "generates the same hash value for a set regardless of the order things were added to it" do
+      item1 = DeterministicHash.new('a', 121)
+      item2 = DeterministicHash.new('b', 474)
+      item3 = DeterministicHash.new('c', 121)
+      S.empty.add(item1).add(item2).add(item3).hash.should == S.empty.add(item3).add(item2).add(item1).hash
+    end
+
+    it "values are sufficiently distributed" do
+      (1..4000).each_slice(4).map { |a, b, c, d| S[a, b, c, d].hash }.uniq.size.should == 1000
+    end
+  end
+end

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

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

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

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

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

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