puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

@@ -5,7 +5,7 @@ Puppet::Parser::Functions::newfunction(
   :doc => <<-DOC
 Applies a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 to every value in a data structure and returns an array or hash containing any elements
-for which the lambda evaluates to `true`.
+for which the lambda evaluates to a truthy value (not `false` or `undef`).
 
 This function takes two mandatory arguments, in this order:
 

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

@@ -14,7 +14,7 @@ Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue
       #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?
+      if Puppet::Util::Platform.windows?
         valid = args[0] =~ /^[a-z]:(?:[\/\\][-.~\w]+)+$/i
       else
         valid = args[0] =~ /^[-\/\w.+]+$/

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

@@ -6,12 +6,12 @@ text result as a String.
 
 The first argument to this function should be a string containing an EPP
 template. In most cases, the last argument is optional; if used, it should be a
-[hash](https://puppet.com/docs/puppet/latest/lang_data_hash.html) that contains parameters to
+[hash](/puppet/latest/reference/lang_data_hash.html) that contains parameters to
 pass to the template.
 
-- See the [template](https://puppet.com/docs/puppet/latest/lang_template.html) documentation
+- See the [template](/puppet/latest/reference/lang_template.html) documentation
 for general template usage information.
-- See the [EPP syntax](https://puppet.com/docs/puppet/latest/lang_template_epp.html)
+- See the [EPP syntax](/puppet/latest/reference/lang_template_epp.html)
 documentation for examples of EPP.
 
 For example, to evaluate an inline EPP template and pass it the `docroot` and
@@ -29,7 +29,7 @@ parameter tag without default values. Puppet produces an error if the
 `inline_epp` function fails to pass any required parameter.
 
 An inline EPP template should be written as a single-quoted string or
-[heredoc](https://puppet.com/docs/puppet/latest/lang_data_string.html#heredocs).
+[heredoc](/puppet/latest/reference/lang_data_string.html#heredocs).
 A double-quoted string is subject to expression interpolation before the string
 is parsed as an EPP template.
 
@@ -45,7 +45,7 @@ END
 ~~~
 
 - Since 3.5
-- Requires [future parser](https://puppet.com/docs/puppet/3.8/experiments_future.html) in Puppet 3.5 to 3.8") do |arguments|
+- Requires [future parser](/puppet/3.8/reference/experiments_future.html) in Puppet 3.5 to 3.8") do |arguments|
 
   Puppet::Parser::Functions::Error.is4x('inline_epp')
 end

data/lib/puppet/parser/resource.rb

@@ -8,7 +8,6 @@ class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/util/tagging'
 
   include Puppet::Util
-  include Puppet::Util::MethodHelper
   include Puppet::Util::Errors
   include Puppet::Util::Logging
 
@@ -337,11 +336,10 @@ class Puppet::Parser::Resource < Puppet::Resource
   end
 
   def replace_sensitive_data
-    parameters.keys.each do |name|
-      param = parameters[name]
+    parameters.each_pair do |name, param|
       if param.value.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
         @sensitive_parameters << name
-        parameters[name] = Puppet::Parser::Resource::Param.from_param(param, param.value.unwrap)
+        param.value = param.value.unwrap
       end
     end
   end

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

@@ -2,14 +2,21 @@
 class Puppet::Parser::Resource::Param
   include Puppet::Util
   include Puppet::Util::Errors
-  include Puppet::Util::MethodHelper
 
   attr_accessor :name, :value, :source, :add, :file, :line
 
-  def initialize(hash)
-    set_options(hash)
-    requiredopts(:name)
-    @name = @name.intern
+  def initialize(name: nil, value: nil, source: nil, line: nil, file: nil, add: nil)
+    @value = value
+    @source = source
+    @line = line
+    @file = file
+    @add = add
+
+    unless name
+      # This must happen after file and line are set to have them reported in the error
+      self.fail(Puppet::ResourceError, "'name' is a required option for #{self.class}")
+    end
+    @name = name.intern
   end
 
   def line_to_i
@@ -19,10 +26,4 @@ class Puppet::Parser::Resource::Param
   def to_s
     "#{self.name} => #{self.value}"
   end
-
-  def self.from_param(param, value)
-    new_param = param.dup
-    new_param.value = value
-    return new_param
-  end
 end

data/lib/puppet/parser/scope.rb

@@ -7,8 +7,6 @@ require 'puppet/parser'
 require 'puppet/parser/templatewrapper'
 require 'puppet/parser/resource'
 
-require 'puppet/util/methodhelper'
-
 # This class is part of the internal parser/evaluator/compiler functionality of Puppet.
 # It is passed between the various classes that participate in evaluation.
 # None of its methods are API except those that are clearly marked as such.
@@ -16,7 +14,6 @@ require 'puppet/util/methodhelper'
 # @api public
 class Puppet::Parser::Scope
   extend Forwardable
-  include Puppet::Util::MethodHelper
 
   # Variables that always exist with nil value even if not set
   BUILT_IN_VARS = ['module_name'.freeze, 'caller_module_name'.freeze].freeze
@@ -374,14 +371,15 @@ class Puppet::Parser::Scope
   end
 
   # Initialize our new scope.  Defaults to having no parent.
-  def initialize(compiler, options = EMPTY_HASH)
+  def initialize(compiler, source: nil, resource: nil)
     if compiler.is_a? Puppet::Parser::AbstractCompiler
       @compiler = compiler
     else
       raise Puppet::DevError, _("you must pass a compiler instance to a new scope object")
     end
 
-    set_options(options)
+    @source = source
+    @resource = resource
 
     extend_with_functions_module
 
@@ -771,8 +769,8 @@ class Puppet::Parser::Scope
       raise Puppet::ParseError, _("Attempt to assign to a reserved variable name: '%{name}'") % { name: name }
     end
 
-    # Check for server_facts reserved variable name if the trusted_sever_facts setting is true
-    if name == VARNAME_SERVER_FACTS && !options[:privileged] && Puppet[:trusted_server_facts]
+    # Check for server_facts reserved variable name
+    if name == VARNAME_SERVER_FACTS && !options[:privileged]
       raise Puppet::ParseError, _("Attempt to assign to a reserved variable name: '%{name}'") % { name: name }
     end
 
@@ -816,7 +814,7 @@ class Puppet::Parser::Scope
   end
 
   # Deeply freezes the given object. The object and its content must be of the types:
-  # Array, Hash, Numeric, Boolean, Symbol, Regexp, NilClass, or String. All other types raises an Error.
+  # Array, Hash, Numeric, Boolean, Regexp, NilClass, or String. All other types raises an Error.
   # (i.e. if they are assignable to Puppet::Pops::Types::Data type).
   #
   def deep_freeze(object)

data/lib/puppet/parser/script_compiler.rb

@@ -66,13 +66,14 @@ class Puppet::Parser::ScriptCompiler
       :current_environment => environment,
       :global_scope => @topscope,             # 4x placeholder for new global scope
       :loaders  => @loaders,                  # 4x loaders
+      :rich_data => true,
     }
   end
 
   # Create a script compiler for the given environment where errors are logged as coming
   # from the given node_name
   #
-  def initialize(environment, node_name)
+  def initialize(environment, node_name, for_agent=false)
     @environment = environment
     @node_name = node_name
 
@@ -80,7 +81,11 @@ class Puppet::Parser::ScriptCompiler
     @topscope = Puppet::Parser::Scope.new(self)
 
     # Initialize loaders and Pcore
-    @loaders = Puppet::Pops::Loaders.new(environment)
+    if for_agent
+      @loaders = Puppet::Pops::Loaders.new(environment, true)
+    else
+      @loaders = Puppet::Pops::Loaders.new(environment)
+    end
 
     # Need to compute overrides here, and remember them, because we are about to
     # Expensive entries in the context are bound lazily.

data/lib/puppet/pops.rb

@@ -70,6 +70,7 @@ module Puppet
       require 'puppet/pops/evaluator/epp_evaluator'
       require 'puppet/pops/evaluator/collector_transformer'
       require 'puppet/pops/evaluator/puppet_proc'
+      require 'puppet/pops/evaluator/deferred_resolver'
       module Collectors
         require 'puppet/pops/evaluator/collectors/abstract_collector'
         require 'puppet/pops/evaluator/collectors/fixed_set_collector'

data/lib/puppet/pops/adaptable.rb

@@ -69,7 +69,11 @@ module Adaptable
     #
     def self.get(o)
       attr_name = self_attr_name
-      o.instance_variable_get(attr_name)
+      if o.instance_variable_defined?(attr_name)
+        o.instance_variable_get(attr_name)
+      else
+        nil
+      end
     end
 
     # Returns an existing adapter for the given object, or creates a new adapter if the
@@ -90,16 +94,17 @@ module Adaptable
     #
     def self.adapt(o, &block)
       attr_name = self_attr_name
-      adapter = if value = o.instance_variable_get(attr_name)
+      adapter = if o.instance_variable_defined?(attr_name) && value = o.instance_variable_get(attr_name)
         value
       else
         associate_adapter(create_adapter(o), o)
       end
       if block_given?
-        if block.arity == 1
-          block.call(adapter)
-        else
-          block.call(adapter, o)
+        case block.arity
+          when 1
+            block.call(adapter)
+          else
+            block.call(adapter, o)
         end
       end
       adapter
@@ -125,7 +130,8 @@ module Adaptable
     def self.adapt_new(o, &block)
       adapter = associate_adapter(create_adapter(o), o)
       if block_given?
-        if block.arity == 1
+        case block.arity
+        when 1
           block.call(adapter)
         else
           block.call(adapter, o)

data/lib/puppet/pops/adapters.rb

@@ -2,6 +2,20 @@
 #
 module Puppet::Pops
 module Adapters
+
+  class ObjectIdCacheAdapter < Puppet::Pops::Adaptable::Adapter
+    attr_accessor :cache
+
+    def initialize
+      @cache = {}
+    end
+
+    # Retrieves a mutable hash with all stored values
+    def retrieve(o)
+      @cache[o.__id__] ||= {}
+    end
+  end
+
   # A documentation adapter adapts an object with a documentation string.
   # (The intended use is for a source text parser to extract documentation and store this
   # in DocumentationAdapter instances).
@@ -85,13 +99,6 @@ module Adapters
 
     class PathsAndNameCacheAdapter < Puppet::Pops::Adaptable::Adapter
       attr_accessor :cache, :paths
-
-      def self.create_adapter(env)
-        adapter = super(env)
-        adapter.paths = env.modulepath.map { |p| Pathname.new(p) }
-        adapter.cache = {}
-        adapter
-      end
     end
 
     # Attempts to find the module that `instance` originates from by looking at it's {SourcePosAdapter} and
@@ -110,7 +117,10 @@ module Adapters
     def self.loader_name_by_source(environment, instance, file)
       file = instance.file if file.nil?
       return nil if file.nil? || EMPTY_STRING == file
-      pn_adapter = PathsAndNameCacheAdapter.adapt(environment)
+      pn_adapter = PathsAndNameCacheAdapter.adapt(environment) do |a|
+        a.paths ||= environment.modulepath.map { |p| Pathname.new(p) }
+        a.cache ||= {}
+      end
       dir = File.dirname(file)
       pn_adapter.cache.fetch(dir) do |key|
         mod = find_module_for_dir(environment, pn_adapter.paths, dir)

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

@@ -20,14 +20,14 @@ class AccessOperator
     @semantic = access_expression
   end
 
-  def access(o, scope, *keys)
+  def access (o, scope, *keys)
     @@access_visitor.visit_this_2(self, o, scope, keys)
   end
 
   protected
 
   def access_Object(o, scope, keys)
-    type = Puppet::Pops::Types::TypeCalculator.infer_callable_methods_t(o)
+    type = Puppet::Pops::Types::TypeCalculator.infer(o)
     if type.is_a?(Puppet::Pops::Types::TypeWithMembers)
       access_func = type['[]']
       return access_func.invoke(o, scope, keys) unless access_func.nil?

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

@@ -45,13 +45,13 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
     return false if objects.empty?
 
     if @overrides and !objects.empty?
-      overrides[:source].override = true
+      overrides[:source].meta_def(:child_of?) do |klass|
+        true
+      end
 
       objects.each do |res|
         unless @collected.include?(res.ref)
-          t = res.type
-          t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t)
-          newres = Puppet::Parser::Resource.new(t, res.title, @overrides)
+          newres = Puppet::Parser::Resource.new(res.type, res.title, @overrides)
           scope.compiler.add_override(newres)
         end
       end

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

@@ -24,6 +24,6 @@ class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Eval
   end
 
   def to_s
-    "Catalog-Collector[#{@type}]"
+    "Catalog-Collector[#{@type.to_s}]"
   end
 end

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

@@ -64,6 +64,6 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
   end
 
   def to_s
-    "Exported-Collector[#{@type}]"
+    "Exported-Collector[#{@type.to_s}]"
   end
 end

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

@@ -23,7 +23,7 @@ class CompareOperator
     @@include_visitor ||= Visitor.new(self, "include", 2, 2)
   end
 
-  def equals (a, b)
+  def equals(a, b)
     @@equals_visitor.visit_this_1(self, a, b)
   end
 
@@ -59,6 +59,8 @@ class CompareOperator
   def cmp_Numeric(a, b)
     if b.is_a?(Numeric)
       a <=> b
+    elsif b.is_a?(Time::Timespan) || b.is_a?(Time::Timestamp)
+      -(b <=> a) # compare other way and invert result
     else
       raise ArgumentError.new(_("A Numeric is not comparable to non Numeric"))
     end

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

@@ -0,0 +1,127 @@
+require 'puppet/parser/script_compiler'
+
+module Puppet::Pops
+module Evaluator
+
+# Utility class to help resolve instances of Puppet::Pops::Types::PDeferredType::Deferred
+#
+class DeferredResolver
+  DOLLAR = '$'.freeze
+  DIG    = 'dig'.freeze
+
+  # Resolves and replaces all Deferred values in a catalog's resource attributes
+  # found as direct values or nested inside Array, Hash or Sensitive values.
+  # Deferred values inside of custom Object instances are not resolved as this
+  # is expected to be done by such objects.
+  #
+  # @param facts [Puppet::Node::Facts] the facts object for the node
+  # @param catalog [Puppet::Resource::Catalog] the catalog where all deferred values should be replaced
+  # @return [nil] does not return anything - the catalog is modified as a side effect
+  #
+  def self.resolve_and_replace(facts, catalog)
+    compiler = Puppet::Parser::ScriptCompiler.new(catalog.environment_instance, catalog.name, true)
+    resolver = new(compiler)
+    resolver.set_facts_variable(facts)
+    # TODO:
+    #    # When scripting the trusted data are always local, but set them anyway
+    #    @scope.set_trusted(node.trusted_data)
+    #
+    #    # Server facts are always about the local node's version etc.
+    #    @scope.set_server_facts(node.server_facts)
+
+    resolver.resolve_futures(catalog)
+    nil
+  end
+
+  # Resolves a value such that a direct Deferred, or any nested Deferred values
+  # are resolved and used instead of the deferred value.
+  # A direct Deferred value, or nested deferred values inside of Array, Hash or
+  # Sensitive values are resolved and replaced inside of freshly created
+  # containers.
+  #
+  # The resolution takes place in the topscope of the given compiler.
+  # Variable values are supposed to already have been set.
+  #
+  # @param value [Object] the (possibly nested) value to resolve
+  # @param compiler [Puppet::Parser::ScriptCompiler, Puppet::Parser::Compiler] the compiler in effect
+  # @return [Object] the resolved value (a new Array, Hash, or Sensitive if needed), with all deferred values resolved
+  #
+  def self.resolve(value, compiler)
+    resolver = new(compiler)
+    resolver.resolve(value)
+  end
+
+  def initialize(compiler)
+    @compiler = compiler
+    # Always resolve in top scope
+    @scope = @compiler.topscope
+    @deferred_class = Puppet::Pops::Types::TypeFactory.deferred.implementation_class
+  end
+
+  # @param facts [Puppet::Node::Facts] the facts to set in $facts in the compiler's topscope
+  #
+  def set_facts_variable(facts)
+    @scope.set_facts(facts.nil? ? {} : facts.values)
+  end
+
+  def resolve_futures(catalog)
+    catalog.resources.each do |r|
+      overrides = {}
+      r.parameters.each_pair do |k, v|
+        resolved = resolve(v)
+        # If the value is instance of Sensitive - assign the unwrapped value
+        # and mark it as sensitive if not already marked
+        #
+        if resolved.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+          resolved = resolved.unwrap
+          unless r.sensitive_parameters.include?(k.to_sym)
+            r.sensitive_parameters = (r.sensitive_parameters + [k.to_sym]).freeze
+          end
+        end
+        overrides[ k ] = resolved
+      end
+      r.parameters.merge!(overrides) unless overrides.empty?
+    end
+  end
+
+  def resolve(x)
+    if x.class == @deferred_class
+      resolve_future(x)
+    elsif x.is_a?(Array)
+      x.map {|v| resolve(v) }
+    elsif x.is_a?(Hash)
+      result = {}
+      x.each_pair {|k,v| result[k] = resolve(v) }
+      result
+    elsif x.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+      # rewrap in a new Sensitive after resolving any nested deferred values
+      Puppet::Pops::Types::PSensitiveType::Sensitive.new(resolve(x.unwrap))
+    else
+      x
+    end
+  end
+
+  def resolve_future(f)
+    # If any of the arguments to a future is a future it needs to be resolved first
+    func_name = f.name
+    mapped_arguments = map_arguments(f.arguments)
+    # if name starts with $ then this is a call to dig 
+    if func_name[0] == DOLLAR
+      var_name = func_name[1..-1]
+      func_name = DIG
+      mapped_arguments.insert(0, @scope[var_name])
+    end
+
+    # call the function (name in deferred, or 'dig' for a variable)
+    @scope.call_function(func_name, mapped_arguments)
+  end
+
+  def map_arguments(args)
+    return [] if args.nil?
+    args.map {|v| resolve(v) }
+  end
+  private :map_arguments
+
+end
+end
+end