puppet 5.3.3 → 5.3.4

data/lib/puppet/parser/scope.rb

@@ -378,7 +378,7 @@ class Puppet::Parser::Scope
     if compiler.is_a? Puppet::Parser::Compiler
       @compiler = compiler
     else
-      raise Puppet::DevError, "you must pass a compiler instance to a new scope object"
+      raise Puppet::DevError, _("you must pass a compiler instance to a new scope object")
     end
 
     set_options(options)
@@ -611,6 +611,7 @@ class Puppet::Parser::Scope
       begin
         qs = qualified_scope(class_name)
         unless qs.nil?
+          return qs.get_local_variable(leaf_name) if qs.has_local_variable?(leaf_name)
           iscope = qs.inherited_scope
           return lookup_qualified_variable("#{iscope.source.name}::#{leaf_name}", options) unless iscope.nil?
         end
@@ -623,15 +624,23 @@ class Puppet::Parser::Scope
     return handle_not_found('', fqn, options)
   end
 
+  # @api private
+  def has_local_variable?(name)
+    @ephemeral.last.include?(name)
+  end
+
+  # @api private
+  def get_local_variable(name)
+    @ephemeral.last[name]
+  end
+
   def handle_not_found(class_name, variable_name, position, reason = nil)
     unless Puppet[:strict_variables]
       # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found
       location = if position[:lineproc]
-                   " at #{position[:lineproc].call}"
-                 elsif position[:file] && position[:line]
-                   " at #{position[:file]}:#{position[:line]}"
+                   Puppet::Util::Errors.error_location_with_space(nil, position[:lineproc].call)
                  else
-                   ""
+                   Puppet::Util::Errors.error_location_with_space(position[:file], position[:line])
                  end
       variable_not_found("#{class_name}::#{variable_name}", "#{reason}#{location}")
       return nil
@@ -751,7 +760,7 @@ class Puppet::Parser::Scope
       raise Puppet::ParseError.new(_("Cannot assign to a numeric match result variable '$%{name}'") % { name: name }) # unless options[:ephemeral]
     end
     unless name.is_a? String
-      raise Puppet::ParseError, _("Scope variable name %{value0} is a %{value1}, not a string") % { value0: name.inspect, value1: name.class }
+      raise Puppet::ParseError, _("Scope variable name %{name} is a %{class_type}, not a string") % { name: name.inspect, class_type: name.class }
     end
 
     # Check for reserved variable names
@@ -986,17 +995,17 @@ class Puppet::Parser::Scope
 
   # @api private
   def find_resource_type(type)
-    raise Puppet::DevError, "Scope#find_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
+    raise Puppet::DevError, _("Scope#find_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead")
   end
 
   # @api private
   def find_builtin_resource_type(type)
-    raise Puppet::DevError, "Scope#find_builtin_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
+    raise Puppet::DevError, _("Scope#find_builtin_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead")
   end
 
   # @api private
   def find_defined_resource_type(type)
-    raise Puppet::DevError, "Scope#find_defined_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
+    raise Puppet::DevError, _("Scope#find_defined_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead")
   end
 
 
@@ -1010,14 +1019,14 @@ class Puppet::Parser::Scope
     if respond_to? method
       send(method, *args)
     else
-      raise Puppet::DevError, "Function #{name} not defined despite being loaded!"
+      raise Puppet::DevError, _("Function %{name} not defined despite being loaded!") % { name: name }
     end
   end
 
   # To be removed when enough time has passed after puppet 5.0.0
   # @api private
   def resolve_type_and_titles(type, titles)
-    raise Puppet::DevError, "Scope#resolve_type_and_title() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
+    raise Puppet::DevError, _("Scope#resolve_type_and_title() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead")
   end
 
   # Transforms references to classes to the form suitable for

data/lib/puppet/parser/templatewrapper.rb

@@ -62,7 +62,7 @@ class Puppet::Parser::TemplateWrapper
   # @api private
   def file=(filename)
     unless @__file__ = Puppet::Parser::Files.find_template(filename, scope.compiler.environment)
-      raise Puppet::ParseError, "Could not find template '#{filename}'"
+      raise Puppet::ParseError, _("Could not find template '%{filename}'") % { filename: filename }
     end
   end
 
@@ -78,7 +78,8 @@ class Puppet::Parser::TemplateWrapper
     # Expose all the variables in our scope as instance variables of the
     # current object, making it possible to access them without conflict
     # to the regular methods.
-    benchmark(:debug, _("Bound template variables for %{template_source}") % { template_source: template_source }) do
+    escaped_template_source = template_source.gsub(/%/, '%%')
+    benchmark(:debug, _("Bound template variables for %{template_source} in %%{seconds} seconds") % { template_source: escaped_template_source }) do
       scope.to_hash.each do |name, value|
         realname = name.gsub(/[^\w]/, "_")
         instance_variable_set("@#{realname}", value)
@@ -86,7 +87,7 @@ class Puppet::Parser::TemplateWrapper
     end
 
     result = nil
-    benchmark(:debug, _("Interpolated template %{template_source}") % { template_source: template_source }) do
+    benchmark(:debug, _("Interpolated template %{template_source} in %%{seconds} seconds") % { template_source: escaped_template_source }) do
       template = ERB.new(string, 0, "-")
       template.filename = @__file__
       result = template.result(binding)

data/lib/puppet/pops/evaluator/collector_transformer.rb

@@ -10,7 +10,8 @@ class CollectorTransformer
   end
 
   def transform(o, scope)
-    raise ArgumentError, "Expected CollectExpression" unless o.is_a? Model::CollectExpression
+    #TRANSLATORS 'CollectExpression' is a class name and should not be translated
+    raise ArgumentError, _("Expected CollectExpression") unless o.is_a? Model::CollectExpression
 
     raise "LHS is not a type" unless o.type_expr.is_a? Model::QualifiedReference
     type = o.type_expr.value().downcase()

data/lib/puppet/pops/evaluator/collectors/abstract_collector.rb

@@ -27,7 +27,7 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
     @scope = scope
 
     if !(overrides.nil? || overrides[:parameters])
-      raise ArgumentError, "Exported resource try to override without parameters"
+      raise ArgumentError, _("Exported resource try to override without parameters")
     end
 
     @overrides = overrides

data/lib/puppet/pops/evaluator/epp_evaluator.rb

@@ -4,7 +4,9 @@ class Puppet::Pops::Evaluator::EppEvaluator
 
   def self.inline_epp(scope, epp_source, template_args = nil)
     unless epp_source.is_a?(String)
-      raise ArgumentError, "inline_epp(): the first argument must be a String with the epp source text, got a #{epp_source.class}"
+      #TRANSLATORS 'inline_epp()' is a method name and 'epp' refers to 'Embedded Puppet (EPP) template' and should not be translated
+      raise ArgumentError, _("inline_epp(): the first argument must be a String with the epp source text, got a %{class_name}") %
+          { class_name: epp_source.class }
     end
 
     # Parse and validate the source
@@ -12,7 +14,8 @@ class Puppet::Pops::Evaluator::EppEvaluator
     begin
       result = parser.parse_string(epp_source, 'inlined-epp-text')
     rescue Puppet::ParseError => e
-      raise ArgumentError, "inline_epp(): Invalid EPP: #{e.message}"
+      #TRANSLATORS 'inline_epp()' is a method name and 'EPP' refers to 'Embedded Puppet (EPP) template' and should not be translated
+      raise ArgumentError, _("inline_epp(): Invalid EPP: %{detail}") % { detail: e.message }
     end
 
     # Evaluate (and check template_args)
@@ -21,7 +24,8 @@ class Puppet::Pops::Evaluator::EppEvaluator
 
   def self.epp(scope, file, env_name, template_args = nil)
     unless file.is_a?(String)
-      raise ArgumentError, "epp(): the first argument must be a String with the filename, got a #{file.class}"
+      #TRANSLATORS 'epp()' is a method name and should not be translated
+      raise ArgumentError, _("epp(): the first argument must be a String with the filename, got a %{class_name}") % { class_name: file.class }
     end
 
     unless Puppet::FileSystem.exist?(file)
@@ -41,7 +45,8 @@ class Puppet::Pops::Evaluator::EppEvaluator
     begin
       result = parser.parse_file(template_file)
     rescue Puppet::ParseError => e
-      raise ArgumentError, "epp(): Invalid EPP: #{e.message}"
+      #TRANSLATORS 'epp()' is a method name and 'EPP' refers to 'Embedded Puppet (EPP) template' and should not be translated
+      raise ArgumentError, _("epp(): Invalid EPP: %{detail}") % { detail: e.message }
     end
 
     # Evaluate (and check template_args)
@@ -55,13 +60,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
 
     body = parse_result.body
     unless body.is_a?(Puppet::Pops::Model::LambdaExpression)
-      raise ArgumentError, "#{func_name}(): the parser did not produce a LambdaExpression, got '#{body.class}'"
+      #TRANSLATORS 'LambdaExpression' is a class name and should not be translated
+      raise ArgumentError, _("%{function_name}(): the parser did not produce a LambdaExpression, got '%{class_name}'") %
+          { function_name: func_name, class_name: body.class }
     end
     unless body.body.is_a?(Puppet::Pops::Model::EppExpression)
-      raise ArgumentError, "#{func_name}(): the parser did not produce an EppExpression, got '#{body.body.class}'"
+      #TRANSLATORS 'EppExpression' is a class name and should not be translated
+      raise ArgumentError, _("%{function_name}(): the parser did not produce an EppExpression, got '%{class_name}'") %
+          { function_name: func_name, class_name: body.body.class }
     end
     unless parse_result.definitions.empty?
-      raise ArgumentError, "#{func_name}(): The EPP template contains illegal expressions (definitions)"
+      #TRANSLATORS 'EPP' refers to 'Embedded Puppet (EPP) template'
+      raise ArgumentError, _("%{function_name}(): The EPP template contains illegal expressions (definitions)") %
+          { function_name: func_name }
     end
 
     parameters_specified = body.body.parameters_specified
@@ -86,7 +97,9 @@ class Puppet::Pops::Evaluator::EppEvaluator
       [{}, false]
     else
       unless template_args.is_a?(Hash)
-        raise ArgumentError, "#{func_name}(): the template_args must be a Hash, got a #{template_args.class}"
+        #TRANSLATORS 'template_args' is a variable name and should not be translated
+        raise ArgumentError, _("%{function_name}(): the template_args must be a Hash, got a %{class_name}") %
+            { function_name: func_name, class_name: template_args.class }
       end
       [template_args, true]
     end

data/lib/puppet/pops/evaluator/evaluator_impl.rb

@@ -724,7 +724,8 @@ class EvaluatorImpl
       #evaluate(o.body, scope)
     rescue Puppet::Pops::Evaluator::PuppetStopIteration => ex
       # breaking out of a file level program is not allowed
-      raise Puppet::ParseError.new("break() from context where this is illegal", ex.file, ex.line)
+      #TRANSLATOR break() is a method that should not be translated
+      raise Puppet::ParseError.new(_("break() from context where this is illegal"), ex.file, ex.line)
     end
   end
 

data/lib/puppet/pops/evaluator/external_syntax_support.rb

@@ -19,7 +19,7 @@ module Puppet::Pops::Evaluator::ExternalSyntaxSupport
     if acceptor.error_count > 0
       checker_message = "Invalid produced text having syntax: '#{syntax}'."
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, :message => checker_message)
-      raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
+      raise ArgumentError, _("Internal Error: Configuration of runtime error handling wrong: should have raised exception")
     end
   end
 

data/lib/puppet/pops/evaluator/runtime3_converter.rb

@@ -143,7 +143,9 @@ class Runtime3Converter
           [type_name.nil? ? nil : type_name.sub(/^::/, '').downcase, title.nil? ? '' : title]
         end
       else
-        raise ArgumentError, "Cannot split the type #{catalog_type.class}, it represents neither a PClassType, nor a PResourceType."
+        #TRANSLATORS 'PClassType' and 'PResourceType' are Puppet types and should not be translated
+        raise ArgumentError, _("Cannot split the type %{class_name}, it represents neither a PClassType, nor a PResourceType.") %
+            { class_name: catalog_type.class }
     end
   end
 

data/lib/puppet/pops/evaluator/runtime3_resource_support.rb

@@ -28,7 +28,7 @@ module Runtime3ResourceSupport
     # from the raised exception. (It may be good enough).
     unless resolved_type
       # TODO: do this the right way
-      raise ArgumentError, "Unknown resource type: '#{type_name}'"
+      raise ArgumentError, _("Unknown resource type: '%{type}'") % { type: type_name }
     end
 
     # Build a resource for each title - use the resolved *type* as opposed to a reference

data/lib/puppet/pops/evaluator/runtime3_support.rb

@@ -20,7 +20,7 @@ module Runtime3Support
   def fail(issue, semantic, options={}, except=nil)
     optionally_fail(issue, semantic, options, except)
     # an error should have been raised since fail always fails
-    raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
+    raise ArgumentError, _("Internal Error: Configuration of runtime error handling wrong: should have raised exception")
   end
 
   # Optionally (based on severity) Fails the evaluation of _semantic_ with a given issue
@@ -150,7 +150,7 @@ module Runtime3Support
     # case - it is just wrong, the error should be reported by the caller who knows in more detail where it
     # is in the source.
     #
-    raise ArgumentError, "Internal error - attempt to create a local scope without a hash" unless hash.is_a?(Hash)
+    raise ArgumentError, _("Internal error - attempt to create a local scope without a hash") unless hash.is_a?(Hash)
     scope.ephemeral_from(hash)
   end
 
@@ -288,7 +288,7 @@ module Runtime3Support
     end
 
     # Call via 3x API if function exists there
-    raise ArgumentError, "Unknown function '#{name}'" unless Puppet::Parser::Functions.function(name)
+    raise ArgumentError, _("Unknown function '%{name}'") % { name: name } unless Puppet::Parser::Functions.function(name)
 
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
@@ -526,7 +526,7 @@ module Runtime3Support
         :exception_class => Puppet::PreformattedError
       })
       if errors?
-        raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
+        raise ArgumentError, _("Internal Error: Configuration of runtime error handling wrong: should have raised exception")
       end
     end
   end

data/lib/puppet/pops/functions/dispatch.rb

@@ -79,7 +79,7 @@ class Dispatch < Evaluator::CallableSignature
               # currently only supports :scope injection
               scope
             else
-              raise_error ArgumentError, "Unknown injection #{injection_data[3]}"
+              raise_error ArgumentError, _("Unknown injection %{detail}") % { detail: injection_data[3] }
             end
         else
           # Careful so no new nil arguments are added since they would override default

data/lib/puppet/pops/functions/function.rb

@@ -108,7 +108,10 @@ class Puppet::Pops::Functions::Function
   def internal_call_function(scope, function_name, args, &block)
 
     the_loader = loader
-    raise ArgumentError, "Function #{self.class.name}(): cannot call function '#{function_name}' - no loader specified" unless the_loader
+    unless the_loader
+      raise ArgumentError, _("Function %{class_name}(): cannot call function '%{function_name}' - no loader specified") %
+          { class_name: self.class.name, function_name: function_name }
+    end
 
     func = the_loader.load(:function, function_name)
     if func
@@ -121,7 +124,10 @@ class Puppet::Pops::Functions::Function
     # about where in a puppet manifest this error originates. (Such information is not available here).
     loader_scope = closure_scope
     func_3x = Puppet::Parser::Functions.function(function_name, loader_scope.environment) if loader_scope.is_a?(Puppet::Parser::Scope)
-    raise ArgumentError, "Function #{self.class.name}(): Unknown function: '#{function_name}'" unless func_3x
+    unless func_3x
+      raise ArgumentError, _("Function %{class_name}(): Unknown function: '%{function_name}'") %
+          { class_name: self.class.name, function_name: function_name }
+    end
 
     # Call via 3x API
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.

data/lib/puppet/pops/issue_reporter.rb

@@ -68,8 +68,13 @@ class IssueReporter
         emitted += 1
         break if emitted >= max_errors
       end
-      warnings_message = (emit_warnings && warnings.size > 0) ? ", and #{warnings.size} warnings" : ""
-      giving_up_message = "Language validation logged #{errors.size} errors#{warnings_message}. Giving up"
+      giving_up_message = if (emit_warnings && warnings.size > 0)
+                            _("Language validation logged %{error_count} errors, and %{warning_count} warnings. Giving up") %
+                                { error_count: errors.size, warning_count: warnings.size }
+                          else
+                            _("Language validation logged %{error_count} errors. Giving up") %
+                                { error_count: errors.size }
+                          end
       exception = emit_exception.new(giving_up_message)
       exception.file = errors[0].file
       raise exception

data/lib/puppet/pops/issues.rb

@@ -774,9 +774,12 @@ module Issues
   end
 
   HIERA_BACKEND_MULTIPLY_DEFINED = hard_issue :HIERA_BACKEND_MULTIPLY_DEFINED, :name, :first_line do
-    msg = _("Backend '%{name}' is defined more than once") % { name: name }
+    msg = _("Backend '%{name}' is defined more than once.") % { name: name }
     fl = first_line
-    fl ? _("%{msg}. First defined at line %{line}") % { msg: msg, line: fl } : msg
+    if fl
+      msg += ' ' + _("First defined at %{error_location}") % { error_location: Puppet::Util::Errors.error_location(nil, fl) }
+    end
+    msg
   end
 
   HIERA_NO_PROVIDER_FOR_BACKEND = hard_issue :HIERA_NO_PROVIDER_FOR_BACKEND, :name do
@@ -784,9 +787,12 @@ module Issues
   end
 
   HIERA_HIERARCHY_NAME_MULTIPLY_DEFINED = hard_issue :HIERA_HIERARCHY_NAME_MULTIPLY_DEFINED, :name, :first_line do
-    msg = _("Hierarchy name '%{name}' defined more than once") % { name: name }
+    msg = _("Hierarchy name '%{name}' defined more than once.") % { name: name }
     fl = first_line
-    fl ? _("%{msg}. First defined at line %{line}") % { msg: msg, line: fl } : msg
+    if fl
+      msg += ' ' + _("First defined at %{error_location}") % { error_location: Puppet::Util::Errors.error_location(nil, fl) }
+    end
+    msg
   end
 
   HIERA_V3_BACKEND_NOT_GLOBAL = hard_issue :HIERA_V3_BACKEND_NOT_GLOBAL do

data/lib/puppet/pops/label_provider.rb

@@ -73,7 +73,7 @@ module Puppet::Pops::LabelProvider
     end
 
     if char == ""
-      raise Puppet::DevError, "<#{string}> does not appear to contain a word"
+      raise Puppet::DevError, _("<%{string}> does not appear to contain a word") % { string: string }
     end
 
     char

data/lib/puppet/pops/loader/module_loaders.rb

@@ -98,7 +98,8 @@ module ModuleLoaders
       @loaders = loaders
       @loadables = loadables
       unless (loadables - LOADABLE_KINDS).empty?
-        raise ArgumentError, 'given loadables are not of supported loadable kind'
+        #TRANSLATORS 'loadables' is a variable containing loadable modules and should not be translated
+        raise ArgumentError, _('given loadables are not of supported loadable kind')
       end
       loaders.add_loader_by_name(self)
     end
@@ -149,7 +150,9 @@ module ModuleLoaders
               return set_entry(typed_name, value, origin)
             end
 
-            raise ArgumentError,"The code loaded from #{origin} does not define the TypeSet '#{module_name.capitalize}'"
+            #TRANSLATORS 'TypeSet' should not be translated
+            raise ArgumentError, _("The code loaded from %{origin} does not define the TypeSet '%{module_name}'") %
+                { origin: origin, module_name: module_name.capitalize }
           end
         else
           # anything else cannot possibly be in this module

data/lib/puppet/pops/loader/static_loader.rb

@@ -6,7 +6,7 @@ module Loader
 class StaticLoader < Loader
 
   BUILTIN_TYPE_NAMES = %w{
-      Auegas
+      Augeas
       Component
       Computer
       Cron

data/lib/puppet/pops/loaders.rb

@@ -152,7 +152,7 @@ class Loaders
   # @api private
   def self.loaders
     loaders = Puppet.lookup(:loaders) { nil }
-    raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing" if loaders.nil?
+    raise Puppet::ParseError, _("Internal Error: Puppet Context ':loaders' missing") if loaders.nil?
     loaders
   end
 
@@ -186,7 +186,9 @@ class Loaders
       # TODO : Later check if definition is private, and then add it to private_loader_for_module
       #
       loader = public_loader_for_module(module_name)
-      raise Puppet::ParseError, "Internal Error: did not find public loader for module: '#{module_name}'" if loader.nil?
+      if loader.nil?
+        raise Puppet::ParseError, _("Internal Error: did not find public loader for module: '%{module_name}'") % { module_name: module_name }
+      end
       loader
     end
   end
@@ -225,7 +227,9 @@ class Loaders
 
   def add_loader_by_name(loader)
     name = loader.loader_name
-    raise Puppet::ParseError, "Internal Error: Attempt to redefine loader named '#{name}'" if @loaders_by_name.include?(name)
+    if @loaders_by_name.include?(name)
+      raise Puppet::ParseError, _("Internal Error: Attempt to redefine loader named '%{name}'") % { name: name }
+    end
     @loaders_by_name[name] = loader
   end
 

data/lib/puppet/pops/lookup/explainer.rb

@@ -491,7 +491,8 @@ module Lookup
         when :invalid_key
           ExplainInvalidKey.new(@current, qualifier)
         else
-          raise ArgumentError, "Unknown Explain type #{qualifier_type}"
+          #TRANSLATORS 'Explain' is referring to the 'Explainer' class and should not be translated
+          raise ArgumentError, _("Unknown Explain type %{qualifier_type}") % { qualifier_type: qualifier_type }
         end
       @current.branches << node
       @current = node