puppet 6.19.0-x64-mingw32 → 7.3.0-x64-mingw32

data/lib/puppet/network/http/handler.rb

@@ -2,7 +2,6 @@ module Puppet::Network::HTTP
 end
 
 require 'puppet/network/http'
-require 'puppet/network/rights'
 require 'puppet/util/profiler'
 require 'puppet/util/profiler/aggregate'
 require 'resolv'

data/lib/puppet/network/http_pool.rb

@@ -1,19 +1,15 @@
 require 'puppet/network/http/connection'
-require 'puppet/network/http/connection_adapter'
-require 'puppet/util/platform'
 
 module Puppet::Network; end
 
-# This module contains the factory methods that should be used for getting a
-# {Puppet::Network::HTTP::Connection} instance. The pool may return a new
-# connection or a persistent cached connection, depending on the underlying
-# pool implementation in use.
+# This module is deprecated.
 #
 # @api public
+# @deprecated Use {Puppet::HTTP::Client} instead.
 #
 module Puppet::Network::HttpPool
 
-  @http_client_class = Puppet::Network::HTTP::ConnectionAdapter
+  @http_client_class = Puppet::Network::HTTP::Connection
 
   def self.http_client_class
     @http_client_class
@@ -30,37 +26,20 @@ module Puppet::Network::HttpPool
   # @param verify_peer [Boolean] Whether to verify the peer credentials, if possible. Verification will not take place if the CA certificate is missing.
   # @return [Puppet::Network::HTTP::Connection]
   #
-  # @deprecated Use {#http_connection} instead.
+  # @deprecated Use {Puppet.runtime[:http]} instead.
   # @api public
   #
   def self.http_instance(host, port, use_ssl = true, verify_peer = true)
-    verifier = if verify_peer
-                 Puppet::SSL::Validator.default_validator()
-               else
-                 Puppet::SSL::Validator.no_validator()
-               end
+    Puppet.warn_once('deprecations', self, "The method 'Puppet::Network::HttpPool.http_instance' is deprecated. Use Puppet.runtime[:http] instead")
 
-    http_client_class.new(host, port,
-                            :use_ssl => use_ssl,
-                            :verify => verifier)
-  end
-
-  # Get an http connection that will be secured with SSL and have the
-  # connection verified with the given verifier
-  #
-  # @param host [String] the DNS name to connect to
-  # @param port [Integer] the port to connect to
-  # @param verifier [#setup_connection, #peer_certs, #verify_errors] An object that will setup the appropriate
-  #   verification on a Net::HTTP instance and report any errors and the certificates used.
-  # @return [Puppet::Network::HTTP::Connection]
-  #
-  # @deprecated Use {#http_connection} instead.
-  # @api public
-  #
-  def self.http_ssl_instance(host, port, verifier = Puppet::SSL::Validator.default_validator())
-    http_client_class.new(host, port,
-                            :use_ssl => true,
-                            :verify => verifier)
+    if verify_peer
+      verifier = Puppet::SSL::Verifier.new(host, nil)
+      http_client_class.new(host, port, use_ssl: use_ssl, verifier: verifier)
+    else
+      ssl = Puppet::SSL::SSLProvider.new
+      verifier = Puppet::SSL::Verifier.new(host, ssl.create_insecure_context)
+      http_client_class.new(host, port, use_ssl: use_ssl, verifier: verifier)
+    end
   end
 
   # Retrieve a connection for the given host and port.
@@ -72,9 +51,12 @@ module Puppet::Network::HttpPool
   #   when making HTTPS connections. Required when `use_ssl` is `true`.
   # @return [Puppet::Network::HTTP::Connection]
   #
+  # @deprecated Use {Puppet.runtime[:http]} instead.
   # @api public
   #
   def self.connection(host, port, use_ssl: true, ssl_context: nil)
+    Puppet.warn_once('deprecations', self, "The method 'Puppet::Network::HttpPool.connection' is deprecated. Use Puppet.runtime[:http] instead")
+
     if use_ssl
       unless ssl_context
         # TRANSLATORS 'ssl_context' is an argument and should not be translated

data/lib/puppet/node.rb

@@ -183,36 +183,7 @@ class Puppet::Node
   # Calculate the list of names we might use for looking
   # up our node.  This is only used for AST nodes.
   def names
-    return [name] if Puppet.settings[:strict_hostname_checking]
-
-    names = []
-
-    names += split_name(name) if name.include?(".")
-
-    # First, get the fqdn
-    fqdn = parameters["fqdn"]
-    unless fqdn
-      if parameters["hostname"] and parameters["domain"]
-        fqdn = parameters["hostname"] + "." + parameters["domain"]
-      else
-        Puppet.warning _("Host is missing hostname and/or domain: %{name}") % { name: name }
-      end
-    end
-
-    # Now that we (might) have the fqdn, add each piece to the name
-    # list to search, in order of longest to shortest.
-    names += split_name(fqdn) if fqdn
-
-    # And make sure the node name is first, since that's the most
-    # likely usage.
-    #   The name is usually the Certificate CN, but it can be
-    # set to the 'facter' hostname instead.
-    if Puppet[:node_name] == 'cert'
-      names.unshift name
-    else
-      names.unshift parameters["hostname"]
-    end
-    names.uniq
+    @names ||= [name]
   end
 
   def split_name(name)

data/lib/puppet/pal/json_catalog_encoder.rb

@@ -4,6 +4,8 @@
 #
 # @api public
 #
+module Puppet
+module Pal
 class JsonCatalogEncoder
   # Is the resulting Json pretty printed or not.
   attr_reader :pretty
@@ -65,3 +67,5 @@ class JsonCatalogEncoder
   end
   private :possibly_filtered_catalog
 end
+end
+end

data/lib/puppet/pal/pal_impl.rb

@@ -5,6 +5,7 @@ require 'puppet'
 require 'puppet/parser/script_compiler'
 require 'puppet/parser/catalog_compiler'
 
+module Puppet
 # This is the main entry point for "Puppet As a Library" PAL.
 # This file should be required instead of "puppet"
 # Initially, this will require ALL of puppet - over time this will change as the monolithical "puppet" is broken up
@@ -24,7 +25,7 @@ require 'puppet/parser/catalog_compiler'
 #   end
 #   # The result is what 'mymodule::myfunction' returns
 #
-module Puppet
+# @api public
 module Pal
 
   # Defines a context in which multiple operations in an env with a script compiler can be performed in a given block.
@@ -58,8 +59,8 @@ module Pal
       configured_by_env: false,
       manifest_file:     nil,
       code_string:       nil,
-      facts:             nil,
-      variables:         nil,
+      facts:             {},
+      variables:         {},
       set_local_facts:   true,
       &block
     )
@@ -93,7 +94,14 @@ module Pal
 
     # If manifest_file is nil, the #main method will use the env configured manifest
     # to do things in the block while a Script Compiler is in effect
-    main(manifest_file, facts, variables, :script, set_local_facts, &block)
+    main(
+      manifest:                manifest_file,
+      facts:                   facts,
+      variables:               variables,
+      internal_compiler_class: :script,
+      set_local_facts:         set_local_facts,
+      &block
+    )
   ensure
     Puppet[:tasks] = previous_tasks_value
     Puppet[:code] = previous_code_value
@@ -157,8 +165,9 @@ module Pal
     configured_by_env: false,
       manifest_file:     nil,
       code_string:       nil,
-      facts:             nil,
-      variables:         nil,
+      facts:             {},
+      variables:         {},
+      target_variables:  {},
       &block
   )
     # TRANSLATORS: do not translate variable name strings in these assertions
@@ -193,7 +202,15 @@ module Pal
 
     # If manifest_file is nil, the #main method will use the env configured manifest
     # to do things in the block while a Script Compiler is in effect
-    main(manifest_file, facts, variables, :catalog, false, &block)
+    main(
+      manifest:                manifest_file,
+      facts:                   facts,
+      variables:               variables,
+      target_variables:        target_variables,
+      internal_compiler_class: :catalog,
+      set_local_facts:         false,
+      &block
+    )
   ensure
     # Clean up after ourselves
     Puppet[:tasks] = previous_tasks_value
@@ -258,6 +275,7 @@ module Pal
   # @return [Object] returns what the given block returns
   # @yieldparam [Puppet::Pal] context, a context that responds to Puppet::Pal methods
   #
+  # @api public
   def self.in_environment(env_name,
       modulepath:    nil,
       pre_modulepath: [],
@@ -382,11 +400,12 @@ module Pal
   # the provided block
   #
   def self.main(
-    manifest,
-    facts,
-    variables,
-    internal_compiler_class,
-    set_local_facts
+    manifest:                nil,
+    facts:                   {},
+    variables:               {},
+    target_variables:        {},
+    internal_compiler_class: nil,
+    set_local_facts:         true
   )
     # Configure the load path
     env = Puppet.lookup(:pal_env)
@@ -403,14 +422,11 @@ module Pal
     pal_variables = Puppet.lookup(:pal_variables)
 
     overrides = {}
+
     unless facts.nil? || facts.empty?
       pal_facts = pal_facts.merge(facts)
       overrides[:pal_facts] = pal_facts
     end
-    unless variables.nil? || variables.empty?
-      pal_variables = pal_variables.merge(variables)
-      overrides[:pal_variables] = pal_variables
-    end
 
     prepare_node_facts(node, pal_facts)
 
@@ -463,10 +479,17 @@ module Pal
         # TRANSLATORS: Do not translate, symbolic name
         Puppet.override(overrides, "PAL::with_#{internal_compiler_class}_compiler") do
           compiler.compile do | compiler_yield |
-            # In case the varaibles passed to the compiler are PCore types defined in modules, they
+            # In case the variables passed to the compiler are PCore types defined in modules, they
             # need to be deserialized and added from within the this scope, so that loaders are
             # available during deserizlization.
-            add_variables(compiler.topscope, Puppet::Pops::Serialization::FromDataConverter.convert(pal_variables))
+            pal_variables = Puppet::Pops::Serialization::FromDataConverter.convert(pal_variables)
+            variables     = Puppet::Pops::Serialization::FromDataConverter.convert(variables)
+
+            # Merge together target variables and plan variables. This will also shadow any
+            # collisions with facts and emit a warning.
+            topscope_vars = pal_variables.merge(merge_vars(target_variables, variables, node.facts.values))
+
+            add_variables(compiler.topscope, topscope_vars)
             # wrap the internal compiler to prevent it from leaking in the PAL API
             if block_given?
               yield(pal_compiler)
@@ -486,6 +509,38 @@ module Pal
   end
   private_class_method :main
 
+  # Warn and remove variables that will be shadowed by facts of the same
+  # name, which are set in scope earlier.
+  def self.merge_vars(target_vars, vars, facts)
+    # First, shadow plan and target variables by facts of the same name
+    vars        = shadow_vars(facts || {}, vars, 'fact', 'plan variable')
+    target_vars = shadow_vars(facts || {}, target_vars, 'fact', 'target variable')
+    # Then, shadow target variables by plan variables of the same name
+    target_vars = shadow_vars(vars, target_vars, 'plan variable', 'target variable')
+
+    target_vars.merge(vars)
+  end
+  private_class_method :merge_vars
+
+  def self.shadow_vars(vars, other_vars, vars_type, other_vars_type)
+    collisions, valid = other_vars.partition do |k, _|
+      vars.include?(k)
+    end
+
+    if collisions.any?
+      names = collisions.map { |k, _| "$#{k}" }.join(', ')
+      plural = collisions.length == 1 ? '' : 's'
+
+      Puppet.warning(
+        "#{other_vars_type.capitalize}#{plural} #{names} will be overridden by "\
+        "#{vars_type}#{plural} of the same name in the apply block"
+      )
+    end
+
+    valid.to_h
+  end
+  private_class_method :shadow_vars
+
   def self.create_internal_compiler(compiler_class_reference, node)
     case compiler_class_reference
     when :script

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

@@ -50,8 +50,9 @@ class Puppet::Parser::AST::HostName < Puppet::Parser::AST::Leaf
 end
 
 class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
-  def initialize(hash)
-    super(**hash)
+  def initialize(value: nil, file: nil, line: nil, pos: nil)
+    super(value: value, file: file, line: line, pos: pos)
+
     # transform value from hash options unless it is already a regular expression
     @value = Regexp.new(@value) unless @value.is_a?(Regexp)
   end

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

@@ -92,14 +92,8 @@ class Puppet::Parser::AST::PopsBridge
           instantiate_HostClassDefinition(d, modname)
         when Puppet::Pops::Model::ResourceTypeDefinition
           instantiate_ResourceTypeDefinition(d, modname)
-        when Puppet::Pops::Model::CapabilityMapping
-          instantiate_CapabilityMapping(d, modname)
         when Puppet::Pops::Model::NodeDefinition
           instantiate_NodeDefinition(d, modname)
-        when Puppet::Pops::Model::SiteDefinition
-            instantiate_SiteDefinition(d, modname)
-        when Puppet::Pops::Model::Application
-          instantiate_ApplicationDefinition(d, modname)
         else
           loaders = Puppet::Pops::Loaders.loaders
           loaders.instantiate_definition(d, loaders.find_loader(modname))
@@ -214,27 +208,6 @@ class Puppet::Parser::AST::PopsBridge
       instance
     end
 
-    def instantiate_CapabilityMapping(o, modname)
-      # Use an intermediate 'capability_mapping' type to pass this info to the compiler where the
-      # actual mapping takes place
-      Puppet::Resource::Type.new(:capability_mapping, "#{o.component} #{o.kind} #{o.capability}", { :arguments => {
-        'component'     => o.component,
-        'kind'          => o.kind,
-        'blueprint'     => {
-          :capability => o.capability,
-          :mappings   => o.mappings.reduce({}) do |memo, mapping|
-            memo[mapping.attribute_name] =
-              Expression.new(:value => mapping.value_expr)
-            memo
-          end
-      }}})
-    end
-
-    def instantiate_ApplicationDefinition(o, modname)
-      args = args_from_definition(o, modname)
-      Puppet::Resource::Type.new(:application, o.name, @context.merge(args))
-    end
-
     def instantiate_NodeDefinition(o, modname)
       args = { :module_name => modname }
 
@@ -253,17 +226,6 @@ class Puppet::Parser::AST::PopsBridge
       end
     end
 
-    def instantiate_SiteDefinition(o, modname)
-      args = { :module_name => modname }
-
-      unless is_nop?(o.body)
-        args[:code] = Expression.new(:value => o.body)
-      end
-
-      args = @ast_transformer.merge_location(args, o)
-      Puppet::Resource::Type.new(:site, 'site', @context.merge(args))
-    end
-
     def code()
       Expression.new(:value => @value)
     end

data/lib/puppet/parser/compiler.rb

@@ -72,22 +72,6 @@ class Puppet::Parser::Compiler
   end
 
   def add_resource(scope, resource)
-    type = resource.resource_type
-    if type.is_a?(Puppet::Resource::Type) && type.application?
-      @applications << resource
-      assert_app_in_site(scope, resource)
-      return
-    end
-
-    if @current_app
-      # We are in the process of pulling application components out that
-      # apply to this node
-      Puppet.notice "Check #{resource}"
-      return unless @current_components.any? do |comp|
-        comp.type == resource.type && comp.title == resource.title
-      end
-    end
-
     @resources << resource
 
     # Note that this will fail if the resource is not unique.
@@ -110,22 +94,6 @@ class Puppet::Parser::Compiler
     end
   end
 
-  def assert_app_in_site(scope, resource)
-    if resource.type == 'App'
-      if scope.resource
-        # directly contained in a Site
-        return if scope.resource.type == 'Site'
-        # contained in something that may be contained in Site
-        upstream = @catalog.upstream_from_vertex(scope.resource)
-        if upstream
-          return if upstream.keys.map(&:type).include?('Site')
-        end
-      end
-      #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
-
   # Store the fact that we've evaluated a class
   def add_class(name)
     @catalog.add_class(name) unless name == ""
@@ -160,22 +128,13 @@ class Puppet::Parser::Compiler
 
       Puppet::Util::Profiler.profile(_("Compile: Created settings scope"), [:compiler, :create_settings_scope]) { create_settings_scope }
 
-      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 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 node classes"), [:compiler, :evaluate_node_classes]) { evaluate_node_classes }
 
-      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 generators"), [:compiler, :evaluate_generators]) { evaluate_generators }
 
       Puppet::Util::Profiler.profile(_("Compile: Validate Catalog pre-finish"), [:compiler, :validate_pre_finish]) do
@@ -184,8 +143,6 @@ class Puppet::Parser::Compiler
 
       Puppet::Util::Profiler.profile(_("Compile: Finished catalog"), [:compiler, :finish_catalog]) { finish }
 
-      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
@@ -243,112 +200,6 @@ class Puppet::Parser::Compiler
     evaluate_classes(classes_without_params, @node_scope || topscope)
   end
 
-  # Evaluates the site - the top container for an environment catalog
-  # The site contain behaves analogous to a node - for the environment catalog, node expressions are ignored
-  # as the result is cross node. The site expression serves as a container for everything that is across
-  # all nodes.
-  #
-  # @api private
-  #
-  def evaluate_site
-    # Has a site been defined? If not, do nothing but issue a warning.
-    #
-    site = environment.known_resource_types.find_site()
-    unless site
-      on_empty_site()
-      return
-    end
-
-    # Create a resource to model this site and add it to catalog
-    resource = site.ensure_in_catalog(topscope)
-
-    # The site sets node scope to be able to shadow what is in top scope
-    @node_scope = topscope.class_scope(site)
-
-    # Evaluates the logic contain in the site expression
-    resource.evaluate
-  end
-
-  # @api private
-  def on_empty_site
-    # do nothing
-  end
-
-  # Prunes the catalog by dropping all resources are contained under the Site (if a site expression is used).
-  # As a consequence all edges to/from dropped resources are also dropped.
-  # Once the pruning is performed, this compiler returns the pruned list when calling the #resources method.
-  # The pruning does not alter the order of resources in the resources list.
-  #
-  # @api private
-  def prune_catalog
-    prune_node_catalog
-  end
-
-  def prune_node_catalog
-    # Everything under Site[site] should be pruned as that is for the environment catalog, not a node
-    #
-    the_site_resource = @catalog.resource('Site', 'site')
-
-    if the_site_resource
-      # Get downstream vertexes returns a hash where the keys are the resources and values nesting level
-      to_be_removed = @catalog.downstream_from_vertex(the_site_resource).keys
-
-      # Drop the Site[site] resource if it has no content
-      if to_be_removed.empty?
-        to_be_removed << the_site_resource
-      end
-    else
-      to_be_removed = []
-    end
-
-    # keep_from_site is populated with any App resources.
-    application_resources = @resources.select {|r| r.type == 'App' }
-    # keep all applications plus what is directly referenced from applications
-    keep_from_site = application_resources
-    keep_from_site += application_resources.map {|app| @catalog.direct_dependents_of(app) }.flatten
-
-    to_be_removed -= keep_from_site
-    @catalog.remove_resource(*to_be_removed)
-    # set the pruned result
-    @resources = @catalog.resources
-  end
-
-  # @api private
-  def evaluate_applications
-    @applications.each do |app|
-      components = []
-      mapping = app.parameters[:nodes] ? app.parameters[:nodes].value : {}
-      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}: 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}: 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
-      begin
-        @current_app = app
-        @current_components = components
-        unless @current_components.empty?
-          Puppet.notice "EVAL APP #{app} #{components.inspect}"
-          # Add the app itself since components mapped to the current node
-          # will have a containment edge for it
-          # @todo lutter 2015-01-28: the node mapping winds up in the
-          # catalog, but probably shouldn't
-          @catalog.add_resource(@current_app)
-          @current_app.evaluate
-        end
-      ensure
-        @current_app = nil
-        @current_components = nil
-      end
-    end
-  end
-
-
   # If ast nodes are enabled, then see if we can find and evaluate one.
   #
   # @api private
@@ -391,12 +242,6 @@ class Puppet::Parser::Compiler
       classes = classes.keys
     end
 
-    unless @current_components.nil?
-      classes = classes.select do |title|
-        @current_components.any? { |comp| comp.class? && comp.title == title }
-      end
-    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: name, node: node.name }
     end
@@ -427,16 +272,6 @@ class Puppet::Parser::Compiler
 
   def initialize(node, code_id: nil)
     @node = sanitize_node(node)
-    # Array of resources representing all application instances we've found
-    @applications = []
-    # We use @current_app and @current_components to signal to the
-    # evaluator that we are in the middle of evaluating an
-    # application. They are set in evaluate_applications to the application
-    # instance, resp. to an array of the components of that application
-    # that is mapped to the current node. They are only non-nil when we are
-    # in the middle of executing evaluate_applications
-    @current_app = nil
-    @current_components = nil
     @code_id = code_id
     initvars
     add_catalog_validators
@@ -481,39 +316,6 @@ class Puppet::Parser::Compiler
     [already_included, newly_included]
   end
 
-  def evaluate_capability_mappings
-    krt = environment.known_resource_types
-    krt.capability_mappings.each_value do |capability_mapping|
-      args = capability_mapping.arguments
-      component_ref = args['component']
-      kind = args['kind']
-
-      # That component_ref is either a QREF or a Class['literal'|QREF] is asserted during validation so no
-      # need to check that here
-      if component_ref.is_a?(Puppet::Pops::Model::QualifiedReference)
-        component_name = component_ref.cased_value
-        component_type = 'type'
-        component = krt.find_definition(component_name)
-      else
-        component_name = component_ref.keys[0].value
-        component_type = 'class'
-        component = krt.find_hostclass(component_name)
-      end
-      if component.nil?
-        raise Puppet::ParseError, _("Capability mapping error: %{kind} clause references nonexistent %{component_type} %{component_name}") %
-            { kind: kind, component_type: component_type, component_name: component_name }
-      end
-
-      blueprint = args['blueprint']
-      if kind == 'produces'
-        component.add_produces(blueprint)
-      else
-        component.add_consumes(blueprint)
-      end
-    end
-    krt.capability_mappings.clear # No longer needed
-  end
-
   # Evaluate our collections and return true if anything returned an object.
   # The 'true' is used to continue a loop, so it's important.
   def evaluate_collections