duck_puncher 4.4.2 → 5.0.1

data/.ruby-gemset

@@ -1 +0,0 @@
-duck_puncher

data/.ruby-version

@@ -1 +0,0 @@
-ruby-2.3.0

data/.travis.yml

@@ -1,10 +0,0 @@
-language: ruby
-rvm:
-  - 2.0.0
-  - 2.1.0
-  - 2.1.5
-  - 2.2.1
-  - 2.2.2
-  - 2.2.3
-  - 2.3.0
-before_install: gem install bundler -v 1.10.5

data/CHANGELOG.md

@@ -1,20 +0,0 @@
-4.4.2 (01/10/2016)
-==================
-
-* Fix glaring bug in Duck class where the `:only` option is ignored (since 4.4.0)
-
-4.4.1 (12/19/2016)
-==================
-
-* Lazy load the rubygems/dependency_installer only when `require!` is called
-
-4.4.0 (12/4/2016)
-=================
-
-* Target objects are no longer extended with the [Usable](https://github.com/ridiculous/usable) module
-
-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/Gemfile

@@ -1,9 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in duck_puncher.gemspec
-gemspec
-
-if RUBY_VERSION >= '2.0'
-  gem 'byebug'
-  # gem 'object_tracker'
-end

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2016 Ryan Buckley
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,272 +0,0 @@
-# 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 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!`.
-
-## Install
-
-```ruby
-gem 'duck_puncher', '~> 4.3'
-```
-
-## Usage
-
-Punch all registered ducks:
-
-```ruby
-DuckPuncher.()
-```
-
-Punch individual ducks by name:
-
-```ruby
-DuckPuncher.(Hash, Object)
-```
-
-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:
-
-```ruby
-DuckPuncher.(Numeric, only: [:to_currency, :to_duration])
-```
-
-If you punch `Object` then you can use `#punch!` on any object to extend individual instances:
-
-```ruby
->> DuckPuncher.(Object, only: :punch!)
->> %w[yes no 1].punch!.m!(:punch).m(:to_boolean)
-=> [true, false, true]
-```
-
-Alternatively, there is also the `Object#punch` method which returns a decorated copy of an object with punches mixed in:
-```ruby
->> DuckPuncher.(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:
-```ruby
->> LovableDuck = Module.new { def inspect() "I love #{self.first}" end }
->> 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
->> 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"
-* /.../delegate.rb:85:in `method_missing'
-=> ["A", "B", "C", "D", "E", "F", "G", "H", "I", ...]
->> hard_punch
-"a".."z"
-* (irb):11:in `hard_punch'
-=> ["AAA", "BBB", "CCC", "DDDD", ...]
-```
-
-## 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
-```
-
-#### 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#L10).
-
-```ruby
-DuckPuncher.register <class>, [<module>, ...]
-```
-
-A full example:
-```ruby
-# Define some extensions
-module Billable
-  def call(amt)
-    puts "Attempting to bill #{name} for $#{amt}"
-    fail Errno::ENOENT
-  end
-end
-
-module Retryable
-  def call_with_retry(*args, retries: 3)
-    call *args
-  rescue Errno::ENOENT
-    puts 'retrying'
-    retry if (retries -= 1) > 0
-  end
-end
-```
-
-```ruby
-# Our duck
-class User < Struct.new(:name)
-end
-
-# Register the extensions
-DuckPuncher.register User, Billable, Retryable
-
-# Add the #punch method to User instances
-DuckPuncher.(Object, only: :punch)
-
-# Usage
-user = User.new('Ryan').punch
-user.call_with_retry(19.99)
-```
-
-To register the extension _and_ punch the class, use `DuckPuncher.register!`
-
-## Logging
-
-Get notified of all punches/extensions by changing the logger level:
-
-```ruby
-DuckPuncher.logger.level = Logger::INFO
-```
-
-The default log level is `DEBUG`
-
-## Experimental
-
-__Object#require!__ will try to require a gem, or, if it's not found, then _download_ it! It will also keep track of any
-downloaded gems and load them for subsequent IRB/rails console sessions. Gems are _not_ 
-saved to the Gemfile.
-
-In the wild:
-
-```bash
->> `require 'pry'` 
-LoadError: cannot load such file -- pry
- from (irb):1:in `require'
- from (irb):1
- from bin/console:10:in `<main>'
->> DuckPuncher.(Object, only: :require!)
-=> nil
->> require! 'pry'
-Fetching: method_source-0.8.2.gem (100%)
-Fetching: slop-3.6.0.gem (100%)
-Fetching: coderay-1.1.0.gem (100%)
-Fetching: pry-0.10.3.gem (100%)
-=> true
->> Pry.start
-[1] pry(main)>
-```
-
-Perfect! Mostly ... although, it doesn't work well with bigger gems or those with native extensions ¯\\\_(ツ)_/¯
-
-__Object#track__ builds upon `require!` to download the [ObjectTracker](https://github.com/ridiculous/object_tracker) gem,
-if it's not available in the current load path, and starts tracking the current object!
-
-```ruby
-Duck = Class.new
-Donald = Module.new { def tap_tap() self end }
-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)
-# =>  ...
-```
-
-## Contributing
-
-* Fork it
-* Run tests with `rake`
-* Start an IRB console that already has all your ducks in a row: `bin/console`
-* Start an IRB console without punching ducks: `PUNCH=no bin/console`
-* Make changes and submit a PR to [https://github.com/ridiculous/duck_puncher](https://github.com/ridiculous/duck_puncher)
-
-## License
-
-MIT

data/Rakefile

@@ -1,13 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rake'
-require 'rake/testtask'
-
-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: tasks.map(&:name)

data/bin/console

@@ -1,30 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-require 'pp'
-require 'irb'
-require 'byebug'
-
-# Stub out Rails
-module Rails
-  module VERSION
-    MAJOR = 4
-  end
-end
-
-# And AR
-module ActiveRecord
-  class Base
-  end
-end
-
-require 'duck_puncher'
-require_relative '../test/fixtures/wut'
-
-DuckPuncher.logger.level = Logger::DEBUG
-
-if ENV['PUNCH'] != 'no'
-  DuckPuncher.()
-end
-
-IRB.start

data/test/fixtures/test_classes.rb

@@ -1,42 +0,0 @@
-module CustomPunch
-  def talk
-    p self
-    self
-  end
-end
-
-module CustomPunch2
-  def quack
-    'quack'
-  end
-end
-
-module CustomPunch3
-  def wobble
-  end
-end
-
-module ModWithOverride
-  def talk
-    'talk is cheap'
-  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

data/test/fixtures/wut.rb

@@ -1,7 +0,0 @@
-class Wut
-  def to_a
-    ['w'] + ['u'] + ['t']
-  end
-
-  def to_f() Float::INFINITY end
-end

data/test/lib/duck_puncher/duck_test.rb

@@ -1,45 +0,0 @@
-require_relative '../../test_helper'
-
-class DuckTest < MiniTest::Test
-  def setup
-    @class = Class.new
-    @object = @class.new
-    @mod = Module.new { %w[foo bar baz].each { |x| define_method(x, -> {}) } }
-    @subject = DuckPuncher::Duck.new(@class, @mod)
-  end
-
-  def test_punch
-    @subject.target = Kaia
-    refute_respond_to Kaia.new, :baz
-    @subject.call
-    assert_respond_to Kaia.new, :foo
-    assert_respond_to Kaia.new, :bar
-    assert_respond_to Kaia.new, :baz
-  end
-
-  def test_punch_with_instance
-    e = assert_raises ArgumentError do
-      @subject.call target: @object
-    end
-    assert_match /Invalid target #<#{@class}:.*>\. Please pass a module as :target/,
-                 e.message
-  end
-
-  def test_punch_with_only
-    refute_respond_to @object, :foo
-    refute_respond_to @object, :bar
-    @subject.call(only: :foo)
-    refute_respond_to @object, :bar
-    assert_respond_to @object, :foo
-    @subject.call(only: :bar)
-    assert_respond_to @object, :bar
-  end
-
-  def test_punch_with_only_target
-    refute_respond_to @object, :bar
-    @subject.call target: @class, only: [:foo, :bar]
-    assert_respond_to @object, :bar
-    assert_respond_to @object, :foo
-    refute_respond_to @object, :baz
-  end
-end