tools 0.4.5 → 0.4.6

data/lib/lib/files.rb

@@ -2,9 +2,7 @@ require 'singleton'
 class ToolsFiles
   include Singleton
 
-  def initialize(options = {})
-  end
-
+  def initialize(options = {}); end
 
   # Purge files in directory
   #
@@ -15,15 +13,16 @@ class ToolsFiles
   # @param select (sample: *.log)
   # @param elipsed_time in seconds (sample: 2 weeks = 14*24*60*60)
   # @return
-  def self.purge_files path, select, time #Cmdapi.configuration.home+'/.cmdapi/backup', '*',   14*24*60*60
-    to_clean = Dir.glob(File.join(path, select)).select { |a|
-      Time.now - File.ctime(a) > time }
+  # Cmdapi.configuration.home+'/.cmdapi/backup', '*',   14*24*60*60
+  def self.purge_files(path, select, time)
+    to_clean = Dir.glob(File.join(path, select)).select do |a|
+      Time.now - File.ctime(a) > time
+    end
     to_clean.each do |file_to_delete|
       File.delete(file_to_delete)
     end
   end
 
-
   # Create a directory in work area
   #
   #  Sample
@@ -33,14 +32,10 @@ class ToolsFiles
   # @param directory
   # @param directory_name
   # @return
-  def self.create_dir directory, directory_name
-    unless directory.end_with? '/'
-      directory += '/'
-    end
-    complete_file = (directory + '/').gsub('//','/')
-    unless File.exists? complete_file
-      Dir.mkdir(complete_file)
-    end
+  def self.create_dir(directory, directory_name)
+    directory += '/' unless directory.end_with? '/'
+    complete_file = (directory + '/').gsub('//', '/')
+    Dir.mkdir(complete_file) unless File.exist? complete_file
     ToolsUtil.set_variable directory_name, complete_file
   end
 
@@ -55,11 +50,9 @@ class ToolsFiles
   # @param file_name
   # @param file_name_set
   # @return
-  def self.create_file directory, file_name, file_name_set
-    complete_file = (directory + '/' + file_name).gsub('//','/')
-    unless File.exists? complete_file
-      file = File.open( complete_file , 'w')
-    end
+  def self.create_file(directory, file_name, file_name_set)
+    complete_file = (directory + '/' + file_name).gsub('//', '/')
+    File.open(complete_file, 'w') unless File.exist? complete_file
     ToolsUtil.set_variable file_name_set, complete_file
   end
 
@@ -70,11 +63,10 @@ class ToolsFiles
   #  ToolsFiles.load_file file_to_load
   # @param file_to_load Object
   # @return
-  def self.load_file file_to_load
-    if File.exists? file_to_load
-      file = File.open( file_to_load , 'r')
-      return file
-    end
+  def self.load_file(file_to_load)
+    return unless File.exist? file_to_load
+
+    File.open(file_to_load, 'r')
   end
 
   # Delete a file in work area
@@ -84,27 +76,17 @@ class ToolsFiles
   #  ToolsFiles.delete_file file_to_delete
   # @param file_to_delete Object
   # @return
-  def self.remove_file file_to_removee
-    if File.exists? file_to_removee
-      file = FileUtils.remove_file( file_to_removee )
-      return file
-    end
-  end
+  def self.remove_file(file_to_remove)
+    return unless File.exist? file_to_remove
 
+    FileUtils.remove_file(file_to_remove)
+  end
 
-  def self.open_file file, default_editor=nil
-    begin
-      if default_editor.nil?
-        TTY::Editor.open( file, command: :vi)
-      else
-        TTY::Editor.open( file, command: default_editor)
-      end
-    rescue Exception => e
-      return e
+  def self.open_file(file, default_editor = nil)
+    if default_editor.nil?
+      TTY::Editor.open(file, command: :vi)
+    else
+      TTY::Editor.open(file, command: default_editor)
     end
   end
-
 end
-
-
-

data/lib/lib/hash.rb

@@ -4,24 +4,24 @@ module HashRecursiveBlank
     each_pair do |key, val|
       r[key] = val.rblank if val.is_a?(Hash)
     end
-    return r.keep_if { |key, val| val.is_a?(Hash) }
+    r.keep_if { |_key, val| val.is_a?(Hash) }
   end
 
   def rblank!
     each_pair do |key, val|
       self[key] = val.rblank! if val.is_a?(Hash)
     end
-    return keep_if { |key, val| val.is_a?(Hash) }
+    keep_if { |_key, val| val.is_a?(Hash) }
   end
 end
 
 module HashRecursiveMerge
   def rmerge(other_hash, concat_if_array = false)
     r = {}
-    return merge(other_hash) do |key, oldval, newval|
+    merge(other_hash) do |key, oldval, newval|
       if oldval.is_a?(Hash)
         r[key] = oldval.rmerge(newval, concat_if_array)
-      elsif oldval.is_a?(Array) and newval.is_a?(Array)
+      elsif oldval.is_a?(Array) && newval.is_a?(Array)
         r[key] = concat_if_array ? oldval + newval : newval
       else
         newval
@@ -30,10 +30,10 @@ module HashRecursiveMerge
   end
 
   def rmerge!(other_hash, concat_if_array = false)
-    return merge!(other_hash) do |key, oldval, newval|
+    merge!(other_hash) do |_key, oldval, newval|
       if oldval.is_a?(Hash)
         oldval.rmerge!(newval, concat_if_array)
-      elsif oldval.is_a?(Array) and newval.is_a?(Array)
+      elsif oldval.is_a?(Array) && newval.is_a?(Array)
         concat_if_array ? oldval + newval : newval
       else
         newval
@@ -47,33 +47,32 @@ class Hash
   include HashRecursiveBlank
 
   def diff(other)
-      (self.keys + other.keys).uniq.inject({}) do |memo, key|
-        unless self[key] == other[key]
-          if self[key].kind_of?(Hash) &&  other[key].kind_of?(Hash)
-            memo[key] = self[key].diff(other[key])
-          else
-            memo[key] = [self[key], other[key]]
-          end
-        end
-        memo
-      end
+    (keys + other.keys).uniq.each_with_object({}) do |key, memo|
+      next if self[key] == other[key]
+
+      memo[key] = if self[key].is_a?(Hash) && other[key].is_a?(Hash)
+                    self[key].diff(other[key])
+                  else
+                    [self[key], other[key]]
+                  end
     end
+  end
 end
 
-
 class Hash
-
   # ensures nested hash from keys, and sets final key to value
   # keys: Array of Symbol|String
   # value: any
   def nested_set(keys, value)
-    raise "DEBUG: nested_set keys must be an Array" unless keys.is_a?(Array)
+    raise 'DEBUG: nested_set keys must be an Array' unless keys.is_a?(Array)
 
     final_key = keys.pop
     return unless valid_key?(final_key)
+
     position = self
-    for key in keys
+    keys.each do |key|
       return unless valid_key?(key)
+
       position[key] = {} unless position[key].is_a?(Hash)
       position = position[key]
     end
@@ -85,7 +84,7 @@ class Hash
   # returns true if key is valid
   def valid_key?(key)
     return true if key.is_a?(Symbol) || key.is_a?(String)
+
     raise "DEBUG: nested_set invalid key: #{key} (#{key.class})"
   end
-
-end
+end

data/lib/lib/log.rb

@@ -2,8 +2,7 @@ require 'singleton'
 class ToolsLog
   include Singleton
 
-  def initialize(options = {})
-  end
+  def initialize(options = {}); end
 
   # Create a Log file in work area
   #
@@ -21,22 +20,20 @@ class ToolsLog
   # @param log_name LogName to create
   # @param log_file LogFile path
   # @return
-  def self.create_log_file log_name, log_file
-    if File.exists? log_file
-      unless File.ctime(log_file).to_date == Time.now.to_date
-        File.delete(log_file)
-      end
+  def self.create_log_file(log_name, log_file)
+    if File.exist? log_file
+      File.delete(log_file) unless File.ctime(log_file).to_date == Time.now.to_date
     end
     ToolsUtil.set_variable "#{log_name}_log_file", log_file
     ToolsUtil.set_variable "#{log_name}_logger", Logger.new(log_file, 'daily')
-    (ToolsUtil.get_variable "#{log_name}_logger").formatter = proc do |severity, datetime, progname, msg|
-      "#{severity.chars.first} #{datetime.strftime "%H:%M:%S"}: #{msg}\n"
+    (ToolsUtil.get_variable "#{log_name}_logger").formatter = proc do |severity, datetime, _progname, msg|
+      "#{severity.chars.first} #{datetime.strftime '%H:%M:%S'}: #{msg}\n"
     end
-    #ToolsUtil.purge_files Tools.home+'/.tools/backup', '*', 14*24*60*60
+    # ToolsUtil.purge_files Tools.home+'/.tools/backup', '*', 14*24*60*60
   end
 
-  def self.method_missing(method, *args, &block)
-    #expected call format =>    STRING_LOGGER_TYPE + '_' + LOGGER_TYPE
+  def self.method_missing(method, *args)
+    # expected call format =>    STRING_LOGGER_TYPE + '_' + LOGGER_TYPE
     # Ex.:  tools_info
     logger_name   = method.to_s.split('_').first
     logger_method = method.to_s.split('_').last
@@ -44,27 +41,26 @@ class ToolsLog
     color         = args.extract_color
     if color.eql? :default
       case logger_method
-        when 'info'
-          color = :cyan
-        when 'warn'
-          color = :yellow
-        when 'debug'
-          color = :green
-        when 'error'
-          color = :light_red
-        when 'ucolor'
-          color = nil
-          logger_method = 'info'
-        else
-          return false
+      when 'info'
+        color = :cyan
+      when 'warn'
+        color = :yellow
+      when 'debug'
+        color = :green
+      when 'error'
+        color = :light_red
+      when 'ucolor'
+        color = nil
+        logger_method = 'info'
+      else
+        return false
       end
     end
-    unless color.nil?
-      text_to_print = args.first.colorize(color)
-    else
-      text_to_print = args.first
-    end
+    text_to_print = if color.nil?
+                      args.first
+                    else
+                      args.first.colorize(color)
+                    end
     logger.method(logger_method).call text_to_print
   end
-
-end
+end

data/lib/lib/net.rb

@@ -2,69 +2,57 @@ require 'singleton'
 class ToolsNet
   include Singleton
 
-  def initialize(options = {})
-  end
+  def initialize(options = {}); end
 
-  def self.ping? host
-    return Net::Ping::External.new(host || '0.0.0.1000', timeout=1).ping?
+  # Test a host.
+  #
+  # Net::Ping::External.new(host || '0.0.0.1000', timeout = 1).ping?
+  #
+  # @param            host or ip variable to test
+  # @return [Boolean]
+  def self.ping?(host)
+    Net::Ping::External.new(host || '0.0.0.1000', 1).ping?
   end
 
   def self.get_current_ip
-    # begin
-    #   ip = Socket::getaddrinfo(Socket.gethostname, "echo", Socket::AF_INET)[0][3]
-    #   return ip if IPAddress.valid?(ip)
-    # rescue Exception => e
-    # end
-    ip = (`ifconfig | grep -E '10\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}'  | awk '{print $2}'`).split("\n").first
+    ip = `ifconfig | grep -E '10\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}'  | awk '{print $2}'`.split("\n").first
     unless valid_ip? ip
-      ip = (`ifconfig | grep -E '192\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}'  | awk '{print $2}'`).split("\n").first
+      ip = `ifconfig | grep -E '192\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}'  | awk '{print $2}'`.split("\n").first
     end
     ip = ip.split("\n").first if ip.include? "\n"
     return ip if IPAddress.valid?(ip)
   end
 
-
   # Resolv a ip to a dns.
   #
   # @param           ip variable ip to resolv
   # @return [String] Dns name resolved
-  def self.resolv_ip_name ip
-    s = ''
-    begin
-      ret = Resolv.new.getname(ip)
-      return ret.instance_variable_get('@labels').join('.')
-    rescue Exception => e
-      case e.message
-        when "Dnsruby::NXDomain"
-          return nil
-        else
-          return e.message
-      end
+  def self.resolv_ip_name(ip)
+    ret = Resolv.new.getname(ip)
+    ret.instance_variable_get('@labels').join('.')
+  rescue Exception => e
+    case e.message
+    when 'Dnsruby::NXDomain' then nil
+    else
+      e.message
     end
-    return s.strip
   end
 
-
   # Resolv a dns to a ip.
   #
   # @param domain variable ip to resolv
   # @return [String] Dns address resolved
-  def self.resolv_dns domain
-    begin
-      dns = Dnsruby::DNS.new()
-      ret = dns.getaddress(domain).to_s
-    rescue Exception => e
-      case e.message
-        when "Dnsruby::NXDomain"
-          return nil
-        else
-          return e.message
-      end
+  def self.resolv_dns(domain)
+    dns = Dnsruby::DNS.new
+    dns.getaddress(domain).to_s
+  rescue Exception => e
+    case e.message
+    when 'Dnsruby::NXDomain' then nil
+    else
+      e.message
     end
-    return ret
   end
 
-
   # Do the request, validate and decode response and do the retries if needed
   #
   # - restclient_obj: initialized RestClient object
@@ -82,7 +70,7 @@ class ToolsNet
   # @param validate_opts  validate opts
   # @param retry_opts     retry opts
   # @param show_progress  default false
-  def self.doreq( restclient_obj, path, method, method_opts: {},validate_opts: {}, retry_opts: {}, show_progress: false)
+  def self.doreq(restclient_obj, path, method, method_opts: {}, validate_opts: {}, retry_opts: {}, show_progress: false)
     res = nil
     code = nil
     data = method_opts.fetch(:data, nil)
@@ -100,23 +88,22 @@ class ToolsNet
           res  = validate_decode_response(response, request, result, validate_opts)
           code = result.code.to_i
         end
-      rescue Exception => error
+      rescue Exception => e
         flag_error = true
       end
       # Other conditionals to retry
       unless retry_opts.empty?
-        if retry_opts.has_key?(:when_res)
+        if retry_opts.key?(:when_res)
           flag_error = true if retry_opts[:when_res].include?(res)
         end
-        if retry_opts.has_key?(:when_code)
+        if retry_opts.key?(:when_code)
           flag_error = true if retry_opts[:when_code].include?(code)
         end
       end
       return res unless flag_error # got response, break the loop
-      doReqMSG = sprintf "%d/%d", try, retries
-      if show_progress
-         ap doReqMSG
-      end
+
+      doReqMSG = format '%d/%d', try, retries
+      ap doReqMSG if show_progress
       if try >= retries
         ap doreq_code
         return nil
@@ -133,8 +120,8 @@ class ToolsNet
   # @param   result
   # @param   validate_opts
   # @return [Object type] Array or Proc or String or Error
-  def self.validate_decode_response response, request, result, validate_opts
-    if validate_opts.has_key? :expected
+  def self.validate_decode_response(response, request, result, validate_opts)
+    if validate_opts.key? :expected
       expected = validate_opts[:expected]
       case expected.class.name
       when 'Array'
@@ -157,31 +144,25 @@ class ToolsNet
     else
       return response
     end
-    return true
+    true
   end
 
-
   # Validate.: port number between valid range?.
   #
   # @param            port number to be validate.
   # @return [Boolean]
-  def self.valid_port? port
-    if port.to_s.strip.match(/^\d{1,5}(?!\d)$/).nil?
-      return false
-    end
-    unless port.to_i.between?(1, 65535)
-      return false
-    end
-    return true
-  end
-
+  def self.valid_port?(port)
+    return false if port.to_s.strip.match(/^\d{1,5}(?!\d)$/).nil?
+    return false unless port.to_i.between?(1, 65_535)
 
+    true
+  end
 
   # Validate.: ip number or mask are valids?.
   #
   # @param  that number or mask to be validate.
   # @return [Hash] result info ip or ask or error
-  def self.validate_ipaddress that
+  def self.validate_ipaddress(that)
     result = {}
     result[:status]  = false
     result[:type]    = ''
@@ -189,9 +170,9 @@ class ToolsNet
     result[:address] = that
     result[:resolv]  = ''
 
-    if IPAddress::valid_ipv4? that
+    if IPAddress.valid_ipv4? that
       begin
-        ip = IPAddress::valid_ipv4? that
+        ip = IPAddress.valid_ipv4? that
         result[:status] = true
         result[:type]   = 'ip'
         result[:oct1]   = that.split('.')[0]
@@ -223,43 +204,40 @@ class ToolsNet
         # end
       end
     end
-    return result
+    result
   end
 
-
   # Validate.: ip number is a backend?.
   #
   # @param  original_addr number to be validate.
   # @return [Boolean]
-  def self.is_backend? original_addr
-    glbbackend  = NetAddr::CIDR.create('10.0.0.0/8')
-    return glbbackend.contains? original_addr
+  def self.is_backend?(original_addr)
+    glbbackend = NetAddr::CIDR.create('10.0.0.0/8')
+    glbbackend.contains? original_addr
   end
 
-  def self.valid_ip? original_addr
+  def self.valid_ip?(original_addr)
     status = false
     begin
       status = IPAddress.valid?(original_addr)
-    rescue
+    rescue Exception => e
+      e
     end
-    return status
+    status
   end
 
   # Validate.: ip number is avalid network.
   #
   # @param  original_addr network number to be validate.
   # @return [Boolean]
-  def self.valid_network? original_addr
+  def self.valid_network?(original_addr)
     status = false
     begin
       ip = IPAddress original_addr
       status = true if ip.network?
-    rescue
+    rescue Exception => e
+      e
     end
-    return status
+    status
   end
-
-
-
-
-end
+end