footing 0.0.2 → 0.0.3

data/README.md

@@ -1,10 +1,10 @@
 # Footing
 
-#### NOTE: this lib is experimental at the moment
-
 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.
 
+#### NOTE: this lib is experimental at the moment
+
 ## No implicit monkey patching
 
 **No surprises here.** You must explicitly patch.
@@ -59,10 +59,19 @@ For the lazy and brave, you can also patch everything at once.
 Footing.patch_all!
 ```
 
+## Patch free
+
+Dont like monkey patches? Run patch free by setting up utility methods instead.
+
+```ruby
+Footing.util! Footing::String
+Footing::String.escape "foo", "o" # => "f\\o\\o"
+```
+
 ## Kick the tires
 
 * `git clone git://github.com/hopsoft/footing.git`
 * `cd /path/to/footing`
 * `bundle`
 * `./console`
-* `Footing.patch String, Footing::String`
+* `Footing.patch! String, Footing::String`

data/lib/extensions/hash.rb

@@ -0,0 +1,30 @@
+module Footing
+  module Hash
+
+    def self.included(mod)
+      mod.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+
+      # Rekeys the Hash by invoking a method on the existing keys
+      # and uses the return value as the new key.
+      #
+      # NOTE: Creates and return a new Hash.
+      #
+      # Example:
+      #   h = { [1] => "short", [1,2] => "medium", [1,2,3] => "long" }
+      #   h.rekey(:length) # => { 1 => "short", 2 => "medium", 3 => "long" }
+      #
+      # @param [Symbol] name The method name to invoke on the existing keys.
+      # @return [Hash] A new Hash that has been re-keyed.
+      def rekey(method_name)
+        inject({}) do |new_hash, (key, value)|
+          new_hash[key.send(method_name)] = value
+          new_hash
+        end
+      end
+
+    end
+  end
+end

data/lib/extensions/kernel.rb

@@ -1,5 +1,26 @@
 module Footing
   module Kernel
 
+    def self.included(mod)
+      mod.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+
+      # Safely evals text inside of a sandbox.
+      # @see http://phrogz.net/programmingruby/taint.html Ruby safe level description.
+      # @param [String] text The text to eval.
+      # @param [Integer] level The safe level to apply.
+      # @return [Object]
+      def safe_eval(text, level=4)
+        sandbox = lambda do
+          $SAFE = level
+          eval(text.to_s)
+        end
+        sandbox.call
+      end
+
+    end
+
   end
 end

data/lib/extensions/numeric.rb

@@ -7,6 +7,23 @@ module Footing
 
     module InstanceMethods
 
+      # Returns a positive representation of the number.
+      def positive
+        return self if self >= 0
+        flip_sign
+      end
+
+      # Returns a negative representation of the number.
+      def negative
+        return self if self < 0
+        flip_sign
+      end
+
+      # Flips the sign on the number making it either either positive or negative.
+      def flip_sign
+        self * -1
+      end
+
       # Returns the percentage that this number is of the passed number.
       # @example
       #   8.percent_of(10) # => 80.0

data/lib/extensions/string.rb

@@ -2,9 +2,21 @@ module Footing
   module String
 
     def self.included(mod)
+      mod.extend ClassMethods
       mod.send :include, InstanceMethods
     end
 
+    module ClassMethods
+
+      ## Generates a random string (upcase alpha-numeric)
+      ## Returns a string with the length provided, defaulting to 12 chars
+      def random(length=12)
+        chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+        (0...length).map { chars.split('')[rand(chars.length)] }.join
+      end
+
+    end
+
     module InstanceMethods
 
       # Escapes a series of chars in the current string.
@@ -16,5 +28,6 @@ module Footing
       end
 
     end
+
   end
 end

data/lib/footing.rb

@@ -6,7 +6,8 @@ module Footing
       "Kernel",
       "Object",
       "String",
-      "Numeric"
+      "Numeric",
+      "Hash"
     ]
 
     list.each do |name|
@@ -34,6 +35,28 @@ module Footing
     context.send :include, extension
   end
 
+  # Creates class methods for all InstanceMethods in the module.
+  # This allows users to invoke utility methods rather than monkey patching if they so desire.
+  # @param [Module] mod The Module to setup util methods for.
+  def self.util!(mod)
+    proxy = ::Object.new
+    proxy_eigen = class << proxy
+      self
+    end
+
+    Footing.patch! proxy, mod
+
+    eigen = class << mod
+      self
+    end
+
+    mod.const_get("InstanceMethods").instance_methods(false).each do |method|
+      eigen.send :define_method, method do |value, *args|
+        proxy_eigen.instance_method(method).bind(value).call(*args)
+      end
+    end
+  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.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-23 00:00:00.000000000 Z
+date: 2012-07-24 00:00:00.000000000 Z
 dependencies: []
 description: ! "    Footing provides some sanity for monkey patching practices.\n
   \   It's also a utility lib that contains additional functionality for core objects
@@ -20,6 +20,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/extensions/hash.rb
 - lib/extensions/kernel.rb
 - lib/extensions/numeric.rb
 - lib/extensions/object.rb