duck_puncher 2.15.0 → 2.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0396fdad209bbef11b8fdcbd981c93d58a1d7ac9
-  data.tar.gz: 0dea0bc87f6f20719c7f571982b2808825ceee90
+  metadata.gz: a8a2fed5af6189e26acdeb046ec66ff7dec8368d
+  data.tar.gz: 6f487f85bd05ea581fcc4463e11b2b1c611a7f1e
 SHA512:
-  metadata.gz: 0f0ea32d017582b6ce51691f510f7eb3614c1be71a4af861a346c1cb45f09656ed65de6bf174c5541ea26dbdf0053602a4e1ff16c25b2dc7d59669e5000e6cfd
-  data.tar.gz: d34ef5fd1266ae89699bf053256e316a5c1be58b196feaaa8d61793b0896a7bc0e30792cf618e48bcd8503005067ec11b2691b81c40af04ea5ab11ad0cecfcfe
+  metadata.gz: 16fac17fdb70185f7deed4f5657cfa32c29203b7427a6cda940765a454eb8300dedcd4ebf056b785c54669dc901eef05ced5e5aa3c2833e4217ff99d1fdd3ba7
+  data.tar.gz: e40705f7bf0bb01eebdf5767e590254d5d83c8190df619cadd36fd31ff310d0d4a2a2ef2875626249ee32e3cd103e4ee9983b062776c5701089ce4924c802289

data/README.md

@@ -100,7 +100,9 @@ module Retryable
     retry if (retries -= 1) > 0
   end
 end
+```
 
+```ruby
 # Register the extensions
 DuckPuncher.register [:Billable, :Retryable]
 
@@ -116,6 +118,13 @@ 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:
+
+```ruby
+DuckPuncher.register :bills, mod: 'Admin::Billable'
+User.new.punch(:bills)
+```
+
 When punching at a class level, the `:class` option is required:
 
 ```ruby

data/lib/duck_puncher/duck.rb

@@ -4,45 +4,66 @@ module DuckPuncher
 
     # @param [Symbol] name of the duck
     # @param [Hash] options to modify the duck #punch method behavior
-    # @option options [String] :class (name) to punch
+    # @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 @klass before +punch+
-    # @option options [Proc] :after A hook that is called with the target @klass after +punch+
+    # @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
       @options = options
     end
 
     # @param [Hash] opts to modify punch
-    # @option options [Class] :target Overrides the @klass to be punched
+    # @option options [Class] :target Specifies the class to be punched
     # @option options [Array,Symbol] :only Specifies the methods to extend onto the current object
+    # @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) || klass
-      options[:before].call(target) if options[:before]
-      target.extend Usable
-      target.usable DuckPuncher::Ducks.const_get(name), opts
+      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]
+        klass.extend Usable
+        klass.usable mod, only: opts[:only], method: opts[:method]
+        options[:after].call(klass) if options[:after]
+      end
       target
     end
 
-    def klass
-      @klass ||= (options[:class] || name).to_s.split('::').inject(Kernel) { |k, part| k.const_get part }
+    # @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
 
     # @param [Class] obj The object being punched
     def delegated(obj = nil)
-      obj_class = obj ? obj.class : klass
+      obj_class = obj ? obj.class : lookup_class
       klass = DelegateClass(obj_class)
-      punch target: klass
+      punch target: klass, method: :prepend
       klass.usable DuckPuncher::Ducks::Object, only: :punch, method: :prepend
       klass
     end
 
     def classify
-      Class.new(klass).tap { |k| punch target: k }
+      Class.new(lookup_class).tap { |k| punch target: k }
     end
   end
 end

data/lib/duck_puncher/ducks/object.rb

@@ -12,7 +12,7 @@ module DuckPuncher
       end
 
       def punch(duck_name = self.class.name)
-        DuckPuncher.delegate_class(duck_name.to_sym, self).new(self)
+        DuckPuncher.delegate_class(duck_name, self).new(self)
       end
 
       def track

data/lib/duck_puncher/ducks/string.rb

@@ -14,6 +14,10 @@ module DuckPuncher
       def to_boolean
         !!BOOLEAN_MAP[downcase]
       end unless method_defined?(:to_boolean)
+
+      def constantize
+        split('::').inject(Object) { |o, name| o.const_get name }
+      end unless method_defined?(:constantize)
     end
   end
 end

data/lib/duck_puncher/ducks.rb

@@ -15,7 +15,7 @@ module DuckPuncher
 
       def [](name)
         list.find { |duck| duck.name == name.to_sym } ||
-          DuckPuncher.log.warn(%Q(Couldn't find "#{name}" in my list of Ducks! I know about: #{list.map(&:name).map(&:to_s)}))
+          fail(ArgumentError, %Q(Couldn't find "#{name}" in my list of Ducks! I know about: #{list.map(&:name).map(&:to_s)}))
       end
 
       def load_path_for(duck)

data/lib/duck_puncher/version.rb

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

data/lib/duck_puncher.rb

@@ -25,7 +25,13 @@ module DuckPuncher
     # @param [Symbol] duck_name
     # @param [Class] obj The object being punched
     def delegate_class(duck_name, obj = nil)
-      delegations[duck_name] ||= const_set "#{duck_name}DuckDelegated", Ducks[duck_name].dup.delegated(obj)
+      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)

data/test/lib/duck_puncher/hash_test.rb

@@ -1,12 +1,16 @@
 require_relative '../../test_helper'
-DuckPuncher.punch! :Object
+
+DuckPuncher.punch :Hash
 
 class HashTest < MiniTest::Test
+  def setup
+    @subject = DuckPuncher::HashDuck.new.merge({ a: 1, b: { c: 2 } })
+  end
+
   def test_dig
-    my_hash = { a: 1, b: { c: 2 } }.punch
-    assert_equal my_hash.dig(:a), 1
-    assert_equal my_hash.dig(:b, :a), nil
-    assert_equal my_hash.dig(:b, :c), 2
-    assert_equal my_hash.dig(:b), { c: 2 }
+    assert_equal @subject.dig(:a), 1
+    assert_equal @subject.dig(:b, :a), nil
+    assert_equal @subject.dig(:b, :c), 2
+    assert_equal @subject.dig(:b), { c: 2 }
   end
 end

data/test/lib/duck_puncher/object_test.rb

@@ -2,10 +2,46 @@ require_relative '../../test_helper'
 DuckPuncher.punch! :Object
 
 class ObjectTest < MiniTest::Test
+
+  def setup
+    Object.const_set :User, Class.new
+    @subject = Object.new
+    @user = User.new
+  end
+
+  def teardown
+    DuckPuncher::Ducks.list.delete_if { |duck| [:admin, :super_admin, :User].include?(duck.name) }
+    Object.send :remove_const, :User
+  end
+
   def test_clone!
-    obj = Object.new
-    cloned = obj.clone!
-    assert_equal cloned.class, obj.class
-    refute_equal cloned, obj
+    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)
+  end
+
+  def test_punch_with_a_core_duck
+    assert [].punch(:Array).respond_to?(:m)
+  end
+
+  def test_punch_on_a_custom_duck
+    DuckPuncher.register :User, mod: 'CustomPunch2'
+    assert @user.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)
   end
 end

data/test/lib/duck_puncher/string_test.rb

@@ -4,16 +4,16 @@ DuckPuncher.punch! :String
 
 class StringTest < MiniTest::Test
   def test_pluralize
-    assert_equal 'hour'.pluralize(1), 'hour'
-    assert_equal 'hour'.pluralize(0), 'hours'
-    assert_equal 'hour'.pluralize(2), 'hours'
+    assert_equal 'hour', 'hour'.pluralize(1)
+    assert_equal 'hours', 'hour'.pluralize(0)
+    assert_equal 'hours', 'hour'.pluralize(2)
   end
 
   def test_underscore
-    assert_equal 'MiniTest'.underscore, 'mini_test'
-    assert_equal 'MiniTestDoItToIt'.underscore, 'mini_test_do_it_to_it'
-    assert_equal 'MiniTest::Helper'.underscore, 'mini_test/helper'
-    assert_equal 'MiniTest::Helper::Expectations'.underscore, 'mini_test/helper/expectations'
+    assert_equal 'mini_test', 'MiniTest'.underscore
+    assert_equal 'mini_test_do_it_to_it', 'MiniTestDoItToIt'.underscore
+    assert_equal 'mini_test/helper', 'MiniTest::Helper'.underscore
+    assert_equal 'mini_test/helper/expectations', 'MiniTest::Helper::Expectations'.underscore
     assert_equal 'mini_test.rb', 'mini_test.rb'.underscore
     assert_equal 'duck_puncher/json_storage', 'DuckPuncher::JSONStorage'.underscore
   end
@@ -31,4 +31,9 @@ class StringTest < MiniTest::Test
     refute ''.to_boolean
     refute 'asd'.to_boolean
   end
+
+  def test_constantize
+    assert_equal MiniTest, 'MiniTest'.constantize
+    assert_equal MiniTest::Test, 'MiniTest::Test'.constantize
+  end
 end

data/test/test_helper.rb

@@ -5,6 +5,8 @@ require 'duck_puncher'
 
 Minitest::Reporters.use!
 
+DuckPuncher.log.level = Logger::INFO
+
 module CustomPunch
   def tap_tap
     p self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duck_puncher
 version: !ruby/object:Gem::Version
-  version: 2.15.0
+  version: 2.16.0
 platform: ruby
 authors:
 - Ryan Buckley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-27 00:00:00.000000000 Z
+date: 2016-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: usable