puppet 4.0.0 → 4.9.1

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

@@ -19,9 +19,18 @@ module Puppet::Pops
   module Model
 
     class PopsObject
-      include Puppet::Pops::Visitable
-      include Puppet::Pops::Adaptable
-      include Puppet::Pops::Containment
+      include Visitable
+      include Adaptable
+      include Containment
+    end
+
+    class Positioned
+      module ClassModule
+        def set_loc(offset, length)
+          @offset = offset
+          @length = length
+        end
+      end
     end
 
     class LocatableExpression
@@ -34,7 +43,7 @@ module Puppet::Pops
         #
         def locator
           unless result = getLocator
-            setLocator(result = Puppet::Pops::Parser::Locator.locator(source_text, source_ref(), line_offsets))
+            setLocator(result = Parser::Locator.locator(source_text, source_ref(), line_offsets))
           end
           result
         end
@@ -46,18 +55,18 @@ module Puppet::Pops
         def locator
           unless result = getLocator
             # Adapt myself to get the Locator for me
-            adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(self)
+            adapter = Adapters::SourcePosAdapter.adapt(self)
             # Get the program (root), and deal with case when not contained in a program
             program = eAllContainers.find {|c| c.is_a?(Program) }
             source_ref = program.nil? ? '' : program.source_ref
 
             # An outer locator is needed since SubLocator only deals with offsets. This outer locator
             # has 0,0 as origin.
-            outer_locator = Puppet::Pops::Parser::Locator.locator(adpater.extract_text, source_ref, line_offsets)
+            outer_locator = Parser::Locator.locator(adpater.extract_text, source_ref, line_offsets)
 
             # Create a sublocator that describes an offset from the outer
             # NOTE: the offset of self is the same as the sublocator's leading_offset
-            result = Puppet::Pops::Parser::Locator::SubLocator.new(outer_locator,
+            result = Parser::Locator::SubLocator.new(outer_locator,
               leading_line_count, offset, leading_line_offset)
             setLocator(result)
           end
@@ -98,11 +107,19 @@ module Puppet::Pops
       end
     end
 
+    class QualifiedReference
+      module ClassModule
+        def value
+          @value ||= cased_value.downcase
+        end
+      end
+    end
+
     class Program < PopsObject
       module ClassModule
         def locator
           unless result = getLocator
-            setLocator(result = Puppet::Pops::Parser::Locator.locator(source_text, source_ref(), line_offsets, char_offsets))
+            setLocator(result = Parser::Locator.locator(source_text, source_ref(), line_offsets, char_offsets))
           end
           result
         end

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

@@ -1,10 +1,14 @@
+module Puppet::Pops
+module Model
 # A provider of labels for model object, producing a human name for the model object.
 # 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 ModelLabelProvider
+  include LabelProvider
+
   def initialize
-    @@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
+    @@label_visitor ||= Visitor.new(self,"label",0,0)
   end
 
   # Produces a label for the given objects type/operator without article.
@@ -55,7 +59,9 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_ConcatenatedString o          ; "Double Quoted String"              end
   def label_HeredocExpression o           ; "'@(#{o.syntax})' expression"       end
   def label_HostClassDefinition o         ; "Host Class Definition"             end
+  def label_FunctionDefinition o          ; "Function 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 +70,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
@@ -84,19 +91,34 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
   def label_Hash o                        ; "Hash"                              end
   def label_QualifiedName o               ; "Name"                              end
   def label_QualifiedReference o          ; "Type-Name"                         end
-  def label_PAnyType o                    ; "#{Puppet::Pops::Types::TypeCalculator.string(o)}-Type" end
+  def label_PAnyType o                    ; "#{o}-Type" end
   def label_ReservedWord o                ; "Reserved Word '#{o.word}'"         end
+  def label_CatalogCollector o            ; "Catalog-Collector"                 end
+  def label_ExportedCollector o           ; "Exported-Collector"                end
+  def label_TypeAlias o                   ; "Type Alias"                        end
+  def label_TypeMapping o                 ; "Type Mapping"                      end
+  def label_TypeDefinition o              ; "Type Definition"                   end
+  def label_Binary o                      ; "Binary"                            end
+  def label_Application o                 ; "Application"                       end
+  def label_Sensitive o                   ; "Sensitive"                         end
+  def label_Timestamp o                   ; "Timestamp"                         end
+  def label_Timespan o                    ; "Timespan"                          end
 
   def label_PResourceType o
     if o.title
-      "#{Puppet::Pops::Types::TypeCalculator.string(o)} Resource-Reference"
+      "#{o} Resource-Reference"
     else
-      "#{Puppet::Pops::Types::TypeCalculator.string(o)}-Type"
+      "#{o}-Type"
     end
   end
 
+  def label_Resource o
+    'Resource Statement'
+  end
+
+
   def label_Class o
-    if o <= Puppet::Pops::Types::PAnyType
+    if o <= Types::PAnyType
       simple_name = o.name.split('::').last
       simple_name[1..-5] + "-Type"
     else
@@ -104,3 +126,5 @@ class Puppet::Pops::Model::ModelLabelProvider < Puppet::Pops::LabelProvider
     end
   end
 end
+end
+end

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

@@ -258,7 +258,7 @@ module Puppet::Pops::Model
   class CollectExpression < Expression
     contains_one_uni 'type_expr', Expression, :lowerBound => 1
     contains_one_uni 'query', QueryExpression, :lowerBound => 1
-    contains_many_uni 'operations', AttributeOperation
+    contains_many_uni 'operations', AbstractAttributeOperation
   end
 
   class Parameter < Positioned
@@ -282,11 +282,42 @@ module Puppet::Pops::Model
     contains_one_uni 'body', Expression
   end
 
+  # A function written in the Puppet Langauge
+  class FunctionDefinition < NamedDefinition
+    contains_one_uni 'return_type', Expression
+  end
+
   # A resource type definition (a 'define' in the DSL).
   #
   class ResourceTypeDefinition < NamedDefinition
   end
 
+  class Application < NamedDefinition
+  end
+
+  # Abstract base class for QREF named non-parameterized definitions
+  class QRefDefinition < Definition
+    abstract
+    has_attr 'name', String, :lowerBound => 1
+  end
+
+  # A type alias assignment
+  class TypeAlias < QRefDefinition
+    contains_one_uni 'type_expr', Expression
+  end
+
+  # A type mapping assignment
+  class TypeMapping < Definition
+    contains_one_uni 'type_expr', Expression
+    contains_one_uni 'mapping_expr', Expression
+  end
+
+  # A type definition
+  class TypeDefinition < QRefDefinition
+    has_attr 'parent', String
+    contains_one_uni 'body', Expression
+  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).
   #
@@ -296,6 +327,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
@@ -342,6 +377,7 @@ module Puppet::Pops::Model
   class LambdaExpression < Expression
     contains_many_uni 'parameters', Parameter
     contains_one_uni 'body', Expression
+    contains_one_uni 'return_type', Expression
   end
 
   # If expression. If test is true, the then_expr part should be evaluated, else the (optional)
@@ -463,15 +499,18 @@ module Puppet::Pops::Model
     has_attr 'value', String, :lowerBound => 1
   end
 
-  # Represents a parsed reserved word
+  # Represents a parsed reserved word. If the 'future' attribute is true
+  # the ReserwedWord functions as a deprecation warning + string value
+  #
   class ReservedWord < LiteralValue
     has_attr 'word', String, :lowerBound => 1
+    has_attr 'future', Boolean
   end
 
   # A DSL CLASSREF (one or multiple parts separated by '::' where (at least) the first part starts with an upper case letter).
   #
   class QualifiedReference < LiteralValue
-    has_attr 'value', String, :lowerBound => 1
+    has_attr 'cased_value', String, :lowerBound => 1
   end
 
   # A Variable expression looks up value of expr (some kind of name) in scope.
@@ -527,6 +566,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
@@ -137,6 +141,7 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
   def dump_LambdaExpression o
     result = ["lambda"]
     result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
+    result << ['return_type', do_dump(o.return_type)] unless o.return_type.nil?
     if o.body
       result << do_dump(o.body)
     else
@@ -230,6 +235,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]
@@ -242,12 +257,28 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     result
   end
 
+  def dump_FunctionDefinition o
+    result = ['function', o.name]
+    result << ['parameters'] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
+    result << ['return_type', do_dump(o.return_type)] unless o.return_type.nil?
+    if o.body
+      result << do_dump(o.body)
+    else
+      result << []
+    end
+    result
+  end
+
   def dump_ResourceTypeDefinition o
     result = dump_NamedDefinition(o)
     result[0] = 'define'
     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]
@@ -313,6 +344,7 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
   def dump_CallNamedFunctionExpression o
     result = [o.rval_required ? "call" : "invoke", do_dump(o.functor_expr)]
     o.arguments.collect {|a| result << do_dump(a) }
+    result << do_dump(o.lambda) if o.lambda
     result
   end
 
@@ -397,6 +429,18 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     ["sublocated", do_dump(o.expr)]
   end
 
+  def dump_TypeAlias(o)
+    ['type-alias', o.name, do_dump(o.type_expr)]
+  end
+
+  def dump_TypeMapping(o)
+    ['type-mapping', do_dump(o.type_expr), do_dump(o.mapping_expr)]
+  end
+
+  def dump_TypeDefinition(o)
+    ['type-definition', o.name, o.parent, do_dump(o.body)]
+  end
+
   def dump_Object o
     [o.class.to_s, o.to_s]
   end

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