immutable-ruby 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a963e4f0565bc516534d1cf81f0206357b252f3a
-  data.tar.gz: 38a237bd2bdcef74cb66971375e1414ea36c67bd
+  metadata.gz: f0b9336a378ad7d4e2cf98b8977c0dbac13ed74b
+  data.tar.gz: 2ec6d56a86049914a7c3e9807277a6134f5f4842
 SHA512:
-  metadata.gz: '040888fc5816c86d1df3333bd1e7e922096c7775e196f5bf3c9e9dedc599dc55b888cf31c1b602bcc4bfda8c06e28b436a793d4e221fca54855e69b0b2d2e523'
-  data.tar.gz: fb6bffbec4a70ccc00058140a563007cbf7617c55af03328c2a8385772caaf4d6e0d22e9e10664541ec04ad3f1dfe43f5b3b327268539841d6edb9c7683af1dc
+  metadata.gz: 02a4a9fa583aa94d5a609b8654247d486e41c51efcf0e3f3447ec47f6fd31e2f204e65dc906b6c6b82341dfdcc826b1a9ed55d9a4c8022e88508068999859d2f
+  data.tar.gz: 4246f4d3457284cd82c13ed20b92f1b8d00e9cad02d30a0909f8f9d4194e331deac73fbaf5ebbaa1a4f395199c68f90cfdfef68403ac1c6a81edaf5b5e5878dc

data/lib/immutable/sorted_set.rb

@@ -76,21 +76,43 @@ module Immutable
       def alloc(node)
         allocate.tap { |s| s.instance_variable_set(:@node, node) }.freeze
       end
+
+      # @private
+      # Unfortunately, Ruby's stdlib doesn't do this for us
+      # array must be sorted
+      def uniq_by_comparator!(array, comparator)
+        to_check, shift, sz, prev_obj = 1, 0, array.size, array[0]
+        while to_check < sz
+          next_obj = array[to_check]
+          if comparator.call(prev_obj, next_obj) == 0
+            shift += 1
+          else
+            if shift > 0
+              array[to_check - shift] = next_obj
+            end
+            prev_obj = next_obj
+          end
+          to_check += 1
+        end
+        array.pop(shift) if shift > 0
+      end
     end
 
     def initialize(items=[], &block)
       items = items.to_a
       if block
         if block.arity == 1 || block.arity == -1
+          items = items.uniq(&block)
+          items.sort_by!(&block)
           comparator = lambda { |a,b| block.call(a) <=> block.call(b) }
-          items = items.sort_by(&block)
         else
-          comparator = block
           items = items.sort(&block)
+          SortedSet.uniq_by_comparator!(items, block)
+          comparator = block
         end
         @node = AVLNode.from_items(items, comparator)
       else
-        @node = PlainAVLNode.from_items(items.sort)
+        @node = PlainAVLNode.from_items(items.uniq.sort!)
       end
       freeze
     end
@@ -476,9 +498,11 @@ module Immutable
     def sort(&block)
       if block
         self.class.new(self.to_a, &block)
+      elsif @node.natural_order?
+        self
       else
-        self.class.new(self.to_a.sort)
-      end      
+        self.class.new(self)
+      end
     end
     alias :sort_by :sort
 
@@ -990,7 +1014,8 @@ module Immutable
 
     # @private
     class AVLNode
-      def self.from_items(items, comparator, from = 0, to = items.size-1) # items must be sorted
+      def self.from_items(items, comparator, from = 0, to = items.size-1)
+        # items must be sorted, without duplicates (as determined by comparator)
         size = to - from + 1
         if size >= 3
           middle = (to + from) / 2
@@ -1013,8 +1038,12 @@ module Immutable
       end
       attr_reader :item, :left, :right, :height, :size
 
+      # Used to implement #map
+      # Takes advantage of the fact that Enumerable#map allocates a new Array
       def from_items(items)
-        AVLNode.from_items(items.sort(&@comparator), @comparator)
+        items.sort!(&@comparator)
+        SortedSet.uniq_by_comparator!(items, @comparator)
+        AVLNode.from_items(items, @comparator)
       end
 
       def natural_order?
@@ -1374,7 +1403,9 @@ module Immutable
         end
         def bulk_insert(items)
           items = items.to_a if !items.is_a?(Array)
-          AVLNode.from_items(items.sort(&@comparator), @comparator)
+          items = items.sort(&@comparator)
+          SortedSet.uniq_by_comparator!(items, @comparator)
+          AVLNode.from_items(items, @comparator)
         end
         def bulk_delete(items); self; end
         def keep_only(items);   self; end
@@ -1397,7 +1428,8 @@ module Immutable
     # AVL node which does not use a comparator function; it keeps items sorted
     #   in their natural order
     class PlainAVLNode < AVLNode
-      def self.from_items(items, from = 0, to = items.size-1) # items must be sorted
+      def self.from_items(items, from = 0, to = items.size-1)
+        # items must be sorted, with no duplicates
         size = to - from + 1
         if size >= 3
           middle = (to + from) / 2
@@ -1418,8 +1450,12 @@ module Immutable
       end
       attr_reader :item, :left, :right, :height, :size
 
+      # Used to implement #map
+      # Takes advantage of the fact that Enumerable#map allocates a new Array
       def from_items(items)
-        PlainAVLNode.from_items(items.sort)
+        items.uniq!
+        items.sort!
+        PlainAVLNode.from_items(items)
       end
 
       def natural_order?
@@ -1447,7 +1483,7 @@ module Immutable
         end
         def bulk_insert(items)
           items = items.to_a if !items.is_a?(Array)
-          PlainAVLNode.from_items(items.sort)
+          PlainAVLNode.from_items(items.uniq.sort!)
         end
       end
 

data/lib/immutable/version.rb

@@ -1,5 +1,5 @@
 module Immutable
   # Current released gem version. Note that master will often have the same
   # value as a release gem but with different code.
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

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

@@ -47,13 +47,19 @@ describe Immutable::Set do
   end
 
   describe "#sort_by" do
-    it "only calls the passed block once for each item" do
+    # originally this test checked that #sort_by only called the block once
+    #   for each item
+    # however, when initializing a SortedSet, we need to make sure that it
+    #   does not include any duplicates, and we use the block when checking that
+    # the real point here is that the block should not be called an excessive
+    #   number of times, degrading performance
+    it "calls the passed block no more than twice for each item" do
       count = 0
       fn    = lambda { |x| count += 1; -x }
       items = 100.times.collect { rand(10000) }.uniq
 
       S[*items].sort_by(&fn).to_a.should == items.sort.reverse
-      count.should == items.length
+      count.should <= (items.length * 2)
     end
   end
 end

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

@@ -5,7 +5,7 @@ describe Immutable::SortedSet do
     context "when called without a block" do
       it "returns a sorted set of all items higher than the argument" do
         100.times do
-          items     = rand(100).times.collect { rand(1000) }
+          items     = rand(100).times.collect { rand(1000) }.uniq
           set       = SS.new(items)
           threshold = rand(1000)
           result    = set.above(threshold)
@@ -20,7 +20,7 @@ describe Immutable::SortedSet do
     context "when called with a block" do
       it "yields all the items higher than the argument" do
         100.times do
-          items     = rand(100).times.collect { rand(1000) }
+          items     = rand(100).times.collect { rand(1000) }.uniq
           set       = SS.new(items)
           threshold = rand(1000)
           result    = []

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

@@ -5,7 +5,7 @@ describe Immutable::SortedSet do
     context "when called without a block" do
       it "returns a sorted set of all items lower than the argument" do
         100.times do
-          items     = rand(100).times.collect { rand(1000) }
+          items     = rand(100).times.collect { rand(1000) }.uniq
           set       = SS.new(items)
           threshold = rand(1000)
           result    = set.below(threshold)
@@ -20,7 +20,7 @@ describe Immutable::SortedSet do
     context "when called with a block" do
       it "yields all the items lower than the argument" do
         100.times do
-          items     = rand(100).times.collect { rand(1000) }
+          items     = rand(100).times.collect { rand(1000) }.uniq
           set       = SS.new(items)
           threshold = rand(1000)
           result    = []

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

@@ -5,7 +5,7 @@ describe Immutable::SortedSet do
     context "when called without a block" do
       it "returns a sorted set of all items from the first argument to the second" do
         100.times do
-          items   = rand(100).times.collect { rand(1000) }
+          items   = rand(100).times.collect { rand(1000) }.uniq
           set     = SS.new(items)
           from,to = [rand(1000),rand(1000)].sort
           result  = set.between(from, to)
@@ -20,7 +20,7 @@ describe Immutable::SortedSet do
     context "when called with a block" do
       it "yields all the items lower than the argument" do
         100.times do
-          items   = rand(100).times.collect { rand(1000) }
+          items   = rand(100).times.collect { rand(1000) }.uniq
           set     = SS.new(items)
           from,to = [rand(1000),rand(1000)].sort
           result  = []

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

@@ -5,7 +5,7 @@ describe Immutable::SortedSet 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) }
+          items     = rand(100).times.collect { rand(1000) }.uniq
           set       = SS.new(items)
           threshold = rand(1000)
           result    = set.from(threshold)
@@ -20,7 +20,7 @@ describe Immutable::SortedSet do
     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) }
+          items     = rand(100).times.collect { rand(1000) }.uniq
           set       = SS.new(items)
           threshold = rand(1000)
           result    = []

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

@@ -21,6 +21,10 @@ describe Immutable::SortedSet do
           it "returns a new set with the mapped values" do
             sorted_set.send(method, &:downcase).should eql(SS["a", "b", "c"])
           end
+
+          it "filters out duplicates" do
+            sorted_set.send(method) { 'blah' }.should eq(SS['blah'])
+          end
         end
 
         context "with no block" do
@@ -37,6 +41,10 @@ describe Immutable::SortedSet do
         it "returns a new set with the mapped values" do
           sorted_set.send(method, &:downcase).should == ['c', 'b', 'a']
         end
+
+        it "filters out duplicates" do
+          sorted_set.send(method) { 'blah' }.should eq(SS['blah'])
+        end
       end
     end
   end

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

@@ -18,6 +18,19 @@ describe Immutable::SortedSet do
       sorted_set[2].should be(3)
     end
 
+    it "doesn't mutate the initializer" do
+      array = [3,2,1,3,2,1] # this will need to be sorted and duplicates filtered out
+      sorted_set = SS.new(array)
+      expect(array).to eq([3,2,1,3,2,1])
+    end
+
+    it "doesn't change if the initializer is later mutated" do
+      array = [3,2,1,3,2,1]
+      sorted_set = SS.new(array)
+      array.clear
+      expect(sorted_set.to_a).to eq([1,2,3])
+    end
+
     it "is amenable to overriding of #initialize" do
       class SnazzySortedSet < Immutable::SortedSet
         def initialize
@@ -50,6 +63,51 @@ describe Immutable::SortedSet do
       sorted_set[1].should be(Object)
     end
 
+    it "filters out duplicates" do
+      sorted_set = SS.new(['a', 'b', 'a', 'c', 'b', 'a', 'c', 'c'])
+      expect(sorted_set.size).to be(3)
+    end
+
+    context "when passed a comparator with arity 2" do
+      it "still filters out duplicates" do
+        sorted_set = SS.new([1,2,7,8,9,10]) { |x,y| (x%7) <=> (y%7) }
+        expect(sorted_set.to_a).to eq([7,1,2,10])
+      end
+
+      it "still doesn't mutate the initializer" do
+        array = [3,2,1,3,2,1] # this will need to be sorted and duplicates filtered out
+        sorted_set = SS.new(array) { |x,y| y <=> x }
+        expect(array).to eq([3,2,1,3,2,1])
+      end
+
+      it "still doesn't change if the initializer is later mutated" do
+        array = [3,2,1,3,2,1]
+        sorted_set = SS.new(array) { |x,y| y <=> x }
+        array.clear
+        expect(sorted_set.to_a).to eq([3,2,1])
+      end
+    end
+
+    context "when passed a block with arity 1" do
+      it "still filters out duplicates" do
+        sorted_set = SS.new([1,2,7,8,9,10]) { |x| x % 7 }
+        expect(sorted_set.to_a).to eq([7,1,2,10])
+      end
+
+      it "still doesn't mutate the initializer" do
+        array = [3,2,1,3,2,1] # this will need to be sorted and duplicates filtered out
+        sorted_set = SS.new(array) { |x| x % 7 }
+        expect(array).to eq([3,2,1,3,2,1])
+      end
+
+      it "still doesn't change if the initializer is later mutated" do
+        array = [3,2,1,3,2,1]
+        sorted_set = SS.new(array) { |x| x % 7 }
+        array.clear
+        expect(sorted_set.to_a).to eq([1,2,3])
+      end
+    end
+
     context "from a subclass" do
       it "returns a frozen instance of the subclass" do
         subclass = Class.new(Immutable::SortedSet)
@@ -67,5 +125,13 @@ describe Immutable::SortedSet do
       sorted_set[0].should == 'a'
       sorted_set[1].should == 'b'
     end
+
+    it "filters out duplicate items" do
+      sorted_set = SS['a', 'b', 'a', 'c', 'b', 'a', 'c', 'c']
+      expect(sorted_set.size).to be(3)
+      sorted_set[0].should == 'a'
+      sorted_set[1].should == 'b'
+      sorted_set[2].should == 'c'
+    end
   end
 end

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

@@ -41,4 +41,16 @@ describe Immutable::SortedSet do
       end
     end
   end
+
+  describe :sort do
+    context "on a SortedSet with custom sort order" do
+      let(:sorted_set) { SS.new([1,2,3,4]) { |x,y| y <=> x }}
+
+      it "returns a SortedSet with the natural sort order" do
+        result = sorted_set.sort
+        expect(sorted_set.to_a).to eq([4,3,2,1])
+        expect(result.to_a).to eq([1,2,3,4])
+      end
+    end
+  end
 end

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

@@ -24,4 +24,35 @@ describe Immutable::SortedSet do
       end
     end
   end
+
+  describe :union do
+    it "filters out duplicates when passed an Array" do
+      sorted_set = SS['A', 'B', 'C', 'D'].union(['A', 'A', 'A', 'C', 'A', 'B', 'E'])
+      expect(sorted_set.to_a).to eq(['A', 'B', 'C', 'D', 'E'])
+    end
+
+    it "doesn't mutate an Array which is passed in" do
+      array = [3,2,1,3]
+      sorted_set = SS[1,2,5].union(array)
+      expect(array).to eq([3,2,1,3])
+    end
+
+    context "on a set ordered by a comparator" do
+      # Completely different code is executed when #union is called on a SS
+      #   with a comparator block, so we should repeat all the same tests
+
+      it "still filters out duplicates when passed an Array" do
+        sorted_set = SS.new([1,2,3]) { |x,y| (x%7) <=> (y%7) }
+        sorted_set = sorted_set.union([7,8,9])
+        expect(sorted_set.to_a).to eq([7,1,2,3])
+      end
+
+      it "still doesn't mutate an Array which is passed in" do
+        array = [3,2,1,3]
+        sorted_set = SS.new([1,2,5]) { |x,y| y <=> x }
+        sorted_set = sorted_set.union(array)
+        expect(array).to eq([3,2,1,3])
+      end
+    end
+  end
 end

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

@@ -5,7 +5,7 @@ describe Immutable::SortedSet do
     context "when called without a block" do
       it "returns a sorted set of all items equal to or less than the argument" do
         100.times do
-          items     = rand(100).times.collect { rand(1000) }
+          items     = rand(100).times.collect { rand(1000) }.uniq
           set       = SS.new(items)
           threshold = rand(1000)
           result    = set.up_to(threshold)
@@ -20,7 +20,7 @@ describe Immutable::SortedSet do
     context "when called with a block" do
       it "yields all the items equal to or less than than the argument" do
         100.times do
-          items     = rand(100).times.collect { rand(1000) }
+          items     = rand(100).times.collect { rand(1000) }.uniq
           set       = SS.new(items)
           threshold = rand(1000)
           result    = []

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

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe Immutable::SortedSet do
+  # Utility method used for filtering out duplicate objects, with equality
+  #   determined by comparator
+  describe ".uniq_by_comparator!" do
+    it "can handle empty arrays" do
+      array = []
+      SS.uniq_by_comparator!(array, ->(x,y) { x <=> y })
+      expect(array).to be_empty
+    end
+
+    it "can handle arrays with 1 element" do
+      array = [1]
+      SS.uniq_by_comparator!(array, ->(x,y) { x <=> y })
+      expect(array).to eq([1])
+    end
+
+    it "can handle arrays with 2 elements and no dupes" do
+      array = [1, 2]
+      SS.uniq_by_comparator!(array, ->(x,y) { x <=> y })
+      expect(array).to eq([1, 2])
+    end
+
+    it "can handle arrays with 2 elements and dupes" do
+      array = [1, 1]
+      SS.uniq_by_comparator!(array, ->(x,y) { x <=> y })
+      expect(array).to eq([1])
+    end
+
+    it "can handle arrays with lots of elements" do
+      100.times do
+        array1 = rand(100).times.collect { rand(100) }.sort
+        array2 = array1.dup.uniq
+        SS.uniq_by_comparator!(array1, ->(x,y) { x <=> y })
+        expect(array1).to eq(array2)
+      end
+    end
+
+    it "works with funny comparators" do
+      # let's work in modulo arithmetic
+      comparator = ->(x,y) { (x % 7) <=> (y % 7) }
+      array = [21, 1, 8, 1, 9, 10, 3, 5, 6, 20] # this is "sorted" (modulo 7)
+      SS.uniq_by_comparator!(array, comparator)
+      expect(array).to eq([21, 1, 9, 10, 5, 6])
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: immutable-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Alex Dowad
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-05 00:00:00.000000000 Z
+date: 2018-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -408,6 +408,7 @@ files:
 - spec/lib/immutable/sorted_set/to_set_spec.rb
 - spec/lib/immutable/sorted_set/union_spec.rb
 - spec/lib/immutable/sorted_set/up_to_spec.rb
+- spec/lib/immutable/sorted_set/util_spec.rb
 - spec/lib/immutable/sorted_set/values_at_spec.rb
 - spec/lib/immutable/vector/add_spec.rb
 - spec/lib/immutable/vector/any_spec.rb
@@ -787,6 +788,7 @@ test_files:
 - spec/lib/immutable/sorted_set/group_by_spec.rb
 - spec/lib/immutable/sorted_set/between_spec.rb
 - spec/lib/immutable/sorted_set/sample_spec.rb
+- spec/lib/immutable/sorted_set/util_spec.rb
 - spec/lib/immutable/sorted_set/values_at_spec.rb
 - spec/lib/immutable/sorted_set/marshal_spec.rb
 - spec/lib/immutable/sorted_set/intersect_spec.rb