puppet 4.1.0 → 5.0.0

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

@@ -141,12 +141,12 @@ class Parser
   ## There's one ambiguous case to be aware of: when +:multi+: is true and a
   ## +:default+ is set to an array (of something), it's ambiguous whether this
   ## is a multi-value argument as well as a multi-occurrence argument.
-  ## In thise case, Trollop assumes that it's not a multi-value argument.
+  ## In this case, Trollop assumes that it's not a multi-value argument.
   ## If you want a multi-value, multi-occurrence argument with a default
   ## 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/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
 
@@ -81,7 +81,11 @@ module Puppet
 
       def find_subcommand
         if subcommand_name.nil?
-          NilSubcommand.new(self)
+          if args.include?("--help") || args.include?("-h")
+            ApplicationSubcommand.new("help", CommandLine.new("puppet", ["help"]))
+          else
+            NilSubcommand.new(self)
+          end
         elsif Puppet::Application.available_application_names.include?(subcommand_name)
           ApplicationSubcommand.new(subcommand_name, self)
         elsif path_to_subcommand = external_subcommand
@@ -102,7 +106,7 @@ module Puppet
           # For most applications, we want to be able to load code from the modulepath,
           # such as apply, describe, resource, and faces.
           # For agent, we only want to load pluginsync'ed code from libdir.
-          # For master, we shouldn't ever be loading per-enviroment code into the master's
+          # For master, we shouldn't ever be loading per-environment code into the master's
           # ruby process, but that requires fixing (#17210, #12173, #8750). So for now
           # we try to restrict to only code that can be autoloaded from the node's
           # environment.
@@ -117,6 +121,10 @@ module Puppet
               configured_environment.each_plugin_directory do |dir|
                 $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
               end
+
+              # Puppet requires Facter, which initializes its lookup paths. Reset Facter to
+              # pickup the new $LOAD_PATH.
+              Facter.reset
             end
           end
 
@@ -151,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
@@ -167,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/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

@@ -1,3 +1,4 @@
+require 'timeout'
 require 'puppet/file_system/uniquefile'
 
 module Puppet
@@ -10,7 +11,7 @@ module Puppet
   end
 end
 
-# This module defines methods for execution of system commands. It is intented for inclusion
+# This module defines methods for execution of system commands. It is intended for inclusion
 # in classes that needs to execute system commands.
 # @api public
 module Puppet::Util::Execution
@@ -47,7 +48,7 @@ module Puppet::Util::Execution
   # @yield [pipe] to a block executing a subprocess
   # @yieldparam pipe [IO] the opened pipe
   # @yieldreturn [String] the output to return
-  # @raise [Puppet::ExecutionFailure] if the executed chiled process did not
+  # @raise [Puppet::ExecutionFailure] if the executed child process did not
   #   exit with status == 0 and `failonfail` is `true`.
   # @return [String] a string with the output from the subprocess executed by
   #   the given block
@@ -97,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}
@@ -119,10 +120,10 @@ module Puppet::Util::Execution
   #   user id matches the effective user id of the current process.
   # @option options [Integer, String] :gid (nil) the group id of the group that the process should be run as. Will be ignored if the
   #   group id matches the effective group id of the current process.
-  # @option options [Boolean] :combine sets whether or not to combine stdout/stderr in the output
+  # @option options [Boolean] :combine sets whether or not to combine stdout/stderr in the output, if false stderr output is discarded
   # @option options [String] :stdinfile (nil) sets a file that can be used for stdin. Passing a string for stdin is not currently
   #   supported.
-  # @option options [Boolean] :squelch (true) if true, ignore stdout / stderr completely.
+  # @option options [Boolean] :squelch (false) if true, ignore stdout / stderr completely.
   # @option options [Boolean] :override_locale (true) by default (and if this option is set to true), we will temporarily override
   #   the user/system locale to "C" (via environment variables LANG and LC_*) while we are executing the command.
   #   This ensures that the output of the command will be formatted consistently, making it predictable for parsing.
@@ -152,15 +153,18 @@ module Puppet::Util::Execution
         :squelch => false,
         :override_locale => true,
         :custom_environment => {},
+        :sensitive => false,
     }
 
     options = default_options.merge(options)
 
-    if command.is_a?(Array)
+    if options[:sensitive]
+      command_str = '[redacted]'
+    elsif command.is_a?(Array)
       command = command.flatten.map(&:to_s)
-      str = command.join(" ")
+      command_str = command.join(" ")
     elsif command.is_a?(String)
-      str = command
+      command_str = command
     end
 
     user_log_s = ''
@@ -175,25 +179,40 @@ module Puppet::Util::Execution
     end
 
     if respond_to? :debug
-      debug "Executing#{user_log_s}: '#{str}'"
+      debug "Executing#{user_log_s}: '#{command_str}'"
     else
-      Puppet.debug "Executing#{user_log_s}: '#{str}'"
+      Puppet.debug "Executing#{user_log_s}: '#{command_str}'"
     end
 
     null_file = Puppet.features.microsoft_windows? ? 'NUL' : '/dev/null'
 
     begin
-      stdin = File.open(options[:stdinfile] || null_file, 'r')
-      stdout = options[:squelch] ? File.open(null_file, 'w') : Puppet::FileSystem::Uniquefile.new('puppet')
-      stderr = options[:combine] ? stdout : File.open(null_file, 'w')
+      stdin = Puppet::FileSystem.open(options[:stdinfile] || null_file, nil, 'r')
+      stdout = options[:squelch] ? Puppet::FileSystem.open(null_file, nil, 'w') : Puppet::FileSystem::Uniquefile.new('puppet')
+      stderr = options[:combine] ? stdout : Puppet::FileSystem.open(null_file, nil, 'w')
 
       exec_args = [command, options, stdin, stdout, stderr]
 
       if execution_stub = Puppet::Util::ExecutionStub.current_value
         return execution_stub.call(*exec_args)
       elsif Puppet.features.posix?
-        child_pid = execute_posix(*exec_args)
-        exit_status = Process.waitpid2(child_pid).last.exitstatus
+        child_pid = nil
+        begin
+          child_pid = execute_posix(*exec_args)
+          exit_status = Process.waitpid2(child_pid).last.exitstatus
+          child_pid = nil
+        rescue Timeout::Error => e
+          # NOTE: For Ruby 2.1+, an explicit Timeout::Error class has to be
+          # passed to Timeout.timeout in order for there to be something for
+          # this block to rescue.
+          unless child_pid.nil?
+            Process.kill(:TERM, child_pid)
+            # Spawn a thread to reap the process if it dies.
+            Thread.new { Process.waitpid(child_pid) }
+          end
+
+          raise e
+        end
       elsif Puppet.features.microsoft_windows?
         process_info = execute_windows(*exec_args)
         begin
@@ -209,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 '#{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
@@ -282,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
@@ -301,7 +320,7 @@ module Puppet::Util::Execution
     end.join(" ") if command.is_a?(Array)
 
     options[:custom_environment] ||= {}
-    Puppet::Util.withenv(options[:custom_environment]) do
+    Puppet::Util.withenv(options[:custom_environment], :windows) do
       Puppet::Util::Windows::Process.execute(command, options, stdin, stdout, stderr)
     end
   end
@@ -330,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) and Puppet[:always_cache_features])
+          (@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

data/lib/puppet/util/fileparsing.rb

@@ -43,14 +43,14 @@ module Puppet::Util::FileParsing
     def fields=(fields)
       @fields = fields.collect do |field|
         r = field.intern
-        raise ArgumentError.new("Cannot have fields named #{r}") if INVALID_FIELDS.include?(r)
+        raise ArgumentError.new(_("Cannot have fields named %{name}") % { name: r }) if INVALID_FIELDS.include?(r)
         r
       end
     end
 
     def initialize(type, options = {}, &block)
       @type = type.intern
-      raise ArgumentError, "Invalid record type #{@type}" unless [:record, :text].include?(@type)
+      raise ArgumentError, _("Invalid record type %{record_type}") % { record_type: @type } unless [:record, :text].include?(@type)
 
       set_options(options)
 
@@ -86,7 +86,7 @@ module Puppet::Util::FileParsing
           if self.optional.include?(field)
             self.absent
           else
-            raise ArgumentError, "Field '#{field}' is required"
+            raise ArgumentError, _("Field '%{field}' is required") % { field: field }
           end
         else
           details[field].to_s
@@ -227,7 +227,7 @@ module Puppet::Util::FileParsing
       if val = parse_line(line)
         val
       else
-        error = Puppet::ResourceError.new("Could not parse line #{line.inspect}")
+        error = Puppet::ResourceError.new(_("Could not parse line %{line}") % { line: line.inspect })
         error.line = count
         raise error
       end
@@ -270,7 +270,7 @@ module Puppet::Util::FileParsing
   #   the regex will be removed.
   # * <tt>:separator</tt>: The record separator.  Defaults to /\s+/.
   def record_line(name, options, &block)
-    raise ArgumentError, "Must include a list of fields" unless options.include?(:fields)
+    raise ArgumentError, _("Must include a list of fields") unless options.include?(:fields)
 
     record = FileRecord.new(:record, options, &block)
     record.name = name.intern
@@ -285,7 +285,7 @@ module Puppet::Util::FileParsing
 
   # Define a new type of text record.
   def text_line(name, options, &block)
-    raise ArgumentError, "You must provide a :match regex for text lines" unless options.include?(:match)
+    raise ArgumentError, _("You must provide a :match regex for text lines") unless options.include?(:match)
 
     record = FileRecord.new(:text, options, &block)
     record.name = name.intern
@@ -305,7 +305,7 @@ module Puppet::Util::FileParsing
   # Convert our parsed record into a text record.
   def to_line(details)
     unless record = record_type(details[:record_type])
-      raise ArgumentError, "Invalid record type #{details[:record_type].inspect}"
+      raise ArgumentError, _("Invalid record type %{record_type}") % { record_type: details[:record_type].inspect }
     end
 
     if record.respond_to?(:pre_gen)
@@ -361,7 +361,7 @@ module Puppet::Util::FileParsing
     @record_types ||= {}
     @record_order ||= []
 
-    raise ArgumentError, "Line type #{record.name} is already defined" if @record_types.include?(record.name)
+    raise ArgumentError, _("Line type %{name} is already defined") % { name: record.name } if @record_types.include?(record.name)
 
     @record_types[record.name] = record
     @record_order << record