duck_puncher 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6050f09ba1e9b843078f3d6eb434b668da5687a8
-  data.tar.gz: 30a1083c6ccb5edfa9520e3f395b63c65b221040
+  metadata.gz: f945aea9eb0db7392e51aea5cda254eaad6d5815
+  data.tar.gz: fa1e7a2565caee23e437d38b60358f9fbf382901
 SHA512:
-  metadata.gz: fa163f85c3ec46d0a3071a4d9e75b3c2de14b37bcd5f29b8b8fe3b65d13e617f37f4740894e4fc393482c75a9aedeb25600da618e74469fc30341428512c7001
-  data.tar.gz: 86d3f879aba2e9e78694398d348a7b18e909931584dedf65617538b12e5c88344ef5b0bf0e711fc8899f7a1683e26d9b42400dd293803318d8e10b4371e618df
+  metadata.gz: 3c05f53aad5478fda527751c1cc3625cf6d0dad18397a08311610d56a13ada9fab6705623f7ae8fec63902636f78255cee3ad3fd892e9b0ada44c9132bba3d3e
+  data.tar.gz: b7310b2c603075ce345f24805bb4d2dc7211515c86b69dc0df775d8aa362cf723c656b3a22a8a0696d0a2fd1b6294e7b96c6a91511d26eb35ea61956865f74c4

data/README.md

@@ -3,29 +3,34 @@
 DuckPuncher provides an interface for administering __duck punches__ (a.k.a "monkey patches"). Punches can be administered in several ways: 
 
 * as an extension
-* as a subclass
+* as a decorator
 
 Default extensions:
 
 ```ruby
-Array   #m            => `[].m(:to_s)` => `[].map(&:to_s)`
-        #m!           => `[].m!(:upcase)` => `[].map!(&:upcase)`
-        #mm           => `[].mm(:sub, /[aeiou]/, '*')` => `[].map { |x| x.sub(/[aeiou]/, '*') }` 
-        #mm!          => `[].mm!(:sub, /[aeiou]/, '*')` => `[].map! { |x| x.sub(/[aeiou]/, '*') }` 
-        #except       => `[].except('foo', 'bar')` => `[] - ['foo', 'bar']`
-Hash    #dig          => `{a: 1, b: {c: 2}}.dig(:b, :c)` => 2 (Part of standard lib in Ruby >= 2.3)
-Numeric #to_currency  => `25.245.to_currency` => 25.25 
-        #to_duration  => `10_000.to_duration` => '2 h 46 min'
-        #to_time_ago  => `10_000.to_time_ago` => '2 hours ago'
-        #to_rad       => `10.15.to_rad` => 0.17715091907742445
-String  #pluralize    => `'hour'.pluralize(2)` => "hours"
-        #underscore   => `'DuckPuncher::JSONStorage'.underscore` => 'duck_puncher/json_storage'
-        #to_boolean   => `'1'.to_boolean` => true
-        #constantize  => `'MiniTest::Test'.constantize` => MiniTest::Test
-Object  #clone!       => `Object.new.clone!` => a deep clone of the object (using Marshal.dump)
-        #punch        => `'duck'.punch` => a copy of 'duck' with String punches mixed in
-Method  #to_instruct  => `Benchmark.method(:measure).to_instruct` returns the Ruby VM instruction sequence for the method
-        #to_source    => `Benchmark.method(:measure).to_source` returns the method definition as a string
+Array   #m                  => `[].m(:to_s)` => `[].map(&:to_s)`
+        #m!                 => `[].m!(:upcase)` => `[].map!(&:upcase)`
+        #mm                 => `[].mm(:sub, /[aeiou]/, '*')` => `[].map { |x| x.sub(/[aeiou]/, '*') }` 
+        #mm!                => `[].mm!(:sub, /[aeiou]/, '*')` => `[].map! { |x| x.sub(/[aeiou]/, '*') }` 
+        #except             => `[].except('foo', 'bar')` => `[] - ['foo', 'bar']`
+Hash    #dig                => `{a: 1, b: {c: 2}}.dig(:b, :c)` => 2 (Part of standard lib in Ruby >= 2.3)
+        #compact            => `{a: 1, b: nil}.compact` => {a: 1}
+Numeric #to_currency        => `25.245.to_currency` => 25.25 
+        #to_duration        => `10_000.to_duration` => '2 h 46 min'
+        #to_time_ago        => `10_000.to_time_ago` => '2 hours ago'
+        #to_rad             => `10.15.to_rad` => 0.17715091907742445
+String  #pluralize          => `'hour'.pluralize(2)` => "hours"
+        #underscore         => `'DuckPuncher::JSONStorage'.underscore` => 'duck_puncher/json_storage'
+        #to_boolean         => `'1'.to_boolean` => true
+        #constantize        => `'MiniTest::Test'.constantize` => MiniTest::Test
+Module  #local_methods      => `Kernel.local_methods` returns the methods defined directly in the class + nested constants w/ methods
+Object  #clone!             => `Object.new.clone!` => a deep clone of the object (using Marshal.dump)
+        #punch              => `'duck'.punch` => a copy of 'duck' with String punches mixed in
+        #punch!             => `'duck'.punch!` => destructive version applies extensions directly to the base object
+        #echo               => `'duck'.echo.upcase` => spits out the caller and value of the object and returns the object
+        #track              => `Object.new.track` => Traces methods calls to the object (requires [object_tracker](https://github.com/ridiculous/object_tracker), which it'll try to download)
+Method  #to_instruct        => `Benchmark.method(:measure).to_instruct` returns the Ruby VM instruction sequence for the method
+        #to_source          => `Benchmark.method(:measure).to_source` returns the method definition as a string
 ```
 
 ## Usage
@@ -39,13 +44,13 @@ DuckPuncher.punch_all!
 Punch individual ducks by name:
 
 ```ruby
-DuckPuncher.punch! :Hash, :Object
+DuckPuncher.punch! Hash, Object
 ```
 
 One method to rule them all:
 
 ```ruby
-DuckPuncher.punch! :Object, only: :punch 
+DuckPuncher.punch! Object, only: :punch 
 ```
 
 ### Tactical punches
@@ -53,34 +58,55 @@ DuckPuncher.punch! :Object, only: :punch
 `DuckPuncher` extends the amazing [Usable](https://github.com/ridiculous/usable) gem, so you can configure only the punches you want! For instance:
 
 ```ruby
-DuckPuncher.punch! :Numeric, only: [:to_currency, :to_duration]
+DuckPuncher.punch! Numeric, only: [:to_currency, :to_duration]
 ```
 
-Use `DuckPuncher.punch` to create a new class that __inherits__ from the original (automatically cached for future calls):
+If you punch `Object` then you can use `#punch!` on any object to extend individual instances:
 
 ```ruby
->> DuckPuncher.punch :String
-=> DuckPuncher::StringDuck
->> DuckPuncher::StringDuck.new('Yes').to_boolean
-=> true
->> String.new('Yes').respond_to? :to_boolean
-=> false
+>> DuckPuncher.punch! Object, only: :punch!
+>> %w[yes no 1].punch!.m!(:punch).m(:to_boolean)
+=> [true, false, true]
 ```
 
-If you punch `Object` then you can use `#punch` on any object to extend individual instances:
-
+Alternatively, there is also the `Object#punch` method which returns a decorated copy of an object with punches mixed in:
 ```ruby
->> DuckPuncher.punch! :Object, only: :punch
->> %w[yes no 1].punch.m!(:punch).m(:to_boolean)
-=> [true, false, true]
+>> DuckPuncher.punch! Object, only: :punch
+>> %w[1 2 3].punch.m(:to_i)
+=> [1, 2, 3]
 ```
 
-The `#punch` method will lookup the extension by the object's class name. The above example works because `:Array` and `:String` are default extensions. If you want to punch a specific extension, then you can specify it as an argument:
+The `#punch!` method will lookup the extension by the object's class name. The above example works because `Array` and `String` are default extensions. If you want to punch a specific extension, then you can specify it as an argument:
 ```ruby
 >> LovableDuck = Module.new { def inspect() "I love #{self.first}" end }
->> DuckPuncher.register :with_love, mod: 'LovableDuck'
->> %w[ducks].punch(:with_love)
+>> DuckPuncher.register Array, LovableDuck
+>> ducks = %w[ducks]
+>> soft_punch = ducks.punch
 => "I love ducks"
+>> soft_punch.class
+=> DuckPuncher::ArrayDelegator
+>> ducks.punch!.class
+=> Array
+```
+
+When there are no punches registered for a class, it'll search the ancestor list for a class with registered punches. For example, `Array` doesn't have
+a method defined `echo`, but when we punch `Object`, it means all subclasses have access to the same methods, even with soft punches.
+
+```ruby
+def soft_punch
+  ('a'..'z').punch.echo.to_a.map(&:upcase)
+end
+
+def hard_punch
+  ('a'..'z').to_a.punch!.m!(:upcase).mm!(:*, 3).echo
+end
+
+>> soft_punch
+"a..z -- (irb):8:in `soft_punch'"
+=> ["A", "B", "C", "D", ...]
+>> hard_punch
+"[\"AAA\", \"BBB\", \"CCC\", \"DDD\", ...] -- (irb):12:in `hard_punch'"
+=> ["AAA", "BBB", "CCC", "DDDD", ...]
 ```
 
 ### Registering custom punches
@@ -110,35 +136,21 @@ end
 ```
 
 ```ruby
-# Register the extensions
-DuckPuncher.register [:Billable, :Retryable]
-
 # Our duck
 class User < Struct.new(:name)
 end
 
+# Register the extensions
+DuckPuncher.register User, :Billable, :Retryable
+
 # Add the #punch method to User instances
-DuckPuncher.punch! :Object, only: :punch, target: User
+DuckPuncher.punch! Object, only: :punch
 
 # Usage
-user = User.new('Ryan').punch(:Billable).punch(:Retryable)
+user = User.new('Ryan').punch
 user.call_with_retry(19.99)
 ```
 
-Ducks can be registered under any name, as long as the `:mod` option specifies a module:
-
-```ruby
-DuckPuncher.register :bills, mod: 'Admin::Billable'
-User.new.punch(:bills)
-```
-
-When punching at a class level, the `:class` option is required:
-
-```ruby
-DuckPuncher.register :Billable, class: 'User'
-DuckPuncher.punch! :Billable
-```
-
 ## Install
 
 ```ruby
@@ -150,7 +162,7 @@ gem 'duck_puncher'
 Get notified of all punches/extensions by changing the logger level:
 
 ```ruby
-DuckPuncher.log.level = Logger::INFO
+DuckPuncher.logger.level = Logger::INFO
 ```
 
 The default log level is `DEBUG`
@@ -169,7 +181,7 @@ LoadError: cannot load such file -- pry
  from (irb):1:in `require'
  from (irb):1
  from bin/console:10:in `<main>'
->> DuckPuncher.punch! :Object, only: :require!
+>> DuckPuncher.punch! Object, only: :require!
 => nil
 >> require! 'pry'
 Fetching: method_source-0.8.2.gem (100%)

data/Rakefile

@@ -2,12 +2,12 @@ require 'bundler/gem_tasks'
 require 'rake'
 require 'rake/testtask'
 
-Rake::TestTask.new(:soft_punch_test) do |t|
-  t.pattern = 'test/soft_punch/*_test.rb'
-end
+# Rake::TestTask.new(:soft_punch_test) do |t|
+#   t.pattern = 'test/soft_punch/*_test.rb'
+# end
 
 Rake::TestTask.new(:hard_punch_test) do |t|
   t.pattern = 'test/lib/**/*_test.rb'
 end
 
-task default: [:soft_punch_test, :hard_punch_test]
+task default: [:hard_punch_test]

data/lib/duck_puncher/decoration.rb

@@ -0,0 +1,20 @@
+module DuckPuncher
+  module Decoration
+    def decorators
+      @decorators ||= ancestral_hash
+    end
+
+    def new_decorator(*ducks)
+      targets = ducks.sort.map(&:target)
+      decorator_class = DelegateClass(targets.first)
+      DuckPuncher.redefine_constant "#{targets.first.to_s.tr(':', '')}Delegator", decorator_class
+      ducks.each { |duck| duck.punch target: decorator_class, method: :prepend }
+      decorator_class
+    end
+
+    def undecorate(obj)
+      obj = obj.__getobj__ while obj.respond_to? :__getobj__
+      obj
+    end
+  end
+end

data/lib/duck_puncher/duck.rb

@@ -1,17 +1,17 @@
 module DuckPuncher
   class Duck
-    attr_accessor :name, :options
+    attr_accessor :target, :mod, :options
 
-    # @param [Symbol] name of the duck
+    # @todo test punching a module
+    # @param target [String,Class] Class or module to punch
+    # @param mod [String,Module] The module that defines the extensions (@name is used by default)
     # @param [Hash] options to modify the duck #punch method behavior
-    # @option options [String,Module] :mod The module that defines the extensions (@name is used by default)
-    # @option options [String,Class] :class (name) to punch
-    # @option options [Proc] :if Stops +punch+ if it returns false
-    # @option options [Proc] :before A hook that is called with the target class before +punch+
-    # @option options [Proc] :after A hook that is called with the target class after +punch+
-    def initialize(name, options = {})
-      @name = name
+    # @option options :before [Proc] A hook that is called with the target class before +punch+
+    # @option options :after [Proc] A hook that is called with the target class after +punch+
+    def initialize(target, mod, options = {})
       @options = options
+      @target = DuckPuncher.lookup_constant(target)
+      @mod = DuckPuncher.lookup_constant(mod)
     end
 
     # @param [Hash] opts to modify punch
@@ -20,11 +20,7 @@ module DuckPuncher
     # @option options [Symbol,String] :method Specifies if the methods should be included or prepended (:include)
     # @return [Class] The class that was just punched
     def punch(opts = {})
-      if options[:if] && !options[:if].call
-        DuckPuncher.log.info %Q(Skipping the punch for #{name}!)
-        return nil
-      end
-      target = opts.delete(:target) || lookup_class
+      target = opts.delete(:target) || self.target
       Array(target).each do |klass|
         options[:before].call(klass) if options[:before]
         klass.extend Usable
@@ -34,42 +30,24 @@ module DuckPuncher
       target
     end
 
-    def mod
-      if options[:mod]
-        lookup_constant(options[:mod])
-      else
-        DuckPuncher::Ducks.const_get(name)
-      end
-    end
-
-    # @return [Class] The class that is given to initialize as the option :class or the name of the current duck (module extension)
-    def lookup_class
-      lookup_constant(options[:class] || name)
-    end
-
-    def lookup_constant(const)
-      return const if Module === const
-      if const.to_s.respond_to?(:constantize)
-        const.to_s.constantize
-      else
-        const.to_s.split('::').inject(Object) { |k, part| k.const_get(part) }
-      end
-    end
-
-    def classify
-      Class.new(lookup_class).tap { |k| punch target: k }
-    end
-
     #
     # Required to play nice in a Set
     #
 
     def eql?(other)
-      name == other.name
+      "#{target}-#{mod}" == "#{other.target}-#{other.mod}"
     end
 
     def hash
-      name.hash
+      target.to_s.hash + mod.to_s.hash
+    end
+
+    #
+    # Required for sorting
+    #
+
+    def <=>(other)
+      target <=> other.target
     end
   end
 end

data/lib/duck_puncher/ducks/hash.rb

@@ -17,6 +17,10 @@ module DuckPuncher
 
         sought_value
       end unless method_defined?(:dig)
+
+      def compact
+        delete_if { |_, v| v.nil? }
+      end
     end
   end
 end

data/lib/duck_puncher/ducks/module.rb

@@ -0,0 +1,13 @@
+module DuckPuncher
+  module Ducks
+    module Module
+      def local_methods
+        instance_methods(false).concat constants(false)
+                                         .map! { |c| const_get(c) }
+                                         .keep_if { |c| c.respond_to?(:instance_methods) }
+                                         .flat_map { |c| c.instance_methods(false) }
+                                         .uniq
+      end
+    end
+  end
+end

data/lib/duck_puncher/ducks/object.rb

@@ -11,17 +11,30 @@ module DuckPuncher
         end
       end
 
-      # @description Adds the duck punches to the curren object (meant to be used on instances)
-      def punch(duck_name = self.class.name)
-        extend Ducks[duck_name.to_sym].mod
+      # @description Returns a new decorated version of ourself with the punches mixed in
+      # @return [<self.class>Delegator]
+      def punch
+        DuckPuncher.decorators[DuckPuncher.undecorate(self).class].new(self)
+      end
+
+      # @description Adds the duck punches to the current object (meant to be used on instances, careful with nil and numbers!)
+      # @return self
+      def punch!
+        DuckPuncher::Ducks.load_mods(DuckPuncher.undecorate(self).class).each { |mod| self.extend mod }
+        self
+      end
+
+      def echo
+        p "#{self} -- #{caller_locations[respond_to?(:__getobj__) ? 2 : 0]}"
+        self
       end
 
       def track
         begin
-          require 'object_tracker'
+          require 'object_tracker' || raise(LoadError)
         rescue LoadError
-          DuckPuncher.punch! :Object, only: :require! unless respond_to? :require!
-          require!('object_tracker')
+          DuckPuncher.punch! Object, only: :require! unless respond_to? :require!
+          require! 'object_tracker'
         end
         extend ::ObjectTracker
         track_all!

data/lib/duck_puncher/ducks.rb

@@ -1,34 +1,30 @@
 module DuckPuncher
   module Ducks
+    autoload :String, 'duck_puncher/ducks/string'
+    autoload :Array, 'duck_puncher/ducks/array'
+    autoload :Numeric, 'duck_puncher/ducks/numeric'
+    autoload :Hash, 'duck_puncher/ducks/hash'
+    autoload :Object, 'duck_puncher/ducks/object'
+    autoload :Method, 'duck_puncher/ducks/method'
+    autoload :ActiveRecord, 'duck_puncher/ducks/active_record'
+    autoload :Module, 'duck_puncher/ducks/module'
+
     class << self
       def list
-        @list ||= Set.new [
-          Duck.new(:String),
-          Duck.new(:Array),
-          Duck.new(:Numeric),
-          Duck.new(:Hash),
-          Duck.new(:Object),
-          Duck.new(:Method, before: ->(*) { DuckPuncher::GemInstaller.initialize! }),
-          Duck.new(:ActiveRecord, class: 'ActiveRecord::Base', if: -> { defined? ::ActiveRecord })
-        ]
+        @list ||= DuckPuncher.ancestral_hash
       end
 
-      def [](name)
-        list.find { |duck| duck.name == name.to_sym } ||
-          fail(ArgumentError, %Q(Couldn't find "#{name}" in my list of Ducks! I know about: #{list.map(&:name).map(&:to_s)}))
+      def [](klass)
+        list[klass]
       end
 
-      def load_path_for(duck)
-        "duck_puncher/ducks/#{duck.name.to_s.gsub(/\B([A-Z])/, '_\1').downcase}"
+      def load_mods(klass, loaded_mods: [])
+        if klass.respond_to?(:superclass)
+          load_mods(klass.superclass, loaded_mods: list[klass].to_a.map(&:mod) + loaded_mods)
+        else
+          loaded_mods
+        end
       end
     end
-
-    #
-    # Autoload our ducks
-    #
-
-    list.each do |duck|
-      autoload duck.name, load_path_for(duck)
-    end
   end
 end

data/lib/duck_puncher/registration.rb

@@ -0,0 +1,21 @@
+module DuckPuncher
+  module Registration
+    def register(target, *mods)
+      options = mods.last.is_a?(Hash) ? mods.pop : {}
+      target = DuckPuncher.lookup_constant target
+      Ducks.list[target] = [] unless Ducks.list.key?(target)
+      Array(mods).each do |mod|
+        duck = Duck.new target, mod, options
+        Ducks.list[target] << duck
+        decorators[target] = new_decorator(duck, *Ducks[target])
+      end
+      nil
+    end
+
+    def deregister(*classes)
+      classes.each &Ducks.list.method(:delete)
+      classes.each &decorators.method(:delete)
+      nil
+    end
+  end
+end

data/lib/duck_puncher/version.rb

@@ -1,3 +1,3 @@
 module DuckPuncher
-  VERSION = '3.0.0'.freeze
+  VERSION = '4.0.0'.freeze
 end

data/lib/duck_puncher.rb

@@ -1,8 +1,17 @@
+# Standard lib
 require 'pathname'
 require 'fileutils'
 require 'logger'
+require 'set'
+require 'delegate'
+
+# Gems
 require 'usable'
+
+# Our stuff
 require 'duck_puncher/version'
+require 'duck_puncher/registration'
+require 'duck_puncher/decoration'
 
 module DuckPuncher
   autoload :JSONStorage, 'duck_puncher/json_storage'
@@ -11,48 +20,52 @@ module DuckPuncher
   autoload :Ducks, 'duck_puncher/ducks'
 
   class << self
+    include Registration, Decoration
+
     attr_accessor :log
+    alias_method :logger, :log
 
-    def classes
-      @classes ||= {}
+    def punch!(*classes)
+      options = classes.last.is_a?(Hash) ? classes.pop : {}
+      classes.each do |klass|
+        klass = lookup_constant(klass)
+        Ducks[klass].sort.each do |duck|
+          punches = options[:only] || Ducks::Module.instance_method(:local_methods).bind(duck.mod).call
+          log.info %Q(#{duck.target}#{" <-- #{punches}" if Array(punches).any?})
+          options[:target] = klass
+          unless duck.punch(options)
+            log.error %Q(Failed to punch #{name})
+          end
+        end
+      end
+      nil
     end
 
-    def duck_class(name)
-      classes[name] ||= const_set "#{name}Duck", Ducks[name].dup.classify
+    def punch_all!
+      punch! *Ducks.list.keys
     end
 
-    # @description Extends functionality to a copy of the specified class
-    def punch(*names)
-      singular = names.size == 1
-      punched_ducks = names.map(&method(:duck_class)).compact
-      if singular
-        punched_ducks.first
+    def lookup_constant(const)
+      return const if Module === const
+      if const.to_s.respond_to?(:constantize)
+        const.to_s.constantize
       else
-        punched_ducks
-      end
-    end
-
-    def punch!(*names)
-      options = names.last.is_a?(Hash) ? names.pop : {}
-      names.each do |name|
-        duck = Ducks[name]
-        log.warn %Q(Punching#{" #{options[:only]} onto" if Array(options[:only]).any?} #{options.fetch(:target, name)})
-        unless duck.punch(options)
-          log.error %Q(Failed to punch #{name}!)
-        end
+        const.to_s.split('::').inject(Object) { |k, part| k.const_get(part) }
       end
+    rescue NameError => e
+      log.error "#{e.class}: #{e.message}"
       nil
     end
 
-    def punch_all!
-      log.warn 'Punching all ducks!'
-      Ducks.list.each &:punch
+    def redefine_constant(name, const)
+      if const_defined? name
+        remove_const name
+      end
+      const_set name, const
     end
 
-    def register(*args)
-      Array(args.shift).each do |name|
-        Ducks.list << Duck.new(name, *args)
-      end
+    def ancestral_hash
+      Hash.new { |me, klass| me[klass.superclass] if klass.respond_to?(:superclass) }
     end
   end
 
@@ -62,4 +75,18 @@ module DuckPuncher
   end
 
   log.level = Logger::ERROR
+
+  ducks = [
+    [String, Ducks::String],
+    [Array, Ducks::Array],
+    [Numeric, Ducks::Numeric],
+    [Hash, Ducks::Hash],
+    [Object, Ducks::Object],
+    [Module, Ducks::Module],
+    [Method, Ducks::Method, { before: ->(*) { DuckPuncher::GemInstaller.initialize! } }],
+  ]
+  ducks << ['ActiveRecord::Base', Ducks::ActiveRecord] if defined? ::ActiveRecord
+  ducks.each do |duck|
+    register *duck
+  end
 end

data/test/lib/duck_puncher/array_test.rb

@@ -1,15 +1,16 @@
 require_relative '../../test_helper'
 
-DuckPuncher.punch! :Object
+DuckPuncher.punch! Object
 
 class ArrayTest < MiniTest::Test
   attr_reader :subject
 
   def setup
-    @subject = ('a'..'m').to_a.punch
+    @subject = ('a'..'m').to_a
   end
 
   def test_m
+    subject.punch!
     assert_equal subject.map(&:upcase), subject.m(:upcase)
     refute_equal subject.object_id, subject.m(:upcase).object_id
     assert_equal subject.map!(&:upcase), subject.m!(:upcase)
@@ -17,6 +18,7 @@ class ArrayTest < MiniTest::Test
   end
 
   def test_mm_with_two_args
+    subject.punch!
     assert_equal subject.map { |x| x.prepend('btn-') }, subject.mm(:prepend, 'btn-')
     refute_equal subject.object_id, subject.mm(:prepend, 'btn-')
     assert_equal subject.map! { |x| x.prepend('btn-') }, subject.mm!(:prepend, 'btn-')
@@ -24,10 +26,12 @@ class ArrayTest < MiniTest::Test
   end
 
   def test_mm_with_three_args
+    @subject = @subject.punch
     assert_equal subject.map { |x| x.sub(/[aeiou]/, '*') }, subject.mm(:sub, /[aeiou]/, '*')
   end
 
   def test_except
+    @subject = @subject.punch
     assert_equal subject.except('a'), %w[b c d e f g h i j k l m]
     assert_equal subject.except('a', 'b', 'c'), %w[d e f g h i j k l m]
     assert_equal subject.except, subject

data/test/lib/duck_puncher/hash_test.rb

@@ -1,10 +1,10 @@
 require_relative '../../test_helper'
 
-DuckPuncher.punch :Hash
+DuckPuncher.punch! Hash
 
 class HashTest < MiniTest::Test
   def setup
-    @subject = DuckPuncher::HashDuck.new.merge({ a: 1, b: { c: 2 } })
+    @subject = { a: 1, b: { c: 2 } }
   end
 
   def test_dig
@@ -13,4 +13,11 @@ class HashTest < MiniTest::Test
     assert_equal @subject.dig(:b, :c), 2
     assert_equal @subject.dig(:b), { c: 2 }
   end
+
+  def test_compact
+    assert_equal @subject.compact, { a: 1, b: { c: 2 } }
+    @subject[:b] = nil
+    assert_equal @subject, { a: 1, b: nil }
+    assert_equal @subject.compact, { a: 1 }
+  end
 end

data/test/lib/duck_puncher/method_test.rb

@@ -1,6 +1,6 @@
 require_relative '../../test_helper'
 require_relative '../../fixtures/wut'
-DuckPuncher.punch! :Method
+DuckPuncher.punch! Method
 
 class MethodTest < MiniTest::Test
 

data/test/lib/duck_puncher/module_test.rb

@@ -0,0 +1,9 @@
+require_relative '../../test_helper'
+
+DuckPuncher.punch! Module
+
+class ModuleTest < MiniTest::Test
+  def test_local_methods
+    assert_equal ModWithNestedMod.local_methods, [:instance_method_1, :class_method_1]
+  end
+end

data/test/lib/duck_puncher/numeric_test.rb

@@ -1,5 +1,5 @@
 require_relative '../../test_helper'
-DuckPuncher.punch! :Numeric
+DuckPuncher.punch! Numeric
 
 class NumericTest < MiniTest::Test
 

data/test/lib/duck_puncher/object_test.rb

@@ -1,57 +1,60 @@
 require_relative '../../test_helper'
-DuckPuncher.punch! :Object
+DuckPuncher.punch! Object
 
 class ObjectTest < MiniTest::Test
-
   def setup
-    Object.const_set :User, Class.new
-    @subject = Object.new
-    @user = User.new
+    @animal = Animal.new
+    @dog = Dog.new
+    @kaia = Kaia.new
   end
 
   def teardown
-    DuckPuncher::Ducks.list.delete_if { |duck| [:admin, :super_admin, :User].include?(duck.name) }
-    Object.send :remove_const, :User
+    DuckPuncher.deregister Animal, Dog, Kaia
   end
 
   def test_clone!
-    cloned = @subject.clone!
-    assert_equal cloned.class, @subject.class
-    refute_equal cloned, @subject
-  end
-
-  def test_punch_on_a_core_duck
-    refute [].respond_to?(:m)
-    assert [].respond_to?(:punch)
-    assert [].punch.respond_to?(:m)
+    cloned = @dog.clone!
+    assert_equal cloned.class, @dog.class
+    refute_equal cloned, @dog
   end
 
   def test_punch_with_a_core_duck
-    assert [].punch(:Array).respond_to?(:m)
+    assert [].punch.respond_to?(:m)
   end
 
   def test_punch_on_a_custom_duck
-    DuckPuncher.register :User, mod: 'CustomPunch2'
-    assert @user.punch.respond_to?(:quack)
+    DuckPuncher.register Animal, CustomPunch2
+    assert @animal.punch.respond_to?(:quack)
   end
 
-  def test_punch_with_a_custom_duck
-    refute @user.respond_to?(:quack)
-    DuckPuncher.register :admin, mod: 'CustomPunch2'
-    assert @user.punch(:admin).respond_to?(:quack)
-
-    refute @user.respond_to?(:wobble)
-    DuckPuncher.register :super_admin, mod: 'CustomPunch3'
-    assert @user.punch(:super_admin).respond_to?(:wobble)
+  def test_punch_with_multiple_custom_duck
+    DuckPuncher.register Animal, CustomPunch2
+    DuckPuncher.register Animal, CustomPunch3
+    assert @animal.punch.respond_to?(:wobble)
   end
 
   def test_punch_call_stack
-    User.send(:define_method, :foo) { quack }
-    User.send(:define_method, :quack) { 'foo' }
-    assert_equal 'foo', @user.foo
-    DuckPuncher.register :User, mod: 'CustomPunch2'
-    assert_equal 'quack', @user.punch.foo
-    User.send(:remove_method, :foo)
-    User.send(:remove_method, :quack)
+    Animal.send(:define_method, :foo) { quack }
+    Animal.send(:define_method, :quack) { 'foo' }
+    assert_equal 'foo', @animal.foo
+    DuckPuncher.register Animal, CustomPunch2
+    @animal.punch!
+    assert_equal 'quack', @animal.foo
+  end
+
+  def test_punch_on_ancestor_only
+    DuckPuncher.register Dog, CustomPunch2
+    assert_respond_to @dog.punch, :quack
+  end
+
+  def test_punch_includes_all_ancestors
+    DuckPuncher.register Animal, CustomPunch2
+    DuckPuncher.register Dog, CustomPunch
+    DuckPuncher.register Kaia, CustomPunch3
+    @kaia = Kaia.new
+    @kaia.punch!
+    assert_respond_to @kaia, :wobble
+    assert_respond_to @kaia, :talk
+    assert_respond_to @kaia, :quack
   end
 end

data/test/lib/duck_puncher/string_test.rb

@@ -1,6 +1,6 @@
 require_relative '../../test_helper'
 
-DuckPuncher.punch! :String
+DuckPuncher.punch! String
 
 class StringTest < MiniTest::Test
   def test_pluralize

data/test/lib/duck_puncher_test.rb

@@ -1,27 +1,55 @@
 require_relative '../test_helper'
 
+DuckPuncher.punch! Object, only: :punch
+
 class DuckPuncherTest < MiniTest::Test
-  def test_register
-    refute_respond_to [], :tap_tap
-    DuckPuncher.register :CustomPunch, class: 'Array'
-    DuckPuncher.punch! :CustomPunch
-    assert_respond_to [], :tap_tap
-    DuckPuncher.punch! :Object, only: :punch
-    assert_respond_to [].punch(:CustomPunch), :tap_tap
-    # does not re-register duck with same name
-    duck_list_size = DuckPuncher::Ducks.list.size
-    DuckPuncher.register :CustomPunch, class: 'String'
-    assert_equal duck_list_size, DuckPuncher::Ducks.list.size
+  def setup
+    @subject = Animal.new
+    @kaia = Kaia.new
+    DuckPuncher.deregister Animal, Kaia, Dog
+  end
+
+  def teardown
+    DuckPuncher.deregister Animal, Kaia, Dog
+  end
+
+  def test_punch!
+    refute_respond_to @kaia, :talk
+    refute_respond_to @kaia.punch, :talk
+    DuckPuncher.register Kaia, CustomPunch
+    DuckPuncher.punch! Kaia, only: :talk
+    assert_respond_to @kaia, :talk
+    assert_respond_to @kaia.punch, :talk
+  end
+
+
+  def test_punch_all!
+    DuckPuncher.punch_all!
+    expected_methods = DuckPuncher::Ducks.list.values.m(:to_a).flatten.m(:mod).m(:local_methods).flatten
+    assert expected_methods.size > 1
+    good_ducks = DuckPuncher::Ducks.list.select { |_, ducks|
+      ducks.all? { |duck| (duck.mod.local_methods - duck.target.instance_methods(:false)).size.zero? }
+    }
+    assert good_ducks.size > 5
+  end
+
+  def test_register_with_multiple_mods
+    refute_respond_to @subject, :talk
+    refute_respond_to @subject, :wobble
+    refute_respond_to @subject.punch, :talk
+    refute_respond_to @subject.punch, :wobble
+    DuckPuncher.register Animal, CustomPunch, CustomPunch3
+    assert_respond_to @subject.punch, :talk
+    assert_respond_to @subject.punch, :wobble
   end
 
-  def test_register_with_array
-    refute_respond_to [], :quack
-    refute_respond_to [], :wobble
-    DuckPuncher.register [:CustomPunch2, :CustomPunch3], class: 'Array'
-    DuckPuncher.punch! :CustomPunch2
-    assert_respond_to [], :quack
-    refute_respond_to [], :wobble
-    DuckPuncher.punch! :CustomPunch3
-    assert_respond_to [], :wobble
+  def test_deregister
+    refute_respond_to @subject, :talk
+    refute_respond_to @subject.punch, :talk
+    DuckPuncher.register Animal, CustomPunch
+    assert_respond_to @subject.punch, :talk
+    refute_respond_to @subject, :talk
+    DuckPuncher.deregister Animal
+    refute_respond_to @subject.punch, :talk
   end
 end

data/test/test_helper.rb

@@ -8,7 +8,7 @@ Minitest::Reporters.use!
 DuckPuncher.log.level = Logger::INFO
 
 module CustomPunch
-  def tap_tap
+  def talk
     p self
     self
   end
@@ -24,3 +24,22 @@ module CustomPunch3
   def wobble
   end
 end
+
+module ModWithNestedMod
+  def instance_method_1
+  end
+
+  module ClassMethods
+    def class_method_1
+    end
+  end
+end
+
+class Animal
+end
+
+class Dog < Animal
+end
+
+class Kaia < Dog
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duck_puncher
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Ryan Buckley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-05 00:00:00.000000000 Z
+date: 2016-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: usable
@@ -105,27 +105,30 @@ files:
 - bin/console
 - duck_puncher.gemspec
 - lib/duck_puncher.rb
+- lib/duck_puncher/decoration.rb
 - lib/duck_puncher/duck.rb
 - lib/duck_puncher/ducks.rb
 - lib/duck_puncher/ducks/active_record.rb
 - lib/duck_puncher/ducks/array.rb
 - lib/duck_puncher/ducks/hash.rb
 - lib/duck_puncher/ducks/method.rb
+- lib/duck_puncher/ducks/module.rb
 - lib/duck_puncher/ducks/numeric.rb
 - lib/duck_puncher/ducks/object.rb
 - lib/duck_puncher/ducks/string.rb
 - lib/duck_puncher/gem_installer.rb
 - lib/duck_puncher/json_storage.rb
+- lib/duck_puncher/registration.rb
 - lib/duck_puncher/version.rb
 - test/fixtures/wut.rb
 - test/lib/duck_puncher/array_test.rb
 - test/lib/duck_puncher/hash_test.rb
 - test/lib/duck_puncher/method_test.rb
+- test/lib/duck_puncher/module_test.rb
 - test/lib/duck_puncher/numeric_test.rb
 - test/lib/duck_puncher/object_test.rb
 - test/lib/duck_puncher/string_test.rb
 - test/lib/duck_puncher_test.rb
-- test/soft_punch/duck_puncher_test.rb
 - test/test_helper.rb
 homepage: https://github.com/ridiculous/duck_puncher
 licenses:
@@ -156,9 +159,9 @@ test_files:
 - test/lib/duck_puncher/array_test.rb
 - test/lib/duck_puncher/hash_test.rb
 - test/lib/duck_puncher/method_test.rb
+- test/lib/duck_puncher/module_test.rb
 - test/lib/duck_puncher/numeric_test.rb
 - test/lib/duck_puncher/object_test.rb
 - test/lib/duck_puncher/string_test.rb
 - test/lib/duck_puncher_test.rb
-- test/soft_punch/duck_puncher_test.rb
 - test/test_helper.rb

data/test/soft_punch/duck_puncher_test.rb

@@ -1,30 +0,0 @@
-require_relative '../test_helper'
-
-class DuckPuncherTest < MiniTest::Test
-  DuckString = DuckPuncher.punch :String
-  DuckNumber, DuckArray = DuckPuncher.punch :Numeric, :Array
-
-  def test_duck_string
-    refute_respond_to '', :underscore
-    assert_respond_to DuckString.new, :underscore
-    refute_respond_to '', :underscore
-  end
-
-  def test_duck_number_array
-    refute_respond_to 25, :to_currency
-    refute_respond_to [], :m
-    assert_respond_to DuckNumber.new, :to_currency
-    assert_respond_to DuckArray.new, :m
-    refute_respond_to 25, :to_currency
-    refute_respond_to [], :m
-  end
-
-  def test_excluding_punches
-    refute_respond_to Object.new, :punch
-    DuckPuncher.punch! :Object, only: :punch
-    assert_respond_to Object.new, :punch
-    refute_respond_to Object.new, :require!
-    DuckPuncher.punch! :Object, only: :require!
-    assert_respond_to Object.new, :require!
-  end
-end