puppet 5.0.0 → 6.0.0

data/lib/puppet/indirector/terminus.rb

@@ -46,7 +46,7 @@ class Puppet::Indirector::Terminus
     def inherited(subclass)
       longname = subclass.to_s
       if longname =~ /#<Class/
-        raise Puppet::DevError, "Terminus subclasses must have associated constants"
+        raise Puppet::DevError, _("Terminus subclasses must have associated constants")
       end
       names = longname.split("::")
 
@@ -71,7 +71,7 @@ class Puppet::Indirector::Terminus
       processed_name = names.pop.sub(/^[A-Z]/) { |i| i.downcase }.gsub(/[A-Z]/) { |i| "_#{i.downcase}" }
 
       if processed_name.empty?
-        raise Puppet::DevError, "Could not discern indirection model from class constant"
+        raise Puppet::DevError, _("Could not discern indirection model from class constant")
       end
 
       # This will throw an exception if the indirection instance cannot be found.
@@ -112,7 +112,7 @@ class Puppet::Indirector::Terminus
     # Return all terminus classes for a given indirection.
     def terminus_classes(indirection_name)
       setup_instance_loading indirection_name
-      instance_loader(indirection_name).files_to_load.map do |file|
+      instance_loader(indirection_name).files_to_load(Puppet.lookup(:current_environment)).map do |file|
         File.basename(file).chomp(".rb").intern
       end
     end
@@ -129,7 +129,7 @@ class Puppet::Indirector::Terminus
   end
 
   def initialize
-    raise Puppet::DevError, "Cannot create instances of abstract terminus types" if self.class.abstract_terminus?
+    raise Puppet::DevError, _("Cannot create instances of abstract terminus types") if self.class.abstract_terminus?
   end
 
   def model

data/lib/puppet/indirector/yaml.rb

@@ -9,7 +9,7 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
     return nil unless Puppet::FileSystem.exist?(file)
 
     begin
-      return fix(Puppet::Util::Yaml.load_file(file))
+      return load_file(file)
     rescue Puppet::Util::Yaml::YamlLoadError => detail
       raise Puppet::Error, _("Could not parse YAML data for %{indirection} %{request}: %{detail}") % { indirection: indirection.name, request: request.key, detail: detail }, detail.backtrace
     end
@@ -51,13 +51,13 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
 
   def search(request)
     Dir.glob(path(request.key,'')).collect do |file|
-      fix(Puppet::Util::Yaml.load_file(file))
+      load_file(file)
     end
   end
 
   protected
 
-  def fix(object)
-    object
+  def load_file(file)
+    Puppet::Util::Yaml.safe_load_file(file, [model, Symbol])
   end
 end

data/lib/puppet/info_service/class_information_service.rb

@@ -59,7 +59,7 @@ class Puppet::InfoService::ClassInformationService
       {:classes =>
         parse_result.definitions.select {|d| d.is_a?(Puppet::Pops::Model::HostClassDefinition)}.map do |d|
           {:name   => d.name,
-           :params => params = d.parameters.map {|p| extract_param(p) }
+           :params => d.parameters.map {|p| extract_param(p) }
           }
         end
       }

data/lib/puppet/info_service/task_information_service.rb

@@ -0,0 +1,36 @@
+class Puppet::InfoService::TaskInformationService
+  require 'puppet/module'
+
+  def self.tasks_per_environment(environment_name)
+    # get the actual environment object, raise error if the named env doesn't exist
+    env = Puppet.lookup(:environments).get!(environment_name)
+    env.modules.map do |mod|
+      mod.tasks.map do |task|
+        {:module => {:name => task.module.name}, :name => task.name}
+      end
+    end.flatten
+  end
+
+  def self.task_data(environment_name, module_name, task_name)
+    # raise EnvironmentNotFound if applicable
+    Puppet.lookup(:environments).get!(environment_name)
+
+    pup_module = Puppet::Module.find(module_name, environment_name)
+    if pup_module.nil?
+      raise Puppet::Module::MissingModule, _("Module %{module_name} not found in environment %{environment_name}.") %
+                                            {module_name: module_name, environment_name: environment_name}
+    end
+
+    task = pup_module.tasks.find { |t| t.name == task_name }
+    if task.nil?
+      raise Puppet::Module::Task::TaskNotFound.new(task_name, module_name)
+    end
+
+    begin
+      task.validate
+      {:metadata => task.metadata, :files => task.files}
+    rescue Puppet::Module::Task::Error => err
+      { :metadata => nil, :files => [], :error => err.to_h }
+    end
+  end
+end

data/lib/puppet/info_service.rb

@@ -1,7 +1,17 @@
 
 module Puppet::InfoService
   require 'puppet/info_service/class_information_service'
+  require 'puppet/info_service/task_information_service'
+
   def self.classes_per_environment(env_file_hash)
     Puppet::InfoService::ClassInformationService.new.classes_per_environment(env_file_hash)
   end
+
+  def self.tasks_per_environment(environment_name)
+    Puppet::InfoService::TaskInformationService.tasks_per_environment(environment_name)
+  end
+
+  def self.task_data(environment_name, module_name, task_name)
+    Puppet::InfoService::TaskInformationService.task_data(environment_name, module_name, task_name)
+  end
 end

data/lib/puppet/interface/action.rb

@@ -1,4 +1,4 @@
-require 'puppet/util/methodhelper'
+# coding: utf-8
 require 'prettyprint'
 
 # This represents an action that is attached to a face. Actions should
@@ -7,12 +7,11 @@ require 'prettyprint'
 # {Puppet::Interface::ActionBuilder} in the supplied block.
 # @api private
 class Puppet::Interface::Action
-  include Puppet::Util::MethodHelper
   extend  Puppet::Interface::DocGen
   include Puppet::Interface::FullDocs
 
   # @api private
-  def initialize(face, name, attrs = {})
+  def initialize(face, name)
     raise "#{name.inspect} is an invalid action name" unless name.to_s =~ /^[a-z]\w*$/
     @face    = face
     @name    = name.to_sym
@@ -23,8 +22,6 @@ class Puppet::Interface::Action
     @authors = []
     @license  = 'All Rights Reserved'
 
-    set_options(attrs)
-
     # @options collects the added options in the order they're declared.
     # @options_hash collects the options keyed by alias for quick lookups.
     @options        = []
@@ -78,7 +75,7 @@ class Puppet::Interface::Action
   # @api private
   def when_rendering(type)
     unless type.is_a? Symbol
-      raise ArgumentError, "The rendering format must be a symbol, not #{type.class.name}"
+      raise ArgumentError, _("The rendering format must be a symbol, not %{class_name}") % { class_name: type.class.name }
     end
     # Do we have a rendering hook for this name?
     return @when_rendering[type].bind(@face) if @when_rendering.has_key? type
@@ -94,28 +91,38 @@ class Puppet::Interface::Action
   # @api private
   def set_rendering_method_for(type, proc)
     unless proc.is_a? Proc
-      msg = "The second argument to set_rendering_method_for must be a Proc"
-      msg += ", not #{proc.class.name}" unless proc.nil?
+      msg = if proc.nil?
+              #TRANSLATORS 'set_rendering_method_for' and 'Proc' should not be translated
+              _("The second argument to set_rendering_method_for must be a Proc")
+            else
+              #TRANSLATORS 'set_rendering_method_for' and 'Proc' should not be translated
+              _("The second argument to set_rendering_method_for must be a Proc, not %{class_name}") %
+                  { class_name: proc.class.name }
+            end
       raise ArgumentError, msg
     end
 
     if proc.arity != 1 and proc.arity != (@positional_arg_count + 1)
-      msg =  "the when_rendering method for the #{@face.name} face #{name} action "
-      msg += "takes either just one argument, the result of when_invoked, "
-      msg += "or the result plus the #{@positional_arg_count} arguments passed "
-      msg += "to the when_invoked block, not "
-      if proc.arity < 0 then
-        msg += "a variable number"
-      else
-        msg += proc.arity.to_s
-      end
+      msg = if proc.arity < 0 then
+              #TRANSLATORS 'when_rendering', 'when_invoked' are method names and should not be translated
+              _("The when_rendering method for the %{face} face %{name} action takes either just one argument,"\
+                  " the result of when_invoked, or the result plus the %{arg_count} arguments passed to the"\
+                  " when_invoked block, not a variable number") %
+                  { face: @face.name, name: name, arg_count: @positional_arg_count }
+            else
+              #TRANSLATORS 'when_rendering', 'when_invoked' are method names and should not be translated
+              _("The when_rendering method for the %{face} face %{name} action takes either just one argument,"\
+                  " the result of when_invoked, or the result plus the %{arg_count} arguments passed to the"\
+                  " when_invoked block, not %{string}") %
+                  { face: @face.name, name: name, arg_count: @positional_arg_count, string: proc.arity.to_s }
+            end
       raise ArgumentError, msg
     end
     unless type.is_a? Symbol
-      raise ArgumentError, "The rendering format must be a symbol, not #{type.class.name}"
+      raise ArgumentError, _("The rendering format must be a symbol, not %{class_name}") % { class_name: type.class.name }
     end
     if @when_rendering.has_key? type then
-      raise ArgumentError, "You can't define a rendering method for #{type} twice"
+      raise ArgumentError, _("You can't define a rendering method for %{type} twice") % { type: type }
     end
     # Now, the ugly bit.  We add the method to our interface object, and
     # retrieve it, to rotate through the dance of getting a suitable method
@@ -139,6 +146,17 @@ class Puppet::Interface::Action
     @render_as = value.to_sym
   end
 
+  # @api private
+  # @return [void]
+  def deprecate
+    @deprecated = true
+  end
+
+  # @api private
+  # @return [Boolean]
+  def deprecated?
+    @deprecated
+  end
 
   ########################################################################
   # Initially, this was defined to allow the @action.invoke pattern, which is
@@ -213,7 +231,8 @@ class Puppet::Interface::Action
       # but will on 1.9.2, which treats it as "no arguments".  Which bites,
       # because this just begs for us to wind up in the horrible situation
       # where a 1.8 vs 1.9 error bites our end users. --daniel 2011-04-19
-      raise ArgumentError, "when_invoked requires at least one argument (options) for action #{@name}"
+      #TRANSLATORS 'when_invoked' should not be translated
+      raise ArgumentError, _("when_invoked requires at least one argument (options) for action %{name}") % { name: @name }
     elsif arity > 0 then
       range = Range.new(1, arity - 1)
       decl = range.map { |x| "arg#{x}" } << "options = {}"
@@ -259,9 +278,11 @@ WRAPPER
   def add_option(option)
     option.aliases.each do |name|
       if conflict = get_option(name) then
-        raise ArgumentError, "Option #{option} conflicts with existing option #{conflict}"
+        raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict}") %
+            { option: option, conflict: conflict }
       elsif conflict = @face.get_option(name) then
-        raise ArgumentError, "Option #{option} conflicts with existing option #{conflict} on #{@face}"
+        raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict} on %{face}") %
+            { option: option, conflict: conflict, face: @face }
       end
     end
 
@@ -285,7 +306,10 @@ WRAPPER
   def add_display_global_options(*args)
     @display_global_options ||= []
     [args].flatten.each do |refopt|
-      raise ArgumentError, "Global option #{refopt} does not exist in Puppet.settings" unless Puppet.settings.include? refopt
+      unless Puppet.settings.include? refopt
+        #TRANSLATORS 'Puppet.settings' should not be translated
+        raise ArgumentError, _("Global option %{option} does not exist in Puppet.settings") % { option: refopt }
+      end
       @display_global_options << refopt
     end
     @display_global_options.uniq!
@@ -331,13 +355,14 @@ WRAPPER
     end
 
     unless overlap.empty?
-      msg = overlap.map {|k, v| "(#{k}, #{v.sort.join(', ')})" }.join(", ")
-      raise ArgumentError, "Multiple aliases for the same option passed: #{msg}"
+      overlap_list = overlap.map {|k, v| "(#{k}, #{v.sort.join(', ')})" }.join(", ")
+      raise ArgumentError, _("Multiple aliases for the same option passed: %{overlap_list}") %
+          { overlap_list: overlap_list }
     end
 
     unless unknown.empty?
-      msg = unknown.sort.join(", ")
-      raise ArgumentError, "Unknown options passed: #{msg}"
+      unknown_list = unknown.sort.join(", ")
+      raise ArgumentError, _("Unknown options passed: %{unknown_list}") % { unknown_list: unknown_list }
     end
 
     # Inject default arguments and check for missing mandating options.
@@ -354,8 +379,8 @@ WRAPPER
     end
 
     unless missing.empty?
-      msg = missing.sort.join(', ')
-      raise ArgumentError, "The following options are required: #{msg}"
+      missing_list = missing.sort.join(', ')
+      raise ArgumentError, _("The following options are required: %{missing_list}") % { missing_list: missing_list }
     end
 
     # All done.

data/lib/puppet/interface/action_builder.rb

@@ -17,6 +17,14 @@ class Puppet::Interface::ActionBuilder
     new(face, name, &block).action
   end
 
+  # Deprecates the action
+  # @return [void]
+  # @api private
+  # @dsl Faces
+  def deprecate
+    @action.deprecate
+  end
+
   # Ideally the method we're defining here would be added to the action, and a
   # method on the face would defer to it, but we can't get scope correct, so
   # we stick with this. --daniel 2011-03-24
@@ -49,10 +57,12 @@ class Puppet::Interface::ActionBuilder
   # @dsl Faces
   def when_rendering(type = nil, &block)
     if type.nil? then           # the default error message sucks --daniel 2011-04-18
-      raise ArgumentError, 'You must give a rendering format to when_rendering'
+      #TRANSLATORS 'when_rendering' is a method name and should not be translated
+      raise ArgumentError, _('You must give a rendering format to when_rendering')
     end
     if block.nil? then
-      raise ArgumentError, 'You must give a block to when_rendering'
+      #TRANSLATORS 'when_rendering' is a method name and should not be translated
+      raise ArgumentError, _('You must give a block to when_rendering')
     end
     @action.set_rendering_method_for(type, block)
   end
@@ -111,11 +121,15 @@ class Puppet::Interface::ActionBuilder
   # Sets the default rendering format
   # @api private
   def render_as(value = nil)
-    value.nil? and raise ArgumentError, "You must give a rendering format to render_as"
+    if value.nil?
+      #TRANSLATORS 'render_as' is a method name and should not be translated
+      raise ArgumentError, _("You must give a rendering format to render_as")
+    end
 
     formats = Puppet::Network::FormatHandler.formats
     unless formats.include? value
-      raise ArgumentError, "#{value.inspect} is not a valid rendering format: #{formats.sort.join(", ")}"
+      raise ArgumentError, _("%{value} is not a valid rendering format: %{formats_list}") %
+          { value: value.inspect, formats_list: formats.sort.join(", ")}
     end
 
     @action.render_as = value
@@ -144,6 +158,9 @@ class Puppet::Interface::ActionBuilder
     @face   = face
     @action = Puppet::Interface::Action.new(face, name)
     instance_eval(&block)
-    @action.when_invoked or raise ArgumentError, "actions need to know what to do when_invoked; please add the block"
+    unless @action.when_invoked
+      #TRANSLATORS 'when_invoked' is a method name and should not be translated and 'block' is a Ruby code block
+      raise ArgumentError, _("actions need to know what to do when_invoked; please add the block")
+    end
   end
 end

data/lib/puppet/interface/action_manager.rb

@@ -17,7 +17,7 @@ module Puppet::Interface::ActionManager
   # @dsl Faces
   def action(name, &block)
     @actions ||= {}
-    Puppet.warning "Redefining action #{name} for #{self}" if action?(name)
+    Puppet.warning _("Redefining action %{name} for %{self}") % { name: name, self: self } if action?(name)
 
     action = Puppet::Interface::ActionBuilder.build(self, name, &block)
 

data/lib/puppet/interface/documentation.rb

@@ -56,7 +56,8 @@ class Puppet::Interface
     # @dsl Faces
     attr_doc :summary do |value|
       value =~ /\n/ and
-        raise ArgumentError, "Face summary should be a single line; put the long text in 'description' instead."
+        #TRANSLATORS 'Face' refers to a programming API in Puppet, 'summary' and 'description' are specifc attribute names and should not be translated
+        raise ArgumentError, _("Face summary should be a single line; put the long text in 'description' instead.")
       value
     end
 
@@ -200,11 +201,13 @@ class Puppet::Interface
     def author(value = nil)
       unless value.nil? then
         unless value.is_a? String
-          raise ArgumentError, 'author must be a string; use multiple statements for multiple authors'
+          #TRANSLATORS 'author' is an attribute name and should not be translated
+          raise ArgumentError, _('author must be a string; use multiple statements for multiple authors')
         end
 
         if value =~ /\n/ then
-          raise ArgumentError, 'author should be a single line; use multiple statements for multiple authors'
+          #TRANSLATORS 'author' is an attribute name and should not be translated
+          raise ArgumentError, _('author should be a single line; use multiple statements for multiple authors')
         end
         @authors.push(Puppet::Interface::DocGen.strip_whitespace(value))
       end
@@ -223,7 +226,8 @@ class Puppet::Interface
       # I think it's a bug that this ends up being the exposed
       # version of `author` on ActionBuilder
       if Array(value).any? {|x| x =~ /\n/ } then
-        raise ArgumentError, 'author should be a single line; use multiple statements'
+        #TRANSLATORS 'author' is an attribute name and should not be translated
+        raise ArgumentError, _('author should be a single line; use multiple statements')
       end
       @authors = Array(value).map{|x| Puppet::Interface::DocGen.strip_whitespace(x) }
     end
@@ -243,7 +247,8 @@ class Puppet::Interface
     # @dsl Faces
     def copyright(owner = nil, years = nil)
       if years.nil? and not owner.nil? then
-        raise ArgumentError, 'copyright takes the owners names, then the years covered'
+        #TRANSLATORS 'copyright' is an attribute name and should not be translated
+        raise ArgumentError, _('copyright takes the owners names, then the years covered')
       end
       self.copyright_owner = owner unless owner.nil?
       self.copyright_years = years unless years.nil?
@@ -266,7 +271,8 @@ class Puppet::Interface
       when String then @copyright_owner = value
       when Array  then @copyright_owner = value.join(", ")
       else
-        raise ArgumentError, "copyright owner must be a string or an array of strings"
+        #TRANSLATORS 'copyright' is an attribute name and should not be translated
+        raise ArgumentError, _("copyright owner must be a string or an array of strings")
       end
       @copyright_owner
     end
@@ -302,7 +308,9 @@ class Puppet::Interface
           fault = "after #{future}"
         end
         if fault then
-          raise ArgumentError, "copyright with a year #{fault} is very strange; did you accidentally add or subtract two years?"
+          #TRANSLATORS 'copyright' is an attribute name and should not be translated
+          raise ArgumentError, _("copyright with a year %{value} is very strange; did you accidentally add or subtract two years?") %
+              { value: fault }
         end
 
         input
@@ -314,11 +322,13 @@ class Puppet::Interface
             part.to_i
           elsif found = part.split(/-/) then
             unless found.length == 2 and found.all? {|x| x.strip =~ /^\d+$/ }
-              raise ArgumentError, "#{part.inspect} is not a good copyright year or range"
+              #TRANSLATORS 'copyright' is an attribute name and should not be translated
+              raise ArgumentError, _("%{value} is not a good copyright year or range") % { value: part.inspect }
             end
             Range.new(found[0].to_i, found[1].to_i)
           else
-            raise ArgumentError, "#{part.inspect} is not a good copyright year or range"
+            #TRANSLATORS 'copyright' is an attribute name and should not be translated
+            raise ArgumentError, _("%{value} is not a good copyright year or range") % { value: part.inspect }
           end
         end
 
@@ -335,7 +345,8 @@ class Puppet::Interface
         result
 
       else
-        raise ArgumentError, "#{input.inspect} is not a good copyright year, set, or range"
+        #TRANSLATORS 'copyright' is an attribute name and should not be translated
+        raise ArgumentError, _("%{value} is not a good copyright year, set, or range") % { value: input.inspect }
       end
     end
   end

data/lib/puppet/interface/face_collection.rb

@@ -6,7 +6,9 @@ module Puppet::Interface::FaceCollection
   def self.faces
     unless @loaded
       @loaded = true
-      names = @loader.files_to_load.map {|fn| ::File.basename(fn, '.rb')}.uniq
+      names = @loader.files_to_load(Puppet.lookup(:current_environment)).map do |fn|
+        ::File.basename(fn, '.rb')
+      end.uniq
       names.each {|name| self[name, :current]}
     end
     @faces.keys.select {|name| @faces[name].length > 0 }
@@ -111,7 +113,7 @@ module Puppet::Interface::FaceCollection
     nil
   rescue SyntaxError => e
     raise unless e.message =~ %r{#{path}\.rb:\d+: }
-    Puppet.err "Failed to load face #{name}:\n#{e}"
+    Puppet.err _("Failed to load face %{name}:\n%{detail}") % { name: name, detail: e }
     # ...but we just carry on after complaining.
     nil
   end
@@ -122,7 +124,9 @@ module Puppet::Interface::FaceCollection
 
   def self.underscorize(name)
     unless name.to_s =~ /^[-_a-z][-_a-z0-9]*$/i then
-      raise ArgumentError, "#{name.inspect} (#{name.class}) is not a valid face name"
+      #TRANSLATORS 'face' refers to a programming API in Puppet
+      raise ArgumentError, _("%{name} (%{class_name}) is not a valid face name") %
+          { name: name.inspect, class_name: name.class }
     end
 
     name.to_s.downcase.split(/[-_]/).join('_').to_sym

data/lib/puppet/interface/option.rb

@@ -18,7 +18,7 @@ class Puppet::Interface::Option
     declaration.each do |item|
       if item.is_a? String and item.to_s =~ /^-/ then
         unless item =~ /^-[a-z]\b/ or item =~ /^--[^-]/ then
-          raise ArgumentError, "#{item.inspect}: long options need two dashes (--)"
+          raise ArgumentError, _("%{option}: long options need two dashes (--)") % { option: item.inspect }
         end
         @optparse << item
 
@@ -33,20 +33,21 @@ class Puppet::Interface::Option
         # jeffweiss 17 april 2012
         name = optparse_to_optionname(item)
         if Puppet.settings.include? name then
-          raise ArgumentError, "#{item.inspect}: already defined in puppet"
+          raise ArgumentError, _("%{option}: already defined in puppet") % { option: item.inspect }
         end
         if dup = dups[name] then
-          raise ArgumentError, "#{item.inspect}: duplicates existing alias #{dup.inspect} in #{@parent}"
+          raise ArgumentError, _("%{option}: duplicates existing alias %{duplicate} in %{parent}") %
+              { option: item.inspect, duplicate: dup.inspect, parent: @parent }
         else
           dups[name] = item
         end
       else
-        raise ArgumentError, "#{item.inspect} is not valid for an option argument"
+        raise ArgumentError, _("%{option} is not valid for an option argument") % { option: item.inspect }
       end
     end
 
     if @optparse.empty? then
-      raise ArgumentError, "No option declarations found while building"
+      raise ArgumentError, _("No option declarations found while building")
     end
 
     # Now, infer the name from the options; we prefer the first long option as
@@ -59,15 +60,17 @@ class Puppet::Interface::Option
     # relax this rule later if we find a valid use case for it. --daniel 2011-03-30
     @argument = @optparse.any? { |o| o =~ /[ =]/ }
     if @argument and not @optparse.all? { |o| o =~ /[ =]/ } then
-      raise ArgumentError, "Option #{@name} is inconsistent about taking an argument"
+      raise ArgumentError, _("Option %{name} is inconsistent about taking an argument") % { name: @name }
     end
 
     # Is our argument optional?  The rules about consistency apply here, also,
     # just like they do to taking arguments at all. --daniel 2011-03-30
     @optional_argument = @optparse.any? { |o| o=~/[ =]\[/ }
-    @optional_argument and raise ArgumentError, "Options with optional arguments are not supported"
+    if @optional_argument
+      raise ArgumentError, _("Options with optional arguments are not supported")
+    end
     if @optional_argument and not @optparse.all? { |o| o=~/[ =]\[/ } then
-      raise ArgumentError, "Option #{@name} is inconsistent about the argument being optional"
+      raise ArgumentError, _("Option %{name} is inconsistent about the argument being optional") % { name: @name }
     end
   end
 
@@ -82,7 +85,7 @@ class Puppet::Interface::Option
   # @api private
   def optparse_to_optionname(declaration)
     unless found = declaration.match(/^-+(?:\[no-\])?([^ =]+)/) then
-      raise ArgumentError, "Can't find a name in the declaration #{declaration.inspect}"
+      raise ArgumentError, _("Can't find a name in the declaration %{declaration}") % { declaration: declaration.inspect }
     end
     found.captures.first
   end
@@ -90,7 +93,9 @@ class Puppet::Interface::Option
   # @api private
   def optparse_to_name(declaration)
     name = optparse_to_optionname(declaration).tr('-', '_')
-    raise "#{name.inspect} is an invalid option name" unless name.to_s =~ /^[a-z]\w*$/
+    unless name.to_s =~ /^[a-z]\w*$/
+      raise _("%{name} is an invalid option name") % { name: name.inspect }
+    end
     name.to_sym
   end
 
@@ -110,8 +115,14 @@ class Puppet::Interface::Option
   end
 
   def default=(proc)
-    required and raise ArgumentError, "#{self} can't be optional and have a default value"
-    proc.is_a? Proc or raise ArgumentError, "default value for #{self} is a #{proc.class.name.inspect}, not a proc"
+    if required
+      raise ArgumentError, _("%{name} can't be optional and have a default value") % { name: self }
+    end
+    unless proc.is_a? Proc
+      #TRANSLATORS 'proc' is a Ruby block of code
+      raise ArgumentError, _("default value for %{name} is a %{class_name}, not a proc") %
+          { name: self, class_name: proc.class.name.inspect }
+    end
     @default = proc
   end
 
@@ -122,20 +133,30 @@ class Puppet::Interface::Option
   attr_reader   :parent, :name, :aliases, :optparse
   attr_accessor :required
   def required=(value)
-    has_default? and raise ArgumentError, "#{self} can't be optional and have a default value"
+    if has_default?
+      raise ArgumentError, _("%{name} can't be optional and have a default value") % { name: self }
+    end
     @required = value
   end
 
   attr_accessor :before_action
   def before_action=(proc)
-    proc.is_a? Proc or raise ArgumentError, "before action hook for #{self} is a #{proc.class.name.inspect}, not a proc"
+    unless proc.is_a? Proc
+      #TRANSLATORS 'proc' is a Ruby block of code
+      raise ArgumentError, _("before action hook for %{name} is a %{class_name}, not a proc") %
+          { name: self, class_name: proc.class.name.inspect }
+    end
     @before_action =
       @parent.__send__(:__add_method, __decoration_name(:before), proc)
   end
 
   attr_accessor :after_action
   def after_action=(proc)
-    proc.is_a? Proc or raise ArgumentError, "after action hook for #{self} is a #{proc.class.name.inspect}, not a proc"
+    unless proc.is_a? Proc
+      #TRANSLATORS 'proc' is a Ruby block of code
+      raise ArgumentError, _("after action hook for %{name} is a %{class_name}, not a proc") %
+          { name: self, class_name: proc.class.name.inspect }
+    end
     @after_action =
       @parent.__send__(:__add_method, __decoration_name(:after), proc)
   end