immutable-ruby 0.0.1

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

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#first" do
+    [
+      [[], nil],
+      [["A"], "A"],
+      [%w[A B C], "A"],
+      [%w[Z Y X], "X"]
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          SS[*values].first.should eql(expected)
+        end
+      end
+    end
+  end
+end

data/spec/lib/immutable/sorted_set/from_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#from" do
+    context "when called without a block" do
+      it "returns a sorted set of all items equal to or greater than the argument" do
+        100.times do
+          items     = rand(100).times.collect { rand(1000) }
+          set       = SS.new(items)
+          threshold = rand(1000)
+          result    = set.from(threshold)
+          array     = items.select { |x| x >= threshold }.sort
+          result.class.should be(Immutable::SortedSet)
+          result.size.should == array.size
+          result.to_a.should == array
+        end
+      end
+    end
+
+    context "when called with a block" do
+      it "yields all the items equal to or greater than than the argument" do
+        100.times do
+          items     = rand(100).times.collect { rand(1000) }
+          set       = SS.new(items)
+          threshold = rand(1000)
+          result    = []
+          set.from(threshold) { |x| result << x }
+          array  = items.select { |x| x >= threshold }.sort
+          result.size.should == array.size
+          result.should == array
+        end
+      end
+    end
+
+    context "on an empty set" do
+      it "returns an empty set" do
+        SS.empty.from(1).should be_empty
+        SS.empty.from('abc').should be_empty
+        SS.empty.from(:symbol).should be_empty
+      end
+    end
+
+    context "with an argument higher than all the values in the set" do
+      it "returns an empty set" do
+        result = SS.new(1..100).from(101)
+        result.class.should be(Immutable::SortedSet)
+        result.should be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  [:group_by, :group, :classify].each do |method|
+    describe "##{method}" do
+      context "with a block" do
+        [
+          [[], []],
+          [[1], [true => SS[1]]],
+          [[1, 2, 3, 4], [true => SS[3, 1], false => SS[4, 2]]],
+        ].each do |values, expected|
+          context "on #{values.inspect}" do
+            let(:sorted_set) { SS[*values] }
+
+            it "preserves the original" do
+              sorted_set.send(method, &:odd?)
+              sorted_set.should eql(SS[*values])
+            end
+
+            it "returns #{expected.inspect}" do
+              sorted_set.send(method, &:odd?).should eql(H[*expected])
+            end
+          end
+        end
+      end
+
+      context "without a block" do
+        [
+          [[], []],
+          [[1], [1 => SS[1]]],
+          [[1, 2, 3, 4], [1 => SS[1], 2 => SS[2], 3 => SS[3], 4 => SS[4]]],
+        ].each do |values, expected|
+          context "on #{values.inspect}" do
+            let(:sorted_set) { SS[*values] }
+
+            it "preserves the original" do
+              sorted_set.group_by
+              sorted_set.should eql(SS[*values])
+            end
+
+            it "returns #{expected.inspect}" do
+              sorted_set.group_by.should eql(H[*expected])
+            end
+          end
+        end
+      end
+
+      context "from a subclass" do
+        it "returns an Hash whose values are instances of the subclass" do
+          subclass = Class.new(Immutable::SortedSet)
+          instance = subclass.new(['some', 'strings', 'here'])
+          instance.group_by { |x| x }.values.each { |v| v.class.should be(subclass) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  [:include?, :member?].each do |method|
+    describe "##{method}" do
+      let(:sorted_set) { SS[1, 2, 3, 4.0] }
+
+      [1, 2, 3, 4.0].each do |value|
+        it "returns true for an existing value (#{value.inspect})" do
+          sorted_set.send(method, value).should == true
+        end
+      end
+
+      it "returns false for a non-existing value" do
+        sorted_set.send(method, 5).should == false
+      end
+
+      it "uses #<=> for equality" do
+        sorted_set.send(method, 4).should == true
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Immutable::SortedSet 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|
+      context "for #{a.inspect} and #{b.inspect}" do
+        it "returns #{expected}" do
+          SS[*a].intersect?(SS[*b]).should be(expected)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Immutable::SortedSet 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]],
+        [%w[A M T X], %w[B C D E F G H I M P Q T U], %w[M T]]
+      ].each do |a, b, expected|
+        context "for #{a.inspect} and #{b.inspect}" do
+          it "returns #{expected.inspect}" do
+            SS[*a].send(method, SS[*b]).should eql(SS[*expected])
+          end
+        end
+
+        context "for #{b.inspect} and #{a.inspect}" do
+          it "returns #{expected.inspect}" do
+            SS[*b].send(method, SS[*a]).should eql(SS[*expected])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/immutable/sorted_set/last_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  let(:sorted_set) { SS[*values] }
+
+  describe "#last" do
+    let(:last) { sorted_set.last }
+
+    shared_examples "checking values" do
+      it "returns the last item" do
+        expect(last).to eq(last_item)
+      end
+    end
+
+    context "with an empty set" do
+      let(:last_item) { nil }
+      let(:values) { [] }
+
+      include_examples "checking values"
+    end
+
+    context "with a single item set" do
+      let(:last_item) { "A" }
+      let(:values) { %w[A] }
+
+      include_examples "checking values"
+    end
+
+    context "with a multi-item set" do
+      let(:last_item) { "B" }
+      let(:values) { %w[B A] }
+
+      include_examples "checking values"
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  [:map, :collect].each do |method|
+    describe "##{method}" do
+      context "when empty" do
+        it "returns self" do
+          SS.empty.send(method) {}.should equal(SS.empty)
+        end
+      end
+
+      context "when not empty" do
+        let(:sorted_set) { SS["A", "B", "C"] }
+
+        context "with a block" do
+          it "preserves the original values" do
+            sorted_set.send(method, &:downcase)
+            sorted_set.should eql(SS["A", "B", "C"])
+          end
+
+          it "returns a new set with the mapped values" do
+            sorted_set.send(method, &:downcase).should eql(SS["a", "b", "c"])
+          end
+        end
+
+        context "with no block" do
+          it "returns an Enumerator" do
+            sorted_set.send(method).class.should be(Enumerator)
+            sorted_set.send(method).each(&:downcase).should == SS['a', 'b', 'c']
+          end
+        end
+      end
+
+      context "on a set ordered by a comparator" do
+        let(:sorted_set) { SS.new(["A", "B", "C"]) { |a,b| b <=> a }}
+
+        it "returns a new set with the mapped values" do
+          sorted_set.send(method, &:downcase).should == ['c', 'b', 'a']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#marshal_dump/#marshal_load" do
+    let(:ruby) do
+      File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
+    end
+    let(:child_cmd) do
+      %Q|#{ruby} -I lib -r immutable -e 'set = Immutable::SortedSet[5, 10, 15]; $stdout.write(Marshal.dump(set))'|
+    end
+
+    let(:reloaded_set) do
+      IO.popen(child_cmd, "r+") do |child|
+        reloaded_set = Marshal.load(child)
+        child.close
+        reloaded_set
+      end
+    end
+
+    it "can survive dumping and loading into a new process" do
+      expect(reloaded_set).to eql(SS[5, 10, 15])
+    end
+
+    it "is still possible to find items by index after loading" do
+      expect(reloaded_set[0]).to eq(5)
+      expect(reloaded_set[1]).to eq(10)
+      expect(reloaded_set[2]).to eq(15)
+      expect(reloaded_set.size).to eq(3)
+    end
+
+    it "raises a TypeError if set has a custom sort order" do
+      # this is because comparator block can't be serialized
+      -> { Marshal.dump(SS.new([1, 2, 3]) { |x| -x }) }.should raise_error(TypeError)
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Immutable::SortedSet 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) { SS[*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
+            SS[*values].max.should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe "#min" do
+    [
+      [[], nil],
+      [["A"], "A"],
+      [%w[Ichi Ni San], "Ichi"],
+      [[1,2,3,4,5], 1],
+      [[0, -0.0, 2.2, -4, -4.2], -4.2],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          SS[*values].min.should == expected
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  describe ".new" do
+    it "accepts a single enumerable argument and creates a new sorted set" do
+      sorted_set = SS.new([1,2,3])
+      sorted_set.size.should be(3)
+      sorted_set[0].should be(1)
+      sorted_set[1].should be(2)
+      sorted_set[2].should be(3)
+    end
+
+    it "also works with a Range" do
+      sorted_set = SS.new(1..3)
+      sorted_set.size.should be(3)
+      sorted_set[0].should be(1)
+      sorted_set[1].should be(2)
+      sorted_set[2].should be(3)
+    end
+
+    it "is amenable to overriding of #initialize" do
+      class SnazzySortedSet < Immutable::SortedSet
+        def initialize
+          super(['SNAZZY!!!'])
+        end
+      end
+
+      sorted_set = SnazzySortedSet.new
+      sorted_set.size.should be(1)
+      sorted_set.to_a.should == ['SNAZZY!!!']
+    end
+
+    it "accepts a block with arity 1" do
+      sorted_set = SS.new(1..3) { |a| -a }
+      sorted_set[0].should be(3)
+      sorted_set[1].should be(2)
+      sorted_set[2].should be(1)
+    end
+
+    it "accepts a block with arity 2" do
+      sorted_set = SS.new(1..3) { |a,b| b <=> a }
+      sorted_set[0].should be(3)
+      sorted_set[1].should be(2)
+      sorted_set[2].should be(1)
+    end
+
+    it "can use a block produced by Symbol#to_proc" do
+      sorted_set = SS.new([Object, BasicObject], &:name.to_proc)
+      sorted_set[0].should be(BasicObject)
+      sorted_set[1].should be(Object)
+    end
+
+    context "from a subclass" do
+      it "returns a frozen instance of the subclass" do
+        subclass = Class.new(Immutable::SortedSet)
+        instance = subclass.new(["some", "values"])
+        instance.class.should be subclass
+        instance.frozen?.should be true
+      end
+    end
+  end
+
+  describe ".[]" do
+    it "accepts a variable number of items and creates a new sorted set" do
+      sorted_set = SS['a', 'b']
+      sorted_set.size.should be(2)
+      sorted_set[0].should == 'a'
+      sorted_set[1].should == 'b'
+    end
+  end
+end