mpatch 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7e9027098ef5a1a6e82b4c83f649fffb4e32ab8
-  data.tar.gz: c99db91ab54679f32da1b2036096d85aa6fa8310
+  metadata.gz: 09f45571e4ead5c5407a50275bcca9b13316b3b1
+  data.tar.gz: 79afe3c73630cb5124c58967e9dafc790efa665c
 SHA512:
-  metadata.gz: fe3940bf12ffe41bf3f13e49c44f5c8d681065dfb12838551d5de1b293457a7e5739a9124f451c3fea35cb193cbb437133f50c09d79de3af16bdbd129c0ef43b
-  data.tar.gz: 047825d93ea62e32b0db043432a674c04b8329754c14dc2fd6fae65b94f8a4b1e344f40616736055860fe0732a704c38ab938199f92d7302f3b6b864463e5a65
+  metadata.gz: e47dcb190075aab9e175dc9a02d3cc68d9d77a9a6785154541f8280f6959c2b8bda5468e0aaa5541c3b21b87668917056edb36942bfb1d811a229b6621078ac4
+  data.tar.gz: 256612b44b53b3d28f8f2f69e7a01651a0c312cdd864e0aeac1fae56b21980ffa6fe080cf06e483066af53c88a9ed19693a86fab94b409fc2667bb5630b7caa2

data/README.md

@@ -3,75 +3,125 @@ mpatch
 
 Monkey patch collection for advance helper functions
 
-This project aim to give flexible methods to the developer by giving new inheritance to the base classes
+This project aim to give flexible methods to the developer by giving new methods by inheritance to the base classes.
+This will result in lot of helper methods, and metaprograming tricks
 
-for example
 
-`ruby
+### Install
 
-require 'mpatch'
+    gem install mpatch
 
-class Test
+### Use
 
-  def initialize
+```ruby
+    # load and patch all
+    require 'mpatch'
+```
 
-    @hello= "world"
-    @sup=   "nothing"
 
-  end
+### example with Class methods
+
+```ruby
+    require 'mpatch'
+
+    class Test
+
+      def initialize
+
+        @hello= "world"
+        @sup=   "nothing"
 
-end
+      end
 
-puts Test.new.to_hash
-#> {"hello" => "world", "sup" => "nothing"}
-`
+    end
+
+    puts Test.new.convert_to_hash
+    #> {"hello" => "world", "sup" => "nothing"}
+```
 
 The module give you tools in your hand for inheritance handle.
 For example:
 
-`ruby
-puts Models::MongoidClassName.mixin_ancestors.include? Mongoid::Document
-#> true
+```ruby
+    puts Models::MongoidClassName.mixin_ancestors.include? Mongoid::Document
+    #> true
 
-puts Mongoid::Document.inherited_by.inspect
-#> [MongoidClassName]
+    puts Mongoid::Document.inherited_by.inspect
+    #> [MongoidClassName]
 
-class Test
+    class Test
 
-end
+    end
 
-module Hello
-  class World < Test
-  end
-end
+    module Hello
+      class World < Test
+      end
+    end
+
+    puts Test.inherited_by.inspect
+    #> [Hello::World]
+
+    module ParentModule
+
+    end
 
-puts Test.inherited_by.inspect
-#> [Hello::World]
+    module TargetModule
+      include ParentModule
+    end
 
-module ParentModule
+    module SomeModuleThatInclude
+      include TargetModule
+    end
 
-end
+    class SomeClassThatInclude
+      include TargetModule
+    end
 
-module TargetModule
-  include ParentModule
-end
+    puts TargetModule.inherited_by.inspect
+    #>[SomeClassThatInclude, SomeModuleThatInclude]
 
-module SomeModuleThatInclude
-  include TargetModule
-end
+    puts TargetModule.inherited_by(Class).inspect
+    #>[SomeClassThatInclude]
+```
 
-class SomeClassThatInclude
-  include TargetModule
-end
+### require for use only
 
-puts TargetModule.inherited_by.inspect
-#>[SomeClassThatInclude, SomeModuleThatInclude]
+```ruby
+    require File.join 'mpatch','array' # == require 'mpatch/array' but works on windows alike
 
-puts TargetModule.inherited_by(class).inspect
-#>[SomeClassThatInclude]
+    # sugar syntax
+    # in this case it will help you with Array class for the following
+    #
+    #   Array.__send__ :include/:extend , ::MPatch::Module::Name
+    #
+    # it will always choose include or extend method based on the module use porpuse
+    # now it's a :include
 
-`
+    MPatch.patch! # || inject_patches || inject
+    puts ["asd"].has_any_of?(%W[ 123 hello\ world sup? asd ])
+```
+
+### make your own!
+
+you can make your own monkey patches by the following
+
+```ruby
+  module MPatch
+
+    module Include # if you want to include to the target object
+
+      module TargetClassName #> for example Array
+
+      end
+
+    end
+
+  end
 
+  MPatch.patch!
+  # done, you all set
+  # if you want to contribute with use cases, please do so! :)
+```
 
 But there is a lot of method, for example for modules modules / subbmodules call that retunr modules under that namespace.
 Lot of metaprogrammer stuff there too :)

data/VERSION

@@ -1 +1 @@
-2.3.0
+2.4.0

data/examples/test.rb

@@ -1,4 +1,7 @@
-require 'mpatch'
+require File.join 'mpatch','array'
+MPatch.patch!
 
-puts Module.ancestors.inspect
-puts ["asd"].has_any_of?(["asd"])
+puts ["asd"].has_any_of?(%W[ 123 hello\ world sup? asd])
+
+require File.join 'mpatch' # require and patch all
+puts Object.ancestors.inspect

data/lib/mpatch/all.rb

@@ -0,0 +1,7 @@
+#encoding: UTF-8
+module MPatch
+
+  Dir.glob(File.join(File.absolute_path(File.dirname(__FILE__)),"*.{rb,ru}")).each{|e|require e}
+  self.inject_patches
+
+end

data/lib/mpatch/array.rb

@@ -1,154 +1,162 @@
-module MPatch::Include
+module MPatch
 
-  module Array
+  module Include
 
-    # remove arguments or array of
-    # parameters from the main array
-    def trim(*args)
+    module Array
 
-      args.dup.each do |one_element|
-        if one_element.class <= ::Array
-          args.delete_at(args.index(one_element))
-          args= args+one_element
-        end
-      end
+      # remove arguments or array of
+      # parameters from the main array
+      def trim(*args)
 
-      delete_array= self.class.new
-      args.each do |one_element|
-        index= self.index(one_element)
-        unless index.nil?
-          delete_array.push index
-          self.delete_at(index)
+        args.dup.each do |one_element|
+          if one_element.class <= ::Array
+            args.delete_at(args.index(one_element))
+            args= args+one_element
+          end
         end
-      end
 
-      return self
-
-    end
+        delete_array= self.class.new
+        args.each do |one_element|
+          index= self.index(one_element)
+          unless index.nil?
+            delete_array.push index
+            self.delete_at(index)
+          end
+        end
 
-    # return index of the target element
-    def index_of(target_element)
-      array = self
-      hash = ::Hash[array.map.with_index.to_a]
-      return hash[target_element]
-    end
+        return self
 
-    # remove n. element from the end
-    # and return a new object
-    def pinch n=1
-      return self[0..(self.count-(n+1))]
-    end
+      end
 
-    # remove n. element from the end
-    # and return the original object
-    def pinch! n=1
-      n.times do
-        self.pop
+      # return index of the target element
+      def index_of(target_element)
+        array = self
+        hash = ::Hash[array.map.with_index.to_a]
+        return hash[target_element]
       end
-      return self
-    end
 
-    # return boolean by other array
-    # all element included or
-    # not in the target array
-    def contain?(oth_array)#anothere array
-      (oth_array & self) == oth_array
-    end
+      # remove n. element from the end
+      # and return a new object
+      def pinch n=1
+        return self[0..(self.count-(n+1))]
+      end
 
-    # return boolean by other array
-    # if any element included from
-    # the oth_array, return a true
-    def contain_any_of?(oth_array)
-      oth_array.each do |element|
-        if self.include? element
-          return true
+      # remove n. element from the end
+      # and return the original object
+      def pinch! n=1
+        n.times do
+          self.pop
         end
+        return self
       end
-      return false
-    end
 
-    alias :contains_any_of? :contain_any_of?
-    alias :has_any_of? :contain_any_of?
+      # return boolean by other array
+      # all element included or
+      # not in the target array
+      def contain?(oth_array)#anothere array
+        (oth_array & self) == oth_array
+      end
 
-    # do safe transpose
-    def safe_transpose
-      result = []
-      max_size = self.max { |a,b| a.size <=> b.size }.size
-      max_size.times do |i|
-        result[i] = self.class.new(self.first.size)
-        self.each_with_index { |r,j| result[i][j] = r[i] }
+      # return boolean by other array
+      # if any element included from
+      # the oth_array, return a true
+      def contain_any_of?(oth_array)
+        oth_array.each do |element|
+          if self.include? element
+            return true
+          end
+        end
+        return false
       end
-      result
-    end
 
-    alias :contains? :contain?
+      alias :contains_any_of? :contain_any_of?
+      alias :has_any_of? :contain_any_of?
 
-    # return boolean
-    # if any element class is equal to th given class
-    # return a true , else false
-    def contain_element_of_class?(class_name)
-      target_array= self.map{|e| e.class }.uniq
-      if class_name.class != ::Class
-        raise ::ArgumentError, "Argument must be a Class!"
-      end
-      if target_array.include? class_name
-        return true
+      # do safe transpose
+      def safe_transpose
+        result = []
+        max_size = self.max { |a,b| a.size <=> b.size }.size
+        max_size.times do |i|
+          result[i] = self.class.new(self.first.size)
+          self.each_with_index { |r,j| result[i][j] = r[i] }
+        end
+        result
       end
-      return false
-    end
-
-    alias :contains_element_of_class? :contain_element_of_class?
-    alias :has_element_of_class?      :contain_element_of_class?
 
-    # generate params structure from array
-    # *args => [:opts,:args]
-    def params_separation
+      alias :contains? :contain?
 
-      options= self.map { |element|
-        if element.class == ::Hash
-          element
+      # return boolean
+      # if any element class is equal to th given class
+      # return a true , else false
+      def contain_element_of_class?(class_name)
+        target_array= self.map{|e| e.class }.uniq
+        if class_name.class != ::Class
+          raise ::ArgumentError, "Argument must be a Class!"
+        end
+        if target_array.include? class_name
+          return true
         end
-      }.uniq - [ nil ]
-      #options.each{|e| self.delete(e) }
-      arguments= self.dup - options
-      options= ::Hash[*options]
+        return false
+      end
 
-      return [options,arguments]
+      alias :contains_element_of_class? :contain_element_of_class?
+      alias :has_element_of_class?      :contain_element_of_class?
 
-    end
+      # generate params structure from array
+      # *args => [:opts,:args]
+      def params_separation
 
-    alias :separate_params :params_separation
-    alias :process_params  :params_separation
+        options= self.map { |element|
+          if element.class == ::Hash
+            element
+          end
+        }.uniq - [ nil ]
+        #options.each{|e| self.delete(e) }
+        arguments= self.dup - options
+        options= ::Hash[*options]
 
-    # generate params structure from array
-    # return_array
-    def extract_class! class_name
+        return [options,arguments]
 
-      unless class_name.class <= ::Class
-        raise ::ArgumentError, "parameter must be a class name"
       end
 
-      return_value= self.map { |element|
-        if element.class <= class_name
-          element
+      alias :separate_params :params_separation
+      alias :process_params  :params_separation
+
+      # generate params structure from array
+      # return_array
+      def extract_class! class_name
+
+        unless class_name.class <= ::Class
+          raise ::ArgumentError, "parameter must be a class name"
         end
-      }.uniq - [ nil ]
-      return_value.each{|e| self.delete(e) }
 
-      return_value ||= self.class.new
+        return_value= self.map { |element|
+          if element.class <= class_name
+            element
+          end
+        }.uniq - [ nil ]
+        return_value.each{|e| self.delete(e) }
 
-      return return_value
+        return_value ||= self.class.new
 
-    end
-    alias :cut_class! :extract_class!
+        return return_value
+
+      end
+      alias :cut_class! :extract_class!
+
+      # generate params structure from array
+      # *args - options {}
+      def extract_options!
+        options= self.extract_class! ::Hash
+        return ::Hash[*options]
+      end
+      alias :extract_hash! :extract_options!
 
-    # generate params structure from array
-    # *args - options {}
-    def extract_options!
-      options= self.extract_class! ::Hash
-      return ::Hash[*options]
     end
-    alias :extract_hash! :extract_options!
 
   end
+
+  require File.join 'mpatch','injector'
+
+
 end

data/lib/mpatch/class.rb

@@ -1,94 +1,103 @@
-module MPatch::Include
-  module Class
+module MPatch
 
-    # get singleton methods to target class without super class methods
-    def class_methods
-      self.methods - ::Object.methods
-    end
+  module Include
 
-    # bind a singleton method to a class object
-    def create_class_method(method,&block)
-      self.class_eval do
-        define_singleton_method method do |*args|
-          block.call *args
-        end
+    module Class
+
+      # get singleton methods to target class without super class methods
+      def class_methods
+        self.methods - ::Object.methods
       end
-    end
 
-    # create an instance method
-    def create_instance_method(method,&block)
-      self.class_eval do
-        define_method method do |*args|
-          block.call *args
+      # bind a singleton method to a class object
+      def create_class_method(method,&block)
+        self.class_eval do
+          define_singleton_method method do |*args|
+            block.call *args
+          end
         end
       end
-    end
 
-    # Iterates over all subclasses (direct and indirect)
-    def each_subclass
-      ::ObjectSpace.each_object(::Class) { | candidate |
-        begin
-          yield candidate if candidate < self
-        rescue ::ArgumentError
-          # comparison of Class with Class failed (ArgumentError)
+      # create an instance method
+      def create_instance_method(method,&block)
+        self.class_eval do
+          define_method method do |*args|
+            block.call *args
+          end
         end
-      }
-    end
+      end
 
-    # Returns an Array of subclasses (direct and indirect)
-    def subclasses_all
-      ret = []
-      each_subclass {|c| ret.push c}
-      ret
-    end
+      # Iterates over all subclasses (direct and indirect)
+      def each_subclass
+        ::ObjectSpace.each_object(::Class) { | candidate |
+          begin
+            yield candidate if candidate < self
+          rescue ::ArgumentError
+            # comparison of Class with Class failed (ArgumentError)
+          end
+        }
+      end
 
-    alias :all_subclasses :subclasses_all
+      # Returns an Array of subclasses (direct and indirect)
+      def subclasses_all
+        ret = []
+        each_subclass {|c| ret.push c}
+        ret
+      end
 
-    # Returns an Array of direct subclasses
-    def subclasses
-      ret = []
-      each_subclass {|c| ret.push(c) if c.superclass == self }
-      ret
-    end
-    alias :subclass :subclasses
+      alias :all_subclasses :subclasses_all
+
+      # Returns an Array of direct subclasses
+      def subclasses
+        ret = []
+        each_subclass {|c| ret.push(c) if c.superclass == self }
+        ret
+      end
+      alias :subclass :subclasses
 
-    # create singleton attribute
-    def class_attr_accessor(name)
+      # create singleton attribute
+      def class_attr_accessor(name)
 
-      ### GET
-      begin
-        define_method name do
-          class_variable_get "@@#{name}"
+        ### GET
+        begin
+          define_method name do
+            class_variable_get "@@#{name}"
+          end
         end
-      end
 
-      ### SET
-      begin
-        define_method "#{name}=" do |new_val|
-          class_variable_set "@@#{name}", new_val
+        ### SET
+        begin
+          define_method "#{name}=" do |new_val|
+            class_variable_set "@@#{name}", new_val
+          end
         end
-      end
 
-    end
+      end
 
-    # create class instance attribute
-    def instance_attr_accessor(name)
+      # create class instance attribute
+      def instance_attr_accessor(name)
 
-      ### GET
-      begin
-        define_method name do
-          instance_variable_get "@#{name}"
+        ### GET
+        begin
+          define_method name do
+            instance_variable_get "@#{name}"
+          end
         end
-      end
 
-      ### SET
-      begin
-        define_method "#{name}=" do |new_val|
-          instance_variable_set "@#{name}", new_val
+        ### SET
+        begin
+          define_method "#{name}=" do |new_val|
+            instance_variable_set "@#{name}", new_val
+          end
         end
+
       end
 
     end
 
   end
+
+  require File.join 'mpatch','injector'
+
+
 end