mpatch 1.3.0 → 2.0.0

data/lib/mpatch/hash.rb

@@ -1,109 +1,111 @@
-class 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 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= Hash.new
-    map_hash_obj= self.map &block
-    map_hash_obj.each do |hash|
-
-      if hash.class <= Array
-        hash= Hash[*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

data/lib/mpatch/integer.rb

@@ -1,12 +1,14 @@
 
-class Integer
+module MPatch
+  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
+    # 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
+  end
+end

data/lib/mpatch/module.rb

@@ -1,16 +1,18 @@
-class Module
+module MPatch
+  class Module
 
-  # return the module objects direct sub modules
-  def modules
-    constants.collect {|const_name| const_get(const_name)}.select {|const| const.class == Module}
-  end
+    # return the module objects direct sub modules
+    def modules
+      constants.collect {|const_name| const_get(const_name)}.select {|const| const.class == ::Module}
+    end
 
-  # return the module objects direct sub modules
-  def classes
-    constants.collect {|const_name| const_get(const_name)}.select {|const| const.class == Class}
-  end
+    # return the module objects direct sub modules
+    def classes
+      constants.collect {|const_name| const_get(const_name)}.select {|const| const.class == ::Class}
+    end
 
-  alias :submodules :modules
-  alias :subclasses :classes
+    alias :submodules :modules
+    alias :subclasses :classes
 
+  end
 end