puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

data/lib/puppet/util/autoload.rb

@@ -70,7 +70,7 @@ class Puppet::Util::Autoload
       rescue SystemExit,NoMemoryError
         raise
       rescue Exception => detail
-        message = "Could not autoload #{name}: #{detail}"
+        message = _("Could not autoload %{name}: %{detail}") % { name: name, detail: detail }
         Puppet.log_exception(detail, message)
         raise Puppet::Error, message, detail.backtrace
       end
@@ -184,7 +184,7 @@ class Puppet::Util::Autoload
 
   def initialize(obj, path, options = {})
     @path = path.to_s
-    raise ArgumentError, "Autoload paths cannot be fully qualified" if Puppet::Util.absolute_path?(@path)
+    raise ArgumentError, _("Autoload paths cannot be fully qualified") if Puppet::Util.absolute_path?(@path)
     @object = obj
 
     set_options(options)

data/lib/puppet/util/backups.rb

@@ -23,7 +23,7 @@ module Puppet::Util::Backups
     when "directory"
       # we don't need to backup directories when recurse is on
       return true if self[:recurse]
-      info "Recursively backing up to filebucket"
+      info _("Recursively backing up to filebucket")
       Find.find(self[:path]) { |f| backup_file_with_filebucket(f) if File.file?(f) }
     when "file"; backup_file_with_filebucket(file)
     when "link";
@@ -46,7 +46,7 @@ module Puppet::Util::Backups
     rescue => detail
       # since they said they want a backup, let's error out
       # if we couldn't make one
-      self.fail Puppet::Error, "Could not back #{file} up: #{detail.message}", detail
+      self.fail Puppet::Error, _("Could not back %{file} up: %{message}") % { file: file, message: detail.message }, detail
     end
   end
 
@@ -64,15 +64,15 @@ module Puppet::Util::Backups
     end
 
     if stat.ftype == "directory"
-      raise Puppet::Error, "Will not remove directory backup #{newfile}; use a filebucket"
+      raise Puppet::Error, _("Will not remove directory backup %{newfile}; use a filebucket") % { newfile: newfile }
     end
 
-    info "Removing old backup of type #{stat.ftype}"
+    info _("Removing old backup of type %{file_type}") % { file_type: stat.ftype }
 
     begin
       Puppet::FileSystem.unlink(newfile)
     rescue => detail
-      message = "Could not remove old backup: #{detail}"
+      message = _("Could not remove old backup: %{detail}") % { detail: detail }
       self.log_exception(detail, message)
       self.fail Puppet::Error, message, detail
     end
@@ -80,7 +80,7 @@ module Puppet::Util::Backups
 
   def backup_file_with_filebucket(f)
     sum = self.bucket.backup(f)
-    self.info "Filebucketed #{f} to #{self.bucket.name} with sum #{sum}"
+    self.info _("Filebucketed %{f} to %{filebucket} with sum %{sum}") % { f: f, filebucket: self.bucket.name, sum: sum }
     return sum
     end
 end

data/lib/puppet/util/classgen.rb

@@ -157,11 +157,11 @@ module Puppet::Util::ClassGen
 
     if is_constant_defined?(const)
       if options[:overwrite]
-        Puppet.info "Redefining #{name} in #{self}"
+        Puppet.info _("Redefining %{name} in %{klass}") % { name: name, klass: self }
         remove_const(const)
       else
         raise Puppet::ConstantAlreadyDefined,
-          "Class #{const} is already defined in #{self}"
+          _("Class %{const} is already defined in %{klass}") % { const: const, klass: self }
       end
     end
     const_set(const, klass)
@@ -206,7 +206,7 @@ module Puppet::Util::ClassGen
     if hash = options[:hash]
       if hash.include? klassname and ! options[:overwrite]
         raise Puppet::SubclassAlreadyDefined,
-          "Already a generated class named #{klassname}"
+          _("Already a generated class named %{klassname}") % { klassname: klassname }
       end
 
       hash[klassname] = klass
@@ -218,7 +218,7 @@ module Puppet::Util::ClassGen
               array.find { |c| c.name == klassname } and
               ! options[:overwrite])
         raise Puppet::SubclassAlreadyDefined,
-          "Already a generated class named #{klassname}"
+          _("Already a generated class named %{klassname}") % { klassname: klassname }
       end
 
       array << klass

data/lib/puppet/util/command_line.rb

@@ -63,7 +63,7 @@ module Puppet
       #
       # @return [void]
       def execute
-        Puppet::Util.exit_on_fail("initialize global default settings") do
+        Puppet::Util.exit_on_fail(_("initialize global default settings")) do
           Puppet.initialize_settings(args)
         end
 
@@ -159,10 +159,10 @@ module Puppet
             puts Puppet.version
           elsif @command_line.subcommand_name.nil? && args.count > 0
             # If the subcommand is truly nil and there is an arg, it's an option; print out the invalid option message
-            puts colorize(:hred, "Error: Could not parse application options: invalid option: #{args[0]}")
+            puts colorize(:hred, _("Error: Could not parse application options: invalid option: %{opt}") % { opt: args[0] })
             exit 1
           else
-            puts "See 'puppet help' for help on available puppet subcommands"
+            puts _("See 'puppet help' for help on available puppet subcommands")
           end
         end
       end
@@ -175,7 +175,7 @@ module Puppet
         end
 
         def run
-          puts colorize(:hred, "Error: Unknown Puppet subcommand '#{@subcommand_name}'")
+          puts colorize(:hred, _("Error: Unknown Puppet subcommand '%{cmd}'") % { cmd: @subcommand_name })
           super
           exit 1
         end

data/lib/puppet/util/command_line/puppet_option_parser.rb

@@ -44,7 +44,7 @@ module Puppet
           elsif args.length == 4
             long, short, desc, type = args
           else
-            raise ArgumentError, "this method only takes 3 or 4 arguments. Given: #{args.inspect}"
+            raise ArgumentError, _("this method only takes 3 or 4 arguments. Given: %{args}") % { args: args.inspect }
           end
 
           options = {
@@ -61,7 +61,7 @@ module Puppet
             when :NONE
               options[:type] = :flag
             else
-              raise PuppetOptionError.new("Unsupported type: '#{type}'")
+              raise PuppetOptionError.new(_("Unsupported type: '%{type}'") % { type: type })
           end
 
           @parser.opt long.sub("^--", "").intern, desc, options
@@ -73,7 +73,7 @@ module Puppet
           begin
             @parser.parse args_copy
           rescue Puppet::Util::CommandLine::Trollop::CommandlineError => err
-            raise PuppetOptionError.new("Error parsing arguments", err)
+            raise PuppetOptionError.new(_("Error parsing arguments"), err)
           end
         end
 

data/lib/puppet/util/command_line/trollop.rb

@@ -146,7 +146,7 @@ class Parser
   ## value, you must specify +:type+ as well.
 
   def opt name, desc="", opts={}
-    raise ArgumentError, "you already have an argument named '#{name}'" if @specs.member? name
+    raise ArgumentError, _("you already have an argument named '%{name}'") % { name: name } if @specs.member? name
 
     ## fill in :type
     opts[:type] = # normalize
@@ -194,7 +194,7 @@ class Parser
       when Date; :date
       when Array
         if opts[:default].empty?
-          raise ArgumentError, "multiple argument type cannot be deduced from an empty array for '#{opts[:default][0].class.name}'"
+          raise ArgumentError, _("multiple argument type cannot be deduced from an empty array for '%{value0}'") % { value0: opts[:default][0].class.name }
         end
         case opts[:default][0]    # the first element determines the types
         when Integer; :ints
@@ -203,14 +203,14 @@ class Parser
         when IO; :ios
         when Date; :dates
         else
-          raise ArgumentError, "unsupported multiple argument type '#{opts[:default][0].class.name}'"
+          raise ArgumentError, _("unsupported multiple argument type '%{value0}'") % { value0: opts[:default][0].class.name }
         end
       when nil; nil
       else
-        raise ArgumentError, "unsupported argument type '#{opts[:default].class.name}'"
+        raise ArgumentError, _("unsupported argument type '%{value0}'") % { value0: opts[:default].class.name }
       end
 
-    raise ArgumentError, ":type specification and default type don't match (default type is #{type_from_default})" if opts[:type] && type_from_default && opts[:type] != type_from_default
+    raise ArgumentError, _(":type specification and default type don't match (default type is %{type_from_default})") % { type_from_default: type_from_default } if opts[:type] && type_from_default && opts[:type] != type_from_default
 
     opts[:type] = opts[:type] || type_from_default || :flag
 
@@ -225,7 +225,7 @@ class Parser
       else
         raise ArgumentError, "invalid long option name #{opts[:long].inspect}"
       end
-    raise ArgumentError, "long option name #{opts[:long].inspect} is already taken; please specify a (different) :long" if @long[opts[:long]]
+    raise ArgumentError, _("long option name %{value0} is already taken; please specify a (different) :long") % { value0: opts[:long].inspect } if @long[opts[:long]]
 
     ## fill in :short
     opts[:short] = opts[:short].to_s if opts[:short] unless opts[:short] == :none
@@ -236,8 +236,8 @@ class Parser
     end
 
     if opts[:short]
-      raise ArgumentError, "short option name #{opts[:short].inspect} is already taken; please specify a (different) :short" if @short[opts[:short]]
-      raise ArgumentError, "a short option name can't be a number or a dash" if opts[:short] =~ INVALID_SHORT_ARG_REGEX
+      raise ArgumentError, _("short option name %{value0} is already taken; please specify a (different) :short") % { value0: opts[:short].inspect } if @short[opts[:short]]
+      raise ArgumentError, _("a short option name can't be a number or a dash") if opts[:short] =~ INVALID_SHORT_ARG_REGEX
     end
 
     ## fill in :default for flags
@@ -270,13 +270,13 @@ class Parser
   ## undirected (i.e., mutual) dependencies. Directed dependencies are
   ## better modeled with Trollop::die.
   def depends *syms
-    syms.each { |sym| raise ArgumentError, "unknown option '#{sym}'" unless @specs[sym] }
+    syms.each { |sym| raise ArgumentError, _("unknown option '%{sym}'") % { sym: sym } unless @specs[sym] }
     @constraints << [:depends, syms]
   end
 
   ## Marks two (or more!) options as conflicting.
   def conflicts *syms
-    syms.each { |sym| raise ArgumentError, "unknown option '#{sym}'" unless @specs[sym] }
+    syms.each { |sym| raise ArgumentError, _("unknown option '%{sym}'") % { sym: sym } unless @specs[sym] }
     @constraints << [:conflicts, syms]
   end
 
@@ -310,8 +310,8 @@ class Parser
     required = {}
 
     if handle_help_and_version
-      opt :version, "Print version and exit" if @version unless @specs[:version] || @long["version"]
-      opt :help, "Show this message" unless @specs[:help] || @long["help"]
+      opt :version, _("Print version and exit") if @version unless @specs[:version] || @long["version"]
+      opt :help, _("Show this message") unless @specs[:help] || @long["help"]
     end
 
     @specs.each do |sym, opts|
@@ -333,16 +333,16 @@ class Parser
       when /^--([^-]\S*)$/
         @long[$1] ? @long[$1] : @long["[no-]#{$1}"]
       else
-        raise CommandlineError, "invalid argument syntax: '#{arg}'"
+        raise CommandlineError, _("invalid argument syntax: '%{arg}'") % { arg: arg }
       end
 
       unless sym
         next 0 if ignore_invalid_options
-        raise CommandlineError, "unknown argument '#{arg}'" unless sym
+        raise CommandlineError, _("unknown argument '%{arg}'") % { arg: arg } unless sym
       end
 
       if given_args.include?(sym) && !@specs[sym][:multi]
-        raise CommandlineError, "option '#{arg}' specified multiple times"
+        raise CommandlineError, _("option '%{arg}' specified multiple times") % { arg: arg }
       end
 
       given_args[sym] ||= {}
@@ -379,14 +379,14 @@ class Parser
 
       case type
       when :depends
-        syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} requires --#{@specs[sym][:long]}" unless given_args.include? sym }
+        syms.each { |sym| raise CommandlineError, _("--%{value0} requires --%{value1}") % { value0: @specs[constraint_sym][:long], value1: @specs[sym][:long] } unless given_args.include? sym }
       when :conflicts
-        syms.each { |sym| raise CommandlineError, "--#{@specs[constraint_sym][:long]} conflicts with --#{@specs[sym][:long]}" if given_args.include?(sym) && (sym != constraint_sym) }
+        syms.each { |sym| raise CommandlineError, _("--%{value0} conflicts with --%{value1}") % { value0: @specs[constraint_sym][:long], value1: @specs[sym][:long] } if given_args.include?(sym) && (sym != constraint_sym) }
       end
     end
 
     required.each do |sym, val|
-      raise CommandlineError, "option --#{@specs[sym][:long]} must be specified" unless given_args.include? sym
+      raise CommandlineError, _("option --%{opt} must be specified") % { opt: @specs[sym][:long] } unless given_args.include? sym
     end
 
     ## parse parameters
@@ -395,7 +395,7 @@ class Parser
       params = given_data[:params]
 
       opts = @specs[sym]
-      raise CommandlineError, "option '#{arg}' needs a parameter" if params.empty? && opts[:type] != :flag
+      raise CommandlineError, _("option '%{arg}' needs a parameter") % { arg: arg } if params.empty? && opts[:type] != :flag
 
       vals["#{sym}_given".intern] = true # mark argument as specified on the commandline
 
@@ -455,7 +455,7 @@ class Parser
       end
       time ? Date.new(time.year, time.month, time.day) : Date.parse(param)
     rescue ArgumentError
-      raise CommandlineError, "option '#{arg}' needs a date", $!.backtrace
+      raise CommandlineError, _("option '%{arg}' needs a date") % { arg: arg }, $!.backtrace
     end
   end
 
@@ -488,7 +488,7 @@ class Parser
 
     unless @order.size > 0 && @order.first.first == :text
       stream.puts "#@version\n" if @version
-      stream.puts "Options:"
+      stream.puts _("Options:")
     end
 
     @order.each do |what, opt|
@@ -512,9 +512,9 @@ class Parser
 
         if spec[:default]
           if spec[:desc] =~ /\.$/
-            " (Default: #{default_s})"
+            _(" (Default: %{default_s})") % { default_s: default_s }
           else
-            " (default: #{default_s})"
+            _(" (default: %{default_s})") % { default_s: default_s }
           end
         else
           ""
@@ -551,11 +551,11 @@ class Parser
   ## The per-parser version of Trollop::die (see that for documentation).
   def die arg, msg
     if msg
-      $stderr.puts "Error: argument --#{@specs[arg][:long]} #{msg}."
+      $stderr.puts _("Error: argument --%{value0} %{msg}.") % { value0: @specs[arg][:long], msg: msg }
     else
-      $stderr.puts "Error: #{arg}."
+      $stderr.puts _("Error: %{arg}.") % { arg: arg }
     end
-    $stderr.puts "Try --help for help."
+    $stderr.puts _("Try --help for help.")
     exit(-1)
   end
 
@@ -634,12 +634,12 @@ private
   end
 
   def parse_integer_parameter param, arg
-    raise CommandlineError, "option '#{arg}' needs an integer" unless param =~ /^\d+$/
+    raise CommandlineError, _("option '%{arg}' needs an integer") % { arg: arg } unless param =~ /^\d+$/
     param.to_i
   end
 
   def parse_float_parameter param, arg
-    raise CommandlineError, "option '#{arg}' needs a floating-point number" unless param =~ FLOAT_RE
+    raise CommandlineError, _("option '%{arg}' needs a floating-point number") % { arg: arg } unless param =~ FLOAT_RE
     param.to_f
   end
 
@@ -651,7 +651,7 @@ private
       begin
         open param
       rescue SystemCallError => e
-        raise CommandlineError, "file or url for option '#{arg}' cannot be opened: #{e.message}", e.backtrace
+        raise CommandlineError, _("file or url for option '%{arg}' cannot be opened: %{value0}") % { arg: arg, value0: e.message }, e.backtrace
       end
     end
   end
@@ -778,8 +778,8 @@ def with_standard_exception_handling parser
   begin
     yield
   rescue CommandlineError => e
-    $stderr.puts "Error: #{e.message}."
-    $stderr.puts "Try --help for help."
+    $stderr.puts _("Error: %{value0}.") % { value0: e.message }
+    $stderr.puts _("Try --help for help.")
     exit(-1)
   rescue HelpNeeded
     parser.educate

data/lib/puppet/util/diff.rb

@@ -25,7 +25,7 @@ module Puppet::Util::Diff
   # context defaults to 3 lines
   def lcs_diff(data_old, data_new, format=:unified, context_lines=3)
     unless Puppet.features.diff?
-      Puppet.warning "Cannot provide diff without the diff/lcs Ruby library"
+      Puppet.warning _("Cannot provide diff without the diff/lcs Ruby library")
       return ""
     end
     data_old = data_old.split(/\n/).map! { |e| e.chomp }

data/lib/puppet/util/errors.rb

@@ -37,11 +37,11 @@ module Puppet::Util::Errors
   # @return [String] description of file and line
   def error_context
     if file and line
-      " at #{file}:#{line}"
+      _(" at %{file}:%{line}") % { file: file, line: line }
     elsif line
-      " at line #{line}"
+      _(" at line %{line}") % { line: line }
     elsif file
-      " in #{file}"
+      _(" in %{file}") % { file: file }
     else
       ""
     end
@@ -65,7 +65,7 @@ module Puppet::Util::Errors
     rescue Puppet::Error => detail
       raise adderrorcontext(detail)
     rescue => detail
-      message = options[:message] || "#{self.class} failed with error #{detail.class}: #{detail}"
+      message = options[:message] || _("%{klass} failed with error %{error_type}: %{detail}") % { klass: self.class, error_type: detail.class, detail: detail }
 
       error = options[:type].new(message)
       # We can't use self.fail here because it always expects strings,

data/lib/puppet/util/execution.rb

@@ -83,7 +83,7 @@ module Puppet::Util::Execution
     end
 
     if failonfail && exitstatus != 0
-      raise Puppet::ExecutionFailure, output.to_s
+      raise Puppet::ExecutionFailure, output
     end
 
     output
@@ -98,11 +98,11 @@ module Puppet::Util::Execution
   # @raise [exception] under same conditions as {execute}, but raises the given `exception` with the output as argument
   # @return (see execute)
   # @api public
+  # @deprecated
   def self.execfail(command, exception)
-    output = execute(command)
-    return output
-  rescue Puppet::ExecutionFailure
-    raise exception, output, exception.backtrace
+    execute(command)
+  rescue Puppet::ExecutionFailure => detail
+    raise exception, detail.message, detail.backtrace
   end
 
   # Default empty options for {execute}
@@ -228,11 +228,11 @@ module Puppet::Util::Execution
       # read output in if required
       unless options[:squelch]
         output = wait_for_output(stdout)
-        Puppet.warning "Could not get output" unless output
+        Puppet.warning _("Could not get output") unless output
       end
 
       if options[:failonfail] and exit_status != 0
-        raise Puppet::ExecutionFailure, "Execution of '#{command_str}' returned #{exit_status}: #{output.strip}"
+        raise Puppet::ExecutionFailure, _("Execution of '%{str}' returned %{exit_status}: %{output}") % { str: command_str, exit_status: exit_status, output: output.strip }
       end
     ensure
       if !options[:squelch] && stdout
@@ -301,7 +301,7 @@ module Puppet::Util::Execution
           Kernel.exec(*command)
         end
       rescue => detail
-        Puppet.log_exception(detail, "Could not execute posix command: #{detail}")
+        Puppet.log_exception(detail, _("Could not execute posix command: %{detail}") % { detail: detail })
         exit!(1)
       end
     end
@@ -349,7 +349,7 @@ module Puppet::Util::Execution
         end
       else
         time_to_sleep = try / 2.0
-        Puppet.warning "Waiting for output; will sleep #{time_to_sleep} seconds"
+        Puppet.warning _("Waiting for output; will sleep %{time_to_sleep} seconds") % { time_to_sleep: time_to_sleep }
         sleep(time_to_sleep)
       end
     end

data/lib/puppet/util/feature.rb

@@ -18,7 +18,7 @@ class Puppet::Util::Feature
       begin
         result = yield
       rescue StandardError,ScriptError => detail
-        warn "Failed to load feature test for #{name}: #{detail}"
+        warn _("Failed to load feature test for %{name}: %{detail}") % { name: name, detail: detail }
         result = false
       end
       @results[name] = result
@@ -32,7 +32,7 @@ class Puppet::Util::Feature
       #    configured to always cache
       if block_given?     ||
           @results[name]  ||
-          (@results.has_key?(name) && (Puppet[:always_cache_features] || !Puppet[:always_retry_plugins]))
+          (@results.has_key?(name) && (!Puppet[:always_retry_plugins]))
         @results[name]
       else
         @results[name] = test(name, options)
@@ -79,15 +79,15 @@ class Puppet::Util::Feature
   private
 
   def load_library(lib, name)
-    raise ArgumentError, "Libraries must be passed as strings not #{lib.class}" unless lib.is_a?(String)
+    raise ArgumentError, _("Libraries must be passed as strings not %{klass}") % { klass: lib.class } unless lib.is_a?(String)
 
     @rubygems ||= Puppet::Util::RubyGems::Source.new
     @rubygems.clear_paths
 
     begin
       require lib
-    rescue ScriptError
-      Puppet.debug "Failed to load library '#{lib}' for feature '#{name}'"
+    rescue ScriptError => detail
+      Puppet.debug _("Failed to load library '%{lib}' for feature '%{name}': %{detail}") % { lib: lib, name: name, detail: detail }
       return false
     end
     true