tools 0.4.5 → 0.4.6

data/lib/tools/version.rb

@@ -1,4 +1,4 @@
 module Tools
-  VERSION = "0.4.5"
-  HOMEPAGE = "https://github.com/Xyko/tools"
+  VERSION = '0.4.6'.freeze
+  HOMEPAGE = 'https://github.com/Xyko/tools'.freeze
 end

data/test/mini_array.rb

@@ -1,19 +1,18 @@
 class ToolsModuleTest < Minitest::Test
-
   def self.test_order
     :sorted
   end
 
   def test_hash_A_extract_first
-    assert_equal ['a','b','c'].extract_first, 'a'
+    assert_equal %w[a b c].extract_first, 'a'
   end
 
   def test_hash_B_extract_first
-    assert_equal  (['a',:color,'c'].extract_symbol :color), true
+    assert_equal (['a', :color, 'c'].extract_symbol :color), true
   end
 
   def test_hash_C_extract_color
-    args   = ['xxx', '-x', '-vvv', :yellow, '-c', '-vcv', '-v2', '-vvvvv', '-s', :json,  :red, :json]
+    args   = ['xxx', '-x', '-vvv', :yellow, '-c', '-vcv', '-v2', '-vvvvv', '-s', :json, :red, :json]
     yellow = args.extract_color
     color  = args.extract_color
     assert_equal yellow, :yellow
@@ -21,7 +20,7 @@ class ToolsModuleTest < Minitest::Test
   end
 
   def test_hash_D_extract_option
-    args   = ['xxx', '-x', '-vvv', :yellow, ':red','-c', '-vcv', '-v2', '-vvvvv', '-s', :json,  :red, :json]
+    args   = ['xxx', '-x', '-vvv', :yellow, ':red', '-c', '-vcv', '-v2', '-vvvvv', '-s', :json, :red, :json]
     yellow = args.extract_color
     red1    = args.extract_color
     red2    = args.extract_color
@@ -38,16 +37,12 @@ class ToolsModuleTest < Minitest::Test
   end
 
   def test_hash_D_extract_option_value
-    args   = ['-o', 'um', '-o', 'dois', '--desc', 'description', '-v', '-v', '-o', 'tres', '-s', :json,  :red, :json]
+    args = ['-o', 'um', '-o', 'dois', '--desc', 'description', '-v', '-v', '-o', 'tres', '-s', :json, :red, :json]
     desc_status, desc = args.extract_option_value '--desc'
-    status, origin    = args.extract_option_value '-o', {:multiple => true}
+    status, origin    = args.extract_option_value '-o', multiple: true
     assert_equal desc_status, true
     assert_equal desc, 'description'
     assert_equal status, true
-    assert_equal origin, ['um','um','dois','dois','tres','tres']
+    assert_equal origin, %w[um um dois dois tres tres]
   end
-
-
 end
-
-

data/test/mini_cache.rb

@@ -1,28 +1,25 @@
 class ToolsModuleTest < Minitest::Test
-
   def self.test_order
     :sorted
   end
 
   def test_cache_A_all_operators
     ToolsFiles.remove_file '/home/francisco/2018/xykotools/tools/teste-persistent.cache'
-    ToolsCache.create_cache_file 'tools',  (File.dirname __dir__) + '/teste-persistent.cache', 60
+    ToolsCache.create_cache_file 'tools', (File.dirname __dir__) + '/teste-persistent.cache', 60
     assert_equal ToolsCache.tools_list, {}
     ToolsCache.tools_set :k1, 100
-    assert_equal ToolsCache.tools_list, {:k1 => 100}
+    assert_equal ToolsCache.tools_list, k1: 100
     ToolsCache.tools_unset :k1
     assert_equal ToolsCache.tools_list, {}
-    ToolsCache.tools_set :k2, {:i => 100, :j => 200}
-    ToolsCache.tools_set :k2, {:l => 100, :m => 200}
+    ToolsCache.tools_set :k2, i: 100, j: 200
+    ToolsCache.tools_set :k2, l: 100, m: 200
     ToolsCache.tools_set :k3, []
-    ToolsCache.tools_set :k3, [1,2,3]
-    ToolsCache.tools_set :k3, [4, ['a','b']]
-    assert_equal (ToolsCache.tools_get :k3), [1,2,3,4,['a','b']]
-    assert_equal (ToolsCache.tools_get :k2), {:i => 100, :j => 200,:l => 100, :m => 200}
+    ToolsCache.tools_set :k3, [1, 2, 3]
+    ToolsCache.tools_set :k3, [4, %w[a b]]
+    assert_equal (ToolsCache.tools_get :k3), [1, 2, 3, 4, %w[a b]]
+    assert_equal (ToolsCache.tools_get :k2), i: 100, j: 200, l: 100, m: 200
     ToolsCache.tools_clear
     assert_equal ToolsCache.tools_list, {}
     ToolsFiles.remove_file '/home/francisco/2018/xykotools/tools/teste-persistent.cache'
   end
-
-
-end
+end

data/test/mini_config.rb

@@ -1,28 +1,37 @@
 class ToolsModuleTest < Minitest::Test
-
   def self.test_order
     :sorted
   end
 
-  def test_log_A_all_operations
-
+  def test_config_A_before
     ToolsFiles.remove_file (File.dirname __dir__) + '/tools_yaml.config'
     ToolsFiles.remove_file (File.dirname __dir__) + '/tools_json.config'
-    ToolsConfig.create_config_file 'tools_yaml', (File.dirname __dir__) +'/tools_yaml.config', :yaml, {:first_time => true}
-    ToolsConfig.create_config_file 'tools_json', (File.dirname __dir__) +'/tools_json.config', :json, {:first_time => true}
-    ToolsConfig.create_config_file 'tools_json', (File.dirname __dir__) +'/tools_json.config', :json, {:first_time => true}
+  end
+
+  def test_config_B_create
+    ToolsConfig.create_config_file 'tools_yaml', (File.dirname __dir__) + '/tools_yaml.config', :yaml, first_time: true
+    ToolsConfig.create_config_file 'tools_json', (File.dirname __dir__) + '/tools_json.config', :json, first_time: true
+    ToolsConfig.create_config_file 'tools_json', (File.dirname __dir__) + '/tools_json.config', :json, first_time: true
+  end
+
+  def test_config_C_load
     ToolsConfig.load_config (File.dirname __dir__) + '/tools_yaml.config'
     ToolsConfig.load_config (File.dirname __dir__) + '/tools_json.config'
+  end
 
-    ToolsConfig.insert_in_config (File.dirname __dir__) +'/tools_yaml.config', {:first_time => false,}
-    ToolsConfig.insert_in_config (File.dirname __dir__) +'/tools_json.config', {:first_time => false,}
+  def test_config_D_insert
+    ToolsConfig.insert_in_config (File.dirname __dir__) + '/tools_yaml.config', first_time: false
+    ToolsConfig.insert_in_config (File.dirname __dir__) + '/tools_json.config', first_time: false
+  end
 
-    ToolsConfig.change_value_in_config (File.dirname __dir__) +'/tools_yaml.config', true , :first_time
-    ToolsConfig.change_value_in_config (File.dirname __dir__) +'/tools_json.config', true , :first_time
+  def test_config_E_change
+    ToolsConfig.change_value_in_config (File.dirname __dir__) + '/tools_yaml.config', true, :first_time
+    ToolsConfig.change_value_in_config (File.dirname __dir__) + '/tools_json.config', true, :first_time
+  end
 
+  def test_config_F_after
     ToolsFiles.remove_file (File.dirname __dir__) + '/tools_yaml.config'
     ToolsFiles.remove_file (File.dirname __dir__) + '/tools_json.config'
-
   end
 
-end
+end

data/test/mini_console.rb

@@ -1,20 +1,18 @@
-
 class ToolsModuleTest < Minitest::Test
-
   def self.test_order
     :sorted
   end
 
-
   def test_console_A_run_console
-     mock = MiniTest::Mock.new
-    def mock.start *args; true; end
+    mock = MiniTest::Mock.new
+    def mock.start(*_args)
+      true
+    end
     Prompt::Console.stub :start, mock do
       assert_equal ToolsConsole.create_console.class, Array
       assert_equal (ToolsConsole.exec_console ['test']), true
       assert_equal (ToolsConsole.exec_console ['tes']), false
-      assert_equal ToolsConsole.run_console.class, Minitest::Mock
+      ToolsConsole.run_console
     end
   end
-
-end
+end

data/test/mini_display.rb

@@ -1,5 +1,4 @@
 class ToolsModuleTest < Minitest::Test
-
   def self.test_order
     :sorted
   end
@@ -9,7 +8,7 @@ class ToolsModuleTest < Minitest::Test
     old_stdout = $stdout
     captured_stdio = StringIO.new('', 'w')
     $stdout = captured_stdio
-    ToolsDisplay.show "TEXTO VERDE", :green
+    ToolsDisplay.show 'TEXTO VERDE', :green
     $stdout = old_stdout
     assert_equal "\e[0;32;49mTEXTO VERDE\n\e[0m", captured_stdio.string
   end
@@ -19,7 +18,7 @@ class ToolsModuleTest < Minitest::Test
     old_stdout = $stdout
     captured_stdio = StringIO.new('', 'w')
     $stdout = captured_stdio
-    ToolsDisplay.show "TEXTO SAMELINE", :sameline
+    ToolsDisplay.show 'TEXTO SAMELINE', :sameline
     $stdout = old_stdout
     assert_equal "\e[0;39;49mTEXTO SAMELINE\e[0m", captured_stdio.string
   end
@@ -29,7 +28,7 @@ class ToolsModuleTest < Minitest::Test
     old_stdout = $stdout
     captured_stdio = StringIO.new('', 'w')
     $stdout = captured_stdio
-    ToolsDisplay.show_colorize "red".red+ " " + "white".white
+    ToolsDisplay.show_colorize 'red'.red + ' ' + 'white'.white
     $stdout = old_stdout
     assert_equal "\e[0;31;49mred\e[0m \e[0;37;49mwhite\e[0m\n", captured_stdio.string
   end
@@ -39,15 +38,13 @@ class ToolsModuleTest < Minitest::Test
     old_stdout = $stdout
     captured_stdio = StringIO.new('', 'w')
     $stdout = captured_stdio
-    ToolsDisplay.show "red".red+ " " + "white".white, :colorized
+    ToolsDisplay.show 'red'.red + ' ' + 'white'.white, :colorized
     $stdout = old_stdout
     assert_equal "\e[0;31;49mred\e[0m \e[0;37;49mwhite\e[0m\n", captured_stdio.string
   end
 
   def test_dislay_E_error
     result = ToolsDisplay.show []
-    assert_equal "Array", result
+    assert_equal 'Array', result
   end
-
-
-end
+end

data/test/mini_file.rb

@@ -1,32 +1,32 @@
 class ToolsModuleTest < Minitest::Test
-
   def self.test_order
     :sorted
   end
 
   def test_file_A_purge
     mock = MiniTest::Mock.new
-    def mock.delete *args; Array; end
+    def mock.delete(*_args)
+      Array
+    end
     File.stub :delete, mock do
-      assert_equal (ToolsFiles.purge_files (File.dirname __dir__)+'/pkg', '*.gem', 1).class, Array
+      assert_equal (ToolsFiles.purge_files (File.dirname __dir__) + '/pkg', '*.gem', 1).class, Array
     end
   end
 
   def test_file_B_create_dir
     mock = MiniTest::Mock.new
-    def mock.mkdir *args; String; end
+    def mock.mkdir(*_args)
+      String
+    end
     Dir.stub :mkdir, mock do
-      assert_equal (ToolsFiles.create_dir (File.dirname __dir__)+'/pkg', 'minitest').class, String
-      assert_equal (ToolsFiles.create_dir (File.dirname __dir__)+'/pkg2', 'minitest').class, String
+      assert_equal (ToolsFiles.create_dir (File.dirname __dir__) + '/pkg', 'minitest').class, String
+      assert_equal (ToolsFiles.create_dir (File.dirname __dir__) + '/pkg2', 'minitest').class, String
     end
   end
 
-  def test_file_C_create_file
-    mock = MiniTest::Mock.new
-    def mock.open *args; String; end
-    File.stub :open, mock do
-      assert_equal (ToolsFiles.create_file (File.dirname __dir__)+'/pkg', 'minitest', 'minitest').class, String
-    end
+  def test_file_C_create_delete_file
+    ToolsFiles.create_file (File.dirname __dir__), '/create_file', 'teste'
+    ToolsFiles.remove_file (File.dirname __dir__) + '/create_file'
   end
 
   def test_file_D_load_file
@@ -44,21 +44,17 @@ class ToolsModuleTest < Minitest::Test
   end
 
   def test_file_G_open_file
+
     mock = MiniTest::Mock.new
-    def mock.open *args; true; end
+    def mock.open(*_args)
+      true
+    end
     TTY::Editor.stub :open, mock do
-      assert_equal (ToolsFiles.open_file '').class, Minitest::Mock
-      assert_equal (ToolsFiles.open_file '', :vi).class, Minitest::Mock
+      file = (File.dirname __dir__) + '/TODO.txt'
+      ToolsFiles.open_file file, :vi
+      ToolsFiles.open_file file
     end
   end
 
 
-  def test_file_H_remove_file
-    mock = MiniTest::Mock.new
-    def mock.remove_file *args; String; end
-    FileUtils.stub :remove_file, mock do
-      assert_equal (ToolsFiles.remove_file (File.dirname __dir__)+'/pkg').class, Minitest::Mock
-    end
-  end
-
-end
+end

data/test/mini_hash.rb

@@ -1,5 +1,4 @@
 class ToolsModuleTest < Minitest::Test
-
   def self.test_order
     :sorted
   end
@@ -8,60 +7,51 @@ class ToolsModuleTest < Minitest::Test
     data = {
       'k1' => 100,
       'k2' => 'v2',
-      :k3  => {
-        :a => 100,
-      },
+      :k3 => {
+        a: 100
+      }
     }
     result = {
-      "k1" => 100,
-      "k2" => "v2",
-       :k3 => {
-           :a => 100,
-          :k2 => 200
+      'k1' => 100,
+      'k2' => 'v2',
+      :k3 => {
+        a: 100,
+        k2: 200
       },
-       :k1 => 100,
+      :k1 => 100
     }
-    data.rmerge!( {:k1 => 100} )
-    data.rmerge!( {:k3 => {:k2 => 200}})
+    data.rmerge!(k1: 100)
+    data.rmerge!(k3: { k2: 200 })
     assert_equal data, result
 
     result_merge = {
-        "k1" => 100,
-        "k2" => "v2",
-         :k3 => {
-             :a => 100,
-            :k2 => 200
-        },
-         :k1 => 100
+      'k1' => 100,
+      'k2' => 'v2',
+      :k3 => {
+        a: 100,
+        k2: 200
+      },
+      :k1 => 100
     }
 
-    hash = data.rmerge( {:k1 => 100} )
+    hash = data.rmerge(k1: 100)
     assert_equal hash, result_merge
 
-    x = {:k1 => 100 , :k2 => { :k3 => {:a => 100}}}
-    assert_equal x.rblank,  {:k2 => {:k3 => {}}}
-    assert_equal x.rblank!,  {:k2 => {:k3 => {}}}
+    x = { k1: 100, k2: { k3: { a: 100 } } }
+    assert_equal x.rblank, k2: { k3: {} }
+    assert_equal x.rblank!,  k2: { k3: {} }
 
-    x = {:k1 => 100 , :k2 => { :k3 => {:a => 100}}}
+    x = { k1: 100, k2: { k3: { a: 100 } } }
     y = x.rblank
     diff = x.diff y
-    assert_equal diff, {:k1=>[100, nil], :k2=>{:k3=>{:a=>[100, nil]}}}
-
-
-    x = {:k1 => 100 , :k2 => { :k3 => {:a => 100}}}
-    y = x.nested_set [:k2,:k3,:a], 200
-    assert_equal x, {:k1 => 100 , :k2 => { :k3 => {:a => 200}}}
+    assert_equal diff, k1: [100, nil], k2: { k3: { a: [100, nil] } }
 
+    x = { k1: 100, k2: { k3: { a: 100 } } }
+    y = x.nested_set %i[k2 k3 a], 200
+    assert_equal x, k1: 100, k2: { k3: { a: 200 } }
   end
-
-
-
-
-
 end
 
-
-
 # module HashRecursiveBlank
 #   def rblank
 #     r = {}
@@ -124,7 +114,6 @@ end
 #     end
 # end
 
-
 # class Hash
 
 #   # ensures nested hash from keys, and sets final key to value

data/test/mini_log.rb

@@ -1,5 +1,4 @@
 class ToolsModuleTest < Minitest::Test
-
   def self.test_order
     :sorted
   end
@@ -8,7 +7,7 @@ class ToolsModuleTest < Minitest::Test
     ToolsFiles.remove_file (File.dirname __dir__) + '/teste.log'
     ToolsLog.create_log_file 'test', (File.dirname __dir__) + '/teste.log'
     ToolsLog.create_log_file 'test', (File.dirname __dir__) + '/teste.log'
-    FileUtils.touch (File.dirname __dir__) + '/teste.log', :mtime => (Time.now - 86400)
+    FileUtils.touch (File.dirname __dir__) + '/teste.log', mtime: (Time.now - 86_400)
     ToolsLog.test_info  'Minitest.: test_log'
     ToolsLog.test_warn  'Minitest.: test_log'
     ToolsLog.test_error 'Minitest.: test_log'
@@ -17,5 +16,4 @@ class ToolsModuleTest < Minitest::Test
     ToolsLog.test_ucolorx 'Minitest.: test_log'
     ToolsFiles.remove_file (File.dirname __dir__) + '/teste.log'
   end
-
-end
+end

data/test/mini_net.rb

@@ -1,5 +1,4 @@
 class ToolsModuleTest < Minitest::Test
-
   def self.test_order
     :sorted
   end
@@ -15,209 +14,192 @@ class ToolsModuleTest < Minitest::Test
     assert_equal (ToolsNet.validate_ipaddress ip)[:type], 'ip'
     assert_equal (ToolsNet.validate_ipaddress '100.0.0.0/28')[:status], true
     assert_equal (ToolsNet.validate_ipaddress '100.0.0.0/28')[:type], 'mask'
-    assert_equal (ToolsNet.validate_ipaddress ip+'x')[:status], false
+    assert_equal (ToolsNet.validate_ipaddress ip + 'x')[:status], false
     assert_equal (ToolsNet.validate_ipaddress '100.0.0.0/28x')[:status], false
     assert_equal (ToolsNet.is_backend? '10.1.2.3'), true
     assert_equal (ToolsNet.is_backend? '201.0.0.1'), false
     assert_equal (ToolsNet.valid_network? ip), false
     assert_equal (ToolsNet.valid_network? '110.0.0.0/28'), true
-    assert_equal (ToolsNet.resolv_dns 'www.wikipedia.org'), "208.80.154.224"
+    assert_equal (ToolsNet.resolv_dns 'www.wikipedia.org'), '208.80.154.224'
     assert_nil   (ToolsNet.resolv_dns 'www.wikipedia.orgx')
-    assert_equal (ToolsNet.resolv_ip_name "208.80.154.224"), "text-lb.eqiad.wikimedia.org"
-    assert_equal (ToolsNet.resolv_ip_name "208.80.154.224x"), "cannot interpret as address: 208.80.154.224x"
+    assert_equal (ToolsNet.resolv_ip_name '208.80.154.224'), 'text-lb.eqiad.wikimedia.org'
+    assert_equal (ToolsNet.resolv_ip_name '208.80.154.224x'), 'cannot interpret as address: 208.80.154.224x'
   end
 
   def test_net_C_valid_port
     assert_equal (ToolsNet.valid_port? 8888), true
     assert_equal (ToolsNet.valid_port? -1), false
     assert_equal (ToolsNet.valid_port? 0), false
-    assert_equal (ToolsNet.valid_port? 100000), false
+    assert_equal (ToolsNet.valid_port? 100_000), false
   end
 
-
   def test_net_D_doreq
     resource = RestClient::Resource.new('www.google.com')
-    validate_opts = {quit_on_error: false}
+    validate_opts = { quit_on_error: false }
     method_opts   = {}
-    params={:method => :get}
+    params = { method: :get }
     uri = ''
-    if params.has_key? :expected
-      validate_opts[:expected] = params[:expected]
-    end
-    if params.has_key? :data
-      method_opts = {:data => params[:data].to_json}
-    end
-    result =  ToolsNet.doreq resource,
-                                uri,
-                                params[:method],
-                                show_progress: true,
-                                method_opts: method_opts,
-                                validate_opts: validate_opts,
-                                retry_opts: {
-                                  attempts: 1,
-                                  when_res: [nil, [], {}, ''],
-                                  when_code: []}
+    validate_opts[:expected] = params[:expected] if params.key? :expected
+    method_opts = { data: params[:data].to_json } if params.key? :data
+    result = ToolsNet.doreq resource,
+                            uri,
+                            params[:method],
+                            show_progress: true,
+                            method_opts: method_opts,
+                            validate_opts: validate_opts,
+                            retry_opts: {
+                              attempts: 1,
+                              when_res: [nil, [], {}, ''],
+                              when_code: []
+                            }
     assert_equal result.code, 200
   end
-
-
 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
-  #   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
-  #   end
-  #   return ret
-  # end
-
-
-  # # Do the request, validate and decode response and do the retries if needed
-  # #
-  # # - restclient_obj: initialized RestClient object
-  # # - path: URL path to request
-  # # - method: symbol for HTTP Method to request
-  # # - method_opts: options as passed to a RestClient call
-  # # - validate_opts: options for response validation as used with
-  # # validate_decode_response()
-  # # - retry_opts: when_res: [nil, [], {}, 'str'], when_code: [404, 500],
-  # # conditionals to retry even if no exceptions were catched
-  # # @param restclient_obj Rest Object
-  # # @param path           path
-  # # @param method         method
-  # # @param method_opts    method opts
-  # # @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)
-  #   res = nil
-  #   code = nil
-  #   data = method_opts.fetch(:data, nil)
-  #   method_opts.delete(:data)
-
-  #   # Retry loop due to:
-  #   # - 404 from Router API right after applying patch over a target
-  #   # - Intermittent connection reset from Manager API (HTTPS)
-  #   retries = retry_opts.fetch(:attempts, 10)
-  #   1.upto(retries) do |try|
-  #     flag_error = false
-  #     # The request
-  #     begin
-  #       restclient_obj[path].send(method, *data, **method_opts) do |response, request, result|
-  #         res  = validate_decode_response(response, request, result, validate_opts)
-  #         code = result.code.to_i
-  #       end
-  #     rescue Exception => error
-  #       flag_error = true
-  #     end
-  #     # Other conditionals to retry
-  #     unless retry_opts.empty?
-  #       if retry_opts.has_key?(:when_res)
-  #         flag_error = true if retry_opts[:when_res].include?(res)
-  #       end
-  #       if retry_opts.has_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
-  #     if try >= retries
-  #       ap doreq_code
-  #       return nil
-  #     else
-  #       sleep 1 # wait before next
-  #     end
-  #   end
-  # end
-
-  # # Return a valid decode response.
-  # #
-  # # @param   response
-  # # @param   request
-  # # @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
-  #     expected = validate_opts[:expected]
-  #     case expected.class.name
-  #     when 'Array'
-  #       if validate_opts[:expected].include? response
-  #         return true
-  #       else
-  #         return false
-  #       end
-  #     when 'Proc'
-  #       response = expected.call(response, request, result)
-  #       return response
-  #     when 'String'
-  #       return result   if validate_opts[:expected].eql? 'result'
-  #       return request  if validate_opts[:expected].eql? 'request'
-  #       return response if validate_opts[:expected].eql? 'response'
-  #     else
-  #       ap expected.class.name
-  #       return response
-  #     end
-  #   else
-  #     return response
-  #   end
-  #   return 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
-
-
-
-
-
+# # 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
+#   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
+#   end
+#   return ret
+# end
+
+# # Do the request, validate and decode response and do the retries if needed
+# #
+# # - restclient_obj: initialized RestClient object
+# # - path: URL path to request
+# # - method: symbol for HTTP Method to request
+# # - method_opts: options as passed to a RestClient call
+# # - validate_opts: options for response validation as used with
+# # validate_decode_response()
+# # - retry_opts: when_res: [nil, [], {}, 'str'], when_code: [404, 500],
+# # conditionals to retry even if no exceptions were catched
+# # @param restclient_obj Rest Object
+# # @param path           path
+# # @param method         method
+# # @param method_opts    method opts
+# # @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)
+#   res = nil
+#   code = nil
+#   data = method_opts.fetch(:data, nil)
+#   method_opts.delete(:data)
+
+#   # Retry loop due to:
+#   # - 404 from Router API right after applying patch over a target
+#   # - Intermittent connection reset from Manager API (HTTPS)
+#   retries = retry_opts.fetch(:attempts, 10)
+#   1.upto(retries) do |try|
+#     flag_error = false
+#     # The request
+#     begin
+#       restclient_obj[path].send(method, *data, **method_opts) do |response, request, result|
+#         res  = validate_decode_response(response, request, result, validate_opts)
+#         code = result.code.to_i
+#       end
+#     rescue Exception => error
+#       flag_error = true
+#     end
+#     # Other conditionals to retry
+#     unless retry_opts.empty?
+#       if retry_opts.has_key?(:when_res)
+#         flag_error = true if retry_opts[:when_res].include?(res)
+#       end
+#       if retry_opts.has_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
+#     if try >= retries
+#       ap doreq_code
+#       return nil
+#     else
+#       sleep 1 # wait before next
+#     end
+#   end
+# end
+
+# # Return a valid decode response.
+# #
+# # @param   response
+# # @param   request
+# # @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
+#     expected = validate_opts[:expected]
+#     case expected.class.name
+#     when 'Array'
+#       if validate_opts[:expected].include? response
+#         return true
+#       else
+#         return false
+#       end
+#     when 'Proc'
+#       response = expected.call(response, request, result)
+#       return response
+#     when 'String'
+#       return result   if validate_opts[:expected].eql? 'result'
+#       return request  if validate_opts[:expected].eql? 'request'
+#       return response if validate_opts[:expected].eql? 'response'
+#     else
+#       ap expected.class.name
+#       return response
+#     end
+#   else
+#     return response
+#   end
+#   return 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