puppet 5.0.0 → 6.0.0

data/lib/puppet/pops/utils.rb

@@ -105,11 +105,11 @@ module Utils
 
   # is the name absolute (i.e. starts with ::)
   def self.is_absolute? name
-    name.start_with? "::"
+    name.start_with? "::".freeze
   end
 
   def self.name_to_segments name
-    name.split("::")
+    name.split("::".freeze)
   end
 
   def self.relativize_name name

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

@@ -15,19 +15,25 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   attr_reader :acceptor
   attr_reader :migration_checker
 
+  def self.check_visitor
+    # Class instance variable rather than Class variable because methods visited
+    # may be overridden in subclass
+    @check_visitor ||= Visitor.new(nil, 'check', 0, 0)
+  end
+
   # Initializes the validator with a diagnostics producer. This object must respond to
   # `:will_accept?` and `:accept`.
   #
   def initialize(diagnostics_producer)
     super()
-    @@check_visitor       ||= Visitor.new(nil, "check", 0, 0)
     @@rvalue_visitor      ||= Visitor.new(nil, "rvalue", 0, 0)
     @@hostname_visitor    ||= Visitor.new(nil, "hostname", 1, 2)
     @@assignment_visitor  ||= Visitor.new(nil, "assign", 0, 1)
     @@query_visitor       ||= Visitor.new(nil, "query", 0, 0)
     @@relation_visitor    ||= Visitor.new(nil, "relation", 0, 0)
-    @@idem_visitor        ||= Visitor.new(self, "idem", 0, 0)
+    @@idem_visitor        ||= Visitor.new(nil, "idem", 0, 0)
 
+    @check_visitor = self.class.check_visitor
     @acceptor = diagnostics_producer
 
     # Use null migration checker unless given in context
@@ -42,6 +48,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     # tree iterate the model, and call check for each element
     @path = []
     check(model)
+    internal_check_top_construct_in_module(model)
     model._pcore_all_contents(@path) { |element| check(element) }
   end
 
@@ -51,7 +58,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
 
   # Performs regular validity check
   def check(o)
-    @@check_visitor.visit_this_0(self, o)
+    @check_visitor.visit_this_0(self, o)
   end
 
   # Performs check if this is a vaid hostname expression
@@ -286,8 +293,8 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   def check_CapabilityMapping(o)
     ok =
     case o.component
-    when Model::QualifiedName
-      name = o.component.value
+    when Model::QualifiedReference
+      name = o.component.cased_value
       acceptor.accept(Issues::ILLEGAL_CLASSREF, o.component, {:name=>name}) unless name =~ Patterns::CLASSREF_EXT
       true
     when Model::AccessExpression
@@ -380,9 +387,7 @@ class Checker4_0 < Evaluator::LiteralEvaluator
   }
 
   FUTURE_RESERVED_WORDS = {
-    'application' => true,
-    'produces' => true,
-    'consumes' => true
+    'plan' => true
   }
 
   # for 'class', 'define', and function
@@ -391,6 +396,8 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     if o.name !~ Patterns::CLASSREF_DECL
       acceptor.accept(Issues::ILLEGAL_DEFINITION_NAME, o, {:name=>o.name})
     end
+
+    internal_check_file_namespace(o)
     internal_check_reserved_type_name(o, o.name)
     internal_check_future_reserved_word(o, o.name)
   end
@@ -526,6 +533,126 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     end
   end
 
+  NO_NAMESPACE = :no_namespace
+  NO_PATH = :no_path
+  BAD_MODULE_FILE = :bad_module_file
+
+  def internal_check_file_namespace(o)
+    file = o.locator.file
+    return if file.nil? || file == '' #e.g. puppet apply -e '...'
+
+    file_namespace = namespace_for_file(file)
+    return if file_namespace == NO_NAMESPACE
+
+    # Downcasing here because check is case-insensitive
+    if file_namespace == BAD_MODULE_FILE || !o.name.downcase.start_with?(file_namespace)
+      acceptor.accept(Issues::ILLEGAL_DEFINITION_LOCATION, o, {:name => o.name, :file => file})
+    end
+  end
+
+  def internal_check_top_construct_in_module(prog)
+    return unless prog.is_a?(Model::Program) && !prog.body.nil?
+
+    #Check that this is a module autoloaded file
+    file = prog.locator.file
+    return if file.nil?
+    return if namespace_for_file(file) == NO_NAMESPACE
+
+    body = prog.body
+    if(body.is_a?(Model::BlockExpression))
+      body.statements.each { |s| acceptor.accept(Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION, s) unless valid_top_construct?(s) }
+    else
+      acceptor.accept(Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION, body) unless valid_top_construct?(body)
+    end
+  end
+
+  def valid_top_construct?(o)
+    o.is_a?(Model::Definition) && !o.is_a?(Model::NodeDefinition)
+  end
+
+  # @api private
+  class Puppet::Util::FileNamespaceAdapter < Puppet::Pops::Adaptable::Adapter
+    attr_accessor :file_to_namespace
+  end
+
+  def namespace_for_file(file)
+    env = Puppet.lookup(:current_environment)
+    return NO_NAMESPACE if env.nil?
+
+    Puppet::Util::FileNamespaceAdapter.adapt(env) do |adapter|
+      adapter.file_to_namespace ||= {}
+
+      file_namespace = adapter.file_to_namespace[file]
+      return file_namespace unless file_namespace.nil? # No cache entry, so we do the calculation
+
+      path = Pathname.new(file)
+
+      return adapter.file_to_namespace[file] = NO_NAMESPACE if path.extname != ".pp"
+
+      path = path.expand_path
+
+      return adapter.file_to_namespace[file] = NO_NAMESPACE if initial_manifest?(path, env.manifest)
+
+      #All auto-loaded files from modules come from a module search path dir
+      relative_path = get_module_relative_path(path, env.full_modulepath)
+
+      return adapter.file_to_namespace[file] = NO_NAMESPACE if relative_path == NO_PATH
+
+      #If a file comes from a module, but isn't in the right place, always error
+      names = dir_to_names(relative_path)
+
+      return adapter.file_to_namespace[file] = (names == BAD_MODULE_FILE ? BAD_MODULE_FILE : names.join("::").freeze)
+    end
+  end
+
+  def initial_manifest?(path, manifest_setting)
+    return false if manifest_setting.nil? || manifest_setting == :no_manifest
+
+    string_path = path.to_s
+
+    string_path == manifest_setting || string_path.start_with?(manifest_setting)
+  end
+
+  def get_module_relative_path(file_path, modulepath_directories)
+    clean_file = file_path.cleanpath
+    parent_path = modulepath_directories.find { |path_dir| is_parent_dir_of(path_dir, clean_file) }
+    return NO_PATH if parent_path.nil?
+
+    file_path.relative_path_from(Pathname.new(parent_path))
+  end
+
+  def is_parent_dir_of(parent_dir, child_dir)
+    parent_dir_path = Pathname.new(parent_dir)
+    clean_parent = parent_dir_path.cleanpath
+
+    return child_dir.to_s.start_with?(clean_parent.to_s)
+  end
+
+  def dir_to_names(relative_path)
+    # Downcasing here because check is case-insensitive
+    path_components = relative_path.to_s.downcase.split(File::SEPARATOR)
+
+    # Example definition dir: manifests in this path:
+    # <module name>/manifests/<module subdir>/<classfile>.pp
+    dir = path_components[1]
+
+    # How can we get this result?
+    # If it is not an initial manifest, it must come from a module,
+    # and from the manifests dir there.  This may never get used...
+    return BAD_MODULE_FILE unless dir == 'manifests' || dir == 'functions' || dir == 'types' || dir == 'plans'
+
+    names = path_components[2 .. -2] # Directories inside module
+    names.unshift(path_components[0]) # Name of the module itself
+
+    # Do not include name of module init file at top level of module
+    # e.g. <module name>/manifests/init.pp
+    filename = path_components[-1]
+    if !(path_components.length == 3 && filename == 'init.pp')
+      names.push(filename[0 .. -4]) # Remove .pp from filename
+    end
+
+    names
+  end
 
   RESERVED_PARAMETERS = {
     'name' => true,
@@ -904,6 +1031,10 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     true
   end
 
+  def idem_MatchExpression(o)
+    false # can have side effect of setting $n match variables
+  end
+
   def idem_RelationshipExpression(o)
     # Always side effect
     false
@@ -955,6 +1086,12 @@ class Checker4_0 < Evaluator::LiteralEvaluator
     true
   end
 
+  # An apply expression exists purely for the side effect of applying a
+  # catalog somewhere, so it always has side effects
+  def idem_ApplyExpression(o)
+    false
+  end
+
   def idem_IfExpression(o)
     [o.test, o.then_expr, o.else_expr].all? {|e| idem(e) }
   end

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

@@ -0,0 +1,101 @@
+module Puppet::Pops
+module Validation
+
+# Validator that limits the set of allowed expressions to not include catalog related operations
+# @api private
+class TasksChecker < Checker4_0
+  def in_ApplyExpression?
+    top = container(0)
+    step = -1
+    until container(step) == top do
+      return true if container(step).is_a? Puppet::Pops::Model::ApplyBlockExpression
+      step -= 1
+    end
+  end
+
+  def check_Application(o)
+    illegalTasksExpression(o)
+  end
+
+  def check_CapabilityMapping(o)
+    illegalTasksExpression(o)
+  end
+
+  def check_CollectExpression(o)
+    # Only virtual resource queries are allowed in apply blocks, not exported
+    # resource queries
+    if in_ApplyExpression?
+      if o.query.is_a?(Puppet::Pops::Model::VirtualQuery)
+        super(o)
+      else
+        acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, o, {:klass => o})
+      end
+    else
+      illegalTasksExpression(o)
+    end
+  end
+
+  def check_HostClassDefinition(o)
+    illegalTasksExpression(o)
+  end
+
+  def check_NodeDefinition(o)
+    illegalTasksExpression(o)
+  end
+
+  def check_RelationshipExpression(o)
+    if in_ApplyExpression?
+      super(o)
+    else
+      illegalTasksExpression(o)
+    end
+  end
+
+  def check_ResourceDefaultsExpression(o)
+    if in_ApplyExpression?
+      super(o)
+    else
+      illegalTasksExpression(o)
+    end
+  end
+
+  def check_ResourceExpression(o)
+    if in_ApplyExpression?
+      super(o)
+    else
+      illegalTasksExpression(o)
+    end
+  end
+
+  def check_ResourceOverrideExpression(o)
+    if in_ApplyExpression?
+      super(o)
+    else
+      illegalTasksExpression(o)
+    end
+  end
+
+  def check_ResourceTypeDefinition(o)
+    illegalTasksExpression(o)
+  end
+
+  def check_SiteDefinition(o)
+    illegalTasksExpression(o)
+  end
+
+  def check_ApplyExpression(o)
+    if in_ApplyExpression?
+      acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_COMPILING, o, {:klass => o})
+    end
+  end
+
+  def illegalTasksExpression(o)
+    acceptor.accept(Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING, o, {:klass => o})
+  end
+
+  def resource_without_title?(o)
+    false
+  end
+end
+end
+end

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

@@ -7,7 +7,12 @@ class ValidatorFactory_4_0 < Factory
 
   # Produces the checker to use
   def checker diagnostic_producer
-    Checker4_0.new(diagnostic_producer)
+    if Puppet[:tasks]
+      require_relative 'tasks_checker'
+      TasksChecker.new(diagnostic_producer)
+    else
+      Checker4_0.new(diagnostic_producer)
+    end
   end
 
   # Produces the label provider to use
@@ -22,15 +27,15 @@ class ValidatorFactory_4_0 < Factory
     # Configure each issue that should **not** be an error
     #
     # Validate as per the current runtime configuration
-    p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
-    p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
+    p[Issues::RT_NO_STORECONFIGS_EXPORT]      = Puppet[:storeconfigs] ? :ignore : :warning
+    p[Issues::RT_NO_STORECONFIGS]             = Puppet[:storeconfigs] ? :ignore : :warning
 
-    p[Issues::FUTURE_RESERVED_WORD]          = :deprecation
+    p[Issues::FUTURE_RESERVED_WORD]           = :deprecation
 
-    p[Issues::DUPLICATE_KEY]                 = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
-    p[Issues::NAME_WITH_HYPHEN]              = :error
-    p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
-    p[Issues::CLASS_NOT_VIRTUALIZABLE]      = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+    p[Issues::DUPLICATE_KEY]                  = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
+    p[Issues::NAME_WITH_HYPHEN]               = :error
+    p[Issues::EMPTY_RESOURCE_SPECIALIZATION]  = :ignore
+    p[Issues::CLASS_NOT_VIRTUALIZABLE]        = Puppet[:strict] == :off ? :warning : Puppet[:strict]
     p
   end
 end

data/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/lib/puppet/pops.rb

@@ -70,6 +70,7 @@ module Puppet
       require 'puppet/pops/evaluator/epp_evaluator'
       require 'puppet/pops/evaluator/collector_transformer'
       require 'puppet/pops/evaluator/puppet_proc'
+      require 'puppet/pops/evaluator/deferred_resolver'
       module Collectors
         require 'puppet/pops/evaluator/collectors/abstract_collector'
         require 'puppet/pops/evaluator/collectors/fixed_set_collector'
@@ -113,8 +114,8 @@ module Puppet
   end
 
   require 'puppet/parser/ast/pops_bridge'
-  require 'puppet/bindings'
   require 'puppet/functions'
+  require 'puppet/datatypes'
 
   Puppet::Pops::Model.register_pcore_types
 end

data/lib/puppet/property/ensure.rb

@@ -59,7 +59,7 @@ class Puppet::Property::Ensure < Puppet::Property
     rescue Puppet::Error, Puppet::DevError
       raise
     rescue => detail
-      raise Puppet::DevError, "Could not convert change #{self.name} to string: #{detail}", detail.backtrace
+      raise Puppet::DevError, _("Could not convert change %{name} to string: %{detail}") % { name: self.name, detail: detail }, detail.backtrace
     end
   end
 
@@ -82,7 +82,7 @@ class Puppet::Property::Ensure < Puppet::Property
     elsif @resource.respond_to?(:exists?)
       result = @resource.exists?
     else
-      raise Puppet::DevError, "No ability to determine if #{@resource.class.name} exists"
+      raise Puppet::DevError, _("No ability to determine if %{name} exists") % { name: @resource.class.name }
     end
     if result
       return :present

data/lib/puppet/property/keyvalue.rb

@@ -12,9 +12,20 @@ module Puppet
     # @todo The node with an important message is not very clear.
     #
     class KeyValue < Property
+      class << self
+        # This is a class-level variable that child properties can override
+        # if they wish.
+        attr_accessor :log_only_changed_or_new_keys
+      end
+
+      self.log_only_changed_or_new_keys = false
 
       def hash_to_key_value_s(hash)
-        hash.select { |k,v| true }.map { |pair| pair.join(separator) }.join(delimiter)
+        if self.class.log_only_changed_or_new_keys
+          hash = hash.select { |k, _| @changed_or_new_keys.include?(k) }
+        end
+
+        hash.map { |*pair| pair.join(separator) }.join(delimiter)
       end
 
       def should_to_s(should_value)
@@ -33,11 +44,19 @@ module Puppet
         @resource[membership] == :inclusive
       end
 
-      def hashify(key_value_array)
-        #turns string array into a hash
-        key_value_array.inject({}) do |hash, key_value|
+      def hashify_should
+        # Puppet casts all should values to arrays. Thus, if the user
+        # passed in a hash for our property's should value, the should_value
+        # parameter will be a single element array so we just extract our value
+        # directly.
+        if ! @should.empty? && @should.first.is_a?(Hash)
+          return @should.first
+        end
+
+        # Here, should is an array of key/value pairs.
+        @should.inject({}) do |hash, key_value|
           tmp = key_value.split(separator)
-          hash[tmp[0].intern] = tmp[1]
+          hash[tmp[0].strip.intern] = tmp[1]
           hash
         end
       end
@@ -53,11 +72,24 @@ module Puppet
       def should
         return nil unless @should
 
-        members = hashify(@should)
+        members = hashify_should
         current = process_current_hash(retrieve)
 
         #shared keys will get overwritten by members
-        current.merge(members)
+        should_value = current.merge(members)
+
+        # Figure out the keys that will actually change in our Puppet run.
+        # This lets us reduce the verbosity of Puppet's logging for instances
+        # of this class when we want to.
+        #
+        # NOTE: We use ||= here because we only need to compute the
+        # changed_or_new_keys once (since this property will only be synced once).
+        #
+        @changed_or_new_keys ||= should_value.keys.select do |key|
+          ! current.key?(key) || current[key] != should_value[key]
+        end
+
+        should_value
       end
 
       # @return [String] Returns a default separator of "="
@@ -84,12 +116,42 @@ module Puppet
 
       # Returns true if there is no _is_ value, else returns if _is_ is equal to _should_ using == as comparison.
       # @return [Boolean] whether the property is in sync or not.
-      #
       def insync?(is)
         return true unless is
 
         (is == self.should)
       end
+
+      # We only accept an array of key/value pairs (strings), a single
+      # key/value pair (string) or a Hash as valid values for our property.
+      # Note that for an array property value, the 'value' passed into the
+      # block corresponds to the array element.
+      validate do |value|
+        unless value.is_a?(String) || value.is_a?(Hash)
+          raise ArgumentError, _("The %{name} property must be specified as a hash or an array of key/value pairs (strings)!") % { name: name }
+        end
+
+        next if value.is_a?(Hash)
+
+        unless value.include?("#{separator}")
+          raise ArgumentError, _("Key/value pairs must be separated by '%{separator}'") % {separator: separator}
+        end
+      end
+
+      # The validate step ensures that our passed-in value is
+      # either a String or a Hash. If our value's a string,
+      # then nothing else needs to be done. Otherwise, we need
+      # to stringify the hash's keys and values to match our
+      # internal representation of the property's value.
+      munge do |value|
+        next value if value.is_a?(String)
+
+        munged_value = value.to_a.map! do |hash_key, hash_value|
+          [hash_key.to_s.strip.to_sym, hash_value.to_s]
+        end
+
+        Hash[munged_value]
+      end
     end
   end
 end

data/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
@@ -364,10 +365,12 @@ class Puppet::Property < Puppet::Parameter
     begin
       @should = should
       insync?(is)
-    rescue => detail
+    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