duck_puncher 4.2.3 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f3865242be8b73f05bd76345f5d48af3ce41dcb
-  data.tar.gz: 8b5d46549c916081521a43ca500abd836d1d9cc0
+  metadata.gz: 54ed4f3463d0da2ed92a25d2d91953a9ac1ac4ab
+  data.tar.gz: 8972aa4d5fb7e54300db682202d41147d9dc770f
 SHA512:
-  metadata.gz: 5c7e01041bc9440fb98bfe60a52e5be1597c5cfd3aaa38f96b0a66042b7bf34cdd70d2c21e647328fa375d123969f57c6d1f709b4eae68db90bfceeb29e606a9
-  data.tar.gz: 6093aeca1a64b78ad8376ed2075c765e950d320a0a1fca42a915aebc8ab88c8ca60d51a5f15b5a53ce8860e08a1073bf8cd7fb0ee2e245a181b54b156f64f0dd
+  metadata.gz: 1a460f7785607d0b87656670d0c1fbb5f2d8868803d40aed864b202ae4fb60449922f99224ecac2aaa75d3d72c686390cfeb1593d265b4392de62f0263477eae
+  data.tar.gz: c931bcbf428f270460f7f41509a2cd808393bc6f2ac377c8c611c3342da1e4c8a9514c329b993d633b1d59584c8a277cec1c3b849815f617a2617ae58e004548

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+4.3.0 (10/10/2016)
+==================
+
+* Fix issue with not being able to punch the same duck with different options
+* Add the `:target` option to `.call` to override the receiving class

data/README.md

@@ -1,44 +1,13 @@
 # DuckPuncher [![Gem Version](https://badge.fury.io/rb/duck_puncher.svg)](http://badge.fury.io/rb/duck_puncher)  [![Build Status](https://travis-ci.org/ridiculous/duck_puncher.svg)](https://travis-ci.org/ridiculous/duck_puncher) [![Code Climate](https://codeclimate.com/github/ridiculous/duck_puncher/badges/gpa.svg)](https://codeclimate.com/github/ridiculous/duck_puncher)
 
-DuckPuncher provides an interface for administering __duck punches__ (a.k.a "monkey patches"). Punches can be administered in several ways: 
+DuckPuncher provides an interface for administering __duck punches__ (a.k.a "monkey patches"). Punches can be applied permanently via an extension
+or temporarily as a decorator. Decorator classes are generated when an extension is registered and used via `Object#punch`. The object is wrapped
+in one decorator for each of the object's ancestors (with registered punches) and behaves much like it's extended cousin, `Object.punch!`.
 
-* as an extension
-* as a decorator
-
-Default extensions:
+## Install
 
 ```ruby
-Enumerable (including Array, Set, Range, and Enumerator)
-        #m                  # => `[].m(:to_s)`
-        #m!                 # => `[].m!(:upcase)`
-        #mm                 # => `[].mm(:sub, /[aeiou]/, '*')` 
-        #mm!                # => `[].mm!(:sub, /[aeiou]/, '*')` 
-        #except             # => `[].except('foo', 'bar')`
-        #map_keys           # => `[].map_keys(:id)`
-Hash
-        #dig                # => `{a: 1, b: {c: 2}}.dig(:b, :c)` (Standard 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         # => `'DJ::JSONStorage'.underscore` # => 'dj/json_storage'
-        #to_boolean         # => `'true'.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              # => `Object.new.punch`        # => a copy of Object.new with String punches mixed in
-        #punch!             # => `Object.new.punch!`       # => destructive version applies extensions directly to the base object
-        #echo               # => `Object.new.echo.inspect` # => spits out the caller and value of the object and returns the object
-        #track              # => `Object.new.track`        # => Trace 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
+gem 'duck_puncher', '~> 4.3'
 ```
 
 ## Usage
@@ -55,12 +24,18 @@ Punch individual ducks by name:
 DuckPuncher.(Hash, Object)
 ```
 
-One method to rule them all:
+Add `punch` as a proxy method to all punches:
 
 ```ruby
 DuckPuncher.(Object, only: :punch)
 ```
 
+Redirect the punches registered for a class to another target:
+
+```ruby
+DuckPuncher.(Object, target: String)
+```
+
 ### Tactical punches
 
 `DuckPuncher` extends the amazing [Usable](https://github.com/ridiculous/usable) gem, so you can configure only the punches you want! For instance:
@@ -101,27 +76,84 @@ When there are no punches registered for a class, it'll search the ancestor list
 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').punch!.m!(:upcase).mm!(:*, 3).echo
-end
-
+>> DuckPuncher.(Object, only: [:punch, :punch!])
+>> def soft_punch() ('a'..'z').punch.echo(1).map(&:upcase) end
+>> def hard_punch() ('a'..'z').punch!.echo(1).mm(:*, 3) end
 >> soft_punch
-"a..z -- (irb):8:in `soft_punch'"
-=> ["A", "B", "C", "D", ...]
+"a".."z"
+* /.../delegate.rb:85:in `method_missing'
+=> ["A", "B", "C", "D", "E", "F", "G", "H", "I", ...]
 >> hard_punch
-"[\"AAA\", \"BBB\", \"CCC\", \"DDD\", ...] -- (irb):12:in `hard_punch'"
+"a".."z"
+* (irb):11:in `hard_punch'
 => ["AAA", "BBB", "CCC", "DDDD", ...]
 ```
 
-### Registering custom punches
+## Default extensions
+
+#### Enumerable (including Array, Set, Range, and Enumerator)
+```ruby
+[].m(:to_s)
+[].m!(:upcase)
+[].mm(:sub, /[aeiou]/, '*')
+[].mm!(:sub, /[aeiou]/, '*')
+[].except(:foo, :bar, :baz)
+[].map_keys(:id)
+```
+
+#### Hash
+```ruby
+{ a: 1, b: { c: 2 }}.dig(:b, :c)  # => 2
+                                  # ii Standard in Ruby >= 2.3
+{ a: 1, b: nil }.compact          # => {a: 1}
+                                  # !! destructive
+```
+
+#### Numeric
+```ruby
+25.245.to_currency # => "25.25"
+10_000.to_duration # => "2 h 46 min"
+10_000.to_time_ago # => "2 hours ago"
+10.15.to_rad       # => "0.17715091907742445"
+```
+
+#### String
+```ruby
+'hour'.pluralize(2)           # => "hours"
+'DJ::JSONStorage'.underscore  # => "dj/json_storage"
+'true'.to_boolean             # => "true"
+'MiniTest::Test'.constantize  # => MiniTest::Test
+```
+
+#### Module
+```ruby
+Kernel.local_methods  # => methods defined directly in the class + nested constants w/ methods
+```
+
+#### Object
+```ruby
+Object.new.clone!  # => a deep clone of the object (using Marshal.dump)
+Object.new.punch   # => a copy of Object.new with String punches mixed in
+Object.new.punch!  # => destructive version applies extensions directly to the base object
+Object.new.echo    # => prints and returns itself. Accepts a number,
+                   #    indicating how many lines of the trace to display
+Object.new.track   # => Trace methods calls to the object
+                   # !! requires [object_tracker](https://github.com/ridiculous/object_tracker), which it'll try to download
+```
 
-DuckPuncher allows you to utilize the `punch` interface to __extend__ any kind of object with your own punches. Simply 
+#### Method
+```ruby
+require 'benchmark'
+
+Benchmark.method(:measure).to_instruct # => the Ruby VM instruction sequence for the method
+Benchmark.method(:measure).to_source   # => the method definition as a string
+```
+
+## Registering custom punches
+
+DuckPuncher allows you to utilize the `punch` and `punch!` interface to __decorate__ or __extend__, respectively, any object with your own punches. Simply 
 call `DuckPuncher.register` with the name of your module (or an array of names) and any of
-[these options](https://github.com/ridiculous/duck_puncher/blob/master/lib/duck_puncher/duck.rb#L11).
+[these options](https://github.com/ridiculous/duck_puncher/blob/master/lib/duck_puncher/duck.rb#L10).
 
 
 ```ruby
@@ -159,13 +191,7 @@ user = User.new('Ryan').punch
 user.call_with_retry(19.99)
 ```
 
-To register _and_ punch in one swoop, use `DuckPuncher.register!`
-
-## Install
-
-```ruby
-gem 'duck_puncher'
-```
+To register the extension _and_ punch the class, use `DuckPuncher.register!`
 
 ## Logging
 
@@ -215,36 +241,18 @@ DuckPuncher.(:Object, only: :track)
 Donald.track
 Duck.track
 >> Duck.usable Donald, only: :tap_tap
-  * called "Donald.respond_to?" with to_str, true [RUBY CORE] (0.00002)
-  * called "Donald.respond_to?" with to_str, true [RUBY CORE] (0.00001)
-  * called "Donald.respond_to?" with to_ary, true [RUBY CORE] (0.00001)
-  * called "Donald.to_s" [RUBY CORE] (0.00001)
-  * called "Duck.usable_config" [ruby-2.3.0@duck_puncher/gems/usable-1.2.0/lib/usable.rb:10] (0.00002)
-  * called "Duck.usable_config" [ruby-2.3.0@duck_puncher/gems/usable-1.2.0/lib/usable.rb:10] (0.00001)
-  * called "Donald.const_defined?" with UsableSpec [RUBY CORE] (0.00001)
-  * called "Donald.dup" [RUBY CORE] (0.00002)
-  * called "Donald.name" [RUBY CORE] (0.00000)
-  * called "Donald.instance_methods" [RUBY CORE] (0.00001)
-  * called "Duck.const_defined?" with DonaldUsed [RUBY CORE] (0.00001)
-  * called "Donald.respond_to?" with to_str, true [RUBY CORE] (0.00001)
-  * called "Donald.respond_to?" with to_str, true [RUBY CORE] (0.00000)
-  * called "Donald.respond_to?" with to_ary, true [RUBY CORE] (0.00000)
-  * called "Donald.to_s" [RUBY CORE] (0.00035)
-  * called "Duck.const_set" with DonaldUsed, #<Module:0x007fe23a261618> [RUBY CORE] (0.00002)
-  * called "Duck.usable_config" [ruby-2.3.0@duck_puncher/gems/usable-1.2.0/lib/usable.rb:10] (0.00000)
-  * called "Donald.respond_to?" with to_str, true [RUBY CORE] (0.00000)
-  * called "Donald.respond_to?" with to_ary, true [RUBY CORE] (0.00001)
-  * called "Donald.to_s" [RUBY CORE] (0.00019)
-  * called "Donald.respond_to?" with to_str, true [RUBY CORE] (0.00001)
-  * called "Donald.respond_to?" with to_str, true [RUBY CORE] (0.00000)
-  * called "Donald.respond_to?" with to_ary, true [RUBY CORE] (0.00000)
-  * called "Donald.to_s" [RUBY CORE] (0.00000)
-  * called "Duck.include" with Duck::DonaldUsed [RUBY CORE] (0.00001)
-  * called "Duck#send" with include, Duck::DonaldUsed [RUBY CORE] (0.00024)
-  * called "Duck.usable!" with #<Usable::ModExtender:0x007fe23a261ca8> [ruby-2.3.0@duck_puncher/gems/usable-1.2.0/lib/usable.rb:41] (0.00143)
-  * called "Donald.const_defined?" with UsableSpec [RUBY CORE] (0.00001)
-  * called "Duck.usable" with Donald, {:only=>:tap_tap} [ruby-2.3.0@duck_puncher/gems/usable-1.2.0/lib/usable.rb:30] (0.00189)
-  # ... You get the idea.
+# =>  * called "Donald.respond_to?" with to_str, true [RUBY CORE] (0.00002)
+# =>  * called "Donald.respond_to?" with to_str, true [RUBY CORE] (0.00001)
+# =>  * called "Donald.respond_to?" with to_ary, true [RUBY CORE] (0.00001)
+# =>  * called "Donald.to_s" [RUBY CORE] (0.00001)
+# =>  * called "Duck.usable_config" [ruby-2.3.0@duck_puncher/gems/usable-1.2.0/lib/usable.rb:10] (0.00002)
+# =>  * called "Duck.usable_config" [ruby-2.3.0@duck_puncher/gems/usable-1.2.0/lib/usable.rb:10] (0.00001)
+# =>  * called "Donald.const_defined?" with UsableSpec [RUBY CORE] (0.00001)
+# =>  * called "Donald.dup" [RUBY CORE] (0.00002)
+# =>  * called "Donald.name" [RUBY CORE] (0.00000)
+# =>  * called "Donald.instance_methods" [RUBY CORE] (0.00001)
+# =>  * called "Duck.const_defined?" with DonaldUsed [RUBY CORE] (0.00001)
+# =>  ...
 ```
 
 ## Contributing

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(:hard_punch_test) do |t|
-  t.pattern = 'test/lib/**/*_test.rb'
+root = Pathname.new File.expand_path('..', __FILE__)
+tasks = []
+Dir[root.join('test/lib/**/*_test.rb')].each do |file|
+  tasks << Rake::TestTask.new(file.split('/').last[/\w+/].to_sym) do |t|
+    t.pattern = file.sub(root.to_s + '/', '')
+  end
 end
 
-task default: [:hard_punch_test]
+task default: tasks.map(&:name)

data/lib/duck_puncher.rb

@@ -15,6 +15,7 @@ require 'duck_puncher/utilities'
 require 'duck_puncher/ancestral_hash'
 require 'duck_puncher/duck'
 require 'duck_puncher/ducks'
+require 'duck_puncher/unique_duck'
 
 module DuckPuncher
   autoload :GemInstaller, 'duck_puncher/gem_installer'
@@ -22,11 +23,10 @@ module DuckPuncher
 
   class << self
     # @description Include additional functionality
-    #   Registration[:register, :deregister]
-    #   Decoration[:decorators, :build_decorator_class, :decorate, :cached_decorators, :undecorate]
-    #   Utilities[:lookup_constant, :redefine_constant]
-    #   AncestralHash[:ancestral_hash]
-    include Registration, Decoration, Utilities, AncestralHash
+    include Registration    # [:register, :deregister]
+    include Decoration      # [:decorators, :build_decorator_class, :decorate, :cached_decorators, :undecorate]
+    include Utilities       # [:lookup_constant, :redefine_constant]
+    include AncestralHash   # [:ancestral_hash]
 
     attr_accessor :logger
 
@@ -39,14 +39,15 @@ module DuckPuncher
       classes = args.any? ? args : Ducks.list.keys
       classes.each do |klass|
         klass = lookup_constant(klass)
-        (Ducks[klass] - punched_ducks).sort.each do |duck|
-          punches = Array(options[:only] || duck.options[:only] || Ducks::Module.instance_method(:local_methods).bind(duck.mod).call)
-          options[:target] = klass
-          logger.info %Q(#{klass}#{" <-- #{duck.mod.name}#{punches}" if punches.any?})
-          if duck.punch(options)
+        Ducks[klass].sort.each do |duck|
+          duck.punch_options = Ducks::Object.instance_method(:clone!).bind(options).call
+          duck.punch_options[:target] ||= klass
+          if punched_ducks.include?(duck)
+            logger.warn %(Already punched #{duck.mod.name})
+          elsif duck.punch(duck.punch_options).any?
             punched_ducks << duck
           else
-            logger.error %Q(Failed to punch #{name})
+            logger.warn %(No punches were thrown)
           end
         end
       end
@@ -58,7 +59,18 @@ module DuckPuncher
     alias punch! call
 
     def punched_ducks
-      @punched_ducks ||= []
+      @punched_ducks ||= Set.new
+    end
+
+    def register(*)
+      target, *_ = super
+      decorators[target] = build_decorator_class(*Ducks[target])
+      @cached_decorators = nil
+    end
+
+    def deregister(*)
+      super
+      @cached_decorators = nil
     end
   end
 end

data/lib/duck_puncher/duck.rb

@@ -3,7 +3,7 @@ module DuckPuncher
     attr_accessor :target, :mod, :options
 
     # @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 mod [String,Module] The module that defines the extensions
     # @param [Hash] options to modify the duck #punch method behavior
     # @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+
@@ -19,35 +19,17 @@ 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 = {})
-      opts = options.merge opts
+      opts = options.merge(opts)
       targets = Array(opts[:target] || self.target)
       targets.each do |target|
         options[:before].call(target) if options[:before]
+        punches = Array(opts[:only] || Ducks::Module.instance_method(:local_methods).bind(mod).call)
+        DuckPuncher.logger.info %Q(#{target}#{" <-- #{mod.name}#{punches}" if punches.any?})
         target.extend Usable
         target.usable mod, only: opts[:only], method: opts[:method]
         options[:after].call(target) if options[:after]
       end
       targets
     end
-
-    #
-    # Required to play nice in a Set
-    #
-
-    def eql?(other)
-      "#{target}-#{mod}" == "#{other.target}-#{other.mod}"
-    end
-
-    def 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/object.rb

@@ -25,8 +25,10 @@ module DuckPuncher
         self
       end
 
-      def echo
-        p "#{self} -- #{caller_locations[respond_to?(:__getobj__) ? 2 : 0]}"
+      # @param [Integer] trace The number of lines from the stack trace to print (nil)
+      def echo(trace = nil)
+        p self
+        puts caller_locations.take(trace).map { |l| l.to_s.prepend('* ') }.join("\n") if trace
         self
       end
 

data/lib/duck_puncher/ducks/string.rb

@@ -1,7 +1,7 @@
 module DuckPuncher
   module Ducks
     module String
-      BOOLEAN_MAP = ::Hash[%w(true 1 yes y on).product([true]) + ['false', '0', 'no', 'n', 'off', ''].product([false])].freeze
+      BOOLEAN_MAP = ::Hash[%w(true 1 yes y on).product([true])].freeze
 
       def pluralize(count)
         "#{self}#{'s' if count != 1}"

data/lib/duck_puncher/registration.rb

@@ -5,12 +5,11 @@ module DuckPuncher
       options = mods.last.is_a?(Hash) ? mods.pop : {}
       target = DuckPuncher.lookup_constant target
       Ducks.list[target] = Set.new [] unless Ducks.list.key?(target)
-      Array(mods).each do |mod|
-        duck = Duck.new target, mod, options
+      mods = Array(mods).each do |mod|
+        duck = UniqueDuck.new Duck.new target, mod, options
         Ducks.list[target] << duck
-        decorators[target] = build_decorator_class(duck, *Ducks[target])
       end
-      @cached_decorators = nil
+      [target, *mods]
     end
 
     def register!(*args)
@@ -21,7 +20,6 @@ module DuckPuncher
     def deregister(*classes)
       classes.each &Ducks.list.method(:delete)
       classes.each &decorators.method(:delete)
-      @cached_decorators = nil
     end
   end
 end

data/lib/duck_puncher/unique_duck.rb

@@ -0,0 +1,26 @@
+module DuckPuncher
+  class UniqueDuck < DelegateClass(Duck)
+    attr_accessor :punch_options
+
+    #
+    # Required to play nice in a Set
+    #
+
+    def eql?(other)
+      "#{target}-#{mod}" == "#{other.target}-#{other.mod}"
+    end
+
+    def hash
+      target.to_s.hash + mod.to_s.hash + punch_options.to_s.hash
+    end
+
+    #
+    # Sorting
+    #
+
+    def <=>(other)
+      target <=> other.target
+    end
+
+  end
+end

data/lib/duck_puncher/version.rb

@@ -1,3 +1,3 @@
 module DuckPuncher
-  VERSION = '4.2.3'.freeze
+  VERSION = '4.3.0'.freeze
 end

data/test/lib/duck_puncher/numeric_test.rb

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

data/test/lib/duck_puncher/string_test.rb

@@ -1,6 +1,6 @@
 require_relative '../../test_helper'
 
-DuckPuncher.punch! String
+DuckPuncher.(String)
 
 class StringTest < MiniTest::Test
   def test_pluralize
@@ -29,7 +29,7 @@ class StringTest < MiniTest::Test
     refute 'no'.to_boolean
     refute 'off'.to_boolean
     refute ''.to_boolean
-    refute 'asd'.to_boolean
+    refute 'f'.to_boolean
   end
 
   def test_constantize

data/test/lib/duck_puncher_test.rb

@@ -35,11 +35,18 @@ class DuckPuncherTest < MiniTest::Test
     DuckPuncher.()
     expected_methods = DuckPuncher::Ducks.list.values.m(:to_a).flatten.m(:mod).m(:local_methods).flatten
     assert expected_methods.size > 1
+    # Find all ducks that have copied all their methods to the target class (e.g. String)
     good_ducks = DuckPuncher::Ducks.list.select { |_, ducks|
-      # Assert that all methods were copied over
       ducks.all? { |duck| (duck.mod.local_methods - duck.target.instance_methods(:false)).size.zero? }
     }
-    assert good_ducks.size > 5
+    assert good_ducks.size == 6, "Good ducks should be equal to 6 but are #{good_ducks.size}"
+  end
+
+  def test_call_with_target
+    DuckPuncher.(String, only: [:to_boolean])
+    refute_respond_to @subject, :to_boolean
+    DuckPuncher.(String, target: @subject.class)
+    assert_respond_to @subject, :to_boolean
   end
 
   def test_register_with_multiple_mods

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duck_puncher
 version: !ruby/object:Gem::Version
-  version: 4.2.3
+  version: 4.3.0
 platform: ruby
 authors:
 - Ryan Buckley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-01 00:00:00.000000000 Z
+date: 2016-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: usable
@@ -98,6 +98,7 @@ files:
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -121,6 +122,7 @@ files:
 - lib/duck_puncher/gem_installer.rb
 - lib/duck_puncher/json_storage.rb
 - lib/duck_puncher/registration.rb
+- lib/duck_puncher/unique_duck.rb
 - lib/duck_puncher/utilities.rb
 - lib/duck_puncher/version.rb
 - test/fixtures/test_classes.rb