puppet 4.10.0 → 5.0.0

data/lib/puppet/parser/functions.rb

@@ -146,7 +146,7 @@ module Puppet::Parser::Functions
     name = name.intern
     environment = options[:environment] || Puppet.lookup(:current_environment)
 
-    Puppet.warning "Overwriting previous definition for function #{name}" if get_function(name, environment)
+    Puppet.warning _("Overwriting previous definition for function %{name}") % { name: name } if get_function(name, environment)
 
     arity = options[:arity] || -1
     ftype = options[:type] || :statement
@@ -164,16 +164,16 @@ module Puppet::Parser::Functions
     env_module = environment_module(environment)
 
     env_module.send(:define_method, fname) do |*args|
-      Puppet::Util::Profiler.profile("Called #{name}", [:functions, name]) do
+      Puppet::Util::Profiler.profile(_("Called %{name}") % { name: name }, [:functions, name]) do
         if args[0].is_a? Array
           if arity >= 0 and args[0].size != arity
-            raise ArgumentError, "#{name}(): Wrong number of arguments given (#{args[0].size} for #{arity})"
+            raise ArgumentError, _("%{name}(): Wrong number of arguments given (%{arg_count} for %{arity})") % { name: name, arg_count: args[0].size, arity: arity }
           elsif arity < 0 and args[0].size < (arity+1).abs
-            raise ArgumentError, "#{name}(): Wrong number of arguments given (#{args[0].size} for minimum #{(arity+1).abs})"
+            raise ArgumentError, _("%{name}(): Wrong number of arguments given (%{arg_count} for minimum %{min_arg_count})") % { name: name, arg_count: args[0].size, min_arg_count: (arity+1).abs }
           end
           self.send(real_fname, args[0])
         else
-          raise ArgumentError, "custom functions must be called with a single array that contains the arguments. For example, function_example([1]) instead of function_example(1)"
+          raise ArgumentError, _("custom functions must be called with a single array that contains the arguments. For example, function_example([1]) instead of function_example(1)")
         end
       end
     end
@@ -272,7 +272,7 @@ module Puppet::Parser::Functions
 
   class Error
     def self.is4x(name)
-      raise Puppet::ParseError, "#{name}() can only be called using the 4.x function API. See Scope#call_function"
+      raise Puppet::ParseError, _("%{name}() can only be called using the 4.x function API. See Scope#call_function") % { name: name }
     end
   end
 end

data/lib/puppet/parser/parser_factory.rb

@@ -16,8 +16,6 @@ module Puppet::Parser
     # EvaluatingParser to the 3x way of parsing.
     #
     def self.evaluating_parser
-      # Since RGen is optional, test that it is installed
-      assert_rgen_installed()
       unless defined?(Puppet::Pops::Parser::E4ParserAdapter)
         require 'puppet/parser/e4_parser_adapter'
         require 'puppet/pops/parser/code_merger'
@@ -25,34 +23,6 @@ module Puppet::Parser
       E4ParserAdapter.new
     end
 
-    # Asserts that RGen >= 0.6.6 is installed by checking that certain behavior is available.
-    # Note that this assert is expensive as it also requires puppet/pops (if not already loaded).
-    #
-    def self.assert_rgen_installed
-      @@asserted ||= false
-      return if @@asserted
-      @@asserted = true
-      begin
-        require 'rgen/metamodel_builder'
-      rescue LoadError
-        raise Puppet::DevError.new("The gem 'rgen' version >= 0.7.0 is required when using the setting '--parser future'. Please install 'rgen'.")
-      end
-      # Since RGen is optional, there is nothing specifying its version.
-      # It is not installed in any controlled way, so not possible to use gems to check (it may be installed some other way).
-      # Instead check that "eContainer, and eContainingFeature" has been installed.
-      require 'puppet/pops'
-      begin
-        litstring = Puppet::Pops::Model::LiteralString.new();
-        container = Puppet::Pops::Model::ArithmeticExpression.new();
-        container.left_expr = litstring
-        raise "no eContainer" if litstring.eContainer() != container
-        raise "no eContainingFeature" if litstring.eContainingFeature() != :left_expr
-      rescue => e
-        # TODO: RGen can raise exceptions for other reasons!
-        raise Puppet::DevError.new("The gem 'rgen' version >= 0.7.0 is required when using '--parser future'. An older version is installed, please update.")
-      end
-    end
-
     def self.code_merger
       Puppet::Pops::Parser::CodeMerger.new
     end

data/lib/puppet/parser/relationship.rb

@@ -3,10 +3,11 @@ class Puppet::Parser::Relationship
 
   PARAM_MAP = {:relationship => :before, :subscription => :notify}
 
-  def arrayify(resources)
+  def arrayify(resources, left)
     case resources
     when Puppet::Pops::Evaluator::Collectors::AbstractCollector
-      resources.collected.values
+      # on the LHS, go as far left as possible, else whatever the collected result is
+      left ? leftmost_alternative(resources) : resources.collected.values
     when Array
       resources
     else
@@ -15,8 +16,8 @@ class Puppet::Parser::Relationship
   end
 
   def evaluate(catalog)
-    arrayify(source).each do |s|
-      arrayify(target).each do |t|
+    arrayify(source, true).each do |s|
+      arrayify(target, false).each do |t|
         mk_relationship(s, t, catalog)
       end
     end
@@ -27,28 +28,56 @@ class Puppet::Parser::Relationship
   end
 
   def param_name
-    PARAM_MAP[type] || raise(ArgumentError, "Invalid relationship type #{type}")
+    PARAM_MAP[type] || raise(ArgumentError, _("Invalid relationship type %{relationship_type}") % { relationship_type: type })
   end
 
   def mk_relationship(source, target, catalog)
-    # There was once an assumption that this could be an array. These raise
-    # assertions are here as a sanity check for 4.0 and can be removed after
-    # a release or two
-    raise ArgumentError, "source shouldn't be an array" if source.is_a?(Array)
-    raise ArgumentError, "target shouldn't be an array" if target.is_a?(Array)
-    source = source.to_s
-    target = target.to_s
-
-    unless source_resource = catalog.resource(source)
-      raise ArgumentError, "Could not find resource '#{source}' for relationship on '#{target}'"
+    source_ref = canonical_ref(source)
+    target_ref = canonical_ref(target)
+    rel_param = param_name
+
+    unless source_resource = catalog.resource(*source_ref)
+      raise ArgumentError, _("Could not find resource '%{source}' for relationship on '%{target}'") % { source: source.to_s, target: target.to_s }
     end
-    unless catalog.resource(target)
-      raise ArgumentError, "Could not find resource '#{target}' for relationship from '#{source}'"
+    unless catalog.resource(*target_ref)
+      raise ArgumentError, _("Could not find resource '%{target}' for relationship from '%{source}'") % { target: target.to_s, source: source.to_s }
     end
     Puppet.debug {"Adding relationship from #{source} to #{target} with '#{param_name}'"}
-    if source_resource[param_name].class != Array
-      source_resource[param_name] = [source_resource[param_name]].compact
+    if source_resource[rel_param].class != Array
+      source_resource[rel_param] = [source_resource[rel_param]].compact
+    end
+    source_resource[rel_param] << (target_ref[1].nil? ? target_ref[0] : "#{target_ref[0]}[#{target_ref[1]}]")
+  end
+
+  private
+
+  # Finds the leftmost alternative for a collector (if it is empty, try its empty alternative recursively until there is
+  # either nothing left, or a non empty set is found.
+  #
+  def leftmost_alternative(x)
+    if x.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+      collected = x.collected
+      return collected.values unless collected.empty?
+      adapter = Puppet::Pops::Adapters::EmptyAlternativeAdapter.get(x)
+      adapter.nil? ? [] : leftmost_alternative(adapter.empty_alternative)
+    elsif x.is_a?(Array) && x.size == 1 && x[0].is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
+      leftmost_alternative(x[0])
+    else
+      x
+    end
+  end
+
+  # Turns a PResourceType or PHostClassType into an array [type, title] and all other references to [ref, nil]
+  # This is needed since it is not possible to find resources in the catalog based on the type system types :-(
+  # (note, the catalog is also used on the agent side)
+  def canonical_ref(ref)
+    case ref
+    when Puppet::Pops::Types::PResourceType
+      [ref.type_name, ref.title]
+    when Puppet::Pops::Types::PHostClassType
+      ['class', ref.class_name]
+    else
+      [ref.to_s, nil]
     end
-    source_resource[param_name] << target
   end
 end

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

@@ -1,11 +1,8 @@
-require 'puppet/parser/yaml_trimmer'
-
 # The parameters we stick in Resources.
 class Puppet::Parser::Resource::Param
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::MethodHelper
-  include Puppet::Parser::YamlTrimmer
 
   attr_accessor :name, :value, :source, :add, :file, :line
 

data/lib/puppet/parser/resource.rb

@@ -6,13 +6,11 @@ require 'puppet/resource'
 class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/parser/resource/param'
   require 'puppet/util/tagging'
-  require 'puppet/parser/yaml_trimmer'
 
   include Puppet::Util
   include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
-  include Puppet::Parser::YamlTrimmer
 
   attr_accessor :source, :scope, :collector_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
@@ -60,7 +58,7 @@ class Puppet::Parser::Resource < Puppet::Resource
     return unless self.class?
 
     unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
-      raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
+      raise ArgumentError, _("Could not find stage %{stage} specified by %{resource}") % { stage: self[:stage] || :main, resource: self }
     end
 
     self[:stage] ||= stage.title unless stage.title == :main
@@ -70,7 +68,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   # Retrieve the associated definition and evaluate it.
   def evaluate
     return if evaluated?
-    Puppet::Util::Profiler.profile("Evaluated resource #{self}", [:compiler, :evaluate_resource, self]) do
+    Puppet::Util::Profiler.profile(_("Evaluated resource %{res}") % { res: self }, [:compiler, :evaluate_resource, self]) do
       @evaluated = true
       if builtin_type?
         devfail "Cannot evaluate a builtin type (#{type})"
@@ -99,7 +97,6 @@ class Puppet::Parser::Resource < Puppet::Resource
   #
   def finish_evaluation
     return if @evaluation_finished
-    add_defaults
     add_scope_tags
     @evaluation_finished = true
   end
@@ -124,12 +121,24 @@ class Puppet::Parser::Resource < Puppet::Resource
     @finished
   end
 
-  def initialize(type, title, attributes)
-    raise ArgumentError, 'Resources require a hash as last argument' unless attributes.is_a? Hash
-    raise ArgumentError, 'Resources require a scope' unless attributes[:scope]
-    super
+  def initialize(type, title, attributes, with_defaults = true)
+    raise ArgumentError, _('Resources require a hash as last argument') unless attributes.is_a? Hash
+    raise ArgumentError, _('Resources require a scope') unless attributes[:scope]
+    super(type, title, attributes)
 
     @source ||= scope.source
+
+    if with_defaults
+      scope.lookupdefaults(self.type).each_pair do |name, param|
+        unless @parameters.include?(name)
+          self.debug "Adding default for #{name}"
+
+          param = param.dup
+          @parameters[name] = param
+          tag(*param.value) if param.name == :tag
+        end
+      end
+    end
   end
 
   # Is this resource modeling an isomorphic resource type?
@@ -156,7 +165,7 @@ class Puppet::Parser::Resource < Puppet::Resource
     # Test the resource scope, to make sure the resource is even allowed
     # to override.
     unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
-      raise Puppet::ParseError.new("Only subclasses can override parameters", resource.file, resource.line)
+      raise Puppet::ParseError.new(_("Only subclasses can override parameters"), resource.file, resource.line)
     end
     # Some of these might fail, but they'll fail in the way we want.
     resource.parameters.each do |name, param|
@@ -190,7 +199,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   alias []= set_parameter
 
   def to_hash
-    @parameters.reduce({}) do |result, (_, param)|
+    parse_title.merge(@parameters.reduce({}) do |result, (_, param)|
       value = param.value
       value = (:undef == value) ? nil : value
 
@@ -206,7 +215,7 @@ class Puppet::Parser::Resource < Puppet::Resource
         end
       end
       result
-    end
+    end)
   end
 
   # Convert this resource to a RAL resource.
@@ -242,18 +251,18 @@ class Puppet::Parser::Resource < Puppet::Resource
     map = {}
     [ self[:consume] ].flatten.map do |ref|
       # Assert that the ref really is a resource reference
-      raise Puppet::Error, "Invalid consume in #{self.ref}: #{ref} is not a resource" unless ref.is_a?(Puppet::Resource)
+      raise Puppet::Error, _("Invalid consume in %{value0}: %{ref} is not a resource") % { value0: self.ref, ref: ref } unless ref.is_a?(Puppet::Resource)
 
       # Resolve references
       t = ref.type
       t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
       cap = catalog.resource(t, ref.title)
       if cap.nil?
-        raise "Resource #{ref} could not be found; it might not have been produced yet"
+        raise _("Resource %{ref} could not be found; it might not have been produced yet") % { ref: ref }
       end
 
       # Ensure that the found resource is a capability resource
-      raise Puppet::Error, "Invalid consume in #{ref}: #{cap} is not a capability resource" unless cap.resource_type.is_capability?
+      raise Puppet::Error, _("Invalid consume in %{ref}: %{cap} is not a capability resource") % { ref: ref, cap: cap } unless cap.resource_type.is_capability?
       cap
     end.each do |cns|
       # Establish mappings
@@ -262,7 +271,7 @@ class Puppet::Parser::Resource < Puppet::Resource
       end
       # @todo lutter 2015-08-03: catch this earlier, can we do this during
       # static analysis ?
-      raise "Resource #{self} tries to consume #{cns} but no 'consumes' mapping exists for #{self.resource_type} and #{cns.type}" unless blueprint
+      raise _("Resource %{res} tries to consume %{cns} but no 'consumes' mapping exists for %{resource_type} and %{cns_type}") % { res: self, cns: cns, resource_type: self.resource_type, cns_type: cns.type } unless blueprint
 
       # setup scope that has, for each attr of cns, a binding to cns[attr]
       scope.with_global_scope do |global_scope|
@@ -281,7 +290,7 @@ class Puppet::Parser::Resource < Puppet::Resource
             # @todo lutter 2015-07-01: this should be caught by the checker
             # much earlier. We consume several capres, at least two of which
             # want to map to the same parameter (PUP-5080)
-            raise "Attempt to reassign attribute '#{name}' in '#{self}' caused by multiple consumed mappings to the same attribute" if map[name]
+            raise _("Attempt to reassign attribute '%{name}' in '%{resource}' caused by multiple consumed mappings to the same attribute") % { name: name, resource: self } if map[name]
             map[name] = value
           end
         end
@@ -301,17 +310,6 @@ class Puppet::Parser::Resource < Puppet::Resource
 
   private
 
-  # Add default values from our definition.
-  def add_defaults
-    scope.lookupdefaults(self.type).each do |name, param|
-      unless @parameters.include?(name)
-        self.debug "Adding default for #{name}"
-
-        @parameters[name] = param.dup
-      end
-    end
-  end
-
   def add_scope_tags
     scope_resource = scope.resource
     unless scope_resource.nil? || scope_resource.equal?(self)
@@ -334,8 +332,11 @@ class Puppet::Parser::Resource < Puppet::Resource
     # than replacing an existing one.
     (set_parameter(param) and return) unless current = @parameters[param.name]
 
+    # Parameter is already set - if overriding with a default - simply ignore the setting of the default value
+    return if scope.is_default?(type, param.name, param.value)
+
     # The parameter is already set.  Fail if they're not allowed to override it.
-    unless param.source.child_of?(current.source)
+    unless param.source.child_of?(current.source) || param.source.equal?(current.source) && scope.is_default?(type, param.name, current.value)
       msg = "Parameter '#{param.name}' is already set on #{self}"
       msg += " by #{current.source}" if current.source.to_s != ""
       if current.file or current.line
@@ -380,7 +381,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   def extract_parameters(params)
     params.each do |param|
       # Don't set the same parameter twice
-      self.fail Puppet::ParseError, "Duplicate parameter '#{param.name}' for on #{self}" if @parameters[param.name]
+      self.fail Puppet::ParseError, _("Duplicate parameter '%{param}' for on %{resource}") % { param: param.name, resource: self } if @parameters[param.name]
 
       set_parameter(param)
     end