puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

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

@@ -34,5 +34,5 @@ Would notice the value `[10, 200, 30]`
 * Since 4.8.0
 DOC
 ) do |args|
-  Puppet::Parser::Functions::Error.is4x('next')
+  Error.is4x('next')
 end

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

@@ -102,5 +102,5 @@ $combine = $data.reduce( [d, 4] ) |$memo, $value| {
 - Since 4.0.0
 DOC
 ) do |args|
-  Puppet::Parser::Functions::Error.is4x('reduce')
+  Error.is4x('reduce')
 end

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

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

@@ -4,8 +4,7 @@ Puppet::Parser::Functions::newfunction(
   :doc => <<-DOC
 Immediately returns the given optional value from a function, class body or user defined type body.
 If a value is not given, an `undef` value is returned. This function does not return to the immediate caller.
-If this function is called from within a lambda, the return action is from the scope of the
-function containing the lambda (top scope), not the function accepting the lambda (local scope).
+If called from within a lambda the return will return from the function evaluating the lambda.
 
 The signal produced to return a value bubbles up through
 the call stack until reaching a function, class definition or
@@ -64,29 +63,9 @@ The code would notice `'bar'` but not `'foo'`
 
 Note that the returned value is ignored if used in a class or user defined type.
 
-**Example:** Using `return` in a lambda
-
-```puppet
-# Concatenate three strings into a single string formatted as a list.
-function getFruit() {
-  with("apples", "oranges", "bananas") |$x, $y, $z| {
-    return("${x}, ${y}, and ${z}")
-  }
-  notice "not reached"
-}
-$fruit = getFruit()
-notice $fruit
-
-# The output contains "apples, oranges, and bananas".
-# "not reached" is not output because the function returns its value within the
-# calling function's scope, which stops processing the calling function before
-# the `notice "not reached"` statement.
-# Using `return()` outside of a calling function results in an error.
-```
-
 * Also see functions `return` and `break`
 * Since 4.8.0
 DOC
 ) do |args|
-  Puppet::Parser::Functions::Error.is4x('return')
+  Error.is4x('return')
 end

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

@@ -79,5 +79,5 @@ $transformed_data = map(reverse_each($data)) |$item| { $item * 10 }
 
 DOC
 ) do |args|
-  Puppet::Parser::Functions::Error.is4x('reverse_each')
+  Error.is4x('reverse_each')
 end

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

@@ -35,5 +35,5 @@ to empty arrays for a hash.
 - Since 4.0.0
 DOC
 ) do |args|
-  Puppet::Parser::Functions::Error.is4x('slice')
+  Error.is4x('slice')
 end

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

@@ -29,22 +29,8 @@ Puppet::Parser::Functions::newfunction(
   :arity => -2,
   :doc => "Perform printf-style formatting of text.
 
-  The first parameter is format string describing how the rest of the parameters should be formatted.
-  See the documentation for the `Kernel::sprintf` function in Ruby for all the details."
+      The first parameter is format string describing how the rest of the parameters should be formatted.  See the documentation for the `Kernel::sprintf` function in Ruby for all the details."
 ) do |args|
-  fmt = args[0]
-  args = args[1..-1]
-  begin
-    return sprintf(fmt, *args)
-  rescue KeyError => e
-    if args.size == 1 && args[0].is_a?(Hash)
-      # map the single hash argument such that all top level string keys are symbols
-      # as that allows named arguments to be used in the format string.
-      #
-      result = {}
-      args[0].each_pair { |k,v| result[k.is_a?(String) ? k.to_sym : k] = v }
-      return sprintf(fmt, result)
-    end
-    raise e
-  end
+  fmt = args.shift
+  return sprintf(fmt, *args)
 end

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

@@ -80,5 +80,5 @@ $transformed_data contains [0,50,100,150,200]
 
 DOC
 ) do |args|
-  Puppet::Parser::Functions::Error.is4x('step')
+  Error.is4x('step')
 end

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

@@ -181,5 +181,5 @@ notice($duration.strftime('%M:%S')) # outputs '200:30'
 - Since 4.8.0
 DOC
 ) do |args|
-  Puppet::Parser::Functions::Error.is4x('strftime')
+  Error.is4x('strftime')
 end

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

@@ -69,5 +69,5 @@ was not a String.
 
 DOC
 ) do |args|
-  Puppet::Parser::Functions::Error.is4x('then')
+  Error.is4x('then')
 end

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

@@ -49,5 +49,5 @@ function type(Any $value, InferenceFidelity $fidelity = 'detailed') # returns Ty
 
 DOC
 ) do |args|
-  Puppet::Parser::Functions::Error.is4x('type')
+  Error.is4x('type')
 end

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

@@ -24,5 +24,5 @@ $check_var = $x
 - Since 4.0.0
 DOC
 ) do |args|
-  Puppet::Parser::Functions::Error.is4x('with')
+  Error.is4x('with')
 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.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