around_the_world 0.6.0.pre → 0.6.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27a886d37bde56a1c6edb2c15b966cda10a449c0212d5133e7678109ffe25d10
-  data.tar.gz: 35bf0553fdf79e411fce5dc412075f3daff8d2e61eae3361525110f43f9e6b5a
+  metadata.gz: 5ad71c73cc26ec0d9e5690f03242530c9b56d5f2b54923866e341abab656ccd1
+  data.tar.gz: 5274bc644da8e1ecc75fd50fab63cb21f3f630c293eb5e40e5be9f159feacbcf
 SHA512:
-  metadata.gz: 0673b719dc14327044758b00bc15419d2913b76b81393ebe4840bd9d22ba60f63d74842013b0c4aefdae0a23b232cb19b2b5fef84c5930e9e0bda3f36c72d56d
-  data.tar.gz: 57612955ef4da508567167eea0c6398060b7a40992baf8a99cb84033e8981c62b43beda02e95d2b3070ebe89f632e8b9d67e8c4d69c930463f91c5c8c9b187f8
+  metadata.gz: 8da4f44efc3e95c39d1e30d435d1641faeb52f929c44d41e675ce076fd0a3698b45bd2a17ead4597f5c302dd85e4f506cc2930a1a1b1b37b3bbfac17f6a6adbb
+  data.tar.gz: 655b51406c29c5f6699bf375b201287e8cf71fed081ae49944f76a0cbfc24595d3b5567f61601f9168fcaa1872f738cc28f7d67be7ae7b0d2605bb45818eadc5

data/lib/around_the_world.rb

@@ -2,7 +2,6 @@
 
 require_relative "around_the_world/errors"
 require_relative "around_the_world/method_wrapper"
-require_relative "around_the_world/rewrapper"
 require_relative "around_the_world/proxy_module"
 require_relative "around_the_world/version"
 require "active_support/concern"
@@ -60,32 +59,13 @@ module AroundTheWorld
     # @param method_name [Symbol]
     # @param :prevent_double_wrapping_for [Object]
     #   If defined, this prevents wrapping the method twice for a given purpose. Accepts any argument.
-    # @param :wrap_subclasses [Boolean]
-    #   If true, the given method will still be wrapped by the given block in subclasses that override the given method.
-    #   If false, subclasses that override the method will also override the wrapping block.
-    #   Default: false
-    def around_method(method_name, prevent_double_wrapping_for: nil, wrap_subclasses: false, &block)
+    def around_method(method_name, prevent_double_wrapping_for: nil, &block)
       MethodWrapper.wrap(
         method_name: method_name,
         target: self,
         prevent_double_wrapping_for: prevent_double_wrapping_for,
-        wrap_subclasses: wrap_subclasses,
         &block
       )
-
-      descendants.each { |child| Rewrapper.rewrap(child, proxy_modules_for_subwrapping) }
-    end
-
-    def inherited(child)
-      super
-
-      Rewrapper.rewrap(child, proxy_modules_for_subwrapping)
-    end
-
-    private
-
-    def proxy_modules_for_subwrapping
-      ancestors.select { |mod| mod.is_a?(ProxyModule) && self < mod && mod.wraps_subclasses? }
     end
   end
 end

data/lib/around_the_world/method_wrapper.rb

@@ -23,19 +23,14 @@ module AroundTheWorld
     #   An identifier to define the proxy module's purpose in the ancestor tree.
     #   A method can only be wrapped once for a given purpose, though it can be wrapped
     #   again for other purposes, or for no given purpose.
-    # @param :wrap_subclasses [Boolean]
-    #   If true, the given method will still be wrapped by the given block in subclasses that override the given method.
-    #   If false, subclasses that override the method will also override the wrapping block.
-    #   Default: false
     # @block The block that will be executed when the method is invoked.
     #        Should always call super, at least conditionally.
-    def initialize(method_name:, target:, prevent_double_wrapping_for: nil, wrap_subclasses: false, &block)
+    def initialize(method_name:, target:, prevent_double_wrapping_for: nil, &block)
       raise TypeError, "target must be a module or a class" unless target.is_a?(Module)
 
       @method_name = method_name.to_sym
       @target = target
       @prevent_double_wrapping_for = prevent_double_wrapping_for || nil
-      @wrap_subclasses = wrap_subclasses
       @block = block
     end
 
@@ -50,16 +45,12 @@ module AroundTheWorld
 
     private
 
-    attr_reader :prevent_double_wrapping_for, :wrap_subclasses, :block
+    attr_reader :prevent_double_wrapping_for, :block
 
     def prevent_double_wrapping?
       prevent_double_wrapping_for.present?
     end
 
-    def wrap_subclasses?
-      wrap_subclasses.present?
-    end
-
     def ensure_method_defined!
       return if target.instance_methods(true).include?(method_name) || target.private_method_defined?(method_name)
 
@@ -95,7 +86,7 @@ module AroundTheWorld
 
     # @return [AroundTheWorld::ProxyModule] The proxy module upon which the method wrapper will be defined
     def proxy_module
-      @proxy_module ||= proxy_module_with_purpose(method_name, target, prevent_double_wrapping_for, wrap_subclasses?)
+      @proxy_module ||= proxy_module_with_purpose(method_name, target, prevent_double_wrapping_for)
     end
   end
 end

data/lib/around_the_world/method_wrapper/proxy_creation.rb

@@ -13,16 +13,14 @@ module AroundTheWorld
 
       # @return [AroundTheWorld::ProxyModule] Either an already-defined proxy module for the given purpose,
       #                                       or a new proxy module if one does not exist for the given purpose.
-      def proxy_module_with_purpose(method_name, target, purpose, wrap_subclasses)
-        existing_proxy_module_with_purpose(method_name, target, purpose, wrap_subclasses) ||
-          ProxyModule.new(purpose: purpose, wrap_subclasses: wrap_subclasses?)
+      def proxy_module_with_purpose(method_name, target, purpose)
+        existing_proxy_module_with_purpose(method_name, target, purpose) ||
+          ProxyModule.new(purpose: purpose)
       end
 
-      def existing_proxy_module_with_purpose(method_name, target, purpose, wrap_subclasses)
+      def existing_proxy_module_with_purpose(method_name, target, purpose)
         existing_proxy_modules(target).reverse_each.find do |ancestor|
-          ancestor.for?(purpose) &&
-            !ancestor.defines_proxy_method?(method_name) &&
-            ancestor.wraps_subclasses? == wrap_subclasses
+          ancestor.for?(purpose) && !ancestor.defines_proxy_method?(method_name)
         end
       end
 

data/lib/around_the_world/proxy_module.rb

@@ -4,29 +4,23 @@ module AroundTheWorld
   class ProxyModule < Module
     attr_reader :purpose
 
-    def initialize(purpose: nil, wrap_subclasses: false)
+    # @param :purpose [*] Any string, symbol or object that signifies a purpose for the ProxyModule,
+    #                     i.e. :memoization or SomeMemoizationGem.
+    def initialize(purpose: nil)
       @purpose = purpose unless purpose.blank?
-      @wrap_subclasses = wrap_subclasses
     end
 
     def for?(purpose)
       self.purpose == purpose
     end
 
-    def wraps_subclasses?
-      wrap_subclasses.present?
-    end
-
     def inspect
       "#<#{self.class.name}#{":#{purpose}" if purpose}>"
     end
 
+    # @return [Boolean] True if the ProxyModule defines aa method of the given name, regardless of its privacy.
     def defines_proxy_method?(method_name)
       instance_methods(true).include?(method_name.to_sym) || private_method_defined?(method_name.to_sym)
     end
-
-    private
-
-    attr_reader :wrap_subclasses
   end
 end

data/lib/around_the_world/version.rb

@@ -2,5 +2,5 @@
 
 module AroundTheWorld
   # This constant is managed by spicerack
-  VERSION = "0.6.0.pre"
+  VERSION = "0.6.0.pre2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: around_the_world
 version: !ruby/object:Gem::Version
-  version: 0.6.0.pre
+  version: 0.6.0.pre2
 platform: ruby
 authors:
 - Allen Rettberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-21 00:00:00.000000000 Z
+date: 2019-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -38,7 +38,6 @@ files:
 - lib/around_the_world/method_wrapper.rb
 - lib/around_the_world/method_wrapper/proxy_creation.rb
 - lib/around_the_world/proxy_module.rb
-- lib/around_the_world/rewrapper.rb
 - lib/around_the_world/version.rb
 homepage: https://www.freshly.com
 licenses:
@@ -59,8 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A metaprogramming module which allows you to wrap any method easily.

data/lib/around_the_world/rewrapper.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/array"
-require_relative "method_wrapper/proxy_creation"
-
-module AroundTheWorld
-  class Rewrapper
-    include MethodWrapper::ProxyCreation
-
-    private_class_method :new
-
-    class << self
-      def rewrap(target, proxy_modules)
-        new(target, proxy_modules).rewrap
-      end
-    end
-
-    attr_reader :target, :proxy_modules
-
-    def initialize(target, proxy_modules)
-      @target = target
-      @proxy_modules = Array.wrap(proxy_modules)
-    end
-
-    def rewrap
-      proxy_modules.each do |mod|
-        next if existing_proxy_modules(target).include?(mod)
-
-        target.prepend mod
-      end
-    end
-  end
-end