mpatch 1.3.0 → 2.0.0

data/lib/mpatch/object.rb

@@ -1,268 +1,283 @@
-class Object
+module MPatch
+  module 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}"
+    def boolean?
+      !!self == self
+    end
+
+    def true?
+      self == true
+    end
+
+    def false?
+      self == false
+    end
+
+    # 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
-      end
-    else
-      begin
-        if self != class_name
-          raise ArgumentError, "invalid parameter given: #{self}"
+      else
+        begin
+          if self != class_name
+            raise ::ArgumentError, "invalid parameter given: #{self}"
+          end
         end
       end
+      return self
     end
-    return self
-  end unless method_defined? :must_be
 
-  # The hidden singleton lurks behind everyone
-  def metaclass; class << self; self; end; end
+    # 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
+    # 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
+    # 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
+    # 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?
+    # 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
+      constant = self.class
+      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
 
-      if    input.class == Array
-        input.count.times do |counter|
+    # 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[counter]= input[counter].gsub(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
-      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
+        # return value
+        return input
+      end
     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
+    # 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
-  end
 
-  # map an object => experiment
-  def map_object(symbol_key="$type")
+    # 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
+      stage       = self
+      do_later    = ::Hash.new
+      samples     = ::Hash.new
+      relations   = ::Hash.new
+      main_object = nil
 
-    loop do
+      loop do
 
-      # processing
-      begin
+        # processing
+        begin
 
-        tmp_key = String.new
-        tmp_hash= Hash.new
-        stage.each_universal do |key,value|
+          tmp_key = ::String.new
+          tmp_hash= ::Hash.new
+          stage.each_universal do |key,value|
 
-          if value.class.to_s.downcase == "string"
+            if value.class.to_s.downcase == "string"
 
-            if key== symbol_key
-              tmp_key= value
-              main_object ||= value
-            else
-              tmp_hash[key]= value
-            end
+              if key== symbol_key
+                tmp_key= value
+                main_object ||= value
+              else
+                tmp_hash[key]= value
+              end
 
-          else
+            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
+              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
-              do_later[key_sub]= value_sub
+
             end
+          end
 
+          if tmp_key != ::String.new && tmp_hash != ::Hash.new
+            samples[tmp_key]=tmp_hash
           end
+
         end
 
-        if tmp_key != String.new && tmp_hash != Hash.new
-          samples[tmp_key]=tmp_hash
+        # finish
+        begin
+          break if do_later == ::Hash.new
+          stage= do_later
+          do_later = ::Hash.new
         end
 
       end
 
-      # finish
-      begin
-        break if do_later == Hash.new
-        stage= do_later
-        do_later = Hash.new
-      end
+      return {:samples    => samples,
+              :relations  => relations,
+              :main       => main_object
+      }
 
     end
 
-    return {:samples    => samples,
-            :relations  => relations,
-            :main       => main_object
-    }
+    # is class?
+    def class?
+      self.class == ::Class
+    end
 
-  end
+    # convert class instance instance variables into a hash object
+    def to_hash
 
-  # is class?
-  def class?
-    self.class == Class
-  end
+      unless self.class.class <= ::Class
+        raise ::NoMethodError, "undefined method `to_hash' for #{self.inspect}"
+      end
 
-  # convert class instance instance variables into a hash object
-  def convert_to_hash
+      tmp_hash= ::Hash.new()
 
-    unless self.class.class == Class
-      raise NoMethodError, "undefined method `to_hash' for #{self.inspect}"
-    end
+      self.instance_variables.each do|var|
+        tmp_hash[var.to_s.delete("@")] = self.instance_variable_get(var)
+      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
 
-    return tmp_hash
+    end
 
-  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 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
 
-  # 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
 
-    class_name= self.to_s
+      unless self.class <= ::Class
 
-    unless self.class == Class
+        class_name= class_name[0].upcase+class_name[1..class_name.length]
+        %w[ _ . : / ].each do |one_sym|
 
-      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
 
-        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|
+      create_attribute = ::Proc.new do |*args|
 
-    end
+      end
 
-    unless class_name.class_exists?
+      unless class_name.class_exists?
 
-      Object.const_set(
-          class_name,
-          Class.new
-      )
+        self.class.const_set(
+            class_name,
+            ::Class.new
+        )
 
-    end
+      end
 
 
-    class_name.constantize.class_eval do
-      attributes.each do |one_attribute|
-        attr_accessor one_attribute.to_s.to_sym
+      class_name.constantize.class_eval do
+        attributes.each do |one_attribute|
+          attr_accessor one_attribute.to_s.to_sym
+        end
       end
-    end
 
 
 
-    return true
+      return true
 
-  end
+    end
 
-  alias :create_attributes :to_class
-  alias :map_sample :map_object
-  alias :each_univ :each_universal
-  alias :fnr :find_and_replace
+    alias :create_attributes :to_class
+    alias :map_sample :map_object
+    alias :each_univ :each_universal
+    alias :fnr :find_and_replace
 
+  end
 end

data/lib/mpatch/proc.rb

@@ -1,12 +1,14 @@
-class Proc
+module MPatch
+  module 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? :*
+    # sugar syntax for proc * operator
+    #    a = ->(x){x+1}
+    #    b = ->(x){x*10}
+    #    c = b*a
+    #    c.call(1) #=> 20
+    def *(other)
+      self.class.new { |*args| self[*other[*args]] }
+    end
 
+  end
 end

data/lib/mpatch/process.rb

@@ -1,28 +1,17 @@
-module Process
+module MPatch
+  module Process
 
-  # return a string obj that include the memory usage info
-  def self.memory_usage
+    # return a string obj that include the memory usage info
+    def self.memory_usage
 
-    begin
-      return `pmap #{self.pid}`.lines.to_a(
-      ).last.chomp.scan(/ *\w* *(\w+)/)[0][0]
-    rescue NoMethodError
-      return nil
-    end
-
-  end
+      begin
+        return `pmap #{self.pid}`.lines.to_a(
+        ).last.chomp.scan(/ *\w* *(\w+)/)[0][0]
+      rescue ::NoMethodError
+        return nil
+      end
 
+    end
 
-  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

@@ -1,37 +1,46 @@
-class RND
-  def self.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 self.integer(length= 3)
-    Random.rand(length)
-  end
-  def self.boolean
-    rand(2) == 1
-  end
-  def self.time from = Time.at(1114924812), to = Time.now
-    rand(from..to)
-  end
-  def self.date from = Time.at(1114924812), to = Time.now
-    rand(from..to).to_date
-  end
-  def self.datetime from = Time.at(1114924812), to = Time.now
-    rand(from..to).to_datetime
-  end
-end
+module MPatch
+  module Random
 
-# alias in Random from RND
-begin
-  (RND.singleton_methods-Object.instance_methods).each do |one_method_sym|
-    Random.class_eval do
-      define_singleton_method one_method_sym do |*args|
-        RND.__send__(one_method_sym,*args)
+    def string(length= 7,amount=1,hyphen= " ")
+      amount_container= []
+      amount.times do
+        mrg= ""
+        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)
+      self.class.rand(length)
     end
+
+    def boolean
+      self.class.rand(2) == 1
+    end
+
+    def time from = Time.at(1114924812), to = Time.now
+      self.class.rand(from..to)
+    end
+
+    def date from = Time.at(1114924812), to = Time.now
+      self.class.rand(from..to).to_date
+    end
+
+    def datetime from = Time.at(1114924812), to = Time.now
+      self.class.rand(from..to).to_datetime
+    end
+
   end
 end
+
+## alias in Random from RND
+#begin
+#  (RND.singleton_methods-Object.instance_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