immutable-ruby 0.0.1

data/spec/lib/immutable/nested/construction_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+require "set"
+
+describe Immutable do
+  expectations = [
+    # [Ruby, Immutable]
+    [ { "a" => 1,
+        "b" => [2, {"c" => 3}, 4],
+        "d" => ::Set.new([5, 6, 7]),
+        "e" => {"f" => 8, "g" => 9},
+        "h" => Regexp.new("ijk"),
+        "l" => ::SortedSet.new([1, 2, 3]) },
+      Immutable::Hash[
+        "a" => 1,
+        "b" => Immutable::Vector[2, Immutable::Hash["c" => 3], 4],
+        "d" => Immutable::Set[5, 6, 7],
+        "e" => Immutable::Hash["f" => 8, "g" => 9],
+        "h" => Regexp.new("ijk"),
+        "l" => Immutable::SortedSet.new([1, 2, 3])] ],
+    [ {}, Immutable::Hash[] ],
+    [ {"a" => 1, "b" => 2, "c" => 3}, Immutable::Hash["a" => 1, "b" => 2, "c" => 3] ],
+    [ [], Immutable::Vector[] ],
+    [ [1, 2, 3], Immutable::Vector[1, 2, 3] ],
+    [ ::Set.new, Immutable::Set[] ],
+    [ ::Set.new([1, 2, 3]), Immutable::Set[1, 2, 3] ],
+    [ ::SortedSet.new, Immutable::SortedSet[] ],
+    [ ::SortedSet.new([1, 2, 3]), Immutable::SortedSet[1, 2, 3] ],
+    [ 42, 42 ],
+    [ STDOUT, STDOUT ]
+  ]
+
+  describe ".from" do
+    expectations.each do |input, expected_result|
+      context "with #{input.inspect} as input" do
+        it "should return #{expected_result.inspect}" do
+          Immutable.from(input).should eql(expected_result)
+        end
+      end
+    end
+
+    context "with mixed object" do
+      it "should return Immutable data" do
+        input = {
+          "a" => "b",
+          "c" => {"d" => "e"},
+          "f" => Immutable::Vector["g", "h", []],
+          "i" => Immutable::Hash["j" => {}, "k" => Immutable::Set[[], {}]] }
+        expected_result = Immutable::Hash[
+          "a" => "b",
+          "c" => Immutable::Hash["d" => "e"],
+          "f" => Immutable::Vector["g", "h", Immutable::EmptyVector],
+          "i" => Immutable::Hash["j" => Immutable::EmptyHash, "k" => Immutable::Set[Immutable::EmptyVector, Immutable::EmptyHash]] ]
+        Immutable.from(input).should eql(expected_result)
+      end
+    end
+  end
+
+  describe ".to_ruby" do
+    expectations.each do |expected_result, input|
+      context "with #{input.inspect} as input" do
+        it "should return #{expected_result.inspect}" do
+          Immutable.to_ruby(input).should eql(expected_result)
+        end
+      end
+    end
+
+    context "with Immutable::Deque[] as input" do
+      it "should return []" do
+        Immutable.to_ruby(Immutable::Deque[]).should eql([])
+      end
+    end
+
+    context "with Immutable::Deque[Immutable::Hash[\"a\" => 1]] as input" do
+      it "should return [{\"a\" => 1}]" do
+        Immutable.to_ruby(Immutable::Deque[Immutable::Hash["a" => 1]]).should eql([{"a" => 1}])
+      end
+    end
+
+    context "with mixed object" do
+      it "should return Ruby data structures" do
+        input = Immutable::Hash[
+          "a" => "b",
+          "c" => {"d" => "e"},
+          "f" => Immutable::Vector["g", "h"],
+          "i" => {"j" => Immutable::EmptyHash, "k" => Set.new([Immutable::EmptyVector, Immutable::EmptyHash])}]
+        expected_result = {
+          "a" => "b",
+          "c" => {"d" => "e"},
+          "f" => ["g", "h"],
+          "i" => {"j" => {}, "k" => Set.new([[], {}])} }
+        Immutable.to_ruby(input).should eql(expected_result)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  let(:original) { S["A", "B", "C"] }
+
+  [:add, :<<].each do |method|
+    describe "##{method}" do
+      context "with a unique value" do
+        let(:result) { original.send(method, "D") }
+
+        it "preserves the original" do
+          result
+          original.should eql(S["A", "B", "C"])
+        end
+
+        it "returns a copy with the superset of values" do
+          result.should eql(S["A", "B", "C", "D"])
+        end
+      end
+
+      context "with a duplicate value" do
+        let(:result) { original.send(method, "C") }
+
+        it "preserves the original values" do
+          result
+          original.should eql(S["A", "B", "C"])
+        end
+
+        it "returns self" do
+          result.should equal(original)
+        end
+      end
+
+      it "can add nil to a set" do
+        original.add(nil).should eql(S["A", "B", "C", nil])
+      end
+
+      it "works on large sets, with many combinations of input" do
+        50.times do
+          array = (1..500).to_a.sample(100)
+          set   = S.new(array)
+          to_add = 1000 + rand(1000)
+          set.add(to_add).size.should == 101
+          set.add(to_add).include?(to_add).should == true
+        end
+      end
+    end
+  end
+
+  describe "#add?" do
+    context "with a unique value" do
+      let(:result) { original.add?("D") }
+
+      it "preserves the original" do
+        original.should eql(S["A", "B", "C"])
+      end
+
+      it "returns a copy with the superset of values" do
+        result.should eql(S["A", "B", "C", "D"])
+      end
+    end
+
+    context "with a duplicate value" do
+      let(:result) { original.add?("C") }
+
+      it "preserves the original values" do
+        original.should eql(S["A", "B", "C"])
+      end
+
+      it "returns false" do
+        result.should equal(false)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#any?" do
+    context "when empty" do
+      it "with a block returns false" do
+        S.empty.any? {}.should == false
+      end
+
+      it "with no block returns false" do
+        S.empty.any?.should == false
+      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 true if the block ever returns true (#{value.inspect})" do
+            set.any? { |item| item == value }.should == true
+          end
+        end
+
+        it "returns false if the block always returns false" do
+          set.any? { |item| item == "D" }.should == false
+        end
+
+        it "propagates exceptions raised in the block" do
+          -> { set.any? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+        end
+
+        it "stops iterating as soon as the block returns true" do
+          yielded = []
+          set.any? { |k,v| yielded << k; true }
+          yielded.size.should == 1
+        end
+      end
+
+      context "with no block" do
+        it "returns true if any value is truthy" do
+          S[nil, false, true, "A"].any?.should == true
+        end
+
+        it "returns false if all values are falsey" do
+          S[nil, false].any?.should == false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#clear" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      describe "on #{values}" do
+        let(:set) { S[*values] }
+
+        it "preserves the original" do
+          set.clear
+          set.should eql(S[*values])
+        end
+
+        it "returns an empty set" do
+          set.clear.should equal(S.empty)
+        end
+      end
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Immutable::Set)
+        instance = subclass.new([:a, :b, :c, :d])
+        instance.clear.class.should be(subclass)
+        instance.clear.should be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#compact" do
+    [
+      [[], []],
+      [["A"], ["A"]],
+      [%w[A B C], %w[A B C]],
+      [[nil], []],
+      [[nil, "B"], ["B"]],
+      [["A", nil], ["A"]],
+      [[nil, nil], []],
+      [["A", nil, "C"], %w[A C]],
+      [[nil, "B", nil], ["B"]],
+    ].each do |values, expected|
+      describe "on #{values.inspect}" do
+        let(:set) { S[*values] }
+
+        it "preserves the original" do
+          set.compact
+          set.should eql(S[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          set.compact.should eql(S[*expected])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe ".set" do
+    context "with no values" do
+      it "returns the empty set" do
+        S.empty.should be_empty
+        S.empty.should equal(Immutable::EmptySet)
+      end
+    end
+
+    context "with a list of values" do
+      it "is equivalent to repeatedly using #add" do
+        S["A", "B", "C"].should eql(S.empty.add("A").add("B").add("C"))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  [:dup, :clone].each do |method|
+    let(:set) { S["A", "B", "C"] }
+
+    describe "##{method}" do
+      it "returns self" do
+        set.send(method).should equal(set)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  describe "#count" do
+    [
+      [[], 0],
+      [[1], 1],
+      [[1, 2], 1],
+      [[1, 2, 3], 2],
+      [[1, 2, 3, 4], 2],
+      [[1, 2, 3, 4, 5], 3],
+    ].each do |values, expected|
+      describe "on #{values.inspect}" do
+        let(:set) { S[*values] }
+
+        context "with a block" do
+          it "returns #{expected.inspect}" do
+            set.count(&:odd?).should == expected
+          end
+        end
+
+        context "without a block" do
+          it "returns length" do
+            set.count.should == set.length
+          end
+        end
+      end
+    end
+
+    it "works on large sets" do
+      set = Immutable::Set.new(1..2000)
+      set.count.should == 2000
+      set.count(&:odd?).should == 1000
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+describe Immutable::Set do
+  let(:set) { S["A", "B", "C"] }
+
+  describe "#delete" do
+    context "with an existing value" do
+      it "preserves the original" do
+        set.delete("B")
+        set.should eql(S["A", "B", "C"])
+      end
+
+      it "returns a copy with the remaining values" do
+        set.delete("B").should eql(S["A", "C"])
+      end
+    end
+
+    context "with a non-existing value" do
+      it "preserves the original values" do
+        set.delete("D")
+        set.should eql(S["A", "B", "C"])
+      end
+
+      it "returns self" do
+        set.delete("D").should equal(set)
+      end
+    end
+
+    context "when removing the last value in a set" do
+      it "returns the canonical empty set" do
+        set.delete("B").delete("C").delete("A").should be(Immutable::EmptySet)
+      end
+    end
+
+    it "works on large sets, with many combinations of input" do
+      array = 1000.times.map { %w[a b c d e f g h i j k l m n].sample(5).join }.uniq
+      set = S.new(array)
+      array.each do |key|
+        result = set.delete(key)
+        result.size.should == set.size - 1
+        result.include?(key).should == false
+        other = array.sample
+        (result.include?(other).should == true) if other != key
+      end
+    end
+  end
+
+  describe "#delete?" do
+    context "with an existing value" do
+      it "preserves the original" do
+        set.delete?("B")
+        set.should eql(S["A", "B", "C"])
+      end
+
+      it "returns a copy with the remaining values" do
+        set.delete?("B").should eql(S["A", "C"])
+      end
+    end
+
+    context "with a non-existing value" do
+      it "preserves the original values" do
+        set.delete?("D")
+        set.should eql(S["A", "B", "C"])
+      end
+
+      it "returns false" do
+        set.delete?("D").should be(false)
+      end
+    end
+  end
+end