footing 0.0.1 → 0.0.2

data/README.md

@@ -2,33 +2,39 @@
 
 #### NOTE: this lib is experimental at the moment
 
-This lib extends native objects with additional functionality.
+Footing provides some sanity for monkey patching practices.
+It's also a utility lib that contains additional functionality for core objects that you might find useful.
 
 ## No implicit monkey patching
 
-**No surprises here.** You must explicitly ask for Footing goodness to be added to your objects.
+**No surprises here.** You must explicitly patch.
 
 ```ruby
 # some examples of explicit patching
-Footing.patch!(String)
+Footing.patch! String, Footing::String
+Footing.patch! Numeric, Footing::Numeric
+```
+
+```ruby
+# instrospect the changes
 String.ancestors
 [
   String,
   Footing::String::InstanceMethods,
+  Footing::String,
   Comparable,
   Object,
-  PP::ObjectMixin,
   Kernel,
   BasicObject
 ]
 
-Footing.patch!(Numeric)
+Numeric.ancestors
 [
   Numeric,
   Footing::Numeric::InstanceMethods,
+  Footing::Numeric,
   Comparable,
   Object,
-  PP::ObjectMixin,
   Kernel,
   BasicObject
 ]
@@ -36,19 +42,27 @@ Footing.patch!(Numeric)
 
 ## Instance patching
 
-If you don't want to corrupt your entire runtime, you can patch an instance.
+If you don't want to corrupt the entire runtime, you can patch an instance.
 
 ```ruby
 s = "foo"
-Footing.patch!(s)
+Footing.patch! s, Footing::String
 s.respond_to? :escape # => true
 "foo".respond_to? :escape # => false
 ```
 
+## Shotgun patching
+
+For the lazy and brave, you can also patch everything at once.
+
+```ruby
+Footing.patch_all!
+```
+
 ## Kick the tires
 
 * `git clone git://github.com/hopsoft/footing.git`
 * `cd /path/to/footing`
 * `bundle`
 * `./console`
-* `Footing.patch(String)`
+* `Footing.patch String, Footing::String`

data/lib/extensions/numeric.rb

@@ -1,6 +1,10 @@
 module Footing
   module Numeric
 
+    def self.included(mod)
+      mod.send :include, InstanceMethods
+    end
+
     module InstanceMethods
 
       # Returns the percentage that this number is of the passed number.

data/lib/extensions/object.rb

@@ -1,5 +1,10 @@
 module Footing
   module Object
+
+    def self.included(mod)
+      mod.send :include, InstanceMethods
+    end
+
     module InstanceMethods
 
       # Returns the eigen class for the object.

data/lib/extensions/string.rb

@@ -1,5 +1,10 @@
 module Footing
   module String
+
+    def self.included(mod)
+      mod.send :include, InstanceMethods
+    end
+
     module InstanceMethods
 
       # Escapes a series of chars in the current string.

data/lib/footing.rb

@@ -1,55 +1,39 @@
 module Footing
 
-  # Patches the object with all applicable Hopsoft extensions and monkey patches.
-  # Works for Modules, Classes, and instances of objects.
-  # @param [Object] obj The object to patch.
-  def self.patch!(obj)
-    if obj.class == Module || obj.class == Class
-      # patching a Module or Class
-      violate(obj)
-    else
-      # patching an instance
-      eigen = nil
+  # Applies all Footing patches.
+  def self.patch_all!
+    list = [
+      "Kernel",
+      "Object",
+      "String",
+      "Numeric"
+    ]
+
+    list.each do |name|
+      context = Object.const_get(name)
+      footing = Footing.const_get(name)
+      patch! context, footing
+    end
+  end
+
+  # Patches a Module or instance with the given extension.
+  # @param [Module, Object] obj The Module or instance to patch.
+  # @param [Module] extension The Module that contains the patches.
+  def self.patch!(obj, extension)
+    context = obj if obj.is_a? Module
+    if context.nil?
       begin
-        eigen = class << obj
+        context = class << obj
           self
         end
       rescue Exception => ex
       end
-
-      raise "#{obj.class.name} doesn't support instance patching!" unless eigen
-      violate(eigen)
     end
-  end
-
-  private
 
-  # Violates the object by applying all applicable Footing extensions and monkey patches.
-  # @param [Object] obj The object to voilate.
-  def self.violate(obj)
-    chain = obj.ancestors.reduce({}) do |memo, ancestor|
-      memo[ancestor] = ancestor.name.split("::")
-      memo
-    end
-    chain[obj] = obj.name.split("::") if obj.name
-
-    chain.each do |ancestor, names|
-      context = obj
-      footing_context = Footing
-
-      names.each do |name|
-        const = context.const_get(name)
-        footing_const = footing_context.const_get(name) if footing_context.const_defined?(name) break unless footing_const.name =~ /^Footing/
-        break if footing_const.name =~ /^(Footing|Footing::Object)$/
-        const.extend footing_const::ClassMethods if defined?(footing_const::ClassMethods)
-        const.send :include, footing_const::InstanceMethods if defined?(footing_const::InstanceMethods)
-        context = const
-        footing_context = footing_const
-      end
-    end
-
-    true
+    raise "#{obj.class.name} doesn't support patching!" unless context
+    context.send :include, extension
   end
+
 end
 
 Dir[File.expand_path(File.join(File.dirname(__FILE__), "**/*.rb"))].each do |file|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: footing
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ cert_chain: []
 date: 2012-07-23 00:00:00.000000000 Z
 dependencies: []
 description: ! "    Footing provides some sanity for monkey patching practices.\n
-  \   It also is a utility lib that contains additional functionality for core objects
+  \   It's also a utility lib that contains additional functionality for core objects
   that you might find useful.\n"
 email:
 - natehop@gmail.com