puppet 4.3.0 → 4.4.0

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
@@ -102,7 +111,7 @@ module Puppet::Pops
       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,12 +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
-  include 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.
@@ -57,6 +59,7 @@ class Puppet::Pops::Model::ModelLabelProvider
   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
@@ -88,16 +91,18 @@ class Puppet::Pops::Model::ModelLabelProvider
   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_TypeDefinition o              ; "Type Definition"                   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
 
@@ -107,7 +112,7 @@ class Puppet::Pops::Model::ModelLabelProvider
 
 
   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
@@ -115,3 +120,5 @@ class Puppet::Pops::Model::ModelLabelProvider
     end
   end
 end
+end
+end

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

@@ -294,6 +294,23 @@ module Puppet::Pops::Model
   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 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).
   #

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

@@ -415,6 +415,14 @@ 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_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/egrammar.ra

@@ -20,8 +20,8 @@ token NUMBER
 token HEREDOC SUBLOCATE
 token RENDER_STRING RENDER_EXPR EPP_START EPP_END EPP_END_TRIM
 token FUNCTION
-token PRIVATE ATTR TYPE
-token FUNCTION
+token TYPE
+token PRIVATE ATTR
 token APPLICATION_R CONSUMES_R PRODUCES_R SITE_R
 token APPLICATION PRODUCES CONSUMES SITE
 token LOW
@@ -160,7 +160,7 @@ resource
         # If the attribute operations does not include +>, then the found expression
         # is actually a LEFT followed by LITERAL_HASH
         #
-        unless tmp = transform_resource_wo_title(val[0], val[2])
+        unless tmp = transform_resource_wo_title(val[0], val[2], val[1], val[4])
           error val[1], "Syntax error resource body without title or hash with +>"
         end
         tmp
@@ -250,6 +250,8 @@ primary_expression
   | site_definition_expression
   | epp_render_expression
   | function_definition
+  | type_alias
+  | type_definition
   | reserved_word
   | array
   | hash
@@ -268,25 +270,29 @@ primary_expression
 # Produces Model::CallNamedFunction
 
 call_function_expression
-  : expression LPAREN assignments endcomma RPAREN {
-      result = Factory.CALL_NAMED(val[0], true, val[2])
-      loc result, val[0], val[4]
+  : call_function_start assignments endcomma RPAREN {
+      result = Factory.CALL_NAMED(val[0], true, val[1])
+      loc result, val[0], val[3]
     }
-  | expression LPAREN RPAREN {
+  | call_function_start RPAREN {
       result = Factory.CALL_NAMED(val[0], true, [])
-      loc result, val[0], val[2]
+      loc result, val[0], val[1]
     }
-  | expression LPAREN assignments endcomma RPAREN lambda {
-      result = Factory.CALL_NAMED(val[0], true, val[2])
+  | call_function_start assignments endcomma RPAREN lambda {
+      result = Factory.CALL_NAMED(val[0], true, val[1])
       loc result, val[0], val[4]
-      result.lambda = val[5]
+      result.lambda = val[4]
     }
-  | expression LPAREN RPAREN  lambda {
+  | call_function_start RPAREN  lambda {
       result = Factory.CALL_NAMED(val[0], true, [])
       loc result, val[0], val[2]
-      result.lambda = val[3]
+      result.lambda = val[2]
     }
 
+call_function_start
+  : expression LPAREN { result = val[0] }
+  | TYPE LPAREN { result = Factory.QNAME(val[0][:value]); loc result, val[0] }
+
 #---CALL METHOD
 #
 call_method_with_lambda_expression
@@ -676,6 +682,25 @@ parameter_type
   : type { result = val[0] }
   | type LBRACK expressions RBRACK { result = val[0][*val[2]] ; loc result, val[0], val[3] }
 
+#--TYPE ALIAS
+type_alias
+  : TYPE CLASSREF EQUALS expression {
+      result = add_definition(Factory.TYPE_ALIAS(val[1][:value], val[3]))
+      loc(result, val[0], val[3])
+    }
+
+#--TYPE definition
+# TODO: Uses the optional_statements rule temporarily since the actual body awaits final spec on methods and attributes.
+type_definition
+  : TYPE CLASSREF LBRACE optional_statements RBRACE {
+        result = add_definition(Factory.TYPE_DEFINITION(val[1][:value], nil, val[3]))
+        loc(result, val[0], val[4])
+      }
+  | TYPE CLASSREF INHERITS CLASSREF LBRACE optional_statements RBRACE {
+        result = add_definition(Factory.TYPE_DEFINITION(val[1][:value], val[3][:value], val[5]))
+        loc(result, val[0], val[6])
+      }
+
 #--VARIABLE
 #
 variable
@@ -685,7 +710,6 @@ variable
 #
 reserved_word
   : PRIVATE   { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
-  | TYPE      { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
   | ATTR      { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
   | APPLICATION_R { result = Factory.RESERVED(val[0][:value], true) ; loc result, val[0] }
   | CONSUMES_R    { result = Factory.RESERVED(val[0][:value], true) ; loc result, val[0] }