puppet 4.10.0 → 5.0.0

data/lib/puppet/parser/compiler/catalog_validator/relationship_validator.rb

@@ -5,6 +5,7 @@ class Puppet::Parser::Compiler
     def validate
       catalog.resources.each do |resource|
         next unless resource.is_a?(Puppet::Parser::Resource)
+        next if resource.virtual?
         resource.eachparam do |param|
           pclass = Puppet::Type.metaparamclass(param.name)
           validate_relationship(param) if !pclass.nil? && pclass < Puppet::Type::RelationshipMetaparam
@@ -23,21 +24,17 @@ class Puppet::Parser::Compiler
       if has_capability?(param.value)
         unless CAPABILITY_ACCEPTED_METAPARAMS[param.name]
           raise CatalogValidationError.new(
-            "'#{param.name}' is not a valid relationship to a capability", 
+            _("'%{param}' is not a valid relationship to a capability") % { param: param.name },
               param.file, param.line)
         end
-      elsif Puppet[:strict] != :off
-        # all other relationships requires the referenced resource to exist when mode is strict
+      else
+        # all other relationships requires the referenced resource to exist
         refs = param.value.is_a?(Array) ? param.value.flatten : [param.value]
         refs.each do |r|
           next if r.nil? || r == :undef
           unless catalog.resource(r.to_s)
-            msg = "Could not find resource '#{r.to_s}' in parameter '#{param.name.to_s}'"
-            if Puppet[:strict] == :error
-              raise CatalogValidationError.new(msg, param.file, param.line)
-            else
-              Puppet.warn_once(:undefined_resources, r.to_s, msg, param.file, param.line)
-            end
+            msg = _("Could not find resource '%{res}' in parameter '%{param}'") % { res: r.to_s, param: param.name.to_s }
+            raise CatalogValidationError.new(msg, param.file, param.line)
           end
         end
       end

data/lib/puppet/parser/compiler/catalog_validator/site_validator.rb

@@ -11,7 +11,7 @@ class Puppet::Parser::Compiler
 
       catalog.downstream_from_vertex(the_site_resource).keys.each do |r|
         unless r.is_application_component? || r.resource_type.application?
-          raise CatalogValidationError.new("Only application components can appear inside a site - #{r} is not allowed", r.file, r.line)
+          raise CatalogValidationError.new(_("Only application components can appear inside a site - %{res} is not allowed") % { res: r }, r.file, r.line)
         end
       end
     end

data/lib/puppet/parser/compiler.rb

@@ -42,28 +42,13 @@ class Puppet::Parser::Compiler
  end
 
   attr_reader :node, :facts, :collections, :catalog, :resources, :relationships, :topscope
-
-  # The injector that provides lookup services, or nil if accessed before the compiler has started compiling and
-  # bootstrapped. The injector is initialized and available before any manifests are evaluated.
-  #
-  # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services for this compiler/environment
-  # @api public
-  #
-  attr_accessor :injector
+  attr_reader :qualified_variables
 
   # Access to the configured loaders for 4x
   # @return [Puppet::Pops::Loader::Loaders] the configured loaders
   # @api private
   attr_reader :loaders
 
-  # The injector that provides lookup services during the creation of the {#injector}.
-  # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services during injector creation
-  #   for this compiler/environment
-  #
-  # @api private
-  #
-  attr_accessor :boot_injector
-
   # The id of code input to the compiler.
   # @api private
   attr_accessor :code_id
@@ -107,7 +92,8 @@ class Puppet::Parser::Compiler
     @catalog.add_resource(resource)
 
     if not resource.class? and resource[:stage]
-      raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
+      #TRANSLATORS "stage" is a keyword in Puppet and should not be translated
+      raise ArgumentError, _("Only classes can set 'stage'; normal resources like %{resource} cannot change run stage") % { resource: resource }
     end
 
     # Stages should not be inside of classes.  They are always a
@@ -133,7 +119,8 @@ class Puppet::Parser::Compiler
           return if upstream.keys.map(&:type).include?('Site')
         end
       end
-      raise ArgumentError, "Application instances like '#{resource}' can only be contained within a Site"
+      #TRANSLATORS "Site" is a puppet keyword and should not be translated
+      raise ArgumentError, _("Application instances like '%{resource}' can only be contained within a Site") % { resource: resource }
     end
   end
 
@@ -159,44 +146,43 @@ class Puppet::Parser::Compiler
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
-    Puppet.override( @context_overrides , "For compiling #{node.name}") do
+    Puppet.override( @context_overrides , _("For compiling %{node}") % { node: node.name }) do
       @catalog.environment_instance = environment
 
       # Set the client's parameters into the top scope.
-      Puppet::Util::Profiler.profile("Compile: Set node parameters", [:compiler, :set_node_params]) { set_node_parameters }
+      Puppet::Util::Profiler.profile(_("Compile: Set node parameters"), [:compiler, :set_node_params]) { set_node_parameters }
 
-      Puppet::Util::Profiler.profile("Compile: Created settings scope", [:compiler, :create_settings_scope]) { create_settings_scope }
+      Puppet::Util::Profiler.profile(_("Compile: Created settings scope"), [:compiler, :create_settings_scope]) { create_settings_scope }
 
-      activate_binder
+      Puppet::Util::Profiler.profile(_("Compile: Evaluated capability mappings"), [:compiler, :evaluate_capability_mappings]) { evaluate_capability_mappings }
 
-      Puppet::Util::Profiler.profile("Compile: Evaluated capability mappings", [:compiler, :evaluate_capability_mappings]) { evaluate_capability_mappings }
+      #TRANSLATORS "main" is a function name and should not be translated
+      Puppet::Util::Profiler.profile(_("Compile: Evaluated main"), [:compiler, :evaluate_main]) { evaluate_main }
 
-      Puppet::Util::Profiler.profile("Compile: Evaluated main", [:compiler, :evaluate_main]) { evaluate_main }
+      Puppet::Util::Profiler.profile(_("Compile: Evaluated site"), [:compiler, :evaluate_site]) { evaluate_site }
 
-      Puppet::Util::Profiler.profile("Compile: Evaluated site", [:compiler, :evaluate_site]) { evaluate_site }
+      Puppet::Util::Profiler.profile(_("Compile: Evaluated AST node"), [:compiler, :evaluate_ast_node]) { evaluate_ast_node }
 
-      Puppet::Util::Profiler.profile("Compile: Evaluated AST node", [:compiler, :evaluate_ast_node]) { evaluate_ast_node }
+      Puppet::Util::Profiler.profile(_("Compile: Evaluated node classes"), [:compiler, :evaluate_node_classes]) { evaluate_node_classes }
 
-      Puppet::Util::Profiler.profile("Compile: Evaluated node classes", [:compiler, :evaluate_node_classes]) { evaluate_node_classes }
-
-      Puppet::Util::Profiler.profile("Compile: Evaluated application instances", [:compiler, :evaluate_applications]) { evaluate_applications }
+      Puppet::Util::Profiler.profile(_("Compile: Evaluated application instances"), [:compiler, :evaluate_applications]) { evaluate_applications }
 
       # New capability mappings may have been defined when the site was evaluated
-      Puppet::Util::Profiler.profile("Compile: Evaluated site capability mappings", [:compiler, :evaluate_capability_mappings]) { evaluate_capability_mappings }
+      Puppet::Util::Profiler.profile(_("Compile: Evaluated site capability mappings"), [:compiler, :evaluate_capability_mappings]) { evaluate_capability_mappings }
 
-      Puppet::Util::Profiler.profile("Compile: Evaluated generators", [:compiler, :evaluate_generators]) { evaluate_generators }
+      Puppet::Util::Profiler.profile(_("Compile: Evaluated generators"), [:compiler, :evaluate_generators]) { evaluate_generators }
 
-      Puppet::Util::Profiler.profile("Compile: Validate Catalog pre-finish", [:compiler, :validate_pre_finish]) do
+      Puppet::Util::Profiler.profile(_("Compile: Validate Catalog pre-finish"), [:compiler, :validate_pre_finish]) do
         validate_catalog(CatalogValidator::PRE_FINISH)
       end
 
-      Puppet::Util::Profiler.profile("Compile: Finished catalog", [:compiler, :finish_catalog]) { finish }
+      Puppet::Util::Profiler.profile(_("Compile: Finished catalog"), [:compiler, :finish_catalog]) { finish }
 
-      Puppet::Util::Profiler.profile("Compile: Prune", [:compiler, :prune_catalog]) { prune_catalog }
+      Puppet::Util::Profiler.profile(_("Compile: Prune"), [:compiler, :prune_catalog]) { prune_catalog }
 
       fail_on_unevaluated
 
-      Puppet::Util::Profiler.profile("Compile: Validate Catalog final", [:compiler, :validate_final]) do
+      Puppet::Util::Profiler.profile(_("Compile: Validate Catalog final"), [:compiler, :validate_final]) do
         validate_catalog(CatalogValidator::FINAL)
       end
 
@@ -218,7 +204,6 @@ class Puppet::Parser::Compiler
       :current_environment => environment,
       :global_scope => @topscope,             # 4x placeholder for new global scope
       :loaders  => @loaders,                  # 4x loaders
-      :injector => lambda {|| injector() }    # 4x API - via context instead of via compiler
     }
   end
 
@@ -327,14 +312,14 @@ class Puppet::Parser::Compiler
     @applications.each do |app|
       components = []
       mapping = app.parameters[:nodes] ? app.parameters[:nodes].value : {}
-      raise Puppet::Error, "Invalid node mapping in #{app.ref}: Mapping must be a hash" unless mapping.is_a?(Hash)
+      raise Puppet::Error, _("Invalid node mapping in %{app}: Mapping must be a hash") % { app: app.ref } unless mapping.is_a?(Hash)
       all_mapped = Set.new
       mapping.each do |k,v|
-        raise Puppet::Error, "Invalid node mapping in #{app.ref}: Key #{k} is not a Node" unless k.is_a?(Puppet::Resource) && k.type == 'Node'
+        raise Puppet::Error, _("Invalid node mapping in %{app}: Key %{k} is not a Node") % { app: app.ref, k: k } unless k.is_a?(Puppet::Resource) && k.type == _('Node')
         v = [v] unless v.is_a?(Array)
         v.each do |res|
-          raise Puppet::Error, "Invalid node mapping in #{app.ref}: Value #{res} is not a resource" unless res.is_a?(Puppet::Resource)
-          raise Puppet::Error, "Application #{app.ref} maps component #{res} to multiple nodes" if all_mapped.add?(res.ref).nil?
+          raise Puppet::Error, _("Invalid node mapping in %{app}: Value %{res} is not a resource") % { app: app.ref, res: res } unless res.is_a?(Puppet::Resource)
+          raise Puppet::Error, _("Application %{app} maps component %{res} to multiple nodes") % { app: app.ref, res: res } if all_mapped.add?(res.ref).nil?
           components << res if k.title == node.name
         end
       end
@@ -379,7 +364,7 @@ class Puppet::Parser::Compiler
     end
 
     hostclasses = classes.collect do |name|
-      environment.known_resource_types.find_hostclass(name) or raise Puppet::Error, "Could not find class #{name} for #{node.name}"
+      environment.known_resource_types.find_hostclass(name) or raise Puppet::Error, _("Could not find class %{name} for %{node}") % { name: name, node: node.name }
     end
 
     if class_parameters
@@ -421,6 +406,8 @@ class Puppet::Parser::Compiler
     set_options(options)
     initvars
     add_catalog_validators
+    # Resolutions of fully qualified variable names
+    @qualified_variables = {}
   end
 
   # Create a new scope, with either a specified parent scope or
@@ -437,43 +424,6 @@ class Puppet::Parser::Compiler
     @resource_overrides[resource.ref]
   end
 
-  def injector
-    create_injector if @injector.nil?
-    @injector
-  end
-
-  def boot_injector
-    create_boot_injector(nil) if @boot_injector.nil?
-    @boot_injector
-  end
-
-  # Creates the boot injector from registered system, default, and injector config.
-  # @return [Puppet::Pops::Binder::Injector] the created boot injector
-  # @api private Cannot be 'private' since it is called from the BindingsComposer.
-  #
-  def create_boot_injector(env_boot_bindings)
-    assert_binder_active()
-    pb = Puppet::Pops::Binder
-    boot_contribution = pb::SystemBindings.injector_boot_contribution(env_boot_bindings)
-    final_contribution = pb::SystemBindings.final_contribution
-    binder = pb::Binder.new(pb::BindingsFactory.layered_bindings(final_contribution, boot_contribution))
-    @boot_injector = pb::Injector.new(binder)
-  end
-
-  # Answers if Puppet Binder should be active or not, and if it should and is not active, then it is activated.
-  # @return [Boolean] true if the Puppet Binder should be activated
-  def activate_binder
-    # TODO: this should be in a central place
-    Puppet::Parser::ParserFactory.assert_rgen_installed()
-    @@binder_loaded ||= false
-    unless @@binder_loaded
-      require 'puppet/pops'
-      require 'puppet/plugins/configuration'
-      @@binder_loaded = true
-    end
-    true
-  end
-
   private
 
   def ensure_classes_with_parameters(scope, hostclasses, parameters)
@@ -541,7 +491,7 @@ class Puppet::Parser::Compiler
     end
 
     unless (astnode ||= krt.node("default"))
-      raise Puppet::ParseError, "Could not find node statement with name 'default' or '#{node.names.join(", ")}'"
+      raise Puppet::ParseError, _("Could not find node statement with name 'default' or '%{names}'") % { names: node.names.join(", ") }
     end
 
     # Create a resource to model this node, and then add it to the list
@@ -562,7 +512,7 @@ class Puppet::Parser::Compiler
       # We have to iterate over a dup of the array because
       # collections can delete themselves from the list, which
       # changes its length and causes some collections to get missed.
-      Puppet::Util::Profiler.profile("Evaluated collections", [:compiler, :evaluate_collections]) do
+      Puppet::Util::Profiler.profile(_("Evaluated collections"), [:compiler, :evaluate_collections]) do
         found_something = false
         @collections.dup.each do |collection|
           found_something = true if collection.evaluate
@@ -577,14 +527,14 @@ class Puppet::Parser::Compiler
   # evaluate_generators loop.
   def evaluate_definitions
     exceptwrap do
-      Puppet::Util::Profiler.profile("Evaluated definitions", [:compiler, :evaluate_definitions]) do
+      Puppet::Util::Profiler.profile(_("Evaluated definitions"), [:compiler, :evaluate_definitions]) do
         urs = unevaluated_resources.each do |resource|
-         begin
+          begin
             resource.evaluate
-         rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
-           # needs to be handled specifically as the error has the file/line/position where this
-           # occurred rather than the resource
-           fail(Puppet::Pops::Issues::RUNTIME_ERROR, detail, {:detail => detail.message}, detail)
+          rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
+            # needs to be handled specifically as the error has the file/line/position where this
+            # occurred rather than the resource
+            fail(Puppet::Pops::Issues::RUNTIME_ERROR, detail, {:detail => detail.message}, detail)
 
           rescue Puppet::Error => e
             # PuppetError has the ability to wrap an exception, if so, use the wrapped exception's
@@ -606,7 +556,7 @@ class Puppet::Parser::Compiler
     loop do
       done = true
 
-      Puppet::Util::Profiler.profile("Iterated (#{count + 1}) on generators", [:compiler, :iterate_on_generators]) do
+      Puppet::Util::Profiler.profile(_("Iterated (%{count}) on generators") % { count: count + 1 }, [:compiler, :iterate_on_generators]) do
         # Call collections first, then definitions.
         done = false if evaluate_collections
         done = false if evaluate_definitions
@@ -617,7 +567,7 @@ class Puppet::Parser::Compiler
       count += 1
 
       if count > 1000
-        raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog"
+        raise Puppet::ParseError, _("Somehow looped more than 1000 times while evaluating host catalog")
       end
     end
   end
@@ -648,7 +598,7 @@ class Puppet::Parser::Compiler
     remaining = @resource_overrides.values.flatten.collect(&:ref)
 
     if !remaining.empty?
-      raise Puppet::ParseError, "Could not find resource(s) #{remaining.join(', ')} for overriding"
+      raise Puppet::ParseError, _("Could not find resource(s) %{resources} for overriding") % { resources: remaining.join(', ') }
     end
   end
 
@@ -659,7 +609,7 @@ class Puppet::Parser::Compiler
   def fail_on_unevaluated_resource_collections
     remaining = @collections.collect(&:unresolved_resources).flatten.compact
     if !remaining.empty?
-      raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}"
+      raise Puppet::ParseError, _("Failed to realize virtual resources %{resources}") % { resources: remaining.join(', ') }
     end
   end
 
@@ -688,13 +638,13 @@ class Puppet::Parser::Compiler
 
   def add_resource_metaparams
     unless main = catalog.resource(:class, :main)
-      raise "Couldn't find main"
+      #TRANSLATORS "main" is a function name and should not be translated
+      raise _("Couldn't find main")
     end
 
     names = Puppet::Type.metaparams.select do |name|
       !Puppet::Parser::Resource.relationship_parameter?(name)
     end
-
     data = {}
     catalog.walk(main, :out) do |source, target|
       if source_data = data[source] || metaparams_as_data(source, names)
@@ -761,7 +711,7 @@ class Puppet::Parser::Compiler
     # It cannot survive the initvars method, and is later reinstated
     # as part of compiling...
     #
-    Puppet.override( @context_overrides , "For initializing compiler") do
+    Puppet.override( @context_overrides , _("For initializing compiler")) do
       # THE MAGIC STARTS HERE ! This triggers parsing, loading etc.
       @catalog.version = environment.known_resource_types.version
     end
@@ -843,9 +793,7 @@ class Puppet::Parser::Compiler
     catalog.server_version = node.parameters["serverversion"]
     @topscope.set_trusted(node.trusted_data)
 
-    if Puppet[:trusted_server_facts]
-      @topscope.set_server_facts(node.server_facts)
-    end
+    @topscope.set_server_facts(node.server_facts)
 
     facts_hash = node.facts.nil? ? {} : node.facts.values
     @topscope.set_facts(facts_hash)
@@ -877,21 +825,4 @@ class Puppet::Parser::Compiler
     # The order of these is significant for speed due to short-circuiting
     resources.reject { |resource| resource.evaluated? or resource.virtual? or resource.builtin_type? }
   end
-
-  # Creates the injector from bindings found in the current environment.
-  # @return [void]
-  # @api private
-  #
-  def create_injector
-    assert_binder_active()
-    composer = Puppet::Pops::Binder::BindingsComposer.new()
-    layered_bindings = composer.compose(topscope)
-    @injector = Puppet::Pops::Binder::Injector.new(Puppet::Pops::Binder::Binder.new(layered_bindings))
-  end
-
-  def assert_binder_active
-    unless activate_binder()
-      raise Puppet::DevError, "The Puppet Binder was not activated"
-    end
-  end  # Creates a diagnostic producer
 end

data/lib/puppet/parser/e4_parser_adapter.rb

@@ -21,7 +21,7 @@ class E4ParserAdapter
   def parse(string = nil)
     self.string= string if string
     parser = Pops::Parser::EvaluatingParser.singleton
-    parse_result =
+    model =
     if @use == :string
       # Parse with a source_file to set in created AST objects (it was either given, or it may be unknown
       # if caller did not set a file and the present a string.
@@ -36,7 +36,6 @@ class E4ParserAdapter
     # * a Model::Program
     # * a Model::Expression
     #
-    model = parse_result.nil? ? nil : parse_result.current
     args = {}
     Pops::Model::AstTransformer.new(@file).merge_location(args, model)
 

data/lib/puppet/parser/environment_compiler.rb

@@ -9,7 +9,7 @@ class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
       node.environment = env
       new(node, :code_id => code_id).compile
     rescue => detail
-      message = "#{detail} in environment #{env.name}"
+      message = _("%{detail} in environment %{env}") % { detail: detail, env: env.name }
       Puppet.log_exception(detail, message)
       raise Puppet::Error, message, detail.backtrace
     end
@@ -56,30 +56,28 @@ class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
   def compile
     add_function_overrides
     begin
-      Puppet.override(@context_overrides, "For compiling environment catalog #{environment.name}") do
+      Puppet.override(@context_overrides, _("For compiling environment catalog %{env}") % { env: environment.name }) do
         @catalog.environment_instance = environment
 
-        Puppet::Util::Profiler.profile("Env Compile: Created settings scope", [:compiler, :create_settings_scope]) { create_settings_scope }
+        Puppet::Util::Profiler.profile(_("Env Compile: Created settings scope"), [:compiler, :create_settings_scope]) { create_settings_scope }
 
-        activate_binder
+        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated main"), [:compiler, :evaluate_main]) { evaluate_main }
 
-        Puppet::Util::Profiler.profile("Env Compile: Evaluated main", [:compiler, :evaluate_main]) { evaluate_main }
+        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated site"), [:compiler, :evaluate_site]) { evaluate_site }
 
-        Puppet::Util::Profiler.profile("Env Compile: Evaluated site", [:compiler, :evaluate_site]) { evaluate_site }
+        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated application instances"), [:compiler, :evaluate_applications]) { evaluate_applications }
 
-        Puppet::Util::Profiler.profile("Env Compile: Evaluated application instances", [:compiler, :evaluate_applications]) { evaluate_applications }
+        Puppet::Util::Profiler.profile(_("Env Compile: Prune"), [:compiler, :prune_catalog]) { prune_catalog }
 
-        Puppet::Util::Profiler.profile("Env Compile: Prune", [:compiler, :prune_catalog]) { prune_catalog }
-
-        Puppet::Util::Profiler.profile("Env Compile: Validate Catalog pre-finish", [:compiler, :validate_pre_finish]) do
+        Puppet::Util::Profiler.profile(_("Env Compile: Validate Catalog pre-finish"), [:compiler, :validate_pre_finish]) do
           validate_catalog(CatalogValidator::PRE_FINISH)
         end
 
-        Puppet::Util::Profiler.profile("Env Compile: Finished catalog", [:compiler, :finish_catalog]) { finish }
+        Puppet::Util::Profiler.profile(_("Env Compile: Finished catalog"), [:compiler, :finish_catalog]) { finish }
 
         fail_on_unevaluated
 
-        Puppet::Util::Profiler.profile("Env Compile: Validate Catalog final", [:compiler, :validate_final]) do
+        Puppet::Util::Profiler.profile(_("Env Compile: Validate Catalog final"), [:compiler, :validate_final]) do
           validate_catalog(CatalogValidator::FINAL)
         end
 
@@ -133,7 +131,7 @@ class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
     @catalog.add_resource(resource)
 
     if !resource.class? && resource[:stage]
-      raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
+      raise ArgumentError, _("Only classes can set 'stage'; normal resources like %{resource} cannot change run stage") % { resource: resource }
     end
 
     # Stages should not be inside of classes.  They are always a
@@ -155,13 +153,13 @@ class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
   end
 
   def on_empty_site
-    Puppet.warning("Environment Compiler: Could not find a site definition to evaluate")
+    Puppet.warning(_("Environment Compiler: Could not find a site definition to evaluate"))
   end
 
   def evaluate_applications
     exceptwrap do
       resources.select { |resource| type = resource.resource_type; type.is_a?(Puppet::Resource::Type) && type.application? }.each do |resource|
-        Puppet::Util::Profiler.profile("Evaluated application #{resource}", [:compiler, :evaluate_resource, resource]) do
+        Puppet::Util::Profiler.profile(_("Evaluated application %{resource}") % { resource: resource }, [:compiler, :evaluate_resource, resource]) do
           resource.evaluate
         end
       end

data/lib/puppet/parser/functions/contain.rb

@@ -25,6 +25,6 @@ allowing the function call to `contain` to directly continue.
 "
 ) do |classes|
   # Call the 4.x version of this function in case 3.x ruby code uses this function
-  Puppet.warn_once(:deprecation, '3xfunction#contain', "Calling function_contain via the Scope class is deprecated. Use Scope#call_function instead")
+  Puppet.warn_once('deprecations', '3xfunction#contain', _("Calling function_contain via the Scope class is deprecated. Use Scope#call_function instead"))
   call_function('contain', classes)
 end

data/lib/puppet/parser/functions/create_resources.rb

@@ -47,10 +47,10 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
     final value of a parameter (just as when setting a parameter to `undef` in a puppet language
     resource declaration).
   ENDHEREDOC
-  raise ArgumentError, ("create_resources(): wrong number of arguments (#{args.length}; must be 2 or 3)") if args.length > 3
-  raise ArgumentError, ('create_resources(): second argument must be a hash') unless args[1].is_a?(Hash)
+  raise ArgumentError, (_("create_resources(): wrong number of arguments (%{count}; must be 2 or 3)") % { count: args.length }) if args.length > 3
+  raise ArgumentError, (_('create_resources(): second argument must be a hash')) unless args[1].is_a?(Hash)
   if args.length == 3
-    raise ArgumentError, ('create_resources(): third argument, if provided, must be a hash') unless args[2].is_a?(Hash)
+    raise ArgumentError, (_('create_resources(): third argument, if provided, must be a hash')) unless args[2].is_a?(Hash)
   end
 
   type, instances, defaults = args
@@ -71,10 +71,18 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
 
   if type.start_with? '@@'
     exported = true
+    virtual = true
   elsif type.start_with? '@'
     virtual = true
   end
 
+  if type_name == 'class' && (exported || virtual)
+    # cannot find current evaluator, so use another
+    evaluator = Puppet::Pops::Parser::EvaluatingParser.new.evaluator
+    # optionally fails depending on configured severity of issue
+    evaluator.runtime_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
+  end
+
   instances.map do |title, params|
     # Add support for iteration if title is an array
     resource_titles = title.is_a?(Array) ? title  : [title]

data/lib/puppet/parser/functions/file.rb

@@ -28,6 +28,6 @@ Puppet::Parser::Functions::newfunction(
     if path
       Puppet::FileSystem.read_preserve_line_endings(path)
     else
-      raise Puppet::ParseError, "Could not find any files from #{vals.join(", ")}"
+      raise Puppet::ParseError, _("Could not find any files from %{values}") % { values: vals.join(", ") }
     end
 end

data/lib/puppet/parser/functions/generate.rb

@@ -11,7 +11,8 @@ Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue
     generators, so all shell metacharacters are passed directly to
     the generator.") do |args|
 
-      raise Puppet::ParseError, "Generators must be fully qualified" unless Puppet::Util.absolute_path?(args[0])
+      #TRANSLATORS "fully qualified" refers to a fully qualified file system path
+      raise Puppet::ParseError, _("Generators must be fully qualified") unless Puppet::Util.absolute_path?(args[0])
 
       if Puppet.features.microsoft_windows?
         valid = args[0] =~ /^[a-z]:(?:[\/\\][-.~\w]+)+$/i
@@ -21,17 +22,17 @@ Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue
 
       unless valid
         raise Puppet::ParseError,
-          "Generators can only contain alphanumerics, file separators, and dashes"
+          _("Generators can only contain alphanumerics, file separators, and dashes")
       end
 
       if args[0] =~ /\.\./
         raise Puppet::ParseError,
-          "Can not use generators with '..' in them."
+          _("Can not use generators with '..' in them.")
       end
 
       begin
         Dir.chdir(File.dirname(args[0])) { Puppet::Util::Execution.execute(args).to_str }
       rescue Puppet::ExecutionFailure => detail
-        raise Puppet::ParseError, "Failed to execute generator #{args[0]}: #{detail}", detail.backtrace
+        raise Puppet::ParseError, _("Failed to execute generator %{generator}: %{detail}") % { generator: args[0], detail: detail }, detail.backtrace
       end
 end

data/lib/puppet/parser/functions/hiera_include.rb

@@ -89,7 +89,7 @@ Note that calls using the 'override level' option are not directly supported by
 result must be post processed to get exactly the same result, for example using simple hash/array `+` or
 with calls to stdlib's `deep_merge` function depending on kind of hiera call and setting of merge in hiera.yaml.
 
-See [the documentation](http://links.puppetlabs.com/hierainclude) for more information
+See [the documentation](http://links.puppet.com/hierainclude) for more information
 and a more detailed example of how `hiera_include` uses array merge lookups to classify
 nodes.
 

data/lib/puppet/parser/functions/include.rb

@@ -28,6 +28,7 @@ the future parser's resource and relationship expressions.
 - Since 4.0.0 support for class and resource type values, absolute names
 - Since 4.7.0 returns an Array[Type[Class]] of all included classes 
 ") do |classes|
-  Puppet.warn_once(:deprecation, '3xfunction#include', "Calling function_include via the Scope class is deprecated. Use Scope#call_function instead")
   call_function('include', classes)
+  #TRANSLATORS "function_include", "Scope", and "Scope#call_function" refer to Puppet internals and should not be translated
+  Puppet.warn_once('deprecations', '3xfunction#include', _("Calling function_include via the Scope class is deprecated. Use Scope#call_function instead"))
 end

data/lib/puppet/parser/functions/inline_template.rb

@@ -15,7 +15,7 @@ Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arit
         wrapper.result(string)
       rescue => detail
         raise Puppet::ParseError,
-          "Failed to parse inline template: #{detail}", detail.backtrace
+          _("Failed to parse inline template: %{detail}") % { detail: detail }, detail.backtrace
       end
     end.join("")
 end

data/lib/puppet/parser/functions/new.rb

@@ -635,7 +635,7 @@ Defaults to `s` at top level and `p` inside array or hash.
 
 | Format    | Regexp Formats
 | ----      | --------------
-| s         | Delimiters `/ /`, alternate flag `#` replaces `/` delimiters with quotes.
+| s         | No delimiters, quoted if alternative flag `#` is used.
 | p         | Delimiters `/ /`.
 
 ### Undef to String
@@ -775,6 +775,19 @@ Accepts a single value as argument:
 Conversion to a `Struct` works exactly as conversion to a `Hash`, only that the constructed hash is
 asserted against the given struct type.
 
+Conversion to a Regexp
+---
+A `String` can be converted into a `Regexp`
+
+**Example**: Converting a String into a Regexp
+```puppet
+$s = '[a-z]+\.com'
+$r = Regexp($s)
+if('foo.com' =~ $r) {
+  ...
+}
+```
+
 Creating a SemVer
 ---
 

data/lib/puppet/parser/functions/require.rb

@@ -35,6 +35,6 @@ resource and relationship expressions.
 - Since 4.0.0 Class and Resource types, absolute names
 - Since 4.7.0 Returns an Array[Type[Class]] with references to the required classes
 ") do |classes|
-  Puppet.warn_once(:deprecation, '3xfunction#require', "Calling function_require via the Scope class is deprecated. Use Scope#call_function instead")
   call_function('require', classes)
+  Puppet.warn_once('deprecations', '3xfunction#require', _("Calling function_require via the Scope class is deprecated. Use Scope#call_function instead"))
 end