procemon 0.0.1

data/lib/procemon/function/tmp_dir.rb

@@ -0,0 +1,20 @@
+module Procemon
+  class << self
+
+    require "tmpdir"
+    def tmpdir_init
+      begin
+        Dir.mkdir File.join(Dir.tmpdir,$0)
+      rescue Errno::EEXIST
+      end
+
+      Application.tmpdir=         File.join(Dir.tmpdir,$0)
+
+      Application.pid=            File.join(Application.tmpdir,"pid")
+      Application.log=            File.join(Application.tmpdir,"log")
+      Application.daemon_stderr=  File.join(Application.tmpdir,"daemon_stderr")
+
+    end
+
+  end
+end

data/lib/procemon/mpatch/array.rb

@@ -0,0 +1,59 @@
+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
+  def pinch n=1
+    return self[0..(self.count-2)]
+  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
+    #(oth_array - self).size == 0
+  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] }
+    end
+    result
+  end
+
+  alias :contains? :contain?
+end

data/lib/procemon/mpatch/class.rb

@@ -0,0 +1,85 @@
+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 |
+      yield candidate if candidate < self
+    }
+  end
+
+  # Returns an Array of subclasses (direct and indirect)
+  def subclasses
+    ret = []
+    each_subclass {|c| ret << c}
+    ret
+  end
+
+  # Returns an Array of direct subclasses
+  def direct_subclasses
+    ret = []
+    each_subclass {|c| ret << c if c.superclass == self }
+    ret
+  end
+
+  # 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

@@ -0,0 +1,48 @@
+class File
+  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
+end

data/lib/procemon/mpatch/hash.rb

@@ -0,0 +1,82 @@
+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
+
+  # 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?
+
+end

data/lib/procemon/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/procemon/mpatch/object.rb

@@ -0,0 +1,172 @@
+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
+
+  alias :map_sample :map_object
+  alias :each_univ :each_universal
+  alias :fnr :find_and_replace
+
+end