mpatch 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjkwMmJkYTBlZjA5YWU2MmIwZGU0ZGMzYTE2YTgxNTRmY2M1NjMzNQ==
+  data.tar.gz: !binary |-
+    MjhjMTNlMjVmZjk5ZTlkOTc0MDkzMTU4NTZkNThmY2QxOTMwMTllYQ==
+SHA512:
+  metadata.gz: !binary |-
+    OTdhZmY2NGI1M2JkODUxOTQ3NGFhZjAyZDZkMzM4ODY1NzcwNzA2ZWZmNmRh
+    NjJhNDc2MjdjOTAyZGY4MGZmYzliZDU0N2U2MjQ5ZjA1ZTcxMzdlMjk0ODhk
+    ZmZiY2RkNjJkMjA4MjcyZjk2NTJlZjMyYzk1NTc0OTk0OGY4OTA=
+  data.tar.gz: !binary |-
+    ZmRmMmIzMDBiMWQ5MTI5YzZjMmE3Njc5Y2Q4NWMzZWI2MTBiOWJkOThiYmRm
+    YmNhZmMzNGQ1MjY1NTYxZWZhNzczMmVhZmMxYzZhYzY1NDk5ZTI5ZDBjYzRi
+    MDY1ZjEyZDJiMTJlZTVmM2Y0MDEyYWE3NTFjYjVmNjFmZjYzMDc=

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,4 @@
+mpatch
+======
+
+Monkey patch collection for advance helper functions

data/Rakefile

@@ -0,0 +1 @@
+require File.join "bundler","gem_tasks"

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/files.rb

@@ -0,0 +1,24 @@
+### Get Files from dir
+begin
+
+  files_to_be_loaded = %w[version.rb]
+
+  SpecFiles= Array.new
+
+  Dir[File.expand_path(File.join(File.dirname(__FILE__),"**","*"))].sort.uniq.each do |one_file_name|
+    one_file_name = File.expand_path one_file_name
+    file_name = one_file_name[(File.expand_path(File.dirname(__FILE__)).to_s.length+1)..(one_file_name.length-1)]
+
+    if !one_file_name.include?("pkg")
+      if !File.directory? file_name
+        SpecFiles.push file_name
+        STDOUT.puts file_name if $DEBUG
+        if files_to_be_loaded.include? one_file_name.split(File::SEPARATOR).last
+          load one_file_name
+        end
+      end
+    end
+
+  end
+
+end

data/lib/mpatch/active_support/str2duck.rb

@@ -0,0 +1,90 @@
+require File.join 'active_support','time'
+
+class String
+
+  def duck
+
+    begin
+      if self == self.to_f.to_s
+        return self.to_f
+      end
+    rescue NoMethodError
+    end
+
+    begin
+      if self == self.to_i.to_s
+        return self.to_i
+      end
+    rescue NoMethodError
+    end
+
+    begin
+      if self.gsub(":","") == self.to_datetime.to_s.gsub(
+          "T"," ").gsub("+"," +").gsub(":","")
+        return self.to_datetime
+      end
+    rescue Exception
+    end
+
+    begin
+      if self == self.to_datetime.to_s
+        return self.to_datetime
+      end
+    rescue Exception
+    end
+
+    begin
+      if self == self.to_date.to_s
+        return self.to_date
+      end
+    rescue Exception
+    end
+
+    begin
+      if self == "true"
+        return true
+      end
+    rescue NoMethodError
+    end
+
+
+    begin
+      if self == "false"
+        return false
+      end
+    rescue NoMethodError
+    end
+
+    begin
+      string_input= self
+      contain= nil
+      ["[", "]","^","$","*","/"].each do |one_sym|
+        if string_input.include? one_sym
+          contain ||= true
+        end
+      end
+      if contain == true
+        string_regexp= Regexp.new(string_input).inspect#.gsub('\\','')
+        string_regexp= string_regexp[1..(string_regexp.length-2)]
+        if string_input == string_regexp
+          return Regexp.new(string_input)
+        else
+          raise ArgumentError,"invalid input string"
+        end
+      end
+    rescue ArgumentError
+    end
+
+    begin
+      if self == self.to_s.to_s
+        return self.to_s
+      end
+    rescue NoMethodError
+    end
+
+  end
+
+  alias :to_duck :duck
+  alias :to_d    :duck
+
+end

data/lib/mpatch/array.rb

@@ -0,0 +1,149 @@
+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
+      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)
+      end
+    end
+
+    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
+
+  # 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 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
+
+  # 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
+
+  alias :contains_any_of? :contain_any_of?
+  alias :has_any_of? :contain_any_of?
+
+  # 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] }
+    end
+    result
+  end
+
+  alias :contains? :contain?
+
+  # 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
+    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
+
+    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]
+
+    return [options,arguments]
+
+  end
+
+  alias :separate_params :params_separation
+  alias :process_params  :params_separation
+
+  # generate params structure from array
+  # return_array
+  def extract_class! class_name
+
+    if class_name.class != Class
+      raise ArgumentError, "parameter must be a class name"
+    end
+
+    return_value= self.map { |element|
+      if element.class == class_name
+        element
+      end
+    }.uniq - [ nil ]
+    return_value.each{|e| self.delete(e) }
+
+    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!
+
+end

data/lib/mpatch/boolean.rb

@@ -0,0 +1,15 @@
+class Object
+
+  def boolean?
+    !!self == self
+  end
+
+  def true?
+    self == true
+  end
+
+  def false?
+    self == false
+  end
+
+end

data/lib/mpatch/class.rb

@@ -0,0 +1,92 @@
+class Class
+
+  # 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
+      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
+      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
+
+  # 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
+
+  # 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)
+
+    ### GET
+    begin
+      define_method name do
+        class_variable_get "@@#{name}"
+      end
+    end
+
+    ### SET
+    begin
+      define_method "#{name}=" do |new_val|
+        class_variable_set "@@#{name}", new_val
+      end
+    end
+
+  end
+
+  # create class instance attribute
+  def instance_attr_accessor(name)
+
+    ### GET
+    begin
+      define_method name do
+        instance_variable_get "@#{name}"
+      end
+    end
+
+    ### SET
+    begin
+      define_method "#{name}=" do |new_val|
+        instance_variable_set "@#{name}", new_val
+      end
+    end
+
+  end
+
+end

data/lib/mpatch/file.rb

@@ -0,0 +1,71 @@
+class 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
+
+      #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
+      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]
+        path.shift
+      end
+
+      #job
+      begin
+        if !Dir.exists?(File::SEPARATOR+path.join(File::SEPARATOR))
+
+          at_now = File::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)
+
+          end
+        end
+      end
+
+      # 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
+        else
+          File.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
+        end
+        line_num += 1
+      end
+    end
+  end
+
+end

data/lib/mpatch/hash.rb

@@ -0,0 +1,109 @@
+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)
+              end
+            end
+          end
+
+        when one_element.class == Array
+          begin
+            one_element.each do |one_key|
+              self.delete(one_key)
+            end
+          end
+
+        when  one_element.class == Symbol,
+            one_element.class == String
+          begin
+            self.delete(one_element)
+          end
+
+      end
+    end
+    return self
+
+  end
+
+  #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
+
+  # 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= Hash.new
+    map_hash_obj= self.map &block
+    map_hash_obj.each do |hash|
+
+      if hash.class <= Array
+        hash= Hash[*hash]
+      end
+
+      tmp_hash.deep_merge!(hash)
+
+    end
+
+    return tmp_hash
+  end
+
+end

data/lib/mpatch/integer.rb

@@ -0,0 +1,12 @@
+
+class 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

data/lib/mpatch/kernel.rb

@@ -0,0 +1,9 @@
+def putsf(integer,*args)
+  command_string=String.new
+  args.each do |one_element|
+    command_string+="%-#{integer}s"
+  end
+  command_string+="\n"
+  printf command_string,*args
+end
+

data/lib/mpatch/module.rb

@@ -0,0 +1,16 @@
+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 classes
+    constants.collect {|const_name| const_get(const_name)}.select {|const| const.class == Class}
+  end
+
+  alias :submodules :modules
+  alias :subclasses :classes
+
+end

data/lib/mpatch/object.rb

@@ -0,0 +1,275 @@
+class Object
+
+  # basic validations for those who fear the DUCK!
+  def must_be class_name
+    if class_name.class == Class
+      begin
+        if self.class != class_name
+          raise ArgumentError, "invalid parameter given: #{self}"
+        end
+      end
+    else
+      begin
+        if self != class_name
+          raise ArgumentError, "invalid parameter given: #{self}"
+        end
+      end
+    end
+    return self
+  end unless method_defined? :must_be
+
+  # return the object Binding
+  def binding?
+    return binding
+  end
+
+  alias :get_binding :binding?
+
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+
+  # extend the metaclass with an instance eval
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+
+  # constantize object
+  def constantize
+    camel_cased_word= self.to_s
+    names = camel_cased_word.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
+    end
+    constant
+  end unless method_defined? :constantize
+
+  # find and replace object in object
+  def find_and_replace(input,*params)
+    params=Hash[*params]
+    # some default values
+    begin
+      #None!
+    end
+    # Do the find and replace
+    begin
+
+      if    input.class == Array
+        input.count.times do |counter|
+          params.each do |key,value|
+            input[counter]= input[counter].gsub(key,value)
+          end
+        end
+      elsif input.class == String
+        params.each do |key,value|
+          input= input.gsub(key,value)
+        end
+      elsif input.class == Integer
+        params.each do |key,value|
+          input= input.to_s.gsub(key,value).to_i
+        end
+      elsif input.class == Float
+        params.each do |key,value|
+          input= input.to_s.gsub(key,value).to_f
+        end
+      end
+
+      # return value
+      return input
+    end
+  end
+
+  # each for any object
+  def each_universal(&block)
+    case self.class.to_s.downcase
+      when "hash"
+        self.each do |key,value|
+          block.call(key,value)
+        end
+      when "array"
+        self.each do |one_element|
+          block.call(self.index(one_element),one_element)
+        end
+      else
+        block.call nil,self
+    end
+  end
+
+  # map an object => experiment
+  def map_object(symbol_key="$type")
+
+    stage       = self
+    do_later    = Hash.new
+    samples     = Hash.new
+    relations   = Hash.new
+    main_object = nil
+
+    loop do
+
+      # processing
+      begin
+
+        tmp_key = String.new
+        tmp_hash= Hash.new
+        stage.each_universal do |key,value|
+
+          if value.class.to_s.downcase == "string"
+
+            if key== symbol_key
+              tmp_key= value
+              main_object ||= value
+            else
+              tmp_hash[key]= value
+            end
+
+          else
+
+            value.each_universal do |key_sub,value_sub|
+              if key_sub == symbol_key && tmp_key != String.new
+                child_property = Hash.new
+                child_property['type']= value_sub
+                child_property['class']= value.class.to_s
+                relations[tmp_key]= child_property
+              end
+              do_later[key_sub]= value_sub
+            end
+
+          end
+        end
+
+        if tmp_key != String.new && tmp_hash != Hash.new
+          samples[tmp_key]=tmp_hash
+        end
+
+      end
+
+      # finish
+      begin
+        break if do_later == Hash.new
+        stage= do_later
+        do_later = Hash.new
+      end
+
+    end
+
+    return {:samples    => samples,
+            :relations  => relations,
+            :main       => main_object
+    }
+
+  end
+
+  # is class?
+  def class?
+    self.class == Class
+  end
+
+  # convert class instance instance variables into a hash object
+  def convert_to_hash
+
+    unless self.class.class == Class
+      raise NoMethodError, "undefined method `to_hash' for #{self.inspect}"
+    end
+
+    tmp_hash= Hash.new()
+    self.instance_variables.each do|var|
+      tmp_hash[var.to_s.delete("@")] = self.instance_variable_get(var)
+    end
+
+    return tmp_hash
+
+  end
+
+  # this will check that the class is
+  # defined or not in the runtime memory
+  def class_exists?
+    klass = Module.const_get(self)
+    return klass.is_a?(Class)
+  rescue NameError
+    return false
+  end
+
+  # This will convert a symbol or string and format to be a valid
+  # constant name and create from it a class with instance attribute accessors
+  # Best use is when you get raw data in string from external source
+  # and you want make them class objects
+  #
+  #   :hello_world.to_class(:test)
+  #   HelloWorld.to_class(:sup)
+  #   hw_var = HelloWorld.new
+  #   hw_var.sup = "Fine thanks!"
+  #   hw_var.test = 5
+  #
+  #   puts hw_var.test
+  #
+  #   #> produce 5 :Integer
+  #
+  #   you can also use this formats
+  #   :HelloWorld , "hello.world",
+  #   "hello/world", "Hello::World",
+  #   "hello:world"...
+  def to_class(*attributes)
+
+    unless self.class == Symbol || self.class == String || self.class == Class
+      raise ArgumentError, "object must be symbol or string to make able build class to it"
+    end
+
+    class_name= self.to_s
+
+    unless self.class == Class
+
+      class_name= class_name[0].upcase+class_name[1..class_name.length]
+      %w[ _ . : / ].each do |one_sym|
+
+        loop do
+          index_nmb= class_name.index(one_sym)
+          break if index_nmb.nil?
+          class_name[index_nmb..index_nmb+1]= class_name[index_nmb+1].upcase
+        end
+
+      end
+
+    end
+
+    create_attribute = Proc.new do |*args|
+
+    end
+
+    unless class_name.class_exists?
+
+      Object.const_set(
+          class_name,
+          Class.new
+      )
+
+    end
+
+
+    class_name.constantize.class_eval do
+      attributes.each do |one_attribute|
+        attr_accessor one_attribute.to_s.to_sym
+      end
+    end
+
+
+
+    return true
+
+  end
+
+  alias :create_attributes :to_class
+  alias :map_sample :map_object
+  alias :each_univ :each_universal
+  alias :fnr :find_and_replace
+
+end

data/lib/mpatch/proc.rb

@@ -0,0 +1,27 @@
+class Proc
+
+  # sugar syntax for proc * operator
+  #    a = ->(x){x+1}
+  #    b = ->(x){x*10}
+  #    c = b*a
+  #    c.call(1) #=> 20
+  def *(other)
+    Proc.new { |*args| self[*other[*args]] }
+  end unless method_defined? :*
+
+  def call_with_binding(bind, *args)
+    Bindless.new([bind]).run_proc(self, *args)
+  end
+
+  def call_with_obj(obj, *args)
+    m = nil
+    p = self
+    Object.class_eval do
+      define_method :a_temp_method_name, &p
+      m = instance_method :a_temp_method_name
+      remove_method :a_temp_method_name
+    end
+    m.bind(obj).call(*args)
+  end
+
+end

data/lib/mpatch/process.rb

@@ -0,0 +1,14 @@
+module Process
+  def self.daemonize
+    File.create Application.pid,'a+'
+    File.create Application.log,'a+'
+    File.create Application.daemon_stderr,'a+'
+    Daemon.start fork,
+                 Application.pid,
+                 Application.log,
+                 Application.daemon_stderr
+  end
+  def self.stop
+    Daemon.stop
+  end
+end

data/lib/mpatch/random.rb

@@ -0,0 +1,39 @@
+class RND
+  class << self
+    def string(length= 7,amount=1,hyphen= " ")
+      amount_container= Array.new
+      amount.times do
+        mrg= String.new
+        mrg= (0...length).map{ ('a'..'z').to_a[rand(26)] }.join
+        amount_container.push mrg
+      end
+      return amount_container.join(hyphen)
+    end
+    def integer(length= 3)
+      Random.rand(length)
+    end
+    def boolean
+      rand(2) == 1
+    end
+    def time from = Time.at(1114924812), to = Time.now
+      rand(from..to)
+    end
+    def date from = Time.at(1114924812), to = Time.now
+      rand(from..to).to_date
+    end
+    def datetime from = Time.at(1114924812), to = Time.now
+      rand(from..to).to_datetime
+    end
+  end
+end
+
+# alias in Random from RND
+begin
+  (RND.singleton_methods-Object.singleton_methods).each do |one_method_sym|
+    Random.class_eval do
+      define_singleton_method one_method_sym do |*args|
+        RND.__send__(one_method_sym,*args)
+      end
+    end
+  end
+end

data/lib/mpatch/string.rb

@@ -0,0 +1,78 @@
+class String
+
+  # Find string in othere string
+  def positions(oth_string)
+
+    special_chrs=%w[# _ & < > @ $ . , -]+[*(0..9)]+[*("A".."Z")]+[*("a".."z")]
+    loop do
+      if oth_string.include? special_chrs[0]
+        special_chrs.shift
+      else
+        break
+      end
+    end
+
+    string=self
+    return_array = Array.new
+    loop do
+      break if string.index(oth_string).nil?
+      range_value= ((string.index(oth_string))..(string.index(oth_string)+oth_string.length-1))
+      return_array.push range_value
+      [*range_value].each do |one_index|
+        string[one_index]= special_chrs[0]
+      end
+    end
+
+    # return value
+    return return_array
+  end
+
+  # Standard in rails. See official documentation
+  # [http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html]
+  def camelize(first_letter = :upper)
+    if first_letter == :upper
+      gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      self[0..0].downcase + camelize[1..-1]
+    end
+  end unless method_defined? :camelize
+
+  # Standard in rails. See official documentation
+  # [http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html]
+  def dasherize
+    gsub(/_/, '-')
+  end unless method_defined? :dasherize
+
+  # Standard in rails. See official documentation
+  # [http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html]
+  def demodulize
+    gsub(/^.*::/, '')
+  end unless method_defined? :demodulize
+
+  # Standard in rails. See official documentation
+  # [http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html]
+  def underscore
+    gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+  end unless method_defined? :underscore
+
+  # Check that instance of String is start with an upper case or not
+  def capitalized?
+    self.match(/^[[:upper:]]/) ? true : false
+  end
+
+  # return the number how often the str is with in the self
+  # by default with \b regex border
+  def frequency(str)
+    begin
+      if str.class == String
+        str= '\b'+str+'\b'
+      end
+    end
+    self.scan(/#{str}/).count
+  end
+
+end

data/lib/mpatch/yml.rb

@@ -0,0 +1,11 @@
+require 'yaml'
+module YAML
+  def self.save_file(file_path,config_hash)
+    File.open(file_path, 'w+') {|f| f.write(config_hash.to_yaml) }
+  end
+
+  def self.load_file(file_path)
+    YAML.load(File.open(file_path))
+  end
+end
+

data/lib/mpatch.rb

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

data/mpatch.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+
+require File.expand_path(File.join(File.dirname(__FILE__),"files.rb"))
+
+### Specification for the new Gem
+Gem::Specification.new do |spec|
+
+  spec.name          = "mpatch"
+  spec.version       = File.open(File.join(File.dirname(__FILE__),"VERSION")).read.split("\n")[0].chomp.gsub(' ','')
+  spec.authors       = ["Adam Luzsi"]
+  spec.email         = ["adamluzsi@gmail.com"]
+  spec.description   = %q{This is a collection of my Ruby monkey patches for making easer to use the basic classes}
+  spec.summary       = %q{collection of methods for extend basic classes}
+  spec.homepage      = "https://github.com/adamluzsi/mpatch"
+  spec.license       = "MIT"
+
+  spec.files         = SpecFiles
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: mpatch
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Adam Luzsi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-10 00:00:00.000000000 Z
+dependencies: []
+description: This is a collection of my Ruby monkey patches for making easer to use
+  the basic classes
+email:
+- adamluzsi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- VERSION
+- files.rb
+- lib/mpatch.rb
+- lib/mpatch/active_support/str2duck.rb
+- lib/mpatch/array.rb
+- lib/mpatch/boolean.rb
+- lib/mpatch/class.rb
+- lib/mpatch/exception.rb
+- lib/mpatch/file.rb
+- lib/mpatch/hash.rb
+- lib/mpatch/integer.rb
+- lib/mpatch/kernel.rb
+- lib/mpatch/module.rb
+- lib/mpatch/object.rb
+- lib/mpatch/proc.rb
+- lib/mpatch/process.rb
+- lib/mpatch/random.rb
+- lib/mpatch/string.rb
+- lib/mpatch/yml.rb
+- mpatch.gemspec
+homepage: https://github.com/adamluzsi/mpatch
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: collection of methods for extend basic classes
+test_files: []
+has_rdoc: