mpatch 2.3.0 → 2.4.0

data/lib/mpatch/hash.rb

@@ -1,111 +1,120 @@
-module MPatch::Include
-  module Hash
-
-    # remove elements by keys,
-    # array of keys,
-    # hashTags,
-    # strings
-    def trim(*args)
-
-      args.each do |one_element|
-        case true
-
-          when one_element.class <= ::Hash
-            begin
-              one_element.each do |key,value|
-                if self[key] == value
-                  self.delete(key)
+module MPatch
+
+  module Include
+
+    module Hash
+
+      # remove elements by keys,
+      # array of keys,
+      # hashTags,
+      # strings
+      def trim(*args)
+
+        args.each do |one_element|
+          case true
+
+            when one_element.class <= ::Hash
+              begin
+                one_element.each do |key,value|
+                  if self[key] == value
+                    self.delete(key)
+                  end
                 end
               end
-            end
 
-          when one_element.class <= ::Array
-            begin
-              one_element.each do |one_key|
-                self.delete(one_key)
+            when one_element.class <= ::Array
+              begin
+                one_element.each do |one_key|
+                  self.delete(one_key)
+                end
               end
-            end
 
-          when  one_element.class <= ::Symbol,
-              one_element.class <= ::String
-            begin
-              self.delete(one_element)
-            end
+            when  one_element.class <= ::Symbol,
+                one_element.class <= ::String
+              begin
+                self.delete(one_element)
+              end
 
+          end
         end
-      end
-      return self
-
-    end
+        return self
 
-    #pass single or array of keys, which will be removed, returning the remaining hash
-    def remove!(*keys)
-      keys.each{|key| self.delete(key) }
-      self
-    end
-
-    #non-destructive version
-    def remove(*keys)
-      self.dup.remove!(*keys)
-    end
+      end
 
-    # Returns a new hash with +self+ and +other_hash+ merged recursively.
-    #
-    #   h1 = {:x => {:y => [4,5,6]}, :z => [7,8,9]}
-    #   h2 = {:x => {:y => [7,8,9]}, :z => "xyz"}
-    #
-    #   h1.deep_merge(h2) #=> { :x => {:y => [7, 8, 9]}, :z => "xyz" }
-    #   h2.deep_merge(h1) #=> { :x => {:y => [4, 5, 6]}, :z => [7, 8, 9] }
-    def deep_merge(other_hash)
-      dup.deep_merge!(other_hash)
-    end unless method_defined? :deep_merge
-
-    alias :+ :deep_merge
-
-    # Same as +deep_merge+, but modifies +self+.
-    def deep_merge!(other_hash)
-      other_hash.each_pair do |k,v|
-        tv = self[k]
-        self[k] = tv.is_a?(::Hash) && v.is_a?(::Hash) ? tv.deep_merge(v) : v
+      #pass single or array of keys, which will be removed, returning the remaining hash
+      def remove!(*keys)
+        keys.each{|key| self.delete(key) }
+        self
       end
-      self
-    end unless method_defined? :deep_merge!
-
-    # return bool that does the sub hash all element include the hash who call this or not
-    def deep_include?(sub_hash)
-      sub_hash.keys.all? do |key|
-        self.has_key?(key) && if sub_hash[key].is_a?(::Hash)
-                                self[key].is_a?(::Hash) && self[key].deep_include?(sub_hash[key])
-                              else
-                                self[key] == sub_hash[key]
-                              end
+
+      #non-destructive version
+      def remove(*keys)
+        self.dup.remove!(*keys)
       end
-    end unless method_defined? :deep_include?
-
-    # map hash will work just alike map but instead of an array it will return a hash obj
-    #
-    # {:hello=> "world",:world => "hello"}.map_hash{|k,v| [ k , 123] }
-    # #> {:hello=>123, :world=>123}
-    #
-    # {:hello=> "world",:world => "hello"}.map_hash{|k,v| { k => 123 } }
-    # #> {:hello=>123, :world=>123}
-    #
-    def map_hash &block
-
-      tmp_hash= self.class.new
-      map_hash_obj= self.map &block
-      map_hash_obj.each do |hash|
-
-        if hash.class <= ::Array
-          hash= self.class[*hash]
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      #
+      #   h1 = {:x => {:y => [4,5,6]}, :z => [7,8,9]}
+      #   h2 = {:x => {:y => [7,8,9]}, :z => "xyz"}
+      #
+      #   h1.deep_merge(h2) #=> { :x => {:y => [7, 8, 9]}, :z => "xyz" }
+      #   h2.deep_merge(h1) #=> { :x => {:y => [4, 5, 6]}, :z => [7, 8, 9] }
+      def deep_merge(other_hash)
+        dup.deep_merge!(other_hash)
+      end unless method_defined? :deep_merge
+
+      alias :+ :deep_merge
+
+      # Same as +deep_merge+, but modifies +self+.
+      def deep_merge!(other_hash)
+        other_hash.each_pair do |k,v|
+          tv = self[k]
+          self[k] = tv.is_a?(::Hash) && v.is_a?(::Hash) ? tv.deep_merge(v) : v
         end
+        self
+      end unless method_defined? :deep_merge!
+
+      # return bool that does the sub hash all element include the hash who call this or not
+      def deep_include?(sub_hash)
+        sub_hash.keys.all? do |key|
+          self.has_key?(key) && if sub_hash[key].is_a?(::Hash)
+                                  self[key].is_a?(::Hash) && self[key].deep_include?(sub_hash[key])
+                                else
+                                  self[key] == sub_hash[key]
+                                end
+        end
+      end unless method_defined? :deep_include?
+
+      # map hash will work just alike map but instead of an array it will return a hash obj
+      #
+      # {:hello=> "world",:world => "hello"}.map_hash{|k,v| [ k , 123] }
+      # #> {:hello=>123, :world=>123}
+      #
+      # {:hello=> "world",:world => "hello"}.map_hash{|k,v| { k => 123 } }
+      # #> {:hello=>123, :world=>123}
+      #
+      def map_hash &block
+
+        tmp_hash= self.class.new
+        map_hash_obj= self.map &block
+        map_hash_obj.each do |hash|
 
-        tmp_hash.deep_merge!(hash)
+          if hash.class <= ::Array
+            hash= self.class[*hash]
+          end
 
+          tmp_hash.deep_merge!(hash)
+
+        end
+
+        return tmp_hash
       end
 
-      return tmp_hash
     end
 
   end
+
+  require File.join 'mpatch','injector'
+
+
 end

data/lib/mpatch/injector.rb

@@ -0,0 +1,62 @@
+module MPatch
+
+  class << self
+
+    def inject_patches
+
+      #begin
+      #  @@valid_inject_cmd.nil?
+      #rescue ::NameError
+      #  return nil
+      #end
+
+      self.submodules.each do |module_name|
+
+        method_name= module_name.to_s.split('::').last.downcase.to_s.to_sym
+
+        module_name.__send__ :extend, MPatch::Include::Module
+        module_name.submodules.each do |sub_module_name|
+
+          constant= ::Object
+          constant_name= sub_module_name.to_s.split('::').last
+          array_of_target_constant= []
+
+          case true
+
+            when sub_module_name.to_s.include?('And')
+              sub_module_name.to_s.split('::').last.split('And').each do |tag_module|
+                array_of_target_constant.push tag_module
+              end
+
+            else
+              array_of_target_constant.push constant_name
+
+          end
+
+          array_of_target_constant.each do |name|
+
+            begin
+              target_constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
+              target_constant.__send__ method_name, sub_module_name
+            rescue ::NoMethodError => ex
+              STDERR.puts ex
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+    alias :inject :inject_patches
+    alias :patch! :inject_patches
+
+  end
+
+  require File.join 'mpatch','module'
+  extend  MPatch::Include::Module
+  #@@valid_inject_cmd= true
+
+end

data/lib/mpatch/integer.rb

@@ -1,14 +1,22 @@
+module MPatch
 
-module MPatch::Include
-  module Integer
+  module Include
 
-    # because for i in integer/fixnum not working,
-    # here is a little patch
-    def each &block
-      self.times do |number|
-        block.call   number
+    module Integer
+
+      # because for i in integer/fixnum not working,
+      # here is a little patch
+      def each &block
+        self.times do |number|
+          block.call   number
+        end
       end
+
     end
 
   end
+
+  require File.join 'mpatch','injector'
+
+
 end

data/lib/mpatch/module.rb

@@ -1,77 +1,88 @@
-module MPatch::Include
-  module Module
+module MPatch
 
-    # return the module objects direct sub modules
-    def submodules
-      constants.collect {|const_name| const_get(const_name)}.select {|const| const.class == ::Module}
-    end
+  module Include
 
-    # return the module objects direct sub modules
-    def subclasses
-      constants.collect {|const_name| const_get(const_name)}.select {|const| const.class == ::Class}
-    end
+    module Module
 
-    alias :modules :submodules
-    alias :classes :subclasses
+      # return the module objects direct sub modules
+      def submodules
+        constants.collect {|const_name| const_get(const_name)}.select {|const| const.class == ::Module}
+      end
 
-    def mixin_ancestors(include_ancestors=true)
-      ancestors.take_while {|a| include_ancestors || a != superclass }.
-          select {|ancestor| ancestor.instance_of?( ::Module ) }
-    end
+      # return the module objects direct sub modules
+      def subclasses
+        constants.collect {|const_name| const_get(const_name)}.select {|const| const.class == ::Class}
+      end
 
-    def inherited_by *args
+      alias :modules :submodules
+      alias :classes :subclasses
 
-      if args.empty?
-        args.push(::Class)
-        args.push(::Module)
+      def mixin_ancestors(include_ancestors=true)
+        ancestors.take_while {|a| include_ancestors || a != superclass }.
+            select {|ancestor| ancestor.instance_of?( ::Module ) }
       end
 
-      return_array= []
-      args.each do |type_name|
+      def inherited_by *args
+
+        if args.empty?
+          args.push(::Class)
+          args.push(::Module)
+        end
+
+        return_array= []
+        args.each do |type_name|
+
+          ::ObjectSpace.each_object(type_name) do |candidate|
+            begin
 
-        ::ObjectSpace.each_object(type_name) do |candidate|
-          begin
+              if !return_array.include?(candidate) && candidate != self
+                case self.class.to_s
 
-            if !return_array.include?(candidate) && candidate != self
-              case self.class.to_s
+                  when "Module"
+                    return_array.push candidate if candidate.mixin_ancestors.include?(self)
 
-                when "Module"
-                  return_array.push candidate if candidate.mixin_ancestors.include?(self)
+                  when "Class"
+                    return_array.push candidate if candidate < self
 
-                when "Class"
-                  return_array.push candidate if candidate < self
+                end
 
               end
 
+            rescue ::ArgumentError, ::NoMethodError
             end
-
-          rescue ::ArgumentError, ::NoMethodError
           end
+
         end
+        return_array
 
       end
-      return_array
 
-    end
 
+    end
 
   end
-end
 
-module MPatch::Extend
-  module Module
+  module Extend
+
+    module Module
 
-    def convert_instance_methods_to_singleton_methods
+      def convert_instance_methods_to_singleton_methods
+
+        self.instance_methods.each do |symbol|
+          module_function symbol
+          public symbol
+        end
 
-      self.instance_methods.each do |symbol|
-        module_function symbol
-        public symbol
       end
 
-    end
+      alias :ci2s :convert_instance_methods_to_singleton_methods
+      alias :instances2singletons :convert_instance_methods_to_singleton_methods
 
-    alias :ci2s :convert_instance_methods_to_singleton_methods
-    alias :instances2singletons :convert_instance_methods_to_singleton_methods
+    end
 
   end
-end
+
+  require File.join 'mpatch','injector'
+
+
+end