immutable-ruby 0.0.4 → 0.1.0

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

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#to_set" do
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      context "on #{values.inspect}" do
-        it "returns a set with the same values" do
-          L[*values].to_set.should eql(S[*values])
-        end
-      end
-    end
-  end
-end

data/spec/lib/immutable/list/transpose_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#transpose" do
-    it "takes a list of lists and returns a list of all the first elements, all the 2nd elements, and so on" do
-      L[L[1, 'a'], L[2, 'b'], L[3, 'c']].transpose.should eql(L[L[1, 2, 3], L["a", "b", "c"]])
-      L[L[1, 2, 3], L["a", "b", "c"]].transpose.should eql(L[L[1, 'a'], L[2, 'b'], L[3, 'c']])
-      L[].transpose.should eql(L[])
-      L[L[]].transpose.should eql(L[])
-      L[L[], L[]].transpose.should eql(L[])
-      L[L[0]].transpose.should eql(L[L[0]])
-      L[L[0], L[1]].transpose.should eql(L[L[0, 1]])
-    end
-
-    it "only goes as far as the shortest list" do
-      L[L[1,2,3], L[2]].transpose.should eql(L[L[1,2]])
-    end
-  end
-end

data/spec/lib/immutable/list/union_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  [:union, :|].each do |method|
-    describe "##{method}" do
-      it "is lazy" do
-        -> { Immutable.stream { fail }.union(Immutable.stream { fail }) }.should_not raise_error
-      end
-
-      [
-        [[], [], []],
-        [["A"], [], ["A"]],
-        [%w[A B C], [], %w[A B C]],
-        [%w[A A], ["A"], ["A"]],
-      ].each do |a, b, expected|
-        context "returns #{expected.inspect}" do
-          let(:list_a) { L[*a] }
-          let(:list_b) { L[*b] }
-
-          it "for #{a.inspect} and #{b.inspect}"  do
-            list_a.send(method, list_b).should eql(L[*expected])
-          end
-
-          it "for #{b.inspect} and #{a.inspect}"  do
-            list_b.send(method, list_a).should eql(L[*expected])
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/immutable/list/uniq_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#uniq" do
-    it "is lazy" do
-      -> { Immutable.stream { fail }.uniq }.should_not raise_error
-    end
-
-    context "when passed a block" do
-      it "uses the block to identify duplicates" do
-        L["a", "A", "b"].uniq(&:upcase).should eql(Immutable::List["a", "b"])
-      end
-    end
-
-    [
-      [[], []],
-      [["A"], ["A"]],
-      [%w[A B C], %w[A B C]],
-      [%w[A B A C C], %w[A B C]],
-    ].each do |values, expected|
-      context "on #{values.inspect}" do
-        let(:list) { L[*values] }
-
-        it "preserves the original" do
-          list.uniq
-          list.should eql(L[*values])
-        end
-
-        it "returns #{expected.inspect}" do
-          list.uniq.should eql(L[*expected])
-        end
-      end
-    end
-  end
-end

data/spec/lib/immutable/list/zip_spec.rb

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#zip" do
-    it "is lazy" do
-      -> { Immutable.stream { fail }.zip(Immutable.stream { fail }) }.should_not raise_error
-    end
-
-    [
-      [[], [], []],
-      [["A"], ["aye"], [L["A", "aye"]]],
-      [["A"], [], [L["A", nil]]],
-      [[], ["A"], [L[nil, "A"]]],
-      [%w[A B C], %w[aye bee see], [L["A", "aye"], L["B", "bee"], L["C", "see"]]],
-    ].each do |left, right, expected|
-      context "on #{left.inspect} and #{right.inspect}" do
-        it "returns #{expected.inspect}" do
-          L[*left].zip(L[*right]).should eql(L[*expected])
-        end
-      end
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-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 ],
-
-    # Struct conversion is one-way (from Ruby core Struct to Immutable::Hash), not back again!
-    [ Struct::Customer.new, Immutable::Hash[name: nil, address: nil], true ],
-    [ Struct::Customer.new('Dave', '123 Main'), Immutable::Hash[name: 'Dave', address: '123 Main'], true ]
-  ]
-
-  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, one_way|
-      unless one_way
-        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
-    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

@@ -1,77 +0,0 @@
-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#sample is buggy on RBX 2.5.8; that's why #uniq is needed here
-          # See https://github.com/rubinius/rubinius/issues/3506
-          array = (1..500).to_a.sample(100).uniq
-          set   = S.new(array)
-          to_add = 1000 + rand(1000)
-          set.add(to_add).size.should == array.size + 1
-          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

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

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

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

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

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

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

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

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

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

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Set do
-  [:difference, :subtract, :-].each do |method|
-    describe "##{method}" do
-      [
-        [[], [], []],
-        [["A"], [], ["A"]],
-        [["A"], ["A"], []],
-        [%w[A B C], ["B"], %w[A C]],
-        [%w[A B C], %w[A C], ["B"]],
-        [%w[A B C D E F G H], [], %w[A B C D E F G H]],
-        [%w[A B C M X Y Z], %w[B C D E F G H I J X], %w[A M 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] }
-          let(:result) { set_a.send(method, set_b) }
-
-          it "doesn't modify the original Sets" do
-            result
-            set_a.should eql(S.new(a))
-            set_b.should eql(S.new(b))
-          end
-
-          it "returns #{expected.inspect}"  do
-            result.should eql(S[*expected])
-          end
-        end
-
-        context "when passed a Ruby Array" do
-          it "returns the expected Set" do
-            S[*a].difference(b.freeze).should eql(S[*expected])
-          end
-        end
-      end
-
-      it "works on a wide variety of inputs" do
-        items = ('aa'..'zz').to_a
-        50.times do
-          array1 = items.sample(200)
-          array2 = items.sample(200)
-          result = S.new(array1).send(method, S.new(array2))
-          result.to_a.sort.should eql((array1 - array2).sort)
-        end
-      end
-    end
-  end
-end