immutable-ruby 0.0.1 → 0.1.0

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

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#split_at" do
-    it "is lazy" do
-      -> { Immutable.stream { fail }.split_at(1) }.should_not raise_error
-    end
-
-    [
-      [[], [], []],
-      [[1], [1], []],
-      [[1, 2], [1, 2], []],
-      [[1, 2, 3], [1, 2], [3]],
-      [[1, 2, 3, 4], [1, 2], [3, 4]],
-    ].each do |values, expected_prefix, expected_remainder|
-      context "on #{values.inspect}" do
-        let(:list) { L[*values] }
-        let(:result) { list.split_at(2) }
-        let(:prefix) { result.first }
-        let(:remainder) { result.last }
-
-        it "preserves the original" do
-          result
-          list.should eql(L[*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
-          prefix.should eql(L[*expected_prefix])
-        end
-
-        it "correctly identifies the remainder" do
-          remainder.should eql(L[*expected_remainder])
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#subsequences" do
-    let(:list) { L[1,2,3,4,5] }
-
-    it "yields all sublists with 1 or more consecutive items" do
-      result = []
-      list.subsequences { |l| result << l }
-      result.size.should == (5 + 4 + 3 + 2 + 1)
-      result.sort.should == [[1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5],
-        [2], [2,3], [2,3,4], [2,3,4,5], [3], [3,4], [3,4,5], [4], [4,5], [5]]
-    end
-
-    context "with no block" do
-      it "returns an Enumerator" do
-        list.subsequences.class.should be(Enumerator)
-        list.subsequences.to_a.sort.should == [[1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5],
-        [2], [2,3], [2,3,4], [2,3,4,5], [3], [3,4], [3,4,5], [4], [4,5], [5]]
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#sum" do
-    context "on a really big list" do
-      it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).sum }.should_not raise_error
-      end
-    end
-
-    [
-      [[], 0],
-      [[2], 2],
-      [[1, 3, 5, 7, 11], 27],
-    ].each do |values, expected|
-      context "on #{values.inspect}" do
-        it "returns #{expected.inspect}" do
-          L[*values].sum.should == expected
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#tail" do
-    context "on a really big list" do
-      it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).select(&:nil?).tail }.should_not raise_error
-      end
-    end
-
-    [
-      [[], []],
-      [["A"], []],
-      [%w[A B C], %w[B C]],
-    ].each do |values, expected|
-      context "on #{values.inspect}" do
-        let(:list) { L[*values] }
-
-        it "preserves the original" do
-          list.tail
-          list.should eql(L[*values])
-        end
-
-        it "returns #{expected.inspect}" do
-          list.tail.should eql(L[*expected])
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#tails" do
-    it "is lazy" do
-      -> { Immutable.stream { fail }.tails }.should_not raise_error
-    end
-
-    [
-      [[], []],
-      [["A"], [L["A"]]],
-      [%w[A B C], [L["A", "B", "C"], L["B", "C"], L["C"]]],
-    ].each do |values, expected|
-      context "on #{values.inspect}" do
-        let(:list) { L[*values] }
-
-        it "preserves the original" do
-          list.tails
-          list.should eql(L[*values])
-        end
-
-        it "returns #{expected.inspect}" do
-          list.tails.should eql(L[*expected])
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#take" do
-    it "is lazy" do
-      -> { Immutable.stream { fail }.take(1) }.should_not raise_error
-    end
-
-    [
-      [[], 10, []],
-      [["A"], 10, ["A"]],
-      [["A"], -1, []],
-      [%w[A B C], 0, []],
-      [%w[A B C], 2, %w[A B]],
-    ].each do |values, number, expected|
-      context "#{number} from #{values.inspect}" do
-        let(:list) { L[*values] }
-
-        it "preserves the original" do
-          list.take(number)
-          list.should eql(L[*values])
-        end
-
-        it "returns #{expected.inspect}" do
-          list.take(number).should eql(L[*expected])
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#take_while" do
-    it "is lazy" do
-      -> { Immutable.stream { fail }.take_while { false } }.should_not raise_error
-    end
-
-    [
-      [[], []],
-      [["A"], ["A"]],
-      [%w[A B C], %w[A B]],
-    ].each do |values, expected|
-      context "on #{values.inspect}" do
-        let(:list) { L[*values] }
-
-        context "with a block" do
-          it "returns #{expected.inspect}" do
-            list.take_while { |item| item < "C" }.should eql(L[*expected])
-          end
-
-          it "preserves the original" do
-            list.take_while { |item| item < "C" }
-            list.should eql(L[*values])
-          end
-
-          it "is lazy" do
-            count = 0
-            list.take_while do |item|
-              count += 1
-              true
-            end
-            count.should <= 1
-          end
-        end
-
-        context "without a block" do
-          it "returns an Enumerator" do
-            list.take_while.class.should be(Enumerator)
-            list.take_while.each { |item| item < "C" }.should eql(L[*expected])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  [:to_a, :entries].each do |method|
-    describe "##{method}" do
-      context "on a really big list" do
-        it "doesn't run out of stack" do
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).to_a }.should_not raise_error
-        end
-      end
-
-      [
-        [],
-        ["A"],
-        %w[A B C],
-      ].each do |values|
-        context "on #{values.inspect}" do
-          let(:list) { L[*values] }
-
-          it "returns #{values.inspect}" do
-            list.send(method).should == values
-          end
-
-          it "leaves the original unchanged" do
-            list.send(method)
-            list.should eql(L[*values])
-          end
-
-          it "returns a mutable array" do
-            result = list.send(method)
-            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/list/to_ary_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  let(:list) { L["A", "B", "C", "D"] }
-
-  describe "#to_ary" do
-    context "on a really big list" do
-      it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).to_ary }.should_not raise_error
-      end
-    end
-
-    context "enables implicit conversion to" do
-      it "block parameters" do
-        def func(&block)
-          yield(list)
-        end
-
-        func do |a, b, *c|
-          expect(a).to eq("A")
-          expect(b).to eq("B")
-          expect(c).to eq(%w[C D])
-        end
-      end
-
-      it "method arguments" do
-        def func(a, b, *c)
-          expect(a).to eq("A")
-          expect(b).to eq("B")
-          expect(c).to eq(%w[C D])
-        end
-        func(*list)
-      end
-
-      it "works with splat" do
-        array = *list
-        expect(array).to eq(%w[A B C D])
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#to_list" do
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      context "on #{values.inspect}" do
-        let(:list) { L[*values] }
-
-        it "returns self" do
-          list.to_list.should equal(list)
-        end
-      end
-    end
-  end
-end

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,95 +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 ]
-  ]
-
-  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

@@ -1,75 +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 = (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

@@ -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