mpatch 1.3.0 → 2.0.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    N2RkMzUzNmY4ZmRiN2EyZDk3ODhmNzVhZjcxZjc4OTg5YjYzN2IwZA==
-  data.tar.gz: !binary |-
-    YjliZTYxNTU5OTBjODZmMThiYTdkZDExMDU5OTk1NmNiOWYwNDI0YQ==
+SHA1:
+  metadata.gz: e55cefa7d1160f216bcc28ef4b4f2bc0528e8313
+  data.tar.gz: 99d6f21dcb6f464b75350de5fc10cca80965a92a
 SHA512:
-  metadata.gz: !binary |-
-    ZDgyZDk5NWFmN2I3YTU5ODdhYzA1OTQwZTg2NDMzNzQ4OWE3OWMyNTY1NTIz
-    MDAzNzIxZmVhZjU3ZGY4OGYzMDU4Y2Q5NGQ1OGZhM2I5YjFhM2Q5ZGMwMzll
-    YTExN2FlMzI5MWNiOTRlOGRkZGNmMmFiYWZlMTc0YmM3ZTllMTg=
-  data.tar.gz: !binary |-
-    NTNmY2VkYzY1YWM0ZDJmZGRjYzgzZjNjMjU1ODZkYjdjMWIxNGUzMzI2ZTUy
-    OGEyZWVkN2NkMWFkNmEwY2ZjZGIwYmMzMDZkZTkzNjYwNDZhMGMwYmYxM2U3
-    Njg5NjJmMTc5ZDlkMmUwMzc4YjVlNDg5YWQ5NTk2NjdmYzI0MzA=
+  metadata.gz: f889918a12d38cf8429f0017ed80872e35146d814864f6ead917759630593fec4abfb92471ca899acd3dd6b46e4e8983052cb2d604e6957e68261901ea8c8fcf
+  data.tar.gz: 7193ffa649afd9a1349b14febde2190945bc284bc00fb1bca190a41db5dd6b88149157c5b7cf6010571bf0234697330a6246d52ce670a6728c186186c424f667

data/README.md

@@ -2,3 +2,35 @@ 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
+
+for example
+
+`ruby
+
+require 'mpatch'
+
+class Test
+
+  def initialize
+
+    @hello= "world"
+    @sup=   "nothing"
+
+  end
+
+end
+
+puts Test.new.to_hash
+#> {"hello" => "world", "sup" => "nothing"}
+`
+
+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 :)
+
+please do enjoy :)
+
+ps.:
+
+* you can get each of the modules for only include to your custom class

data/VERSION

@@ -1 +1 @@
-1.3.0
+2.0.0

data/lib/mpatch/array.rb

@@ -1,151 +1,153 @@
-class Array
-
-  # remove arguments or array of
-  # parameters from the main array
-  def trim(*args)
-
-    args.dup.each do |one_element|
-      if one_element.class == Array
-        args.delete_at(args.index(one_element))
-        args= args+one_element
+module MPatch
+  module Array
+
+    # remove arguments or array of
+    # parameters from the main array
+    def trim(*args)
+
+      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
 
-    delete_array= Array.new
-    args.each do |one_element|
-      index= self.index(one_element)
-      unless index.nil?
-        delete_array.push index
-        self.delete_at(index)
+      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
-    end
 
-    return self
+      return self
 
-  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
-
-  # 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] = Array.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
-    }.uniq - [ nil ]
-    #options.each{|e| self.delete(e) }
-    arguments= self.dup - options
-    options= Hash[*options]
+      if target_array.include? class_name
+        return true
+      end
+      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 ||= Array.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
 
-  # 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
+    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!
 
+  end
 end

data/lib/mpatch/class.rb

@@ -1,92 +1,94 @@
-class Class
+module MPatch
+  class Class
 
-  # get singleton methods to target class without super class methods
-  def class_methods
-    self.methods - Object.methods
-  end
+    # get singleton methods to target class without super class methods
+    def class_methods
+      self.methods - ::Object.methods
+    end
 
-  # 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
+    # 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
 
-  # create an instance method
-  def create_instance_method(method,&block)
-    self.class_eval do
-      define_method method do |*args|
-        block.call *args
+    # 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
 
-  # 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
+    # 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
 
-  # Returns an Array of subclasses (direct and indirect)
-  def subclasses_all
-    ret = []
-    each_subclass {|c| ret.push c}
-    ret
-  end
+    # Returns an Array of subclasses (direct and indirect)
+    def subclasses_all
+      ret = []
+      each_subclass {|c| ret.push c}
+      ret
+    end
 
-  alias :all_subclasses :subclasses_all
+    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
+    # 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

data/lib/mpatch/file.rb

@@ -1,33 +1,33 @@
-class File
+module MPatch
+  module File
 
-  # create a file, if not exsist create file, and dir if needed
-  def self.create(route_name ,filemod="w",string_data=String.new)
-    begin
+    # create a file, if not exsist create file, and dir if needed
+    def self.create(route_name ,filemod="w",string_data= ::String.new )
 
       #file_name generate
-      if !route_name.to_s.split(File::SEPARATOR).last.nil? || route_name.to_s.split(File::SEPARATOR).last != ''
-        file_name = route_name.to_s.split(File::SEPARATOR).last
+      if !route_name.to_s.split(self.class::SEPARATOR).last.nil? || route_name.to_s.split(self.class::SEPARATOR).last != ''
+        file_name = route_name.to_s.split(self.class::SEPARATOR).last
       else
         file_name = nil?
       end
 
       #path_way
       begin
-        raise ArgumentError, "missing route_name: #{route_name}"   if route_name.nil?
-        path = File.expand_path(route_name).to_s.split(File::SEPARATOR)
-        path = path - [File.expand_path(route_name).to_s.split(File::SEPARATOR).last]
+        raise ::ArgumentError, "missing route_name: #{route_name}"   if route_name.nil?
+        path = self.class.expand_path(route_name).to_s.split(self.class::SEPARATOR)
+        path = path - [self.class.expand_path(route_name).to_s.split(self.class::SEPARATOR).last]
         path.shift
       end
 
       #job
       begin
-        if !Dir.exists?(File::SEPARATOR+path.join(File::SEPARATOR))
+        if !::Dir.exists?(self.class::SEPARATOR+path.join(self.class::SEPARATOR))
 
-          at_now = File::SEPARATOR
+          at_now = self.class::SEPARATOR
           path.each do |dir_to_be_checked|
 
-            at_now += "#{dir_to_be_checked+File::SEPARATOR}"
-            Dir.mkdir(at_now) if !Dir.exists?(at_now)
+            at_now += "#{dir_to_be_checked+self.class::SEPARATOR}"
+            ::Dir.mkdir(at_now) if !::Dir.exists?(at_now)
 
           end
         end
@@ -35,37 +35,35 @@ class File
 
       # write data
       begin
-        full_path = "#{File::SEPARATOR+path.join(File::SEPARATOR)+File::SEPARATOR}#{file_name}"
-        if File.exist? full_path
-          File.open(full_path,filemod).write string_data
+        full_path = "#{self.class::SEPARATOR+path.join(self.class::SEPARATOR)+self.class::SEPARATOR}#{file_name}"
+        if self.class.exist? full_path
+          self.class.open(full_path,filemod).write string_data
         else
-          File.new(full_path,filemod).write string_data
+          self.class.new(full_path,filemod).write string_data
         end
       end
 
-    rescue Exception => ex
-      puts ex
     end
-  end
 
-  # start read the file object on each line
-  # optionable an integer value to start read line at
-  # compatible with mac (i am linux user, so not tested)
-  def each_line_from(start_at=1,&block)
-    unless [Integer,Fixnum,Bignum].include?(start_at.class)
-      raise ArgumentError, "invalid line index"
-    end
-    begin
-      line_num= 1
-      text= self.read
-      text.gsub!(/\r\n?/, "\n")
-      text.each_line do |*line|
-        if line_num >= start_at
-          block.call #*line
+    # start read the file object on each line
+    # optionable an integer value to start read line at
+    # compatible with mac (i am linux user, so not tested)
+    def each_line_from(start_at=1,&block)
+      unless [::Integer,Fixnum,Bignum].include?(start_at.class)
+        raise ::ArgumentError, "invalid line index"
+      end
+      begin
+        line_num= 1
+        text= self.read
+        text.gsub!(/\r\n?/, "\n")
+        text.each_line do |*line|
+          if line_num >= start_at
+            block.call #*line
+          end
+          line_num += 1
         end
-        line_num += 1
       end
     end
-  end
 
-end
+  end
+end