immutable-ruby 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f0b9336a378ad7d4e2cf98b8977c0dbac13ed74b
-  data.tar.gz: 2ec6d56a86049914a7c3e9807277a6134f5f4842
+SHA256:
+  metadata.gz: d4dfc5d75d70e963c56837a552ac1902889f05f2fd73a3995c69959815780594
+  data.tar.gz: b9daefb94ad6bd5e3bf3a0bc7b74265a9d97188856ab78508f2cdf813b342636
 SHA512:
-  metadata.gz: 02a4a9fa583aa94d5a609b8654247d486e41c51efcf0e3f3447ec47f6fd31e2f204e65dc906b6c6b82341dfdcc826b1a9ed55d9a4c8022e88508068999859d2f
-  data.tar.gz: 4246f4d3457284cd82c13ed20b92f1b8d00e9cad02d30a0909f8f9d4194e331deac73fbaf5ebbaa1a4f395199c68f90cfdfef68403ac1c6a81edaf5b5e5878dc
+  metadata.gz: 306f0ef37c0ba06cf729b230f8eb6ec850cf6ff6130fea45eaf125d307078617f8688bc02b2dd6a75aae11134a45172f7ca11a12e6693409c36d5f00b7f18fc0
+  data.tar.gz: '0039ef718ca215f12d6826ea6803c7e404fd211536095c5a4995ca04e30b0effefa11951a640bca03b37ee9834ff94bac7acd9d1ccaf2d08ba449204850e42cb'

data/lib/immutable/deque.rb

@@ -110,10 +110,38 @@ module Immutable
       @front.last # memoize?
     end
 
+    # Return a new `Deque` with elements rotated by `n` positions.
+    # A positive rotation moves elements to the right, negative to the left, and 0 is a no-op.
+    #
+    # @example
+    #   Immutable::Deque["A", "B", "C"].rotate(1)
+    #   # => Immutable::Deque["C", "A", "B"]
+    #   Immutable::Deque["A", "B", "C"].rotate(-1)
+    #   # => Immutable::Deque["B", "C", "A"]
+    #
+    # @param n [Integer] number of positions to move elements by
+    # @return [Deque]
+    def rotate(n)
+      return self.class.empty if self.empty?
+
+      n %= self.size
+      return self if n == 0
+
+      a, b = @front, @rear
+
+      if b.size >= n
+        n.times { a = a.cons(b.head); b = b.tail }
+      else
+        (self.size - n).times { b = b.cons(a.head); a = a.tail }
+      end
+
+      self.class.alloc(a, b)
+    end
+
     # Return a new `Deque` with `item` added at the end.
     #
     # @example
-    #   Immutable::Deque["A", "B", "C"].add("Z")
+    #   Immutable::Deque["A", "B", "C"].push("Z")
     #   # => Immutable::Deque["A", "B", "C", "Z"]
     #
     # @param item [Object] The item to add
@@ -180,6 +208,13 @@ module Immutable
       self.class.empty
     end
 
+    # Return a new `Deque` with the same items, but in reverse order.
+    #
+    # @return [Deque]
+    def reverse
+      self.class.alloc(@rear, @front)
+    end
+
     # Return true if `other` has the same type and contents as this `Deque`.
     #
     # @param other [Object] The collection to compare with

data/lib/immutable/enumerable.rb

@@ -107,7 +107,7 @@ module Immutable
     # Return true if `other` contains the same elements, in the same order.
     # @return [Boolean]
     def ==(other)
-      self.eql?(other) || other.respond_to?(:to_ary) && to_ary.eql?(other.to_ary)
+      self.eql?(other) || (other.respond_to?(:to_ary) && to_ary == other.to_ary)
     end
 
     # Convert all the elements into strings and join them together, separated by

data/lib/immutable/hash.rb

@@ -771,7 +771,7 @@ module Immutable
     # @param other [Object] The object to compare with
     # @return [Boolean]
     def ==(other)
-      self.eql?(other) || (other.respond_to?(:to_hash) && to_hash.eql?(other.to_hash))
+      self.eql?(other) || (other.respond_to?(:to_hash) && to_hash == other.to_hash)
     end
 
     # Return true if this `Hash` is a proper superset of `other`, which means

data/lib/immutable/trie.rb

@@ -10,8 +10,8 @@ module Immutable
     # Returns the number of key-value pairs in the trie.
     attr_reader :size
 
-    def initialize(significant_bits, size = 0, entries = [], children = [])
-      @significant_bits = significant_bits
+    def initialize(bitshift, size = 0, entries = [], children = [])
+      @bitshift = bitshift
       @entries = entries
       @children = children
       @size = size
@@ -19,7 +19,7 @@ module Immutable
 
     # Returns <tt>true</tt> if the trie contains no key-value pairs.
     def empty?
-      size == 0
+      @size == 0
     end
 
     # Returns <tt>true</tt> if the given key is present in the trie.
@@ -29,15 +29,7 @@ module Immutable
 
     # Calls <tt>block</tt> once for each entry in the trie, passing the key-value pair as parameters.
     def each(&block)
-      # TODO: Using block.call here is slower than using yield by 5-10%, but
-      # the latter segfaults on ruby 2.2 and above. Once that is fixed and
-      # broken versions are sufficiently old, we should revert back to yield
-      # with a warning that the broken versions are unsupported.
-      #
-      # For more context:
-      # * https://bugs.ruby-lang.org/issues/11451
-      # * https://github.com/hamstergem/hamster/issues/189
-      @entries.each { |entry| block.call(entry) if entry }
+      @entries.each { |entry| yield entry if entry }
       @children.each do |child|
         child.each(&block) if child
       end
@@ -65,7 +57,7 @@ module Immutable
 
     # @return [Trie] A copy of `self` with the given value associated with the
     #   key (or `self` if no modification was needed because an identical
-    #   key-value pair wes already stored
+    #   key-value pair was already stored
     def put(key, value)
       index = index_for(key)
       entry = @entries[index]
@@ -74,7 +66,7 @@ module Immutable
         entries = @entries.dup
         key = key.dup.freeze if key.is_a?(String) && !key.frozen?
         entries[index] = [key, value].freeze
-        Trie.new(@significant_bits, @size + 1, entries, @children)
+        Trie.new(@bitshift, @size + 1, entries, @children)
       elsif entry[0].eql?(key)
         if entry[1].equal?(value)
           self
@@ -82,7 +74,7 @@ module Immutable
           entries = @entries.dup
           key = key.dup.freeze if key.is_a?(String) && !key.frozen?
           entries[index] = [key, value].freeze
-          Trie.new(@significant_bits, @size, entries, @children)
+          Trie.new(@bitshift, @size, entries, @children)
         end
       else
         child = @children[index]
@@ -94,12 +86,12 @@ module Immutable
             children = @children.dup
             children[index] = new_child
             new_self_size = @size + (new_child.size - child.size)
-            Trie.new(@significant_bits, new_self_size, @entries, children)
+            Trie.new(@bitshift, new_self_size, @entries, children)
           end
         else
           children = @children.dup
-          children[index] = Trie.new(@significant_bits + 5).put!(key, value)
-          Trie.new(@significant_bits, @size + 1, @entries, children)
+          children[index] = Trie.new(@bitshift + 5).put!(key, value)
+          Trie.new(@bitshift, @size + 1, @entries, children)
         end
       end
     end
@@ -141,14 +133,14 @@ module Immutable
             end
           else
             new_children ||= @children.dup
-            new_children[index] = Trie.new(@significant_bits + 5).put!(key, value)
+            new_children[index] = Trie.new(@bitshift + 5).put!(key, value)
             new_size += 1
           end
         end
       end
 
       if new_entries || new_children
-        Trie.new(@significant_bits, new_size, new_entries || @entries, new_children || @children)
+        Trie.new(@bitshift, new_size, new_entries || @entries, new_children || @children)
       else
         self
       end
@@ -172,7 +164,7 @@ module Immutable
           @children[index] = child.put!(key, value)
           @size += child.size - old_child_size
         else
-          @children[index] = Trie.new(@significant_bits + 5).put!(key, value)
+          @children[index] = Trie.new(@bitshift + 5).put!(key, value)
           @size += 1
         end
       end
@@ -193,7 +185,7 @@ module Immutable
 
     # Returns a copy of <tt>self</tt> with the given key (and associated value) deleted. If not found, returns <tt>self</tt>.
     def delete(key)
-      find_and_delete(key) || Trie.new(@significant_bits)
+      find_and_delete(key) || Trie.new(@bitshift)
     end
 
     # Delete multiple elements from a Trie.  This is more efficient than
@@ -238,7 +230,7 @@ module Immutable
       end
 
       if new_entries || new_children
-        Trie.new(@significant_bits, new_size, new_entries || @entries, new_children || @children)
+        Trie.new(@bitshift, new_size, new_entries || @entries, new_children || @children)
       else
         self
       end
@@ -297,7 +289,7 @@ module Immutable
             children = @children.dup
             children[index] = copy
             new_size = @size - (child.size - copy_size(copy))
-            return Trie.new(@significant_bits, new_size, @entries, children)
+            return Trie.new(@bitshift, new_size, @entries, children)
           end
         end
       end
@@ -318,14 +310,14 @@ module Immutable
         else
           entries[index] = nil
         end
-        Trie.new(@significant_bits, @size - 1, entries, children || @children)
+        Trie.new(@bitshift, @size - 1, entries, children || @children)
       end
     end
 
     private
 
     def index_for(key)
-      (key.hash.abs >> @significant_bits) & 31
+      (key.hash.abs >> @bitshift) & 31
     end
 
     def copy_size(copy)
@@ -334,5 +326,5 @@ module Immutable
   end
 
   # @private
-  EmptyTrie = Trie.new(0)
+  EmptyTrie = Trie.new(0).freeze
 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.3"
+  VERSION = "0.0.4"
 end

data/spec/lib/immutable/deque/dequeue_spec.rb

@@ -26,7 +26,7 @@ describe Immutable::Deque do
     context "on empty subclass" do
       let(:subclass) { Class.new(Immutable::Deque) }
       let(:empty_instance) { subclass.new }
-      it "returns emtpy object of same class" do
+      it "returns empty object of same class" do
         empty_instance.send(method).class.should be subclass
       end
     end

data/spec/lib/immutable/deque/rotate_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+
+describe Immutable::Deque do
+
+  # Deques can have items distributed differently between the 'front' and 'rear' lists
+  #   and still be equivalent
+  # Since the implementation of #rotate depends on how items are distributed between the
+  #   two lists, we need to test both the case where most items are on the 'front' and
+  #   where most are on the 'rear'
+  big_front = D.alloc(L.from_enum([1, 2, 3]), L.from_enum([5, 4]))
+  big_rear  = D.alloc(L.from_enum([1, 2]), L.from_enum([5, 4, 3]))
+
+  describe "#rotate" do
+    [
+      [[], 9999, []],
+      [['A'], -1, ['A']],
+      [['A', 'B', 'C'], -1, ['B', 'C', 'A']],
+      [['A', 'B', 'C', 'D'], 0, ['A', 'B', 'C', 'D']],
+      [%w[A B C D], 2, %w[C D A B]],
+    ].each do |values, rotation, expected|
+      context "on #{values.inspect}" do
+        let(:deque) { D[*values] }
+
+        it "preserves the original" do
+          deque.rotate(rotation)
+          deque.should eql(D[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          deque.rotate(rotation).should eql(D[*expected])
+        end
+
+        it "returns a frozen instance" do
+          deque.rotate(rotation).should be_frozen
+        end
+      end
+    end
+
+    context "on a Deque with most items on 'front' list" do
+      it "works with a small rotation" do
+        big_front.rotate(2).should eql(D[4, 5, 1, 2, 3])
+      end
+
+      it "works with a larger rotation" do
+        big_front.rotate(4).should eql(D[2, 3, 4, 5, 1])
+      end
+    end
+
+    context "on a Deque with most items on 'rear' list" do
+      it "works with a small rotation" do
+        big_rear.rotate(2).should eql(D[4, 5, 1, 2, 3])
+      end
+
+      it "works with a larger rotation" do
+        big_rear.rotate(4).should eql(D[2, 3, 4, 5, 1])
+      end
+    end
+
+    context "on empty subclass" do
+      let(:subclass) { Class.new(Immutable::Deque) }
+      let(:empty_instance) { subclass.new }
+      it "returns an empty object of the same class" do
+        empty_instance.rotate(1).class.should be subclass
+        empty_instance.rotate(-1).class.should be subclass
+      end
+    end
+  end
+end

data/spec/lib/immutable/hash/eql_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+require "bigdecimal"
 
 describe Immutable::Hash do
   let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
@@ -33,6 +34,11 @@ describe Immutable::Hash do
       instance = subclass.new("A" => "aye", "B" => "bee", "C" => "see")
       (hash == instance).should == true
     end
+
+    it "performs numeric conversions between floats and BigDecimals" do
+      expect(H[a: 0.0] == H[a: BigDecimal('0.0')]).to be true
+      expect(H[a: BigDecimal('0.0')] == H[a: 0.0]).to be true
+    end
   end
 
   [:eql?, :==].each do |method|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: immutable-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Alex Dowad
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-12 00:00:00.000000000 Z
+date: 2019-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -167,6 +167,7 @@ files:
 - spec/lib/immutable/deque/pretty_print_spec.rb
 - spec/lib/immutable/deque/push_spec.rb
 - spec/lib/immutable/deque/random_modification_spec.rb
+- spec/lib/immutable/deque/rotate_spec.rb
 - spec/lib/immutable/deque/shift_spec.rb
 - spec/lib/immutable/deque/size_spec.rb
 - spec/lib/immutable/deque/to_a_spec.rb
@@ -504,8 +505,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Efficient, immutable, thread-safe collection classes for Ruby
@@ -606,6 +606,7 @@ test_files:
 - spec/lib/immutable/deque/copying_spec.rb
 - spec/lib/immutable/deque/pop_spec.rb
 - spec/lib/immutable/deque/to_a_spec.rb
+- spec/lib/immutable/deque/rotate_spec.rb
 - spec/lib/immutable/deque/marshal_spec.rb
 - spec/lib/immutable/set/difference_spec.rb
 - spec/lib/immutable/set/disjoint_spec.rb