puppet 4.2.3-x64-mingw32 → 4.3.0-x64-mingw32

data/lib/puppet/pops/lookup/invocation.rb

@@ -0,0 +1,117 @@
+module Puppet::Pops::Lookup
+  class Invocation
+    attr_reader :scope, :override_values, :default_values, :explainer, :module_name
+
+    # Creates a context object for a lookup invocation. The object contains the current scope, overrides, and default
+    # values and may optionally contain an {ExplanationAcceptor} instance that will receive book-keeping information
+    # about the progress of the lookup.
+    #
+    # If the _explain_ argument is a boolean, then _false_ means that no explanation is needed and _true_ means that
+    # the default explanation acceptor should be used. The _explain_ argument may also be an instance of the
+    # `ExplanationAcceptor` class.
+    #
+    # @param scope [Puppet::Parser::Scope] The scope to use for the lookup
+    # @param override_values [Hash<String,Object>|nil] A map to use as override. Values found here are returned immediately (no merge)
+    # @param default_values [Hash<String,Object>] A map to use as the last resort (but before default)
+    # @param explainer [boolean,Explanainer] An boolean true to use the default explanation acceptor or an explainer instance that will receive information about the lookup
+    def initialize(scope, override_values = {}, default_values = {}, explainer = nil)
+      @name_stack = []
+      @scope = scope
+      @override_values = override_values
+      @default_values = default_values
+      unless explainer.is_a?(Explainer)
+        explainer = explainer == true ? Explainer.new : nil
+      end
+      @explainer = explainer
+    end
+
+    def check(name)
+      if @name_stack.include?(name)
+        raise Puppet::DataBinding::RecursiveLookupError, "Recursive lookup detected in [#{@name_stack.join(', ')}]"
+      end
+      return unless block_given?
+
+      @name_stack.push(name)
+      begin
+        yield
+      rescue Puppet::DataBinding::LookupError
+        raise
+      rescue Puppet::Error => detail
+        raise Puppet::DataBinding::LookupError.new(detail.message, detail)
+      ensure
+        @name_stack.pop
+      end
+    end
+
+    # The qualifier_type can be one of:
+    # :global - qualifier is the data binding terminus name
+    # :data_provider - qualifier a DataProvider instance
+    # :path - qualifier is a ResolvedPath instance
+    # :merge - qualifier is a MergeStrategy instance
+    # :module - qualifier is the name of a module
+    # :interpolation - qualifier is the unresolved interpolation expression
+    # :meta - qualifier is the name of a module or nil if that's not applicable
+    #
+    # @param qualifier [Object] A branch, a provider, or a path
+    def with(qualifier_type, qualifier)
+      is_meta = qualifier_type == :meta
+      @module_name = qualifier if is_meta
+      if @explainer.nil?
+        yield
+      else
+        if is_meta
+          save_explainer = @explainer
+          @explainer = nil
+          begin
+            yield
+          ensure
+            @explainer = save_explainer
+          end
+        else
+          @explainer.push(qualifier_type, qualifier)
+          begin
+            yield
+          ensure
+            @explainer.pop
+          end
+        end
+      end
+    end
+
+    def report_found_in_overrides(key, value)
+      @explainer.accept_found_in_overrides(key, value) unless @explainer.nil?
+      value
+    end
+
+    def report_found_in_defaults(key, value)
+      @explainer.accept_found_in_defaults(key, value) unless @explainer.nil?
+      value
+    end
+
+    def report_found(key, value)
+      @explainer.accept_found(key, value) unless @explainer.nil?
+      value
+    end
+
+    # Report the result of a merge or fully resolved interpolated string
+    # @param value [Object] The result to report
+    # @return [Object] the given value
+    def report_result(value)
+      @explainer.accept_result(value) unless @explainer.nil?
+      value
+    end
+
+    def report_not_found(key)
+      @explainer.accept_not_found(key) unless @explainer.nil?
+    end
+
+    def report_path_not_found
+      @explainer.accept_path_not_found unless @explainer.nil?
+    end
+
+    def report_module_not_found
+      @explainer.accept_module_not_found unless @explainer.nil?
+    end
+  end
+end
+

data/lib/puppet/pops/merge_strategy.rb

@@ -4,6 +4,8 @@ module Puppet::Pops
   # Merges to objects into one based on an implemented strategy.
   #
   class MergeStrategy
+    NOT_FOUND = Object.new.freeze
+
     TypeAsserter = Puppet::Pops::Types::TypeAsserter
     TypeParser = Puppet::Pops::Types::TypeParser
 
@@ -20,12 +22,14 @@ module Puppet::Pops
 
     # Finds the merge strategy for the given _merge_, creates an instance of it and returns that instance.
     #
-    # @param merge [String|Symbol|Hash<String,Object>] The merge strategy. Can be a string or symbol denoting the key
+    # @param merge [Puppet::Pops::MergeStrategy,String,Hash<String,Object>,nil] The merge strategy. Can be a string or symbol denoting the key
     #   identifier or a hash with options where the key 'strategy' denotes the key
     # @return [MergeStrategy] The matching merge strategy
     #
     def self.strategy(merge)
-      TypeAsserter.assert_instance_of("MergeStrategies.merge 'merge' parameter", merge_t, merge)
+      return merge if merge.is_a?(MergeStrategy)
+      merge = :first if merge.nil?
+      TypeAsserter.assert_instance_of("MergeStrategy 'merge' parameter", merge_t, merge)
       if merge.is_a?(Hash)
         merge_strategy = merge['strategy']
         if merge_strategy.nil?
@@ -82,7 +86,7 @@ module Puppet::Pops
       @options = options
     end
 
-    # Merges the elements of _e1_ and _e2_ accoring to the implemented strategy and options given when this
+    # Merges the elements of _e1_ and _e2_ according to the rules of this strategy and options given when this
     # instance was created
     #
     # @param e1 [Object] The first element
@@ -95,6 +99,33 @@ module Puppet::Pops
         assert_type('e2', value_t, e2))
     end
 
+    # Merges the result of yielding the given _lookup_variants_ to a given block.
+    #
+    # @param lookup_variants [Array] The variants to pass as second argument to the given block
+    # @return [Object] the merged value.
+    # @yield [} ]
+    # @yieldparam variant [Object] each variant given in the _lookup_variants_ array.
+    # @yieldreturn [Object] the value to merge with other values
+    # @throws :no_such_key if the lookup was unsuccessful
+    #
+    def merge_lookup(lookup_variants)
+      result = lookup_variants.reduce(NOT_FOUND) do |memo, lookup_variant|
+        not_found = true
+        value = catch(:no_such_key) do
+          v = yield(lookup_variant)
+          not_found = false
+          v
+        end
+        if not_found
+          memo
+        else
+          memo.equal?(NOT_FOUND) ? convert_value(value) : merge(memo, value)
+        end
+      end
+      throw :no_such_key if result == NOT_FOUND
+      result
+    end
+
     # Converts a single value to the type expeced when peforming a merge of two elements
     # @param value [Object] the value to convert
     # @return [Object] the converted value
@@ -102,12 +133,20 @@ module Puppet::Pops
       value
     end
 
-    protected
-
     def options
       @options
     end
 
+    def configuration
+      if @options.nil? || @options.empty?
+        self.class.key.to_s
+      else
+        @options.include?('strategy') ? @options : { 'strategy' => self.class.key.to_s }.merge(@options)
+      end
+    end
+
+    protected
+
     # Returns the type used to validate the options hash
     #
     # @return [Puppet::Pops::Types::PStructType] the puppet type
@@ -133,6 +172,35 @@ module Puppet::Pops
     end
   end
 
+  # Simple strategy that returns the first value found. It never merges any values.
+  #
+  class FirstFoundStrategy < MergeStrategy
+    def self.key
+      :first
+    end
+
+    # Returns the first value found
+    #
+    # @param lookup_variants [Array] The variants to pass as second argument to the given block
+    # @return [Object] the merged value
+    # @throws :no_such_key unless the lookup was successful
+    #
+    def merge_lookup(lookup_variants)
+      lookup_variants.each do |lookup_variant|
+        catch(:no_such_key) { return yield(lookup_variant) }
+      end
+      throw :no_such_key
+    end
+
+    protected
+
+    def value_t
+      @value_t ||= Puppet::Pops::Types::PAnyType::DEFAULT
+    end
+
+    MergeStrategy.add_strategy(self)
+  end
+
   # Produces a new hash by merging hash e1 with hash e2 in such a way that the values of duplicate keys
   # will be those of e1
   #

data/lib/puppet/pops/model/factory.rb

@@ -53,6 +53,14 @@ class Puppet::Pops::Model::Factory
 
   # Building of Model classes
 
+  def build_Application(o, n, ps, body)
+    o.name = n
+    ps.each { |p| o.addParameters(build(p)) }
+    b = f_build_body(body)
+    o.body = b.current if b
+    o
+  end
+
   def build_ArithmeticExpression(o, op, a, b)
     o.operator = op
     build_BinaryExpression(o, a, b)
@@ -231,6 +239,15 @@ class Puppet::Pops::Model::Factory
     o
   end
 
+  def build_CapabilityMapping(o, kind, component, capability, mappings)
+    o.kind = kind
+    component = component.current if component.is_a?(Puppet::Pops::Model::Factory)
+    o.component = component
+    o.capability = capability
+    o.mappings = mappings.map { |m| build(m) }
+    o
+  end
+
   # @param o [Model::NodeDefinition]
   # @param hosts [Array<Expression>] host matches
   # @param parent [Expression] parent node matcher
@@ -243,6 +260,14 @@ class Puppet::Pops::Model::Factory
     o
   end
 
+  # @param o [Model::SiteDefinition]
+  # @param body [Object] see {#f_build_body}
+  def build_SiteDefinition(o, body)
+    b = f_build_body(body)
+    o.body = b.current if b
+    o
+  end
+
   def build_Parameter(o, name, expr)
     o.name = name
     o.value = build(expr) if expr # don't build a nil/nop
@@ -584,6 +609,7 @@ class Puppet::Pops::Model::Factory
 
   def self.NODE(hosts, parent, body);    new(Model::NodeDefinition, hosts, parent, body);        end
 
+  def self.SITE(body);                   new(Model::SiteDefinition, body);                       end
 
   # Parameters
 
@@ -755,6 +781,14 @@ class Puppet::Pops::Model::Factory
     new(Model::ResourceTypeDefinition, name, parameters, body)
   end
 
+  def self.CAPABILITY_MAPPING(kind, component, cap_name, mappings)
+    new(Model::CapabilityMapping, kind, component, cap_name, mappings)
+  end
+
+  def self.APPLICATION(name, parameters, body)
+    new(Model::Application, name, parameters, body)
+  end
+
   def self.FUNCTION(name, parameters, body)
     new(Model::FunctionDefinition, name, parameters, body)
   end

data/lib/puppet/pops/model/model_label_provider.rb

@@ -2,7 +2,9 @@
 # As an example, if object is an ArithmeticExpression with operator +, `#a_an(o)` produces "a '+' Expression",
 # #the(o) produces "the + Expression", and #label produces "+ Expression".
 #
-class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
+class Puppet::Pops::Model::ModelLabelProvider
+  include Puppet::Pops::LabelProvider
+
   def initialize
     @@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
   end
@@ -56,6 +58,7 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_HeredocExpression o           ; "'@(#{o.syntax})' expression"       end
   def label_HostClassDefinition o         ; "Host Class Definition"             end
   def label_NodeDefinition o              ; "Node Definition"                   end
+  def label_SiteDefinition o              ; "Site Definition"                   end
   def label_ResourceTypeDefinition o      ; "'define' expression"               end
   def label_ResourceOverrideExpression o  ; "Resource Override"                 end
   def label_Parameter o                   ; "Parameter Definition"              end
@@ -64,6 +67,7 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_UnlessExpression o            ; "'unless' Statement"                end
   def label_CallNamedFunctionExpression o ; "Function Call"                     end
   def label_CallMethodExpression o        ; "Method call"                       end
+  def label_CapabilityMapping o           ; "Capability Mapping"                end
   def label_CaseExpression o              ; "'case' statement"                  end
   def label_CaseOption o                  ; "Case Option"                       end
   def label_RenderStringExpression o      ; "Epp Text"                          end
@@ -97,6 +101,11 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
     end
   end
 
+  def label_Resource o
+    'Resource Statement'
+  end
+
+
   def label_Class o
     if o <= Puppet::Pops::Types::PAnyType
       simple_name = o.name.split('::').last

data/lib/puppet/pops/model/model_meta.rb

@@ -291,6 +291,9 @@ module Puppet::Pops::Model
   class ResourceTypeDefinition < NamedDefinition
   end
 
+  class Application < NamedDefinition
+  end
+
   # A node definition matches hosts using Strings, or Regular expressions. It may inherit from
   # a parent node (also using a String or Regular expression).
   #
@@ -300,6 +303,10 @@ module Puppet::Pops::Model
     contains_one_uni 'body', Expression
   end
 
+  class SiteDefinition < Definition
+    contains_one_uni 'body', Expression
+  end
+
   class LocatableExpression < Expression
     has_many_attr 'line_offsets', Integer
     has_attr 'locator', Object, :lowerBound => 1, :transient => true
@@ -534,6 +541,14 @@ module Puppet::Pops::Model
     contains_many_uni 'bodies', ResourceBody
   end
 
+  class CapabilityMapping < Definition
+    # 'produces' or 'consumes'
+    has_attr 'kind', String, :lowerBound => 1
+    has_attr 'capability', String, :lowerBound => 1
+    contains_one_uni 'component', Expression, :lowerBound => 1
+    contains_many_uni 'mappings', AbstractAttributeOperation
+  end
+
   # A resource defaults sets defaults for a resource type. This class inherits from AbstractResource
   # but does only support the :regular form (this is intentional to be able to produce better error messages
   # when illegal forms are applied to a model.

data/lib/puppet/pops/model/model_tree_dumper.rb

@@ -32,6 +32,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     do_dump(o.current)
   end
 
+  def dump_Application o
+    ["application", o.name, do_dump(o.parameters), do_dump(o.body)]
+  end
+
   def dump_ArithmeticExpression o
     [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
   end
@@ -230,6 +234,16 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     result
   end
 
+  def dump_SiteDefinition o
+    result = ["site"]
+    if o.body
+      result << do_dump(o.body)
+    else
+      result << []
+    end
+    result
+  end
+
   def dump_NamedDefinition o
     # the nil must be replaced with a string
     result = [nil, o.name]
@@ -248,6 +262,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     result
   end
 
+  def dump_CapabilityMapping o
+    [o.kind, do_dump(o.component), o.capability, do_dump(o.mappings)]
+  end
+
   def dump_ResourceOverrideExpression o
     form = o.form == :regular ? '' : o.form.to_s + "-"
     result = [form+"override", do_dump(o.resources), :indent]

data/lib/puppet/pops/parser/code_merger.rb

@@ -8,9 +8,21 @@ class Puppet::Pops::Parser::CodeMerger
     # this is a bit brute force as the result is already 3x ast with wrapped 4x content
     # this could be combined in a more elegant way, but it is only used to process a handful of files
     # at the beginning of a puppet run. TODO: Revisit for Puppet 4x when there is no 3x ast at the top.
+    # PUP-5299, some sites have thousands of entries, and run out of stack when evaluating - the logic
+    # below maps the logic as flatly as possible.
     #
     children = parse_results.select {|x| !x.nil? && x.code}.reduce([]) do |memo, parsed_class|
-      memo << parsed_class.code
+      case parsed_class.code
+      when Puppet::Parser::AST::BlockExpression
+        # the BlockExpression wraps a single 4x instruction that is most likely wrapped in a Factory
+        memo += parsed_class.code.children.map {|c| c.is_a?(Puppet::Pops::Model::Factory) ? c.model : c }
+      when Puppet::Pops::Model::Factory
+        # If it is a 4x instruction wrapped in a Factory
+        memo += parsed_class.code.model
+      else
+        # It is the instruction directly
+        memo << parsed_class.code
+      end
     end
     Puppet::Parser::AST::BlockExpression.new(:children => children)
   end