choria-mcorpc-support 2.20.3 → 2.20.4

data/lib/mcollective/pluginpackager.rb

@@ -10,7 +10,7 @@ module MCollective
     end
 
     def self.[](klass)
-      const_get("#{klass}")
+      const_get(klass.to_s)
     end
 
     # Fetch and return metadata from plugin DDL
@@ -19,12 +19,12 @@ module MCollective
 
       begin
         ddl_file = File.read(Dir.glob(File.join(path, type, "*.ddl")).first)
-      rescue Exception
+      rescue Exception # rubocop:disable Lint/RescueException
         raise "failed to load ddl file in plugin directory : #{File.join(path, type)}"
       end
       ddl.instance_eval ddl_file
 
-      return ddl.meta, ddl.requirements[:mcollective]
+      [ddl.meta, ddl.requirements[:mcollective]]
     end
 
     # Checks if a directory is present and not empty
@@ -34,19 +34,19 @@ module MCollective
 
     # Quietly calls a block if verbose parameter is false
     def self.execute_verbosely(verbose, &block)
-      unless verbose
+      if verbose
+        block.call
+      else
         old_stdout = $stdout.clone
         $stdout.reopen(File.new("/dev/null", "w"))
         begin
           block.call
-        rescue Exception => e
+        rescue Exception # rubocop:disable Lint/RescueException
           $stdout.reopen old_stdout
-          raise e
+          raise
         ensure
           $stdout.reopen old_stdout
         end
-      else
-        block.call
       end
     end
 
@@ -54,15 +54,13 @@ module MCollective
     def self.command_available?(build_tool)
       ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
         builder = File.join(path, build_tool)
-        if File.exists?(builder)
-          return true
-        end
+        return true if File.exist?(builder)
       end
       false
     end
 
     def self.safe_system(*args)
-      raise(RuntimeError, "Failed: #{args.join(' ')}") unless system *args
+      raise("Failed: #{args.join(' ')}") unless system(*args)
     end
 
     # Filter out platform specific dependencies
@@ -77,22 +75,20 @@ module MCollective
           if prefix == $1
             dependency[:name] = $2
             dependency
-          else
-            nil
           end
         else
           dependency
         end
-      end.reject{ |dependency| dependency == nil }
+      end.reject(&:nil?)
     end
 
     # Return the path to a plugin's core directories
     def self.get_plugin_path(target)
-      if (File.exists?(File.join(target, "lib", "mcollective")))
+      if File.exist?(File.join(target, "lib", "mcollective"))
         return File.join(target, "lib", "mcollective")
       end
 
-      return target
+      target
     end
   end
 end

data/lib/mcollective/rpc.rb

@@ -1,4 +1,4 @@
-require 'pp'
+require "pp"
 
 module MCollective
   # Toolset to create a standard interface of client and agent using
@@ -21,15 +21,13 @@ module MCollective
     def rpcoptions
       oparser = MCollective::Optionparser.new({:verbose => false, :progress_bar => true}, "filter")
 
-      options = oparser.parse do |parser, options|
-        if block_given?
-          yield(parser, options)
-        end
+      options = oparser.parse do |parser, opts|
+        yield(parser, opts) if block_given?
 
-        Helpers.add_simplerpc_options(parser, options)
+        Helpers.add_simplerpc_options(parser, opts)
       end
 
-      return options
+      options
     end
 
     # Wrapper to create clients, supposed to be used as
@@ -57,7 +55,7 @@ module MCollective
     # :exit_on_failure is true by default, and causes the application to
     # exit if there is a failure constructing the RPC client. Set this flag
     # to false to cause an Exception to be raised instead.
-    def rpcclient(agent, flags = {})
+    def rpcclient(agent, flags={})
       configfile = flags[:configfile] || Util.config_file_for_user
       options = flags[:options] || nil
 
@@ -71,12 +69,12 @@ module MCollective
       begin
         if options
           rpc = Client.new(agent, :configfile => options[:config], :options => options)
-          @options = rpc.options
         else
           rpc = Client.new(agent, :configfile => configfile)
-          @options = rpc.options
         end
-      rescue Exception => e
+
+        @options = rpc.options
+      rescue Exception => e # rubocop:disable Lint/RescueException:
         if exit_on_failure
           puts("Could not create RPC client: #{e}")
           exit!
@@ -97,7 +95,7 @@ module MCollective
     # printrpcstats can easily get access to it without
     # users having to pass it around in params.
     def self.stats(stats)
-      @@stats = stats
+      @@stats = stats # rubocop:disable Style/ClassVars
     end
 
     # means for other classes to drop discovered hosts into this module
@@ -105,7 +103,7 @@ module MCollective
     # printrpcstats can easily get access to it without
     # users having to pass it around in params.
     def self.discovered(discovered)
-      @@discovered = discovered
+      @@discovered = discovered # rubocop:disable Style/ClassVars
     end
 
     # Prints stats, requires stats to be saved from elsewhere
@@ -125,7 +123,7 @@ module MCollective
 
       flags = {:summarize => false, :caption => "rpc stats"}.merge(flags)
 
-      verbose = @options[:verbose] rescue verbose = false
+      verbose = !!@options[:verbose]
 
       begin
         stats = @@stats
@@ -143,17 +141,17 @@ module MCollective
     # that produce an error will be printed
     #
     # To get details of each result run with the -v command line option.
-    def printrpc(result, flags = {})
-      verbose = @options[:verbose] rescue verbose = false
+    def printrpc(result, flags={})
+      verbose = !!@options[:verbose]
       verbose = flags[:verbose] || verbose
       flatten = flags[:flatten] || false
       format = @options[:output_format]
       forced_mode = @options[:force_display_mode] || false
 
-      result_text =  Helpers.rpcresults(result, {:verbose => verbose, :flatten => flatten, :format => format, :force_display_mode => forced_mode})
+      result_text = Helpers.rpcresults(result, :verbose => verbose, :flatten => flatten, :format => format, :force_display_mode => forced_mode)
 
       if result.is_a?(Array) && format == :console
-        puts "\n%s\n" % [ result_text ]
+        puts "\n%s\n" % [result_text]
       else
         # when we get just one result to print dont pad them all with
         # blank spaces etc, just print the individual result with no

data/lib/mcollective/runnerstats.rb

@@ -60,27 +60,31 @@ module MCollective
 
     # Returns a hash with all stats
     def to_hash
-      stats = {:validated => @validated,
+      stats = {
+        :validated => @validated,
         :unvalidated => @unvalidated,
         :passed => @passed,
         :filtered => @filtered,
         :starttime => @starttime,
         :total => @total,
         :ttlexpired => @ttlexpired,
-        :replies => @replies}
+        :replies => @replies
+      }
 
-      reply = {:stats => stats,
+      reply = {
+        :stats => stats,
         :threads => [],
         :pid => Process.pid,
-        :times => {} }
+        :times => {}
+      }
 
-      ::Process.times.each_pair{|k,v|
+      ::Process.times.each_pair {|k, v|
         k = k.to_sym
         reply[:times][k] = v
       }
 
       Thread.list.each do |t|
-        reply[:threads] << "#{t.inspect}"
+        reply[:threads] << t.inspect.to_s
       end
 
       reply[:agents] = Agents.agentlist

data/lib/mcollective/shell.rb

@@ -36,33 +36,33 @@ module MCollective
 
       options.each do |opt, val|
         case opt.to_s
-          when "stdout"
-            raise "stdout should support <<" unless val.respond_to?("<<")
-            @stdout = val
+        when "stdout"
+          raise "stdout should support <<" unless val.respond_to?("<<")
+          @stdout = val
 
-          when "stderr"
-            raise "stderr should support <<" unless val.respond_to?("<<")
-            @stderr = val
+        when "stderr"
+          raise "stderr should support <<" unless val.respond_to?("<<")
+          @stderr = val
 
-          when "stdin"
-            raise "stdin should be a String" unless val.is_a?(String)
-            @stdin = val
+        when "stdin"
+          raise "stdin should be a String" unless val.is_a?(String)
+          @stdin = val
 
-          when "cwd"
-            raise "Directory #{val} does not exist" unless File.directory?(val)
-            @cwd = val
+        when "cwd"
+          raise "Directory #{val} does not exist" unless File.directory?(val)
+          @cwd = val
 
-          when "environment"
-            if val.nil?
-              @environment = {}
-            else
-              @environment.merge!(val.dup)
-              @environment = @environment.delete_if { |k,v| v.nil? }
-            end
+        when "environment"
+          if val.nil?
+            @environment = {}
+          else
+            @environment.merge!(val.dup)
+            @environment = @environment.delete_if { |_k, v| v.nil? }
+          end
 
-          when "timeout"
-            raise "timeout should be a positive integer or the symbol :on_thread_exit symbol" unless val.eql?(:on_thread_exit) || ( val.is_a?(Integer) && val>0 )
-            @timeout = val
+        when "timeout"
+          raise "timeout should be a positive integer or the symbol :on_thread_exit symbol" unless val.eql?(:on_thread_exit) || (val.is_a?(Integer) && val > 0)
+          @timeout = val
         end
       end
     end
@@ -76,7 +76,6 @@ module MCollective
 
       opts["stdin"] = @stdin if @stdin
 
-
       thread = Thread.current
       # Start a double fork and exec with systemu which implies a guard thread.
       # If a valid timeout is configured the guard thread will terminate the
@@ -90,32 +89,30 @@ module MCollective
             sleep timeout
           else
             # sleep while the agent thread is still alive
-            while(thread.alive?)
-              sleep 0.1
-            end
+            sleep 0.1 while thread.alive?
           end
 
           # if the process is still running
-          if (Process.kill(0, cid))
+          if Process.kill(0, cid)
             # and a timeout was specified
             if timeout
               if Util.windows?
-                Process.kill('KILL', cid)
+                Process.kill("KILL", cid)
               else
                 # Kill the process
-                Process.kill('TERM', cid)
+                Process.kill("TERM", cid)
                 sleep 2
-                Process.kill('KILL', cid) if (Process.kill(0, cid))
+                Process.kill("KILL", cid) if Process.kill(0, cid) # rubocop:disable Metrics/BlockNesting
               end
             end
             # only wait if the parent thread is dead
             Process.waitpid(cid) unless thread.alive?
           end
-        rescue SystemExit
-        rescue Errno::ESRCH
+        rescue SystemExit # rubocop:disable Lint/HandleExceptions
+        rescue Errno::ESRCH # rubocop:disable Lint/HandleExceptions
         rescue Errno::ECHILD
           Log.warn("Could not reap process '#{cid}'.")
-        rescue Exception => e
+        rescue Exception => e # rubocop:disable Lint/RescueException
           Log.info("Unexpected exception received while waiting for child process: #{e.class}: #{e}")
         end
       end

data/lib/mcollective/ssl.rb

@@ -1,6 +1,6 @@
-require 'openssl'
-require 'base64'
-require 'digest/sha1'
+require "openssl"
+require "base64"
+require "digest/sha1"
 
 module MCollective
   # A class that assists in encrypting and decrypting data using a
@@ -161,7 +161,7 @@ module MCollective
       cipher.decrypt
       cipher.key = key
       cipher.pkcs5_keyivgen(key)
-      decrypted_data = cipher.update(crypt_string) + cipher.final
+      cipher.update(crypt_string) + cipher.final
     end
 
     # Signs a string using the private key
@@ -195,9 +195,7 @@ module MCollective
     def self.base64_decode(string)
       # The Base 64 character set is A-Z a-z 0-9 + / =
       # Also allow for whitespace, but raise if we get anything else
-      if string !~ /^[A-Za-z0-9+\/=\s]+$/
-        raise ArgumentError, 'invalid base64'
-      end
+      raise(ArgumentError, "invalid base64") if string !~ /^[A-Za-z0-9+\/=\s]+$/
       Base64.decode64(string)
     end
 
@@ -216,9 +214,9 @@ module MCollective
     #    https://github.com/kwilczynski/puppet-functions/blob/master/lib/puppet/parser/functions/uuid.rb
     #
     def self.uuid(string=nil)
-      string ||= OpenSSL::Random.random_bytes(16).unpack('H*').shift
+      string ||= OpenSSL::Random.random_bytes(16).unpack("H*").shift
 
-      uuid_name_space_dns = [0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8].map {|b| b.chr}.join
+      uuid_name_space_dns = [0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8].map(&:chr).join
 
       sha1 = Digest::SHA1.new
       sha1.update(uuid_name_space_dns)
@@ -236,10 +234,10 @@ module MCollective
       bytes[8] |= 0x80
 
       bytes = [4, 2, 2, 2, 6].collect do |i|
-        bytes.slice!(0, i).pack('C*').unpack('H*')
+        bytes.slice!(0, i).pack("C*").unpack("H*")
       end
 
-      bytes.join('-')
+      bytes.join("-")
     end
 
     # Reads either a :public or :private key from disk, uses an
@@ -280,6 +278,5 @@ module MCollective
         raise "Can only load :public or :private keys"
       end
     end
-
   end
 end

data/lib/mcollective/util.rb

@@ -6,10 +6,10 @@ module MCollective
     # If the passed name starts with a / it's assumed to be regex
     # and will use regex to match
     def self.has_agent?(agent)
-      agent = Regexp.new(agent.gsub("\/", "")) if agent.match("^/")
+      agent = Regexp.new(agent.gsub("\/", "")) if agent.start_with?("/")
 
       if agent.is_a?(Regexp)
-        if Agents.agentlist.grep(agent).size > 0
+        if !Agents.agentlist.grep(agent).empty?
           return true
         else
           return false
@@ -17,8 +17,6 @@ module MCollective
       else
         return Agents.agentlist.include?(agent)
       end
-
-      false
     end
 
     # On windows ^c can't interrupt the VM if its blocking on
@@ -36,7 +34,7 @@ module MCollective
     # If the passed name starts with a / it's assumed to be regex
     # and will use regex to match
     def self.has_cf_class?(klass)
-      klass = Regexp.new(klass.gsub("\/", "")) if klass.match("^/")
+      klass = Regexp.new(klass.gsub("\/", "")) if klass.start_with?("/")
       cfile = Config.instance.classesfile
 
       Log.debug("Looking for configuration management classes in #{cfile}")
@@ -45,11 +43,11 @@ module MCollective
         File.readlines(cfile).each do |k|
           if klass.is_a?(Regexp)
             return true if k.chomp.match(klass)
-          else
-            return true if k.chomp == klass
+          elsif k.chomp == klass
+            return true
           end
         end
-      rescue Exception => e
+      rescue Exception => e # rubocop:disable Lint/RescueException
         Log.warn("Parsing classes file '#{cfile}' failed: #{e.class}: #{e}")
       end
 
@@ -67,7 +65,6 @@ module MCollective
     # If the passed value starts with a / it's assumed to be regex
     # and will use regex to match
     def self.has_fact?(fact, value, operator)
-
       Log.debug("Comparing #{fact} #{operator} #{value}")
       Log.debug("where :fact = '#{fact}', :operator = '#{operator}', :value = '#{value}'")
 
@@ -86,30 +83,28 @@ module MCollective
     end
 
     def self.test_fact_value(fact, value, operator)
-      if operator == '=~'
+      if operator == "=~"
         # to maintain backward compat we send the value
         # as /.../ which is what 1.0.x needed.  this strips
         # off the /'s which is what we need here
-        if value =~ /^\/(.+)\/$/
-          value = $1
-        end
+        value = $1 if value =~ /^\/(.+)\/$/
 
         return true if fact.match(Regexp.new(value))
 
       elsif operator == "=="
         return true if fact == value
 
-      elsif ['<=', '>=', '<', '>', '!='].include?(operator)
+      elsif ["<=", ">=", "<", ">", "!="].include?(operator)
         # Yuk - need to type cast, but to_i and to_f are overzealous
         if value =~ /^[0-9]+$/ && fact =~ /^[0-9]+$/
-          fact = Integer(fact)
-          value = Integer(value)
+          fact = Integer(fact) # rubocop:disable Lint/UselessAssignment
+          value = Integer(value) # rubocop:disable Lint/UselessAssignment
         elsif value =~ /^[0-9]+.[0-9]+$/ && fact =~ /^[0-9]+.[0-9]+$/
-          fact = Float(fact)
-          value = Float(value)
+          fact = Float(fact) # rubocop:disable Lint/UselessAssignment
+          value = Float(value) # rubocop:disable Lint/UselessAssignment
         end
 
-        return true if eval("fact #{operator} value")
+        return true if eval("fact #{operator} value") # rubocop:disable Security/Eval
       end
 
       false
@@ -121,12 +116,12 @@ module MCollective
     # If the passed name starts with a / it's assumed to be regex
     # and will use regex to match
     def self.has_identity?(identity)
-      identity = Regexp.new(identity.gsub("\/", "")) if identity.match("^/")
+      identity = Regexp.new(identity.gsub("\/", "")) if identity.start_with?("/")
 
       if identity.is_a?(Regexp)
         return Config.instance.identity.match(identity)
-      else
-        return true if Config.instance.identity == identity
+      elsif Config.instance.identity == identity
+        return true
       end
 
       false
@@ -139,56 +134,94 @@ module MCollective
 
     # Creates an empty filter
     def self.empty_filter
-      {"fact"     => [],
-       "cf_class" => [],
-       "agent"    => [],
-       "identity" => [],
-       "compound" => []}
+      {
+        "fact"     => [],
+        "cf_class" => [],
+        "agent"    => [],
+        "identity" => [],
+        "compound" => []
+      }
     end
 
     # Returns the PuppetLabs mcollective path for windows
     def self.windows_prefix
-      require 'win32/dir'
-      prefix = File.join(Dir::COMMON_APPDATA, "PuppetLabs", "mcollective")
+      require "win32/dir"
+      File.join(Dir::COMMON_APPDATA, "PuppetLabs", "mcollective")
     end
 
-    # Picks a config file defaults to ~/.mcollective
-    # else /etc/mcollective/client.cfg
-    def self.config_file_for_user
-      # the set of acceptable config files
+    def self.choria_windows_prefix
+      require "win32/dir"
+      File.join(Dir::COMMON_APPDATA, "ChoriaIO", "choria")
+    end
+
+    def self.mcollective_config_paths_for_user
       config_paths = []
 
-      # user dotfile
       begin
         # File.expand_path will raise if HOME isn't set, catch it
         user_path = File.expand_path("~/.mcollective")
         config_paths << user_path
-      rescue Exception
+      rescue Exception # rubocop:disable Lint/RescueException, Lint/HandleExceptions
       end
 
-      # standard locations
-      if self.windows?
-        config_paths << File.join(self.windows_prefix, 'etc', 'client.cfg')
+      if windows?
+        config_paths << File.join(windows_prefix, "etc", "client.cfg")
       else
-        config_paths << '/etc/puppetlabs/mcollective/client.cfg'
-        config_paths << '/etc/mcollective/client.cfg'
+        config_paths << "/etc/puppetlabs/mcollective/client.cfg"
+        config_paths << "/etc/mcollective/client.cfg"
       end
 
-      # use the first readable config file, or if none are the first listed
+      config_paths
+    end
+
+    def self.choria_config_paths_for_user
+      config_paths = []
+
+      begin
+        # File.expand_path will raise if HOME isn't set, catch it
+        user_path = File.expand_path("~/.choriarc")
+        config_paths << user_path
+      rescue Exception # rubocop:disable Lint/RescueException, Lint/HandleExceptions
+      end
+
+      if windows?
+        config_paths << File.join(choria_windows_prefix, "etc", "client.conf")
+      else
+        config_paths << "/etc/choria/client.conf"
+      end
+
+      config_paths
+    end
+
+    # Picks the default user config file, pririties are first Choria ones then old MCollective ones
+    #
+    # In roughly this order, first to exist is used:
+    #
+    # - ~/.choriarc
+    # - APPData/ChoriaIO/choria/etc/client.conf on windows
+    # - /etc/choria/client.conf on unix
+    # - ~/.mcollective
+    # - APPData/PuppetLabs/mcollective/etc/client.cfg on windows
+    # - /etc/puppetlabs/mcollective/client.cfg
+    # - /etc/mcollective/client.cfg
+    def self.config_file_for_user
+      config_paths = choria_config_paths_for_user + mcollective_config_paths_for_user
       found = config_paths.find_index { |file| File.readable?(file) } || 0
-      return config_paths[found]
+      config_paths[found]
     end
 
     # Creates a standard options hash
     def self.default_options
-      {:verbose           => false,
-       :disctimeout       => nil,
-       :timeout           => 5,
-       :config            => config_file_for_user,
-       :collective        => nil,
-       :discovery_method  => nil,
-       :discovery_options => Config.instance.default_discovery_options,
-       :filter            => empty_filter}
+      {
+        :verbose           => false,
+        :disctimeout       => nil,
+        :timeout           => 5,
+        :config            => config_file_for_user,
+        :collective        => nil,
+        :discovery_method  => nil,
+        :discovery_options => Config.instance.default_discovery_options,
+        :filter            => empty_filter
+      }
     end
 
     def self.make_subscriptions(agent, type, collective=nil)
@@ -237,15 +270,15 @@ module MCollective
     # Parse a fact filter string like foo=bar into the tuple hash thats needed
     def self.parse_fact_string(fact)
       if fact =~ /^([^ ]+?)[ ]*=>[ ]*(.+)/
-        return {:fact => $1, :value => $2, :operator => '>=' }
+        {:fact => $1, :value => $2, :operator => ">="}
       elsif fact =~ /^([^ ]+?)[ ]*=<[ ]*(.+)/
-        return {:fact => $1, :value => $2, :operator => '<=' }
+        {:fact => $1, :value => $2, :operator => "<="}
       elsif fact =~ /^([^ ]+?)[ ]*(<=|>=|<|>|!=|==|=~)[ ]*(.+)/
-        return {:fact => $1, :value => $3, :operator => $2 }
+        {:fact => $1, :value => $3, :operator => $2}
       elsif fact =~ /^(.+?)[ ]*=[ ]*\/(.+)\/$/
-        return {:fact => $1, :value => "/#{$2}/", :operator => '=~' }
+        {:fact => $1, :value => "/#{$2}/", :operator => "=~"}
       elsif fact =~ /^([^= ]+?)[ ]*=[ ]*(.+)/
-        return {:fact => $1, :value => $2, :operator => '==' }
+        {:fact => $1, :value => $2, :operator => "=="}
       else
         raise "Could not parse fact #{fact} it does not appear to be in a valid format"
       end
@@ -267,11 +300,11 @@ module MCollective
       # combo is regarded as line continuation and simply ignored.
       str.gsub!(/\n/, "'\n'")
 
-      return str
+      str
     end
 
     def self.windows?
-      !!(RbConfig::CONFIG['host_os'] =~ /mswin|win32|dos|mingw|cygwin/i)
+      !!(RbConfig::CONFIG["host_os"] =~ /mswin|win32|dos|mingw|cygwin/i)
     end
 
     # Return color codes, if the config color= option is false
@@ -279,12 +312,14 @@ module MCollective
     def self.color(code)
       colorize = Config.instance.color
 
-      colors = {:red => "",
-                :green => "",
-                :yellow => "",
-                :cyan => "",
-                :bold => "",
-                :reset => ""}
+      colors = {
+        :red => "",
+        :green => "",
+        :yellow => "",
+        :cyan => "",
+        :bold => "",
+        :reset => ""
+      }
 
       if colorize
         return colors[code] || ""
@@ -295,7 +330,7 @@ module MCollective
 
     # Helper to return a string in specific color
     def self.colorize(code, msg)
-      "%s%s%s" % [ color(code), msg, color(:reset) ]
+      "%s%s%s" % [color(code), msg, color(:reset)]
     end
 
     # Returns the current ruby version as per RUBY_VERSION, mostly
@@ -316,7 +351,7 @@ module MCollective
     # The terminal size is detected by default, but custom line widths can
     # passed. All strings will also be left aligned with 5 whitespace characters
     # by default.
-    def self.align_text(text, console_cols = nil, preamble = 5)
+    def self.align_text(text, console_cols=nil, preamble=5)
       unless console_cols
         console_cols = terminal_dimensions[0]
 
@@ -334,40 +369,36 @@ module MCollective
       console_cols = 80 if console_cols <= 0
 
       text = text.split("\n")
-      piece = ''
+      piece = ""
       whitespace = 0
 
       text.each_with_index do |line, i|
         whitespace = 0
 
-        while whitespace < line.length && line[whitespace].chr == ' '
+        while whitespace < line.length && line[whitespace].chr == " "
           whitespace += 1
         end
 
         # If the current line is empty, indent it so that a snippet
         # from the previous line is aligned correctly.
-        if line == ""
-          line = (" " * whitespace)
-        end
+        line = (" " * whitespace) if line == ""
 
         # If text was snipped from the previous line, prepend it to the
         # current line after any current indentation.
-        if piece != ''
+        if piece != ""
           # Reset whitespaces to 0 if there are more whitespaces than there are
           # console columns
           whitespace = 0 if whitespace >= console_cols
 
           # If the current line is empty and being prepended to, create a new
           # empty line in the text so that formatting is preserved.
-          if text[i + 1] && line == (" " * whitespace)
-            text.insert(i + 1, "")
-          end
+          text.insert(i + 1, "") if text[i + 1] && line == (" " * whitespace)
 
           # Add the snipped text to the current line
           line.insert(whitespace, "#{piece} ")
         end
 
-        piece = ''
+        piece = ""
 
         # Compare the line length to the allowed line length.
         # If it exceeds it, snip the offending text from the line
@@ -375,9 +406,7 @@ module MCollective
         if line.length > (console_cols + preamble)
           reverse = console_cols
 
-          while line[reverse].chr != ' '
-            reverse -= 1
-          end
+          reverse -= 1 while line[reverse].chr != " "
 
           piece = line.slice!(reverse, (line.length - 1)).lstrip
         end
@@ -385,13 +414,13 @@ module MCollective
         # If a snippet exists when all the columns in the text have been
         # updated, create a new line and append the snippet to it, using
         # the same left alignment as the last line in the text.
-        if piece != '' && text[i+1].nil?
-          text[i+1] = "#{' ' * (whitespace)}#{piece}"
-          piece = ''
+        if piece != "" && text[i + 1].nil?
+          text[i + 1] = "#{' ' * whitespace}#{piece}"
+          piece = ""
         end
 
         # Add the preamble to the line and add it to the text
-        line = ((' ' * preamble) + line)
+        line = ((" " * preamble) + line)
         text[i] = line
       end
 
@@ -402,7 +431,7 @@ module MCollective
     #
     # Returns [0, 0] if it can't figure it out or if you're
     # not running on a tty
-    def self.terminal_dimensions(stdout = STDOUT, environment = ENV)
+    def self.terminal_dimensions(stdout=STDOUT, environment=ENV)
       return [0, 0] unless stdout.tty?
 
       return [80, 40] if Util.windows?
@@ -413,8 +442,8 @@ module MCollective
       elsif environment["TERM"] && command_in_path?("tput")
         return [`tput cols`.to_i, `tput lines`.to_i]
 
-      elsif command_in_path?('stty')
-        return `stty size`.scan(/\d+/).map {|s| s.to_i }
+      elsif command_in_path?("stty")
+        return `stty size`.scan(/\d+/).map(&:to_i)
       else
         return [0, 0]
       end
@@ -444,28 +473,26 @@ module MCollective
       ax = version_a.scan(vre)
       bx = version_b.scan(vre)
 
-      while (ax.length>0 && bx.length>0)
+      while !ax.empty? && !bx.empty?
         a = ax.shift
         b = bx.shift
 
-        if( a == b )                 then next
-        elsif (a == '-' && b == '-') then next
-        elsif (a == '-')             then return -1
-        elsif (b == '-')             then return 1
-        elsif (a == '.' && b == '.') then next
-        elsif (a == '.' )            then return -1
-        elsif (b == '.' )            then return 1
-        elsif (a =~ /^\d+$/ && b =~ /^\d+$/) then
-          if( a =~ /^0/ or b =~ /^0/ ) then
-            return a.to_s.upcase <=> b.to_s.upcase
-          end
+        if a == b then next
+        elsif a == "-" && b == "-" then next
+        elsif a == "-"             then return -1
+        elsif b == "-"             then return 1
+        elsif a == "." && b == "." then next
+        elsif a == "."            then return -1
+        elsif b == "."            then return 1
+        elsif a =~ /^\d+$/ && b =~ /^\d+$/
+          return a.to_s.upcase <=> b.to_s.upcase if a =~ /^0/ || b =~ /^0/
           return a.to_i <=> b.to_i
         else
           return a.upcase <=> b.upcase
         end
       end
 
-      version_a <=> version_b;
+      version_a <=> version_b
     end
 
     # we should really use Pathname#absolute? but it's not in all the
@@ -486,7 +513,7 @@ module MCollective
     def self.str_to_bool(val)
       clean_val = val.to_s.strip
       if clean_val =~ /^(1|yes|true|y|t)$/i
-        return  true
+        return true
       elsif clean_val =~ /^(0|no|false|n|f)$/i
         return false
       else
@@ -498,10 +525,10 @@ module MCollective
     def self.templatepath(template_file)
       config_dir = File.dirname(Config.instance.configfile)
       template_path = File.join(config_dir, template_file)
-      return template_path if File.exists?(template_path)
+      return template_path if File.exist?(template_path)
 
       template_path = File.join("/etc/mcollective", template_file)
-      return template_path
+      template_path
     end
 
     # subscribe to the direct addressing queue
@@ -511,68 +538,66 @@ module MCollective
 
     # Get field size for printing
     def self.field_size(elements, min_size=40)
-      max_length = elements.max_by { |e| e.length }.length
+      max_length = elements.max_by(&:length).length
       max_length > min_size ? max_length : min_size
     end
 
     # Calculate number of fields for printing
     def self.field_number(field_size, max_size=90)
-      number = (max_size/field_size).to_i
-      (number == 0) ? 1 : number
+      number = (max_size / field_size).to_i
+      number == 0 ? 1 : number
     end
-    
-    def self.get_hidden_input_on_windows()
-      require 'Win32API'
+
+    def self.get_hidden_input_on_windows # rubocop:disable Naming/AccessorMethodName
+      require "Win32API"
+
       # Hook into getch from crtdll. Keep reading all keys till return
       # or newline is hit.
       # If key is backspace or delete, then delete the character and update
       # the buffer.
-      input = ''
-      while char = Win32API.new("crtdll", "_getch", [ ], "I").Call do
-        break if char == 10 || char == 13 # return or newline
-        if char == 127 || char == 8 # backspace and delete
-          if input.length > 0
-            input.slice!(-1, 1)
-          end
+      input = ""
+
+      while char = Win32API.new("crtdll", "_getch", [], "I").Call
+        break if [10, 13].include?(char) # return or newline
+        if [127, 8].include?(char) # backspace and delete
+          input.slice!(-1, 1) unless input.empty?
         else
           input << char.chr
         end
       end
-      char = ''
+
       input
     end
 
-    def self.get_hidden_input_on_unix()
+    def self.get_hidden_input_on_unix # rubocop:disable Naming/AccessorMethodName
       unless $stdin.tty?
-        raise 'Could not hook to stdin to hide input. If using SSH, try using -t flag while connecting to server.'
+        raise "Could not hook to stdin to hide input. If using SSH, try using -t flag while connecting to server."
       end
-      unless system 'stty -echo -icanon'
-        raise 'Could not hide input using stty command.'
+      unless system "stty -echo -icanon"
+        raise "Could not hide input using stty command."
       end
       input = $stdin.gets
-      ensure
-        unless system 'stty echo icanon'
-          raise 'Could not enable echoing of input. Try executing `stty echo icanon` to debug.'
-        end
+    ensure
+      unless system "stty echo icanon"
+        raise "Could not enable echoing of input. Try executing `stty echo icanon` to debug."
+      end
       input
     end
 
-    def self.get_hidden_input(message='Please enter data: ')
-      unless message.nil?
-        print message
-      end
-      if versioncmp(ruby_version, '1.9.3') >= 0
-        require 'io/console'
+    def self.get_hidden_input(message="Please enter data: ")
+      print message unless message.nil?
+
+      if versioncmp(ruby_version, "1.9.3") >= 0
+        require "io/console"
         input = $stdin.noecho(&:gets)
+      elsif windows? # Use hacks to get hidden input on Ruby <1.9.3
+        input = get_hidden_input_on_windows
       else
-        # Use hacks to get hidden input on Ruby <1.9.3
-        if self.windows?
-          input = self.get_hidden_input_on_windows()
-        else
-          input = self.get_hidden_input_on_unix()
-        end
+        input = get_hidden_input_on_unix
       end
+
       input.chomp! if input
+
       input
     end
   end