cow_proxy 0.2.2 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c1dc57faf10fbc39c1d95e9a43da5d5cbde931cb46be01d479c192949ae607c
-  data.tar.gz: 336d11aa720b1e41408d9849c922584dc3867f3c838d7c695be157b6ffd489b4
+  metadata.gz: cfbd6c5980cadda3b7c607c1ce3abd0a29d7d59094a3a8c58e6c3d0ba1d2f887
+  data.tar.gz: 2b64b690e0a63f964a75efbc8a9f7aac30ed151747ec756802d6d7c059214148
 SHA512:
-  metadata.gz: 15335c75aadb3656ec1c88b7b2afabce03b4d6a5fe3e018317a655bccda2a914a8261e8f98719c433c7c43d584e70d8c48ef63c6d61e980d506387b72b8ec6f0
-  data.tar.gz: 3cb31d2fa247cafeb2c530dc931f3ebe2907a2b22ecfcf4f0a460b9b13a6a0c533d6e4967a88c75f7381f8c5d342aa52fce9aa14b6323487f076ed21fdc0ced5
+  metadata.gz: 71b0c69acbad373ce1b7344474423bfa15e4c008a2b8c73ef256af9aa0b6893dd99e0efef4aa491c01be39e71846015f8486c8ed595f849edfef1b5a588ea7eb
+  data.tar.gz: da7b070003fb7602dd7032d59d7278b18607088f68d0f8432908d6c40c68aa2a40e31f9c693e876182af21ef9e1316ef25bb92a10295b56fe1053db65888f8c2

data/README.md

@@ -27,7 +27,7 @@ CowProxy.wrap(obj)
 
 It doesn't need to be a frozen object, it can be frozen later or only have references to frozen objects, but no object will be duplicated until some change is requested on frozen object.
 
-To create a CowProxy class for custom class, create a new class which inherits from CowProxy::WrapClass(CustomClass):
+To create a CowProxy class for custom class, create a new class which inherits from `CowProxy::WrapClass(CustomClass)`:
 
 ```ruby
 module YourModule
@@ -40,7 +40,7 @@ obj.freeze
 proxy = CowProxy.wrap(obj)
 ```
 
-You can create proxy in CowProxy module too:
+You can create proxy in `CowProxy` module too:
 
 ```ruby
 module CowProxy
@@ -49,9 +49,9 @@ module CowProxy
 end
 ```
 
-If your custom class has some getters with arguments, such as [] method of Array or Hash, you will have to define it in your Proxy so it wraps returned values and memoizes them, and override _copy_on_write to set memoized proxies to duplicated object. Wrapped object can be accessed from proxy with \__getobj\__ method. You can see an example in CowProxy::Indexable module, which is used for Array and Hash classes.
+If your custom class has some getters with arguments, such as `[]` method of `Array` or `Hash`, you will have to define it in your Proxy so it wraps returned values and memoizes them, and override `__copy_on_write__` to set memoized proxies to duplicated object. Wrapped object can be accessed from proxy with `__getobj__` method. You can see an example in `CowProxy::Indexable` module, which is used for `Array` and `Hash` classes.
  
-If your custom class inherits from a class with CowProxy class, you don't need to create an own class, unless you need to override some method. But you must inherit from WrapClass(CustomClass) so your new proxy class is registered:
+If your custom class inherits from a class with `CowProxy` class, you don't need to create an own class, unless you need to override some method. But you must inherit from `WrapClass(CustomClass)` so your new proxy class is registered:
  
  ```ruby
 module CowProxy
@@ -75,7 +75,7 @@ module CowProxy
       @custom_var = {}
     end
 
-    def _copy_on_write(*)
+    def __copy_on_write__(*)
       super.tap do
         if @custom_var
           @custom_var.each do |k, v|

data/lib/cow_proxy.rb

@@ -10,14 +10,10 @@
 #   obj = CustomClass.new
 #   obj.freeze
 #   proxy = CowProxy.wrap(obj)
-
 module CowProxy
   autoload :Enumerable, 'cow_proxy/enumerable.rb'
   autoload :Indexable, 'cow_proxy/indexable.rb'
   class << self
-    # @!visibility private
-    @@wrapper_classes = {}
-
     # Create new proxy class for klass, with copy on write enabled.
     #
     # In other case CowProxy will wrap objects of klass without copy on write
@@ -30,8 +26,8 @@ module CowProxy
     #   end
     #
     # @return new proxy class, so it can be used to create a class which inherits from it
-    def WrapClass(klass)
-      _WrapClass(klass)
+    def WrapClass(klass) # rubocop:disable Naming/MethodName
+      _wrap_class(klass)
     end
 
     # Register proxy to be used when wrapping an object of klass.
@@ -43,8 +39,10 @@ module CowProxy
     #
     # @return proxy_klass
     def register_proxy(klass, proxy_klass)
-      debug { "register proxy for #{klass} with #{proxy_klass}#{" < #{proxy_klass.superclass}" if proxy_klass}" } unless @@wrapper_classes[klass]
-      @@wrapper_classes[klass] ||= proxy_klass
+      return if @wrapper_classes&.dig(klass)
+      debug { "register proxy for #{klass} with #{proxy_klass}#{" < #{proxy_klass.superclass}" if proxy_klass}" }
+      @wrapper_classes ||= {}
+      @wrapper_classes[klass] = proxy_klass
     end
 
     # Returns a proxy wrapping obj, using registered class for obj's class.
@@ -67,10 +65,10 @@ module CowProxy
     #   if none is registered
     def wrapper_class(obj)
       # only classes with defined wrapper and Structs has COW enabled by default
-      if @@wrapper_classes.has_key?(obj.class)
-        @@wrapper_classes[obj.class]
+      if @wrapper_classes&.has_key?(obj.class)
+        @wrapper_classes[obj.class]
       else
-        _WrapClass(obj.class, obj.class < Struct, true)
+        _wrap_class(obj.class, obj.class < ::Struct, true)
       end
     end
 
@@ -87,38 +85,56 @@ module CowProxy
     end
 
     private
-    def _WrapClass(klass, cow = true, register = false)
-      proxy_superclass = get_proxy_klass_for(klass.superclass) || Base
-      debug { "create new proxy class for #{klass}#{" from #{proxy_superclass}" if proxy_superclass}" }
+
+    def _wrap_class(klass, cow = true, register = false)
+      proxy_superclass = get_proxy_klass_for(klass.superclass)
+      debug { "create new proxy class for #{klass} from #{proxy_superclass} with#{'out' unless cow} cow" }
       proxy_klass = Class.new(proxy_superclass) do |k|
         k.wrapped_class = klass
       end
       register_proxy klass, proxy_klass if register
-      methods = klass.instance_methods
-      methods -= [:__copy_on_write__, :__wrap__, :__wrapped_value__, :__wrapped_method__, :__getobj__, :enum_for, :send, :===, :frozen?]
-      methods -= proxy_superclass.wrapped_class.instance_methods if proxy_superclass.wrapped_class
-      methods -= [:inspect] if ENV['DEBUG']
+      define_case_equality klass
 
+      methods = methods_to_wrap(klass, proxy_superclass)
       proxy_klass.module_eval do
         methods.each do |method|
           define_method method, proxy_klass.wrapping_block(method, cow)
         end
       end
-      proxy_klass.define_singleton_method :public_instance_methods do |all=true|
+      proxy_klass.define_singleton_method :public_instance_methods do |all = true|
         super(all) - klass.protected_instance_methods
       end
-      proxy_klass.define_singleton_method :protected_instance_methods do |all=true|
+      proxy_klass.define_singleton_method :protected_instance_methods do |all = true|
         super(all) | klass.protected_instance_methods
       end
       proxy_klass
     end
 
+    # fix case equality for wrapped objects, kind_of?(klass) works, but klass === was failing
+    def define_case_equality(klass)
+      class << klass
+        def ===(other)
+          CowProxy::Base === other ? other.kind_of?(self) : super(other) # rubocop:disable Style/CaseEquality,Style/ClassCheck
+        end
+      end
+    end
+
+    def methods_to_wrap(klass, proxy_superclass)
+      methods = klass.instance_methods
+      methods -= %i[__copy_on_write__ __wrap__ __wrapped_value__ __wrapped_method__ __getobj__
+                    __copy_parent__ enum_for send === frozen?]
+      methods -= proxy_superclass.wrapped_class.instance_methods if proxy_superclass.wrapped_class
+      methods -= [:inspect] if ENV['DEBUG']
+      methods
+    end
+
     def get_proxy_klass_for(klass)
-      wrapper = nil
+      proxy_klass = nil
       klass.ancestors.each do |ancestor|
-        wrapper = @@wrapper_classes[ancestor] and break
+        proxy_klass = @wrapper_classes&.dig ancestor
+        break if proxy_klass
       end
-      wrapper
+      proxy_klass || Base
     end
   end
 end
@@ -128,19 +144,16 @@ end
   CowProxy.register_proxy klass, nil
 end
 
-if 1.class == Integer
+if 1.instance_of? Integer
   CowProxy.register_proxy Integer, nil
 else
-  if defined? Fixnum
-    CowProxy.register_proxy Fixnum, nil
-  end
-  if defined? Bignum
-    CowProxy.register_proxy Bignum, nil
-  end
+  CowProxy.register_proxy Fixnum, nil if defined? Fixnum
+  CowProxy.register_proxy Bignum, nil if defined? Bignum
 end
 
 require 'cow_proxy/base.rb'
 require 'cow_proxy/array.rb'
 require 'cow_proxy/hash.rb'
 require 'cow_proxy/string.rb'
+require 'cow_proxy/struct.rb'
 require 'cow_proxy/set.rb'

data/lib/cow_proxy/base.rb

@@ -17,6 +17,7 @@ module CowProxy
       end
 
       protected
+
       # Return block with proxy implementation.
       #
       # Block calls a method in wrapped object
@@ -28,11 +29,12 @@ module CowProxy
       # @return [Proc] Block with proxy implementation.
       def wrapping_block(method, cow_enabled)
         lambda do |*args, &block|
-          inst_var = "@#{method}" if method.to_s =~ /^\w+$/
-          return _instance_variable_get(inst_var) if inst_var && _instance_variable_defined?(inst_var)
-          if method.to_s =~ /^(\w+)=$/ && _instance_variable_defined?("@#{$1}")
-            CowProxy.debug { "remove #{$1}" }
-            _remove_instance_variable "@#{$1}"
+          if method.to_s =~ /^\w+$/
+            inst_var = "@#{method}"
+            return _instance_variable_get(inst_var) if _instance_variable_defined?(inst_var)
+          elsif method.to_s =~ /^(\w+)=$/ && _instance_variable_defined?("@#{Regexp.last_match(1)}")
+            CowProxy.debug { "remove #{Regexp.last_match(1)}" }
+            _remove_instance_variable "@#{Regexp.last_match(1)}"
           end
           __wrapped_method__(inst_var, cow_enabled, method, *args, &block)
         end
@@ -53,6 +55,7 @@ module CowProxy
     end
 
     protected
+
     # Replace wrapped object with a copy, so object can
     # be modified.
     #
@@ -63,56 +66,63 @@ module CowProxy
     def __copy_on_write__(parent = true)
       CowProxy.debug { "copy on write on #{__getobj__.class.name}" }
       return @delegate_dc_obj if @dc_obj_duplicated
-      @delegate_dc_obj = @delegate_dc_obj.dup.tap do |new_target|
-        @dc_obj_duplicated = true
-        if parent && @parent_proxy
-          @parent_proxy.send :__copy_on_write__, false
-          if @parent_var
-            parent_dc = @parent_proxy._instance_variable_get(:@delegate_dc_obj)
-            method = @parent_var[1..-1] + '='
-            parent_dc.send(method, new_target)
-          end
-        end
-      end
+      @delegate_dc_obj = @delegate_dc_obj.dup
+      @dc_obj_duplicated = true
+      __copy_parent__ if parent && @parent_proxy
+      @delegate_dc_obj
     end
 
     private
+
     def __getobj__
       @delegate_dc_obj
     end
 
+    def __copy_parent__
+      @parent_proxy.send :__copy_on_write__, false
+      return unless @parent_var
+      parent_dc = @parent_proxy._instance_variable_get(:@delegate_dc_obj)
+      method = @parent_var[1..-1] + '='
+      parent_dc.send(method, @delegate_dc_obj)
+    end
+
     def __wrap__(value, inst_var = nil)
-      if value.frozen?
-        CowProxy.debug { "wrap #{value.class.name} with parent #{__getobj__.class.name}" }
-        wrap_klass = CowProxy.wrapper_class(value)
-        wrap_value = wrap_klass.new(value, self, inst_var) if wrap_klass
-        _instance_variable_set(inst_var, wrap_value) if inst_var && wrap_value
-        wrap_value
-      end
+      return unless value.frozen?
+      CowProxy.debug { "wrap #{value.class.name} with parent #{__getobj__.class.name}" }
+      wrap_klass = CowProxy.wrapper_class(value)
+      wrap_value = wrap_klass&.new(value, self, inst_var)
+      _instance_variable_set(inst_var, wrap_value) if inst_var && wrap_value
+      wrap_value
     end
 
     def __wrapped_value__(inst_var, method, *args, &block)
-      CowProxy.debug { "run on #{__getobj__.class.name} (#{__getobj__.object_id}) #{method} #{args.inspect unless args.empty?}" }
+      CowProxy.debug do
+        "run on #{__getobj__.class.name} (#{__getobj__.object_id}) "\
+        "#{method} #{args.inspect unless args.empty?}"
+      end
       value = __getobj__.__send__(method, *args, &block)
-      wrap_value = __wrap__(value, inst_var) if inst_var && args.empty? && block.nil?
+      wrap_value = __wrap__(value, inst_var) if inst_var && args.empty? && !block
       wrap_value || value
     end
 
     def __wrapped_method__(inst_var, cow, method, *args, &block)
       __wrapped_value__(inst_var, method, *args, &block)
-    rescue => e
-      CowProxy.debug { "error #{e.message} on #{__getobj__.class.name} (#{__getobj__.object_id}) #{method} #{args.inspect unless args.empty?} with#{'out' unless cow} cow" }
+    rescue StandardError => e
+      CowProxy.debug do
+        "error #{e.message} on #{__getobj__.class.name} (#{__getobj__.object_id}) #{method} "\
+        "#{args.inspect unless args.empty?} with#{'out' unless cow} cow"
+      end
       raise unless cow && e.message =~ /^can't modify frozen/
-      CowProxy.debug { "copy on write to run #{method} #{args.inspect unless args.empty?} (#{e.message})" }
+      CowProxy.debug { "copy on write to run #{method}" }
       __copy_on_write__
       CowProxy.debug { "new target #{__getobj__.class.name} (#{__getobj__.object_id})" }
       __wrapped_value__(inst_var, method, *args, &block)
     end
 
-    alias :_instance_variable_get :instance_variable_get
-    alias :_instance_variable_set :instance_variable_set
-    alias :_remove_instance_variable :remove_instance_variable
-    alias :_instance_variable_defined? :instance_variable_defined?
-    alias :_instance_variables? :instance_variable_defined?
+    alias _instance_variable_get instance_variable_get
+    alias _instance_variable_set instance_variable_set
+    alias _remove_instance_variable remove_instance_variable
+    alias _instance_variable_defined? instance_variable_defined?
+    alias _instance_variables instance_variables
   end
-end
+end

data/lib/cow_proxy/enumerable.rb

@@ -51,6 +51,7 @@ module CowProxy
     end
 
     private
+
     def mutable_selector(method, &block)
       return send(method) unless block
       @delegate_dc_obj = send(method, &block).tap do

data/lib/cow_proxy/hash.rb

@@ -60,6 +60,13 @@ module CowProxy
       map(&:last)
     end
 
+    # Returns true if the given key is present in hash.
+    #
+    # @return [Array] Wrapped values from hash
+    def include?(key)
+      key?(key)
+    end
+
     # Used for merging into another Hash
     # needs to return unwrapped Hash
     #

data/lib/cow_proxy/indexable.rb

@@ -9,7 +9,7 @@ module CowProxy
     #
     # @return CowProxy wrapped value from wrapped object
     def [](index)
-      return @hash[index] if @hash && @hash.has_key?(index)
+      return @hash[index] if @hash&.has_key?(index)
 
       begin
         value = __getobj__[index]
@@ -20,6 +20,15 @@ module CowProxy
       end
     end
 
+    # Extracts the nested value specified by the sequence of idx objects by calling dig
+    # at each step, returning nil if any intermediate step is nil.
+    #
+    # @return CowProxy wrapped value from wrapped object
+    def dig(key, *args)
+      value = self[key]
+      args.empty? ? value : value&.dig(*args)
+    end
+
     # Extends {CowProxy::Base#initialize}
     def initialize(*)
       super
@@ -27,6 +36,7 @@ module CowProxy
     end
 
     protected
+
     # Copy wrapped values to duplicated wrapped object
     # @see CowProxy::Base#__copy_on_write__
     # @return duplicated wrapped object

data/lib/cow_proxy/set.rb

@@ -4,5 +4,4 @@ module CowProxy
   # Wrapper class for Set
   class Set < WrapClass(::Set)
   end
-
 end

data/lib/cow_proxy/struct.rb

@@ -0,0 +1,13 @@
+module CowProxy
+  # Wrapper class for Struct
+  class Struct < WrapClass(::Struct)
+    # Extracts the nested value specified by the sequence of idx objects by
+    # calling dig at each step, returning nil if any intermediate step is nil.
+    #
+    # @return CowProxy wrapped value from wrapped object
+    def dig(key, *args)
+      value = send(key)
+      args.empty? ? value : value&.dig(*args)
+    end
+  end
+end

data/lib/cow_proxy/version.rb

@@ -1,8 +1,8 @@
 module CowProxy
   module Version
     MAJOR = 0
-    MINOR = 2
-    PATCH = 2
+    MINOR = 3
+    PATCH = 1
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cow_proxy
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.1
 platform: ruby
 authors:
 - Sergio Cambra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-25 00:00:00.000000000 Z
+date: 2019-03-29 00:00:00.000000000 Z
 dependencies: []
 description: Make a COW proxy for a frozen object (or deep frozen), it will delegate
   every read method to proxied object, wrap value in COW proxy if frozen. Trying to
@@ -29,6 +29,7 @@ files:
 - lib/cow_proxy/indexable.rb
 - lib/cow_proxy/set.rb
 - lib/cow_proxy/string.rb
+- lib/cow_proxy/struct.rb
 - lib/cow_proxy/version.rb
 homepage: http://github.com/Programatica/cow_proxy
 licenses:
@@ -42,7 +43,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="