bolt 0.15.0 → 0.16.0

data/vendored/puppet/lib/puppet/pops/model/factory.rb

@@ -802,7 +802,9 @@ class Factory
       end
     else
       # Bad number should already have been caught by lexer - this should never happen
-      raise ArgumentError, "Internal Error, NUMBER token does not contain a valid number, #{name_or_numeric}"
+      #TRANSLATORS 'NUMBER' refers to a method name and the 'name_or_numeric' was the passed in value and should not be translated
+      raise ArgumentError, _("Internal Error, NUMBER token does not contain a valid number, %{name_or_numeric}") %
+          { name_or_numeric: name_or_numeric }
     end
   end
 
@@ -1109,7 +1111,7 @@ class Factory
       elsif e.is_a?(String)
         result << e
       else
-        raise ArgumentError, "can only concatenate strings, got #{e.class}"
+        raise ArgumentError, _("can only concatenate strings, got %{class_name}") % { class_name: e.class }
       end
     end
     infer(result)

data/vendored/puppet/lib/puppet/pops/resource/resource_type_impl.rb

@@ -164,7 +164,7 @@ class ResourceTypeImpl
           # the 'package' type where 'provider' attribute is handled as part of the key without being
           # set from the title.
           #
-          raise Puppet::DevError,"you must specify title patterns when there are two or more key attributes"
+          raise Puppet::DevError, _("you must specify title patterns when there are two or more key attributes")
         end
         @title_patterns_hash.nil? ? [] : @title_patterns_hash.map { |k,v| [ k, v.map { |n| [ n.to_sym] } ] }
       end

data/vendored/puppet/lib/puppet/pops/serialization/abstract_writer.rb

@@ -99,7 +99,8 @@ class AbstractWriter
   #
   # @api private
   def write_tpl(ep, value)
-    raise ArgumentError, 'Internal error. Integers cannot be tabulated in extension payload' if value.is_a?(Integer)
+    #TRANSLATORS 'Integers' is a Ruby class for numbers and should not be translated
+    raise ArgumentError, _('Internal error. Integers cannot be tabulated in extension payload') if value.is_a?(Integer)
     if @tabulate
       index = @written[value]
       if index.nil?

data/vendored/puppet/lib/puppet/pops/serialization/to_data_converter.rb

@@ -188,17 +188,21 @@ module Serialization
     end
 
     def unknown_key_to_string_with_warning(value)
-      str = value.to_s
+      str = unknown_to_string(value)
       serialization_issue(Issues::SERIALIZATION_UNKNOWN_KEY_CONVERTED_TO_STRING, :path => path_to_s, :klass => value.class, :value => str)
       str
     end
 
     def unknown_to_string_with_warning(value)
-      str = value.to_s
+      str = unknown_to_string(value)
       serialization_issue(Issues::SERIALIZATION_UNKNOWN_CONVERTED_TO_STRING, :path => path_to_s, :klass => value.class, :value => str)
       str
     end
 
+    def unknown_to_string(value)
+      value.is_a?(Regexp) ? Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(value) : value.to_s
+    end
+
     def non_string_keyed_hash_to_data(hash)
       if @rich_data
         to_key_extended_hash(hash)

data/vendored/puppet/lib/puppet/pops/types/p_object_type.rb

@@ -143,7 +143,10 @@ class PObjectType < PMetaType
     def assert_override(parent_members)
       parent_member = parent_members[@name]
       if parent_member.nil?
-        raise Puppet::ParseError, "expected #{label} to override an inherited #{feature_type}, but no such #{feature_type} was found" if @override
+        if @override
+          raise Puppet::ParseError, _("expected %{label} to override an inherited %{feature_type}, but no such %{feature_type} was found") %
+              { label: label, feature_type: feature_type }
+        end
         self
       else
         parent_member.assert_can_be_overridden(self)
@@ -157,10 +160,19 @@ class PObjectType < PMetaType
     # @raises [Puppet::ParseError] if the assertion fails
     # @api private
     def assert_can_be_overridden(member)
-      raise Puppet::ParseError, "#{member.label} attempts to override #{label}" unless self.class == member.class
-      raise Puppet::ParseError, "#{member.label} attempts to override final #{label}" if @final && !(constant? && member.constant?)
-      raise Puppet::ParseError, "#{member.label} attempts to override #{label} without having override => true" unless member.override?
-      raise Puppet::ParseError, "#{member.label} attempts to override #{label} with a type that does not match" unless @type.assignable?(member.type)
+      unless self.class == member.class
+        raise Puppet::ParseError, _("%{member} attempts to override %{label}") % { member: member.label, label: label }
+      end
+      if @final && !(constant? && member.constant?)
+        raise Puppet::ParseError, _("%{member} attempts to override final %{label}") % { member: member.label, label: label }
+      end
+      unless member.override?
+        #TRANSLATOR 'override => true' is a puppet syntax and should not be translated
+        raise Puppet::ParseError, _("%{member} attempts to override %{label} without having override => true") % { member: member.label, label: label }
+      end
+      unless @type.assignable?(member.type)
+        raise Puppet::ParseError, _("%{member} attempts to override %{label} with a type that does not match") % { member: member.label, label: label }
+      end
       member
     end
 
@@ -275,19 +287,20 @@ class PObjectType < PMetaType
       @kind = init_hash[KEY_KIND]
       if @kind == ATTRIBUTE_KIND_CONSTANT # final is implied
         if init_hash.include?(KEY_FINAL) && !@final
-          raise Puppet::ParseError, "#{label} of kind 'constant' cannot be combined with final => false"
+          #TRANSLATOR 'final => false' is puppet syntax and should not be translated
+          raise Puppet::ParseError, _("%{label} of kind 'constant' cannot be combined with final => false") % { label: label }
         end
         @final = true
       end
 
       if init_hash.include?(KEY_VALUE)
         if @kind == ATTRIBUTE_KIND_DERIVED || @kind == ATTRIBUTE_KIND_GIVEN_OR_DERIVED
-          raise Puppet::ParseError, "#{label} of kind '#{@kind}' cannot be combined with an attribute value"
+          raise Puppet::ParseError, _("%{label} of kind '%{kind}' cannot be combined with an attribute value") % { label: label, kind: @kind }
         end
         v = init_hash[KEY_VALUE]
         @value = v == :default ? v : TypeAsserter.assert_instance_of(nil, type, v) {"#{label} #{KEY_VALUE}" }
       else
-        raise Puppet::ParseError, "#{label} of kind 'constant' requires a value" if @kind == ATTRIBUTE_KIND_CONSTANT
+        raise Puppet::ParseError, _("%{label} of kind 'constant' requires a value") % { label: label } if @kind == ATTRIBUTE_KIND_CONSTANT
         @value = :undef # Not to be confused with nil or :default
       end
     end
@@ -703,7 +716,9 @@ class PObjectType < PMetaType
     end
     unless constants.nil? || constants.empty?
       constants.each do |key, value|
-        raise Puppet::ParseError, "attribute #{label}[#{key}] is defined as both a constant and an attribute" if attr_specs.include?(key)
+        if attr_specs.include?(key)
+          raise Puppet::ParseError, _("attribute %{label}[%{key}] is defined as both a constant and an attribute") % { label: label, key: key }
+        end
         attr_spec = {
           # Type must be generic here, or overrides would become impossible
           KEY_TYPE => TypeCalculator.infer(value).generalize,
@@ -734,7 +749,7 @@ class PObjectType < PMetaType
         func_spec = { KEY_TYPE => TypeAsserter.assert_instance_of(nil, TYPE_FUNCTION_TYPE, func_spec) { "function #{label}[#{key}]" } } unless func_spec.is_a?(Hash)
         func = PFunction.new(key, self, func_spec)
         name = func.name
-        raise Puppet::ParseError, "#{func.label} conflicts with attribute with the same name" if @attributes.include?(name)
+        raise Puppet::ParseError, _("%{label} conflicts with attribute with the same name") % { label: func.label } if @attributes.include?(name)
         [name, func.assert_override(parent_members)]
       end].freeze
     end
@@ -746,7 +761,8 @@ class PObjectType < PMetaType
     equality = [equality] if equality.is_a?(String)
     if equality.is_a?(Array)
       unless equality.empty?
-        raise Puppet::ParseError, 'equality_include_type = false cannot be combined with non empty equality specification' unless @equality_include_type
+        #TRANSLATORS equality_include_type = false should not be translated
+        raise Puppet::ParseError, _('equality_include_type = false cannot be combined with non empty equality specification') unless @equality_include_type
         parent_eq_attrs = nil
         equality.each do |attr_name|
 
@@ -758,16 +774,21 @@ class PObjectType < PMetaType
             parent_eq_attrs ||= parent_object_type.equality_attributes
             if parent_eq_attrs.include?(attr_name)
               including_parent = find_equality_definer_of(attr)
-              raise Puppet::ParseError, "#{label} equality is referencing #{attr.label} which is included in equality of #{including_parent.label}"
+              raise Puppet::ParseError, _("%{label} equality is referencing %{attribute} which is included in equality of %{including_parent}") %
+                  { label: label, attribute: attr.label, including_parent: including_parent.label }
             end
           end
 
           unless attr.is_a?(PAttribute)
-            raise Puppet::ParseError, "#{label} equality is referencing non existent attribute '#{attr_name}'" if attr.nil?
-            raise Puppet::ParseError, "#{label} equality is referencing #{attr.label}. Only attribute references are allowed"
+            if attr.nil?
+              raise Puppet::ParseError, _("%{label} equality is referencing non existent attribute '%{attribute}'") % { label: label, attribute: attr_name }
+            end
+            raise Puppet::ParseError, _("%{label} equality is referencing %{attribute}. Only attribute references are allowed") %
+                { label: label, attribute: attr.label }
           end
           if attr.kind == ATTRIBUTE_KIND_CONSTANT
-            raise Puppet::ParseError, "#{label} equality is referencing constant #{attr.label}. Reference to constant is not allowed in equality"
+            raise Puppet::ParseError, _("%{label} equality is referencing constant %{attribute}.") % { label: label, attribute: attr.label } + ' ' +
+                _("Reference to constant is not allowed in equality")
           end
         end
       end

data/vendored/puppet/lib/puppet/pops/types/type_calculator.rb

@@ -163,7 +163,8 @@ class TypeCalculator
 
   # Returns an iterable if the t represents something that can be iterated
   def enumerable(t)
-    Puppet.deprecation_warning('TypeCalculator.enumerable is deprecated. Use iterable')
+    #TRANSLATOR 'TypeCalculator.enumerable' and 'iterable' are methods and should not be translated
+    Puppet.deprecation_warning(_('TypeCalculator.enumerable is deprecated. Use iterable'))
     iterable(t)
   end
 

data/vendored/puppet/lib/puppet/pops/types/type_factory.rb

@@ -100,7 +100,9 @@ module TypeFactory
       size_type_or_value.nil? ? PStringType::DEFAULT : PStringType.new(size_type_or_value)
     else
       if Puppet[:strict] != :off
-        Puppet.warn_once('deprecations', "TypeFactory#string_multi_args", "Passing more than one argument to TypeFactory#string is deprecated")
+        #TRANSLATORS 'TypeFactory#string' is a class and method name and should not be translated
+        message = _("Passing more than one argument to TypeFactory#string is deprecated")
+        Puppet.warn_once('deprecations', "TypeFactory#string_multi_args", message)
       end
       deprecated_second_argument.size == 1 ? PStringType.new(deprecated_second_argument[0]) : PEnumType.new(*deprecated_second_argument)
     end

data/vendored/puppet/lib/puppet/pops/types/type_mismatch_describer.rb

@@ -512,7 +512,10 @@ module Types
     end
 
     def tense_deprecated
-      Puppet.warn_once('deprecations', 'typemismatch#tense', "Passing a 'tense' argument to the TypeMismatchDescriber is deprecated and ignored. Everything is now reported using present tense")
+      #TRANSLATORS TypeMismatchDescriber is a class name and 'tense' is a method name and should not be translated
+      message = _("Passing a 'tense' argument to the TypeMismatchDescriber is deprecated and ignored.")
+      message += ' ' + _("Everything is now reported using present tense")
+      Puppet.warn_once('deprecations', 'typemismatch#tense', message)
     end
 
     # Validates that all entries in the give_hash exists in the given param_struct, that their type conforms

data/vendored/puppet/lib/puppet/pops/types/type_parser.rb

@@ -33,6 +33,10 @@ class TypeParser
   # @api public
   #
   def parse(string, context = nil)
+    # quick "peephole" optimization of common data types
+    if t = self.class.opt_type_map[string]
+      return t
+    end
     model = @parser.parse_string(string)
     interpret(model.model.body, context)
   end
@@ -205,6 +209,70 @@ class TypeParser
     }.freeze
   end
 
+  # @api private
+  def self.opt_type_map
+    # Map of common (and simple to optimize) data types in string form
+    # (Note that some types are the result of evaluation even if they appear to be simple
+    # - for example 'Data' and they cannot be optimized this way since the factory calls
+    # back to the parser for evaluation).
+    #
+    @opt_type_map ||= {
+        'Integer'      => TypeFactory.integer,
+        'Float'        => TypeFactory.float,
+        'Numeric'      => TypeFactory.numeric,
+
+        'String'       => TypeFactory.string,
+        'String[1]'    => TypeFactory.string(TypeFactory.range(1, :default)),
+
+        'Binary'       => TypeFactory.binary,
+
+        'Boolean'      => TypeFactory.boolean,
+        'Boolean[true]'  => TypeFactory.boolean(true),
+        'Boolean[false]' => TypeFactory.boolean(false),
+
+        'Array'        => TypeFactory.array_of_any,
+        'Array[1]'     => TypeFactory.array_of(TypeFactory.any, TypeFactory.range(1, :default)),
+
+        'Hash'         => TypeFactory.hash_of_any,
+        'Collection'   => TypeFactory.collection,
+        'Scalar'       => TypeFactory.scalar,
+
+        'Scalardata'   => TypeFactory.scalar_data,
+        'ScalarData'   => TypeFactory.scalar_data,
+
+        'Catalogentry' => TypeFactory.catalog_entry,
+        'CatalogEntry' => TypeFactory.catalog_entry,
+
+        'Undef'        => TypeFactory.undef,
+        'Default'      => TypeFactory.default,
+        'Any'          => TypeFactory.any,
+        'Type'         => TypeFactory.type_type,
+        'Callable'     => TypeFactory.all_callables,
+
+        'Semver'       => TypeFactory.sem_ver,
+        'SemVer'       => TypeFactory.sem_ver,
+
+        'Semverrange'  => TypeFactory.sem_ver_range,
+        'SemVerRange'  => TypeFactory.sem_ver_range,
+
+        'Timestamp'    => TypeFactory.timestamp,
+        'TimeStamp'    => TypeFactory.timestamp,
+
+        'Timespan'     => TypeFactory.timespan,
+        'TimeSpan'     => TypeFactory.timespan,
+
+        'Uri'          => TypeFactory.uri,
+        'URI'          => TypeFactory.uri,
+
+        'Optional[Integer]'      => TypeFactory.optional(TypeFactory.integer),
+        'Optional[String]'       => TypeFactory.optional(TypeFactory.string),
+        'Optional[String[1]]'    => TypeFactory.optional(TypeFactory.string(TypeFactory.range(1, :default))),
+        'Optional[Array]'        => TypeFactory.optional(TypeFactory.array_of_any),
+        'Optional[Hash]'         => TypeFactory.optional(TypeFactory.hash_of_any),
+
+    }.freeze
+  end
+
   # @api private
   def interpret_QualifiedReference(name_ast, context)
     name = name_ast.value
@@ -349,7 +417,7 @@ class TypeParser
         case_insensitive = last
       end
       raise_invalid_parameters_error('Enum', '1 or more', parameters.size) unless parameters.size >= 1
-      parameters.each { |p|  raise Puppet::ParseError, 'Enum parameters must be identifiers or strings' unless p.is_a?(String) }
+      parameters.each { |p| raise Puppet::ParseError, _('Enum parameters must be identifiers or strings') unless p.is_a?(String) }
       PEnumType.new(parameters, case_insensitive)
 
     when 'pattern'
@@ -585,21 +653,21 @@ class TypeParser
   end
 
   def raise_invalid_type_specification_error(ast)
-    raise Puppet::ParseError,
-      "The expression <#{original_text_of(ast)}> is not a valid type specification."
+    raise Puppet::ParseError, _("The expression <%{expression}> is not a valid type specification.") %
+        { expression: original_text_of(ast) }
   end
 
   def raise_invalid_parameters_error(type, required, given)
-    raise Puppet::ParseError,
-      "Invalid number of type parameters specified: #{type} requires #{required}, #{given} provided"
+    raise Puppet::ParseError, _("Invalid number of type parameters specified: %{type} requires %{required}, %{given} provided") %
+        { type: type, required: required, given: given }
   end
 
   def raise_unparameterized_type_error(ast)
-    raise Puppet::ParseError, "Not a parameterized type <#{original_text_of(ast)}>"
+    raise Puppet::ParseError, _("Not a parameterized type <%{type}>") % { type: original_text_of(ast) }
   end
 
   def raise_unknown_type_error(ast)
-    raise Puppet::ParseError, "Unknown type <#{original_text_of(ast)}>"
+    raise Puppet::ParseError, _("Unknown type <%{type}>") % { type: original_text_of(ast) }
   end
 
   def original_text_of(ast)

data/vendored/puppet/lib/puppet/pops/types/types.rb

@@ -1313,7 +1313,7 @@ class PCollectionType < PAnyType
   attr_reader :size_type
 
   def initialize(size_type)
-    @size_type = size_type
+    @size_type = size_type.nil? ? nil : size_type.to_size
   end
 
   def accept(visitor, guard)
@@ -1504,11 +1504,13 @@ class PStringType < PScalarDataType
   def initialize(size_type_or_value, deprecated_multi_args = EMPTY_ARRAY)
     unless deprecated_multi_args.empty?
       if Puppet[:strict] != :off
-        Puppet.warn_once('deprecations', "PStringType#initialize_multi_args", "Passing more than one argument to PStringType#initialize is deprecated")
+        #TRANSLATORS 'PStringType#initialize' is a class and method name and should not be translated
+        Puppet.warn_once('deprecations', "PStringType#initialize_multi_args",
+                         _("Passing more than one argument to PStringType#initialize is deprecated"))
       end
       size_type_or_value = deprecated_multi_args[0]
     end
-    @size_type_or_value = size_type_or_value
+    @size_type_or_value = size_type_or_value.is_a?(PIntegerType) ? size_type_or_value.to_size : size_type_or_value
   end
 
   def accept(visitor, guard)
@@ -1557,7 +1559,8 @@ class PStringType < PScalarDataType
   # @api private
   def values
     if Puppet[:strict] != :off
-      Puppet.warn_once('deprecations', "PStringType#values", "Method PStringType#values is deprecated. Use #value instead")
+      #TRANSLATORS 'PStringType#values' and '#value' are classes and method names and should not be translated
+      Puppet.warn_once('deprecations', "PStringType#values", _("Method PStringType#values is deprecated. Use #value instead"))
     end
     @value.is_a?(String) ? [@value] : EMPTY_ARRAY
   end
@@ -2704,8 +2707,9 @@ class PHashType < PCollectionType
 
   def element_type
     if Puppet[:strict] != :off
+      #TRANSLATOR 'Puppet::Pops::Types::PHashType#element_type' and '#value_type' are class and method names and should not be translated
       Puppet.warn_once('deprecations', 'Puppet::Pops::Types::PHashType#element_type',
-        'Puppet::Pops::Types::PHashType#element_type is deprecated, use #value_type instead')
+        _('Puppet::Pops::Types::PHashType#element_type is deprecated, use #value_type instead'))
     end
     @value_type
   end

data/vendored/puppet/lib/puppet/pops/validation.rb

@@ -125,9 +125,15 @@ module Validation
     # @api public
     #
     def []=(issue, level)
-      raise Puppet::DevError.new("Attempt to set validation severity for something that is not an Issue. (Got #{issue.class})") unless issue.is_a? Issues::Issue
-      raise Puppet::DevError.new("Illegal severity level: #{level} for '#{issue.issue_code}'") unless @@severity_hash[level]
-      raise Puppet::DevError.new("Attempt to demote the hard issue '#{issue.issue_code}' to #{level}") unless issue.demotable? || level == :error
+      unless issue.is_a? Issues::Issue
+        raise Puppet::DevError.new(_("Attempt to set validation severity for something that is not an Issue. (Got %{issue})") % { issue: issue.class })
+      end
+      unless @@severity_hash[level]
+        raise Puppet::DevError.new(_("Illegal severity level: %{level} for '%{issue_code}'") % { issue_code: issue.issue_code, level: level })
+      end
+      unless issue.demotable? || level == :error
+        raise Puppet::DevError.new(_("Attempt to demote the hard issue '%{issue_code}' to %{level}") % { issue_code: issue.issue_code, level: level })
+      end
       @severities[issue] = level
     end
 
@@ -145,14 +151,9 @@ module Validation
     # @api private
     #
     def assert_issue issue
-      raise Puppet::DevError.new("Attempt to get validation severity for something that is not an Issue. (Got #{issue.class})") unless issue.is_a? Issues::Issue
-    end
-
-    # Checks if the given severity level is valid.
-    # @api private
-    #
-    def assert_severity level
-      raise Puppet::DevError.new("Illegal severity level: #{option}") unless @@severity_hash[level]
+      unless issue.is_a? Issues::Issue
+        raise Puppet::DevError.new(_("Attempt to get validation severity for something that is not an Issue. (Got %{issue})") % { issue: issue.class })
+      end
     end
   end
 
@@ -203,7 +204,8 @@ module Validation
       # Accept an Error as semantic if it supports methods #file(), #line(), and #pos()
       if semantic.is_a?(StandardError)
         unless semantic.respond_to?(:file) && semantic.respond_to?(:line) && semantic.respond_to?(:pos)
-          raise Puppet::DevError("Issue #{issue.issue_code}: Cannot pass a #{semantic.class} as a semantic object when it does not support #pos(), #file() and #line()")
+          raise Puppet::DevError, _("Issue %{issue_code}: Cannot pass a %{class_name} as a semantic object when it does not support #pos(), #file() and #line()") %
+              { issue_code: issue.issue_code, class_name: semantic.class }
         end
       end
 

data/vendored/puppet/lib/puppet/property.rb

@@ -95,7 +95,8 @@ class Puppet::Property < Puppet::Parameter
     #
     def array_matching=(value)
       value = value.intern if value.is_a?(String)
-      raise ArgumentError, "Supported values for Property#array_matching are 'first' and 'all'" unless [:first, :all].include?(value)
+      #TRANSLATORS 'Property#array_matching', 'first', and 'all' should not be translated
+      raise ArgumentError, _("Supported values for Property#array_matching are 'first' and 'all'") unless [:first, :all].include?(value)
       @array_matching = value
     end
 
@@ -167,7 +168,7 @@ class Puppet::Property < Puppet::Parameter
       method = value.method.to_sym
       if value.block
         if instance_methods(false).include?(method)
-          raise ArgumentError, "Attempt to redefine method #{method} with block"
+          raise ArgumentError, _("Attempt to redefine method %{method} with block") % { method: method }
         end
         define_method(method, &value.block)
       else
@@ -211,7 +212,7 @@ class Puppet::Property < Puppet::Parameter
     rescue Puppet::Error, Puppet::DevError
       raise
     rescue => detail
-      message = "Could not convert change '#{name}' to string: #{detail}"
+      message = _("Could not convert change '%{name}' to string: %{detail}") % { name: name, detail: detail }
       Puppet.log_exception(detail, message)
       raise Puppet::DevError, message, detail.backtrace
     end
@@ -367,7 +368,9 @@ class Puppet::Property < Puppet::Parameter
     rescue
       # Certain operations may fail, but we don't want to fail the transaction if we can
       # avoid it
-      msg = "Unknown failure using insync_values? on type: #{self.resource.ref} / property: #{self.name} to compare values #{should} and #{is}"
+      #TRANSLATORS 'insync_values?' should not be translated
+      msg = _("Unknown failure using insync_values? on type: %{type} / property: %{name} to compare values %{should} and %{is}") %
+          { type: self.resource.ref, name: self.name, should: should, is: is }
       Puppet.info(msg)
 
       # Return nil, ie. unknown
@@ -489,7 +492,8 @@ class Puppet::Property < Puppet::Parameter
       rescue Puppet::Error
         raise
       rescue => detail
-        error = Puppet::ResourceError.new("Could not set '#{value}' on #{self.class.name}: #{detail}", @resource.file, @resource.line, detail)
+        error = Puppet::ResourceError.new(_("Could not set '%{value}' on %{class_name}: %{detail}") %
+                                              { value: value, class_name: self.class.name, detail: detail }, @resource.file, @resource.line, detail)
         error.set_backtrace detail.backtrace
         Puppet.log_exception(detail, error.message)
         raise error
@@ -584,7 +588,11 @@ class Puppet::Property < Puppet::Parameter
     if features = self.class.value_option(self.class.value_name(value), :required_features)
       features = Array(features)
       needed_features = features.collect { |f| f.to_s }.join(", ")
-      raise ArgumentError, "Provider #{provider.class.name} must have features '#{needed_features}' to set '#{self.class.name}' to '#{value}'" unless provider.satisfies?(features)
+      unless provider.satisfies?(features)
+        #TRANSLATORS 'Provider' refers to a Puppet provider class
+        raise ArgumentError, _("Provider %{provider} must have features '%{needed_features}' to set '%{property}' to '%{value}'") %
+            { provider: provider.class.name, needed_features: needed_features, property: self.class.name, value: value }
+      end
     end
   end