duck_puncher 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee22023f5904a77f13fdc09ac72eefa9170938ea
-  data.tar.gz: 28fb5cc8000d7de6240b6cf6c41e476861c4e255
+  metadata.gz: d30be8964065fb57d3de53e4e23b2deaf8ceb277
+  data.tar.gz: f2bc471c1a31a1f438680f21440b86d489092cd1
 SHA512:
-  metadata.gz: fb0141394a399c457e4650f607ed66c7c924aa9c7e15030faafd1c20a18d812b620bc13864bcda8904720aa1218f65d915fdf8601af4e6dc4c412ebb722a0523
-  data.tar.gz: 9f86ea17b513e5e3e0e4da59c6665c398e6f26b8229b9d58f5f012578147577ad7755ef1775626f75ab69063159abf45b00acb03c323ff583905c52c2fbe98ec
+  metadata.gz: e117be77a8e6a2a80f0ba415315039fa727ba1495e52bfa9b83cd7b5d631b92ebce331eaac51f6b7fb2d5c76a00e2f88f19892f4f84039686fab277976a40588
+  data.tar.gz: 64a2e78858356beacb9f30ea6cd6955046c8f90fc596fd0d15c64cbe2e121423e85b9ffe384e08826655f45eddc74bae824a6c401877e65ebf62c44908adc851

data/README.md

@@ -2,33 +2,42 @@
 
 These are the ducks I can punch:
 
-    Array#m             => `[].m(:to_s)` alias for `[].map(&:to_s)` 
-    Array#mm            => `[].mm(:sub, /[aeiou]/, '*')` alias for `[].map { |x| x.sub(/[aeiou]/, '*') }` 
-    Array#get           => `[].methods.get('ty?')` searches the array for a string matching the 'ty?' (e.g. [:empty?]) 
-    Hash#seek           => `{a: 1, b: {c: 2}}.seek(:b, :c)` returns the value of nested hash keys (e.g. 2)
-    Numeric#to_currency => `25.245.to_currency` formats a number in currency (e.g. '25.25' or '1.00') 
-    Numeric#to_duration => `10_000.to_duration` turns a number into duration (e.g. '2 h 46 min')
-    Numeric#to_time_ago => `10_000.to_time_ago` turns a number into time ago (e.g. '2 hours ago')
-    Numeric#to_rad      => `10.15.to_rad` returns 0.17715091907742445
-    String#pluralize    => `'hour'.pluralize(2)` turns "hour" into "hours"
-    Object#clone!       => `Object.new.clone!` makes a deep clone of the object (using Marshal)
-    Object#require!     =>  Downloads and activates a gem for the current and subsequent consoles. For example:
-                           >> `require 'pry'` 
-                           LoadError: cannot load such file -- pry
-                           	from (irb):1:in `require'
-                           	from (irb):1
-                           	from bin/console:10:in `<main>'
-                           >> 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)>
+    Array#m             => `[].m(:to_s)` => `[].map(&:to_s)` 
+    Array#mm            => `[].mm(:sub, /[aeiou]/, '*')` => `[].map { |x| x.sub(/[aeiou]/, '*') }` 
+    Array#get           => `[].methods.get('ty?')` => [:empty?] 
+    Hash#seek           => `{a: 1, b: {c: 2}}.seek(:b, :c)` => 2
+    Numeric#to_currency => `25.245.to_currency` => 25.25 
+    Numeric#to_duration => `10_000.to_duration` => '2 h 46 min'
+    Numeric#to_time_ago => `10_000.to_time_ago` => '2 hours ago'
+    Numeric#to_rad      => `10.15.to_rad` => 0.17715091907742445
+    String#pluralize    => `'hour'.pluralize(2)` => "hours"
+    String#underscore   => `'DuckPuncher::JSONStorage'.underscore` => 'duck_puncher/json_storage'
+    Object#clone!       => `Object.new.clone!` => a deep clone of the object (using Marshal.dump)
     Method#to_instruct  => `Benchmark.method(:measure).to_instruct` returns the Ruby VM instruction sequence for the method
     Method#to_source    => `Benchmark.method(:measure).to_source` returns the method definition as a string
+    
+I also provide an experimental punch that tries to download the required gem if it doesn't exist on your computer. The
+method is called `require!` and works like this:
+
+Downloads and activates a gem for the current and subsequent consoles. For example:
+
+```bash
+>> `require 'pry'` 
+LoadError: cannot load such file -- pry
+ from (irb):1:in `require'
+ from (irb):1
+ from bin/console:10:in `<main>'
+>> 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)>
+```
 
+Try it out if your feeling frisky! However, I noticed it doesn't work well with bigger gems and those with native extensions.
 
 ## Install
 

data/bin/console

@@ -5,6 +5,7 @@ require 'pp'
 require 'duck_puncher'
 require 'irb'
 require_relative '../test/fixtures/wut'
+
 DuckPuncher.punch_all!
 
 IRB.start

data/lib/duck_puncher/duck.rb

@@ -0,0 +1,30 @@
+module DuckPuncher
+  class Duck
+    attr_accessor :name, :options
+
+    def initialize(name, options = {})
+      @name = name
+      @options = options
+      @punched = false
+    end
+
+    def load_path
+      "duck_puncher/ducks/#{name.to_s.downcase}"
+    end
+
+    def punch
+      return false if options[:if] && !options[:if].call
+      options[:before].call if options[:before]
+      const.send :include, DuckPuncher::Ducks.const_get(name)
+      @punched = true
+    end
+
+    def const
+      @const ||= (options[:class] || name).to_s.split('::').inject(Kernel) { |k, part| k.const_get part }
+    end
+
+    def punched?
+      @punched
+    end
+  end
+end

data/lib/duck_puncher/ducks/active_record.rb

@@ -0,0 +1,48 @@
+module DuckPuncher
+  module ActiveRecord
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def associations?
+      associations.present?
+    end
+
+    def associations
+      reflections.select { |key, _| send(key).present? rescue nil }.keys
+    end
+
+    module ClassMethods
+      def except_for(*ids)
+        scoped.where("#{quoted_table_name}.id NOT IN (?)", ids)
+      end
+
+      def since(time)
+        scoped.where("#{quoted_table_name}.created_at > ?", time)
+      end
+
+      alias created_since since
+
+      def before(time)
+        scoped.where("#{quoted_table_name}.created_at < ?", time)
+      end
+
+      def updated_since(time)
+        scoped.where("#{quoted_table_name}.updated_at > ?", time)
+      end
+
+      def between(start_at, end_at)
+        scoped.where("#{quoted_table_name}.created_at BETWEEN ? AND ", start_at, end_at)
+      end
+
+      def latest
+        scoped.order("#{quoted_table_name}.id ASC").last
+      end
+
+      # shim for backwards compatibility with Rails 3
+      def scoped
+        where(nil)
+      end if Rails::VERSION::MAJOR != 3
+    end
+  end
+end

data/lib/duck_puncher/ducks/array.rb

@@ -0,0 +1,18 @@
+module DuckPuncher
+  module Ducks
+    module Array
+      def m(method_name)
+        map(&method_name)
+      end
+
+      def mm(method_name, *args)
+        map { |x| x.public_send(method_name, *args) }
+      end
+
+      def get(regex_or_str)
+        regex = regex_or_str.is_a?(Regexp) ? regex_or_str : Regexp.new(Regexp.escape(regex_or_str))
+        select { |x| x.to_s =~ regex }
+      end
+    end
+  end
+end

data/lib/duck_puncher/ducks/hash.rb

@@ -0,0 +1,25 @@
+module DuckPuncher
+  module Ducks
+    module Hash
+      # http://coryodaniel.com/index.php/2009/12/30/ruby-getting-deeply-nested-values-from-a-hash-in-one-line-of-code/
+      def seek(*_keys_)
+        last_level = self
+        sought_value = nil
+
+        _keys_.each_with_index do |_key_, _idx_|
+          if last_level.is_a?(Hash) && last_level.has_key?(_key_)
+            if _idx_ + 1 == _keys_.length
+              sought_value = last_level[_key_]
+            else
+              last_level = last_level[_key_]
+            end
+          else
+            break
+          end
+        end
+
+        sought_value
+      end
+    end
+  end
+end

data/lib/duck_puncher/ducks/method.rb

@@ -0,0 +1,56 @@
+module DuckPuncher
+  module Ducks
+    module Method
+      def to_instruct
+        definition = Definition.new(self)
+        RubyVM::InstructionSequence.new(definition.lines.join).disasm if definition.lines.any?
+      end
+
+      def to_source
+        Definition.new(self).to_s
+      end
+
+      class Definition
+        def initialize(method_handle)
+          @file_path, @line_num = *method_handle.source_location
+          @line_num = @line_num.to_i
+        end
+
+        # @description finds the method's source code using the indent size of the file. This means we are
+        # restricted when it comes to parsing crappy formatted ruby files
+        def lines
+          return @lines if defined? @lines
+          return [] unless @file_path
+          @lines = []
+          File.open(@file_path) do |f|
+            found = false
+            i = 0
+            while line = f.gets and i += 1 and !found
+              next if i < @line_num
+              @lines << line
+              if @indent_size
+                found = @indent_size == find_indent_size(line)
+              else
+                @indent_size = find_indent_size(line)
+                found = line.end_with?("end\n")
+              end
+            end
+          end
+          @lines
+        end
+
+        def to_s
+          if lines.any?
+            lines.join.gsub /^\s{#{find_indent_size(lines.first)}}/, ''
+          else
+            ''
+          end
+        end
+
+        def find_indent_size(line)
+          line[/(\s*)/].size
+        end
+      end
+    end
+  end
+end

data/lib/duck_puncher/ducks/numeric.rb

@@ -0,0 +1,51 @@
+module DuckPuncher
+  module Ducks
+    module Numeric
+      def to_currency(prefix = '')
+        "#{prefix}%.2f" % self.round(2)
+      end
+
+      def to_duration(seconds = false)
+        secs = to_i
+        mins = secs / 60
+        hours = mins / 60
+        buffer = ''
+        if hours > 0
+          num_mins = mins % 60
+          buffer << "#{hours} h"
+          buffer << " #{num_mins} min" unless num_mins.zero?
+        elsif mins > 0
+          num_secs = secs % 60
+          buffer << "#{mins} min"
+          buffer << " #{num_secs} s" if seconds && num_secs.nonzero?
+        elsif seconds && secs >= 0
+          buffer << "#{secs} s"
+        end
+        buffer
+      end
+
+      # similar to Rails' #time_ago_in_words
+      def to_time_ago
+        secs = to_i
+        mins = secs / 60
+        hours = mins / 60
+        days = hours / 24
+        buffer = ''
+        if days > 0
+          buffer << "#{days} #{'day'.pluralize(days)}"
+        elsif hours > 0
+          buffer << "#{hours} #{'hour'.pluralize(hours)}"
+        elsif mins > 0
+          buffer << "#{mins} #{'minute'.pluralize(mins)}"
+        elsif secs >= 0
+          buffer << "less than a minute"
+        end
+        buffer << ' ago'
+      end
+
+      def to_rad
+        self / 180 * Math::PI
+      end
+    end
+  end
+end

data/lib/duck_puncher/ducks/object.rb

@@ -0,0 +1,15 @@
+module DuckPuncher
+  module Ducks
+    module Object
+      def clone!
+        Marshal.load Marshal.dump self
+      end unless defined? clone!
+
+      def require!(file_or_gem, version = '')
+        if DuckPuncher::GemInstaller.new.perform(file_or_gem, version)
+          require file_or_gem.tr('-', '/')
+        end
+      end
+    end
+  end
+end

data/lib/duck_puncher/ducks/string.rb

@@ -0,0 +1,13 @@
+module DuckPuncher
+  module Ducks
+    module String
+      def pluralize(count)
+        "#{self}#{'s' if count != 1}"
+      end unless method_defined?(:pluralize)
+
+      def underscore
+        gsub(/\B([A-Z])([a-z_0-9])/, '_\1\2').gsub('::', '/').downcase
+      end unless method_defined?(:underscore)
+    end
+  end
+end

data/lib/duck_puncher/ducks.rb

@@ -0,0 +1,29 @@
+module DuckPuncher
+  module Ducks
+    class << self
+      def list
+        @list ||= [
+          Duck.new(:Array),
+          Duck.new(:Numeric),
+          Duck.new(:Hash),
+          Duck.new(:String),
+          Duck.new(:Object),
+          Duck.new(:Method, before: -> { DuckPuncher::GemInstaller.initialize! }),
+          Duck.new(:ActiveRecord, class: 'ActiveRecord::Base', if: -> { defined? ::ActiveRecord })
+        ]
+      end
+
+      def [](name)
+        list.find { |duck| duck.name == name.to_sym }
+      end
+    end
+
+    #
+    # Autoload our ducks
+    #
+
+    list.each do |duck|
+      autoload duck.name, duck.load_path
+    end
+  end
+end

data/lib/duck_puncher/gem_installer.rb

@@ -1,5 +1,3 @@
-require_relative 'json_storage'
-
 class DuckPuncher::GemInstaller
   def self.initialize!
     spec_data = DuckPuncher::JSONStorage.read('load_paths.json').values
@@ -19,7 +17,6 @@ class DuckPuncher::GemInstaller
   # @param [String] name of the gem
   # @param [String] version of the gem to install (e.g. '1.2.3')
   def perform(*args)
-    require 'rubygems/dependency_installer'
     installer = Gem::DependencyInstaller.new(install_dir: Bundler.bundle_path.to_s, bin_dir: RbConfig::CONFIG['bindir'])
     installer.install *args.reject(&:empty?)
     installer.installed_gems.each do |gem|

data/lib/duck_puncher/version.rb

@@ -1,3 +1,3 @@
 module DuckPuncher
-  VERSION = '2.3.0'.freeze
+  VERSION = '2.4.0'.freeze
 end

data/lib/duck_puncher.rb

@@ -1,24 +1,43 @@
 require 'pathname'
 require 'fileutils'
+require 'logger'
 require 'duck_puncher/version'
 
 module DuckPuncher
-  autoload :Array, 'duck_puncher/array'
-  autoload :Numeric, 'duck_puncher/numeric'
-  autoload :Hash, 'duck_puncher/hash'
-  autoload :String, 'duck_puncher/string'
-  autoload :Object, 'duck_puncher/object'
-  autoload :Method, 'duck_puncher/method'
-
-  if defined? ActiveRecord
-    autoload :ActiveRecordExtensions, 'duck_puncher/active_record_extensions'
-  end
+  autoload :JSONStorage, 'duck_puncher/json_storage'
+  autoload :GemInstaller, 'duck_puncher/gem_installer'
+  autoload :Duck, 'duck_puncher/duck'
+  autoload :Ducks, 'duck_puncher/ducks'
 
   def self.punch!(*names)
-    names.each &method(:const_get)
+    names.each do |name|
+      if duck = Ducks[name]
+        if duck.punched?
+          log.info %Q(Already punched #{name})
+        else
+          log.warn %Q(Punching the #{name} ducky)
+          unless duck.punch
+            log.error %Q(Failed to punch #{name}!)
+          end
+        end
+      else
+        log.info %Q(Couldn't find "#{name}" in my list of Ducks! I know about: #{Ducks.list.map(&:name).map(&:to_s)})
+      end
+    end
+    nil
   end
 
   def self.punch_all!
-    constants.each &method(:const_get)
+    log.warn 'Punching all ducks! Watch out!'
+    Ducks.list.each &:punch
+  end
+
+  class << self
+    attr_accessor :log
+  end
+
+  self.log = Logger.new(STDOUT).tap do |config|
+    config.level = Logger::INFO
+    config.formatter = proc { |*args| "#{args.first}: #{args.last.to_s}\n" }
   end
 end

data/test/duck_puncher/string_test.rb

@@ -6,4 +6,13 @@ class StringTest < MiniTest::Test
     assert_equal 'hour'.pluralize(0), 'hours'
     assert_equal 'hour'.pluralize(2), 'hours'
   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.rb', 'mini_test.rb'.underscore
+    assert_equal 'duck_puncher/json_storage', 'DuckPuncher::JSONStorage'.underscore
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duck_puncher
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Ryan Buckley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-05 00:00:00.000000000 Z
+date: 2016-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,15 +97,17 @@ files:
 - bin/console
 - duck_puncher.gemspec
 - lib/duck_puncher.rb
-- lib/duck_puncher/active_record_extensions.rb
-- lib/duck_puncher/array.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/numeric.rb
+- lib/duck_puncher/ducks/object.rb
+- lib/duck_puncher/ducks/string.rb
 - lib/duck_puncher/gem_installer.rb
-- lib/duck_puncher/hash.rb
 - lib/duck_puncher/json_storage.rb
-- lib/duck_puncher/method.rb
-- lib/duck_puncher/numeric.rb
-- lib/duck_puncher/object.rb
-- lib/duck_puncher/string.rb
 - lib/duck_puncher/version.rb
 - test/duck_puncher/array_test.rb
 - test/duck_puncher/hash_test.rb

data/lib/duck_puncher/active_record_extensions.rb

@@ -1,48 +0,0 @@
-module ActiveRecordExtensions
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-
-  def associations?
-    associations.present?
-  end
-
-  def associations
-    reflections.select { |key, _| send(key).present? rescue nil }.keys
-  end
-
-  module ClassMethods
-    def except_for(*ids)
-      scoped.where("#{quoted_table_name}.id NOT IN (?)", ids)
-    end
-
-    def since(time)
-      scoped.where("#{quoted_table_name}.created_at > ?", time)
-    end
-
-    alias created_since since
-
-    def before(time)
-      scoped.where("#{quoted_table_name}.created_at < ?", time)
-    end
-
-    def updated_since(time)
-      scoped.where("#{quoted_table_name}.updated_at > ?", time)
-    end
-
-    def between(start_at, end_at)
-      scoped.where("#{quoted_table_name}.created_at BETWEEN ? AND ", start_at, end_at)
-    end
-
-    def latest
-      scoped.order("#{quoted_table_name}.id ASC").last
-    end
-
-    # shim for backwards compatibility with Rails 3
-    def scoped
-      where(nil)
-    end if Rails::VERSION::MAJOR != 3
-  end
-end
-
-ActiveRecord::Base.send(:include, ActiveRecordExtensions)

data/lib/duck_puncher/array.rb

@@ -1,18 +0,0 @@
-module DuckPuncher
-  module Array
-    def m(method_name)
-      map(&method_name)
-    end
-
-    def mm(method_name, *args)
-      map { |x| x.public_send(method_name, *args) }
-    end
-
-    def get(regex_or_str)
-      regex = regex_or_str.is_a?(Regexp) ? regex_or_str : Regexp.new(Regexp.escape(regex_or_str))
-      select { |x| x.to_s =~ regex }
-    end
-  end
-end
-
-Array.send(:include, DuckPuncher::Array)

data/lib/duck_puncher/hash.rb

@@ -1,25 +0,0 @@
-module DuckPuncher
-  module Hash
-    # http://coryodaniel.com/index.php/2009/12/30/ruby-getting-deeply-nested-values-from-a-hash-in-one-line-of-code/
-    def seek(*_keys_)
-      last_level = self
-      sought_value = nil
-
-      _keys_.each_with_index do |_key_, _idx_|
-        if last_level.is_a?(Hash) && last_level.has_key?(_key_)
-          if _idx_ + 1 == _keys_.length
-            sought_value = last_level[_key_]
-          else
-            last_level = last_level[_key_]
-          end
-        else
-          break
-        end
-      end
-
-      sought_value
-    end
-  end
-end
-
-Hash.send(:include, DuckPuncher::Hash)

data/lib/duck_puncher/method.rb

@@ -1,56 +0,0 @@
-module DuckPuncher
-  module Method
-    def to_instruct
-      definition = Definition.new(self)
-      RubyVM::InstructionSequence.new(definition.lines.join).disasm if definition.lines.any?
-    end
-
-    def to_source
-      Definition.new(self).to_s
-    end
-
-    class Definition
-      def initialize(method_handle)
-        @file_path, @line_num = *method_handle.source_location
-        @line_num = @line_num.to_i
-      end
-
-      # @description finds the method's source code using the indent size of the file. This means we are
-      # restricted when it comes to parsing crappy formatted ruby files
-      def lines
-        return @lines if defined? @lines
-        return [] unless @file_path
-        @lines = []
-        File.open(@file_path) do |f|
-          found = false
-          i = 0
-          while line = f.gets and i += 1 and !found
-            next if i < @line_num
-            @lines << line
-            if @indent_size
-              found = @indent_size == find_indent_size(line)
-            else
-              @indent_size = find_indent_size(line)
-              found = line.end_with?("end\n")
-            end
-          end
-        end
-        @lines
-      end
-
-      def to_s
-        if lines.any?
-          lines.join.gsub /^\s{#{find_indent_size(lines.first)}}/, ''
-        else
-          ''
-        end
-      end
-
-      def find_indent_size(line)
-        line[/(\s*)/].size
-      end
-    end
-  end
-end
-
-Method.send(:include, DuckPuncher::Method)

data/lib/duck_puncher/numeric.rb

@@ -1,51 +0,0 @@
-module DuckPuncher
-  module Numeric
-    def to_currency(prefix = '')
-      "#{prefix}%.2f" % self.round(2)
-    end
-
-    def to_duration(seconds = false)
-      secs = to_i
-      mins = secs / 60
-      hours = mins / 60
-      buffer = ''
-      if hours > 0
-        num_mins = mins % 60
-        buffer << "#{hours} h"
-        buffer << " #{num_mins} min" unless num_mins.zero?
-      elsif mins > 0
-        num_secs = secs % 60
-        buffer << "#{mins} min"
-        buffer << " #{num_secs} s" if seconds && num_secs.nonzero?
-      elsif seconds && secs >= 0
-        buffer << "#{secs} s"
-      end
-      buffer
-    end
-
-    # similar to Rails' #time_ago_in_words
-    def to_time_ago
-      secs = to_i
-      mins = secs / 60
-      hours = mins / 60
-      days = hours / 24
-      buffer = ''
-      if days > 0
-        buffer << "#{days} #{'day'.pluralize(days)}"
-      elsif hours > 0
-        buffer << "#{hours} #{'hour'.pluralize(hours)}"
-      elsif mins > 0
-        buffer << "#{mins} #{'minute'.pluralize(mins)}"
-      elsif secs >= 0
-        buffer << "less than a minute"
-      end
-      buffer << ' ago'
-    end
-
-    def to_rad
-      self / 180 * Math::PI
-    end
-  end
-end
-
-Numeric.send(:include, DuckPuncher::Numeric)

data/lib/duck_puncher/object.rb

@@ -1,19 +0,0 @@
-require_relative 'json_storage'
-require_relative 'gem_installer'
-
-module DuckPuncher
-  module Object
-    def clone!
-      Marshal.load Marshal.dump self
-    end unless defined? clone!
-
-    def require!(file_or_gem, version = '')
-      if DuckPuncher::GemInstaller.new.perform(file_or_gem, version)
-        require file_or_gem.tr('-', '/')
-      end
-    end
-  end
-end
-
-DuckPuncher::GemInstaller.initialize!
-Object.send(:include, DuckPuncher::Object)

data/lib/duck_puncher/string.rb

@@ -1,9 +0,0 @@
-module DuckPuncher
-  module String
-    def pluralize(count)
-      "#{self}#{'s' if count != 1}"
-    end
-  end
-end
-
-String.send(:include, DuckPuncher::String)