duck_puncher 2.16.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8a2fed5af6189e26acdeb046ec66ff7dec8368d
-  data.tar.gz: 6f487f85bd05ea581fcc4463e11b2b1c611a7f1e
+  metadata.gz: 6050f09ba1e9b843078f3d6eb434b668da5687a8
+  data.tar.gz: 30a1083c6ccb5edfa9520e3f395b63c65b221040
 SHA512:
-  metadata.gz: 16fac17fdb70185f7deed4f5657cfa32c29203b7427a6cda940765a454eb8300dedcd4ebf056b785c54669dc901eef05ced5e5aa3c2833e4217ff99d1fdd3ba7
-  data.tar.gz: e40705f7bf0bb01eebdf5767e590254d5d83c8190df619cadd36fd31ff310d0d4a2a2ef2875626249ee32e3cd103e4ee9983b062776c5701089ce4924c802289
+  metadata.gz: fa163f85c3ec46d0a3071a4d9e75b3c2de14b37bcd5f29b8b8fe3b65d13e617f37f4740894e4fc393482c75a9aedeb25600da618e74469fc30341428512c7001
+  data.tar.gz: 86d3f879aba2e9e78694398d348a7b18e909931584dedf65617538b12e5c88344ef5b0bf0e711fc8899f7a1683e26d9b42400dd293803318d8e10b4371e618df

data/README.md

@@ -4,13 +4,14 @@ DuckPuncher provides an interface for administering __duck punches__ (a.k.a "mon
 
 * as an extension
 * as a subclass
-* as a decorator
 
 Default extensions:
 
 ```ruby
-Array   #m            => `[].m(:to_s)` => `[].map(&:to_s)` 
+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 
@@ -20,6 +21,7 @@ Numeric #to_currency  => `25.245.to_currency` => 25.25
 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
@@ -48,13 +50,13 @@ DuckPuncher.punch! :Object, only: :punch
 
 ### Tactical punches
 
-Punch only certain methods onto a duck:
+`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]
 ```
 
-The `.punch` method creates and caches a new punched class that __inherits__ from the original:
+Use `DuckPuncher.punch` to create a new class that __inherits__ from the original (automatically cached for future calls):
 
 ```ruby
 >> DuckPuncher.punch :String
@@ -65,21 +67,26 @@ The `.punch` method creates and caches a new punched class that __inherits__ fro
 => false
 ```
 
-If you punch `Object` then you can use `punch` on any object to get a new __decorated__ copy of the object with the desired
-functionality mixed in:
+If you punch `Object` then you can use `#punch` on any object to extend individual instances:
 
 ```ruby
 >> DuckPuncher.punch! :Object, only: :punch
->> %w[yes no 1].punch.m(:punch).punch.m(:to_boolean)
+>> %w[yes no 1].punch.m!(:punch).m(:to_boolean)
 => [true, false, true]
 ```
 
-Because `DuckPuncher` extends the amazing [Usable](https://github.com/ridiculous/usable) gem, you can configure only the punches you want! 
+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)
+=> "I love ducks"
+```
 
 ### Registering custom punches
 
-DuckPuncher allows you to utilize the `punch` interface to __decorate__ any kind of object with your own punches. Simply 
-call `.register` with the name of your module (or an array of names) and any of
+DuckPuncher allows you to utilize the `punch` interface to __extend__ any kind of 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).
 
 
@@ -118,7 +125,7 @@ user = User.new('Ryan').punch(:Billable).punch(:Retryable)
 user.call_with_retry(19.99)
 ```
 
-Ducks can be registered under any name you want, as long as the `:mod` option specifies a module:
+Ducks can be registered under any name, as long as the `:mod` option specifies a module:
 
 ```ruby
 DuckPuncher.register :bills, mod: 'Admin::Billable'
@@ -134,8 +141,19 @@ DuckPuncher.punch! :Billable
 
 ## Install
 
-    gem 'duck_puncher'
+```ruby
+gem 'duck_puncher'
+```
+
+## Logging
+
+Get notified of all punches/extensions by changing the logger level:
+
+```ruby
+DuckPuncher.log.level = Logger::INFO
+```
 
+The default log level is `DEBUG`
 
 ## Experimental
 

data/duck_puncher.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Ryan Buckley"]
   spec.email         = ["arebuckley@gmail.com"]
   spec.description   = %q{Administer precision punches}
-  spec.summary       = %q{Administer precision punches to your favorite Ruby classes}
+  spec.summary       = %q{Administer precision extensions (a.k.a "punches") to your favorite Ruby classes}
   spec.homepage      = "https://github.com/ridiculous/duck_puncher"
   spec.license       = "MIT"
 

data/lib/duck_puncher.rb

@@ -1,6 +1,5 @@
 require 'pathname'
 require 'fileutils'
-require 'delegate'
 require 'logger'
 require 'usable'
 require 'duck_puncher/version'
@@ -14,26 +13,10 @@ module DuckPuncher
   class << self
     attr_accessor :log
 
-    def delegations
-      @delegations ||= {}
-    end
-
     def classes
       @classes ||= {}
     end
 
-    # @param [Symbol] duck_name
-    # @param [Class] obj The object being punched
-    def delegate_class(duck_name, obj = nil)
-      delegations["#{obj.class}#{duck_name}"] ||= begin
-        duck_const = duck_name.to_s
-        if duck_const[/^[A-Z]/].nil?
-          duck_const = duck_const.split('_').map(&:capitalize).join
-        end
-        const_set "#{duck_const}DuckDelegated", Ducks[duck_name.to_sym].dup.delegated(obj)
-      end
-    end
-
     def duck_class(name)
       classes[name] ||= const_set "#{name}Duck", Ducks[name].dup.classify
     end

data/lib/duck_puncher/duck.rb

@@ -24,11 +24,6 @@ module DuckPuncher
         DuckPuncher.log.info %Q(Skipping the punch for #{name}!)
         return nil
       end
-      if options[:mod]
-        mod = lookup_constant(options[:mod])
-      else
-        mod = DuckPuncher::Ducks.const_get(name)
-      end
       target = opts.delete(:target) || lookup_class
       Array(target).each do |klass|
         options[:before].call(klass) if options[:before]
@@ -39,6 +34,14 @@ 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)
@@ -53,17 +56,20 @@ module DuckPuncher
       end
     end
 
-    # @param [Class] obj The object being punched
-    def delegated(obj = nil)
-      obj_class = obj ? obj.class : lookup_class
-      klass = DelegateClass(obj_class)
-      punch target: klass, method: :prepend
-      klass.usable DuckPuncher::Ducks::Object, only: :punch, method: :prepend
-      klass
-    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
+    end
+
+    def hash
+      name.hash
+    end
   end
 end

data/lib/duck_puncher/ducks.rb

@@ -2,7 +2,7 @@ module DuckPuncher
   module Ducks
     class << self
       def list
-        @list ||= [
+        @list ||= Set.new [
           Duck.new(:String),
           Duck.new(:Array),
           Duck.new(:Numeric),

data/lib/duck_puncher/ducks/array.rb

@@ -5,10 +5,18 @@ module DuckPuncher
         map(&method_name)
       end
 
+      def m!(method_name)
+        map!(&method_name)
+      end
+
       def mm(method_name, *args)
         map { |x| x.public_send(method_name, *args) }
       end
 
+      def mm!(method_name, *args)
+        map! { |x| x.public_send(method_name, *args) }
+      end
+
       def except(*args)
         self - args
       end

data/lib/duck_puncher/ducks/object.rb

@@ -11,8 +11,9 @@ 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)
-        DuckPuncher.delegate_class(duck_name, self).new(self)
+        extend Ducks[duck_name.to_sym].mod
       end
 
       def track

data/lib/duck_puncher/version.rb

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

data/test/lib/duck_puncher/array_test.rb

@@ -11,10 +11,16 @@ class ArrayTest < MiniTest::Test
 
   def test_m
     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)
+    assert_equal subject.object_id, subject.m!(:upcase).object_id
   end
 
   def test_mm_with_two_args
     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-')
+    assert_equal subject.object_id, subject.mm!(:prepend, 'btn-').object_id
   end
 
   def test_mm_with_three_args

data/test/lib/duck_puncher/object_test.rb

@@ -44,4 +44,14 @@ class ObjectTest < MiniTest::Test
     DuckPuncher.register :super_admin, mod: 'CustomPunch3'
     assert @user.punch(:super_admin).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)
+  end
 end

data/test/lib/duck_puncher_test.rb

@@ -8,6 +8,10 @@ class DuckPuncherTest < MiniTest::Test
     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
   end
 
   def test_register_with_array

data/test/test_helper.rb

@@ -16,6 +16,7 @@ end
 
 module CustomPunch2
   def quack
+    'quack'
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duck_puncher
 version: !ruby/object:Gem::Version
-  version: 2.16.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Ryan Buckley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-03 00:00:00.000000000 Z
+date: 2016-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: usable
@@ -150,7 +150,7 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Administer precision punches to your favorite Ruby classes
+summary: Administer precision extensions (a.k.a "punches") to your favorite Ruby classes
 test_files:
 - test/fixtures/wut.rb
 - test/lib/duck_puncher/array_test.rb