procemon 0.8.1 → 0.9.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NGI0YTZlYmZhZDhhNWI2ZWFiOTdmNmUyNzk0OTA2NmI4N2Q5OTA0Zg==
+    ZTc0ZjMxOGUyM2YwZjI0ZTBmMTBlMGFiMzY2MDk1M2JmMDUwZjAxMA==
   data.tar.gz: !binary |-
-    NDgyOTFkYzBhNDIxZTMzOTA3YjU4MjFkMTFlMWVkZDVhZGZhOWU5YQ==
+    ZWU2NzZjZGRhYzM5ZGVkNmMzYmM4Yjc0NWUyMDkzYWU3NzkzMDFkZA==
 SHA512:
   metadata.gz: !binary |-
-    NjliMTM0YzUyMTFlMDBkYWZjNWQ0ZGExOTc1YmM5ZTY1MzgwZDFlOTJjNDEz
-    OTk3OGE1MmQ1YTIzNzU3ZDE2NDhhYjcyYTIzMjQwZDdlMjAxMzgyZTVlMDA3
-    OGUxOGViMDdhMmZjYzdkNTg0YWQ5OGQ3MTdkYTVmNzA3YTI4MWE=
+    MzA2MmE3NTQ0NjM1YjRhZDcxYjdhMzkyOTUzYThmNGI3OTI5NGY2YmYxZjk1
+    MzFiYWQxYzNkYzVjYTUzZTAwY2E0ZDY2YmYyOGNjN2U0OWY3NmMyMzBlOWMy
+    OWNiYTE2ZGMxYjNkY2ZlYzU1ZmU0ZGJmOTMzODAxNjYwNTVlZmQ=
   data.tar.gz: !binary |-
-    NjM3Zjc2MmE2MmY0ODEzMWIwNzE1NjYyYWVlMmU3OGFkNTU5ZjExYzBmMWFj
-    YWU0ZDljM2Q2OTM4ZTQ2MTI2MWZhYjFlOTdhYjZmMzg4YWIzMzJlNmI1YWY2
-    NTc2ZmFhZDRiMmVmNDFmMmM0NjBjMzM1ODk5OTE4Yjg1MmFlYzQ=
+    NTViNmJhYTAwYjZjYTMwMDZjMzU5MTUxZGE5ODc5NmIxYzEyMmJlNjFlYWM4
+    ZTU1ZDdlNGJhYWJhODgzODVmODNjY2E0M2U0N2U2Yjc1OTNiZGQ3YTg3YzUz
+    Nzc0MGNkODBhNzAyZTYxZTc5YTQzYzU2NDk0NTE1ZTY4YjE0MWE=

data/Gemfile.lock

@@ -1,16 +1,18 @@
 PATH
   remote: .
   specs:
-    procemon (0.7.0)
+    procemon (0.8.1)
       asynchronous
       loader
+      mpatch
       sourcerer
 
 GEM
   remote: http://rubygems.org/
   specs:
-    asynchronous (1.0.3)
+    asynchronous (1.0.4)
     loader (1.0.2)
+    mpatch (1.0.0)
     sourcerer (0.5.2)
 
 PLATFORMS

data/VERSION

@@ -1 +1 @@
-0.8.1
+0.9.0

data/lib/procemon/extra/str2duck.rb

@@ -1,90 +1,2 @@
 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
+require File.join 'mpatch','active_support','str2duck'

data/lib/procemon.rb

@@ -4,8 +4,8 @@ module Procemon
   require 'asynchronous'
   require 'sourcerer'
   require 'loader'
+  require 'mpatch'
 
-  require_relative_directory File.join("procemon","mpatch")
   require_relative_directory File.join("procemon","function")
 
   def self.init_all

data/procemon.gemspec

@@ -22,5 +22,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "asynchronous"
   spec.add_dependency "sourcerer"
   spec.add_dependency "loader"
+  spec.add_dependency "mpatch"
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: procemon
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-05 00:00:00.000000000 Z
+date: 2014-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asynchronous
@@ -52,6 +52,20 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mpatch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ! 'This is a collection of my Ruby Procs in the adventure of becoming
   the best! In short this provides extra tools in Application configs, argumens processing,daemonise,eval,
   getting source of a block,method,process and work with it, or even fuse them into
@@ -81,7 +95,6 @@ files:
 - lib/procemon/extra/str2duck.rb
 - lib/procemon/function/application.rb
 - lib/procemon/function/argv.rb
-- lib/procemon/function/binding/binding.rb
 - lib/procemon/function/binding/bindless.rb
 - lib/procemon/function/daemon.rb
 - lib/procemon/function/documentation.rb
@@ -92,22 +105,6 @@ files:
 - lib/procemon/function/name.rb
 - lib/procemon/function/port.rb
 - lib/procemon/function/tmp_dir.rb
-- lib/procemon/function/validation.rb
-- lib/procemon/mpatch/array.rb
-- lib/procemon/mpatch/boolean.rb
-- lib/procemon/mpatch/class.rb
-- lib/procemon/mpatch/exception.rb
-- lib/procemon/mpatch/file.rb
-- lib/procemon/mpatch/hash.rb
-- lib/procemon/mpatch/integer.rb
-- lib/procemon/mpatch/kernel.rb
-- lib/procemon/mpatch/module.rb
-- lib/procemon/mpatch/object.rb
-- lib/procemon/mpatch/proc.rb
-- lib/procemon/mpatch/process.rb
-- lib/procemon/mpatch/random.rb
-- lib/procemon/mpatch/string.rb
-- lib/procemon/mpatch/yml.rb
 - procemon.gemspec
 - scripts/doc_gen.rb
 - scripts/test.txt

data/lib/procemon/function/binding/binding.rb

@@ -1,17 +0,0 @@
-class Object
-
-  def binding?
-    return binding
-  end
-
-  alias :get_binding :binding?
-
-end
-
-class Array
-  def debug binding
-    self.each do |arg|
-      puts "arg = #{eval(arg, binding).inspect}"
-    end
-  end
-end

data/lib/procemon/function/validation.rb

@@ -1,21 +0,0 @@
-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
-
-end

data/lib/procemon/mpatch/array.rb

@@ -1,149 +0,0 @@
-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/procemon/mpatch/boolean.rb

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

data/lib/procemon/mpatch/class.rb

@@ -1,92 +0,0 @@
-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/procemon/mpatch/file.rb

@@ -1,71 +0,0 @@
-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/procemon/mpatch/hash.rb

@@ -1,101 +0,0 @@
-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?
-
-  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/procemon/mpatch/integer.rb

@@ -1,12 +0,0 @@
-
-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/procemon/mpatch/kernel.rb

@@ -1,9 +0,0 @@
-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/procemon/mpatch/module.rb

@@ -1,16 +0,0 @@
-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/procemon/mpatch/object.rb

@@ -1,250 +0,0 @@
-class Object
-
-  # 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/procemon/mpatch/proc.rb

@@ -1,27 +0,0 @@
-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/procemon/mpatch/process.rb

@@ -1,14 +0,0 @@
-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/procemon/mpatch/random.rb

@@ -1,39 +0,0 @@
-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/procemon/mpatch/string.rb

@@ -1,78 +0,0 @@
-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/procemon/mpatch/yml.rb

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