puppet 4.10.12 → 5.0.0

data/lib/puppet/parser/ast/leaf.rb

@@ -70,6 +70,6 @@ class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
   end
 
   def to_s
-    Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(@value)
+    "/#{@value.source}/"
   end
 end

data/lib/puppet/parser/ast/node.rb

@@ -4,7 +4,7 @@ class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct
   def initialize(names, context = {})
     raise ArgumentError, "names should be an array" unless names.is_a? Array
     if context[:parent]
-      raise Puppet::DevError, "Node inheritance is removed in Puppet 4.0.0. See http://links.puppetlabs.com/puppet-node-inheritance-deprecation"
+      raise Puppet::DevError, "Node inheritance is removed in Puppet 4.0.0. See http://links.puppet.com/puppet-node-inheritance-deprecation"
     end
 
     @names = names

data/lib/puppet/parser/ast/pops_bridge.rb

@@ -180,7 +180,7 @@ class Puppet::Parser::AST::PopsBridge
         # when running tests that run a partial setup.
         # This is bad if the logic is trying to compile, but a warning can not be issues since it is a normal
         # use case that there is no scope when requesting the type in order to just get the parameters.
-        Puppet.debug {"Instantiating Resource with type checked parameters - scope is missing, skipping type checking."}
+        Puppet.debug {_("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.")}
         nil
       end
       scope
@@ -207,7 +207,7 @@ class Puppet::Parser::AST::PopsBridge
 
     def instantiate_ResourceTypeDefinition(o, modname)
       instance = Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname, ExpressionSupportingReturn)))
-      Puppet::Pops::Loaders.register_runtime3_type(instance.name, Puppet::Pops::Adapters::SourcePosAdapter.adapt(o).to_uri)
+      Puppet::Pops::Loaders.register_runtime3_type(instance.name, o.locator.to_uri(o))
       instance
     end
 
@@ -269,7 +269,7 @@ class Puppet::Parser::AST::PopsBridge
 
       # Instantiate Function, and store it in the loader
       typed_name, f = Puppet::Pops::Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
-      loader.set_entry(typed_name, f, Puppet::Pops::Adapters::SourcePosAdapter.adapt(function_definition).to_uri)
+      loader.set_entry(typed_name, f, function_definition.locator.to_uri(function_definition))
 
       nil # do not want the function to inadvertently leak into 3x
     end

data/lib/puppet/parser/ast/resource.rb

@@ -6,7 +6,7 @@ class Puppet::Parser::AST::Resource < Puppet::Parser::AST::Branch
   attr_accessor :type, :instances, :exported, :virtual
 
   def initialize(argshash)
-    Puppet.warn_once('deprecation', 'AST::Resource', 'Use of Puppet::Parser::AST::Resource is deprecated and not fully functional')
+    Puppet.warn_once('deprecations', 'AST::Resource', _('Use of Puppet::Parser::AST::Resource is deprecated and not fully functional'))
     super(argshash)
   end
 

data/lib/puppet/parser/ast/resource_instance.rb

@@ -4,7 +4,7 @@
 class Puppet::Parser::AST::ResourceInstance < Puppet::Parser::AST::Branch
   attr_accessor :title, :parameters
   def initialize(argshash)
-    Puppet.warn_once('deprecation', 'AST::ResourceInstance', 'Use of Puppet::Parser::AST::ResourceInstance is deprecated')
+    Puppet.warn_once('deprecations', 'AST::ResourceInstance', _('Use of Puppet::Parser::AST::ResourceInstance is deprecated'))
     super(argshash)
   end
 end

data/lib/puppet/parser/ast/resourceparam.rb

@@ -4,7 +4,7 @@ class Puppet::Parser::AST::ResourceParam < Puppet::Parser::AST::Branch
   attr_accessor :value, :param, :add
 
   def initialize(argshash)
-    Puppet.warn_once('deprecation', 'AST::ResourceParam', 'Use of Puppet::Parser::AST::ResourceParam is deprecated and not fully functional')
+    Puppet.warn_once('deprecations', 'AST::ResourceParam', _('Use of Puppet::Parser::AST::ResourceParam is deprecated and not fully functional'))
     super(argshash)
   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
 
@@ -156,51 +143,46 @@ class Puppet::Parser::Compiler
   # Return a list of all of the defined classes.
   def_delegator :@catalog, :classes, :classlist
 
-  def with_context_overrides(description = '', &block)
-    Puppet.override( @context_overrides , description, &block)
-  end
-
   # 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
 
@@ -222,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
 
@@ -331,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
@@ -383,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
@@ -425,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
@@ -441,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)
@@ -545,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
@@ -566,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
@@ -581,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
@@ -610,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
@@ -621,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
@@ -652,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
 
@@ -663,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
 
@@ -692,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)
@@ -765,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
@@ -847,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)
@@ -881,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/compiler/catalog_validator/env_relationship_validator.rb

@@ -14,7 +14,7 @@ class Puppet::Parser::Compiler
         end
       end
       assumed_exports.each_pair do |key, (param, cap)|
-        raise CatalogValidationError.new("Capability '#{cap}' referenced by '#{param.name}' is never exported", param.file, param.line) unless exported.include?(key)
+        raise CatalogValidationError.new(_("Capability '%{cap}' referenced by '%{param}' is never exported") % { cap: cap, param: param.name }, param.file, param.line) unless exported.include?(key)
       end
       nil
     end
@@ -53,7 +53,7 @@ class Puppet::Parser::Compiler
         unless rt.nil? || !rt.is_capability?
           title_key = catalog.title_key_for_ref(value.ref)
           if hash.include?(title_key)
-            raise CatalogValidationError.new("'#{value}' is exported by both '#{hash[title_key]}' and '#{resource}'", param.file, param.line)
+            raise CatalogValidationError.new(_("'%{value}' is exported by both '%{hash}' and '%{resource}'") % { value: value, hash: hash[title_key], resource: resource }, param.file, param.line)
           else
             hash[title_key] = resource
           end

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