puppet 5.4.0 → 5.5.0

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

@@ -179,7 +179,8 @@ class Factory
   end
 
   def build_ConcatenatedString(o, args)
-    @init_hash['segments'] = args
+    # Strip empty segments
+    @init_hash['segments'] = args.reject { |arg| arg.model_class == LiteralString && arg['value'].empty? }
   end
 
   def build_HeredocExpression(o, name, expr)
@@ -452,10 +453,12 @@ class Factory
       #
       parent = type_expr['key']
       hash = type_expr['value']
-      unless parent['cased_value'] == 'Object'
+      pn = parent['cased_value']
+      unless pn == 'Object' || pn == 'TypeSet'
         hash['entries'] << Factory.KEY_ENTRY(Factory.QNAME('parent'), parent)
+        parent = Factory.QREF('Object')
       end
-      type_expr = Factory.QREF('Object').access([hash])
+      type_expr = parent.access([hash])
     elsif type_expr.model_class <= LiteralHash
       # LiteralHash is used for the form:
       #

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

@@ -28,6 +28,10 @@ class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
     o.value.to_s
   end
 
+  def dump_QualifiedReference o
+    o.cased_value.to_s
+  end
+
   def dump_Factory o
     o['locator'] ||= Puppet::Pops::Parser::Locator.locator("<not from source>", nil)
     do_dump(o.model)

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

@@ -0,0 +1,400 @@
+module Puppet::Pops
+module Model
+
+
+class PNTransformer
+  def self.visitor
+    @visitor ||= Visitor.new(nil, 'transform', 0, 0)
+  end
+
+  def self.singleton
+    @singleton ||= new(visitor)
+  end
+
+  def self.transform(ast)
+    singleton.transform(ast)
+  end
+
+  def initialize(visitor)
+    @visitor = visitor
+  end
+
+  def transform(ast)
+    @visitor.visit_this_0(self, ast)
+  end
+
+  def transform_AccessExpression(e)
+    PN::List.new([transform(e.left_expr)] + pn_array(e.keys)).as_call('access')
+  end
+
+  def transform_AndExpression(e)
+    binary_op(e, 'and')
+  end
+
+  def transform_Application(e)
+    definition_to_pn(e, 'application')
+  end
+
+  def transform_ArithmeticExpression(e)
+    binary_op(e, e.operator)
+  end
+
+  def transform_Array(a)
+    PN::List.new(pn_array(a))
+  end
+
+  def transform_AssignmentExpression(e)
+    binary_op(e, e.operator)
+  end
+
+  def transform_AttributeOperation(e)
+    PN::Call.new(e.operator, PN::Literal.new(e.attribute_name), transform(e.value_expr))
+  end
+
+  def transform_AttributesOperation(e)
+    PN::Call.new('splat-hash', transform(e.expr))
+  end
+
+  def transform_BlockExpression(e)
+    transform(e.statements).as_call('block')
+  end
+
+  def transform_CallFunctionExpression(e)
+    call_to_pn(e, 'call-lambda', 'invoke-lambda')
+  end
+
+  def transform_CallMethodExpression(e)
+    call_to_pn(e, 'call-method', 'invoke-method')
+  end
+
+  def transform_CallNamedFunctionExpression(e)
+    call_to_pn(e, 'call', 'invoke')
+  end
+
+  def transform_CapabilityMapping(e)
+    PN::Call.new(e.kind, transform(e.component), PN::List.new([PN::Literal.new(e.capability)] + pn_array(e.mappings)))
+  end
+
+  def transform_CaseExpression(e)
+    PN::Call.new('case', transform(e.test), transform(e.options))
+  end
+
+  def transform_CaseOption(e)
+    PN::Map.new([transform(e.values).with_name('when'), block_as_entry('then', e.then_expr)])
+  end
+
+  def transform_CollectExpression(e)
+    entries = [transform(e.type_expr).with_name('type'), transform(e.query).with_name('query')]
+    entries << transform(e.operations).with_name('ops') unless e.operations.empty?
+    PN::Map.new(entries).as_call('collect')
+  end
+
+  def transform_ComparisonExpression(e)
+    binary_op(e, e.operator)
+  end
+
+  def transform_ConcatenatedString(e)
+    transform(e.segments).as_call('concat')
+  end
+
+  def transform_EppExpression(e)
+    e.body.nil? ? PN::Call.new('epp') : transform(e.body).as_call('epp')
+  end
+
+  def transform_ExportedQuery(e)
+    is_nop?(e.expr) ? PN::Call.new('exported-query') : PN::Call.new('exported-query', transform(e.expr))
+  end
+
+  def transform_Factory(e)
+    transform(e.model)
+  end
+
+  def transform_FunctionDefinition(e)
+    definition_to_pn(e, 'function', nil, e.return_type)
+  end
+
+  def transform_HeredocExpression(e)
+    entries = []
+    entries << PN::Literal.new(e.syntax).with_name('syntax') unless e.syntax == ''
+    entries << transform(e.text_expr).with_name('text')
+    PN::Map.new(entries).as_call('heredoc')
+  end
+
+  def transform_HostClassDefinition(e)
+    definition_to_pn(e, 'class', e.parent_class)
+  end
+
+  def transform_IfExpression(e)
+    if_to_pn(e, 'if')
+  end
+
+  def transform_InExpression(e)
+    binary_op(e, 'in')
+  end
+
+  def transform_KeyedEntry(e)
+    PN::Call.new('=>', transform(e.key), transform(e.value))
+  end
+
+  def transform_LambdaExpression(e)
+    entries = []
+    entries << parameters_entry(e.parameters) unless e.parameters.empty?
+    entries << transform(e.return_type).with_name('returns') unless e.return_type.nil?
+    entries << block_as_entry('body', e.body) unless e.body.nil?
+    PN::Map.new(entries).as_call('lambda')
+  end
+
+  def transform_LiteralBoolean(e)
+    PN::Literal.new(e.value)
+  end
+
+  def transform_LiteralDefault(_)
+    PN::Call.new('default')
+  end
+
+  def transform_LiteralFloat(e)
+    PN::Literal.new(e.value)
+  end
+
+  def transform_LiteralHash(e)
+    transform(e.entries).as_call('hash')
+  end
+
+  def transform_LiteralInteger(e)
+    vl = PN::Literal.new(e.value)
+    e.radix == 10 ? vl : PN::Map.new([PN::Literal.new(e.radix).with_name('radix'), vl.with_name('value')]).as_call('int')
+  end
+
+  def transform_LiteralList(e)
+    transform(e.values).as_call('array')
+  end
+
+  def transform_LiteralRegularExpression(e)
+    PN::Literal.new(Types::PRegexpType.regexp_to_s(e.value)).as_call('regexp')
+  end
+
+  def transform_LiteralString(e)
+    PN::Literal.new(e.value)
+  end
+
+  def transform_LiteralUndef(_)
+    PN::Literal.new(nil)
+  end
+
+  def transform_MatchExpression(e)
+    binary_op(e, e.operator)
+  end
+
+  def transform_NamedAccessExpression(e)
+    binary_op(e, '.')
+  end
+
+  def transform_NodeDefinition(e)
+    entries = [transform(e.host_matches).with_name('matches')]
+    entries << transform(e.parent).with_name('parent') unless e.parent.nil?
+    entries << block_as_entry('body', e.body) unless e.body.nil?
+    PN::Map.new(entries).as_call('node')
+  end
+
+  def transform_Nop(_)
+    PN::Call.new('nop')
+  end
+
+  def transform_NotExpression(e)
+    PN::Call.new('!', transform(e.expr))
+  end
+
+  def transform_OrExpression(e)
+    binary_op(e, 'or')
+  end
+
+  def transform_Parameter(e)
+    entries = [PN::Literal.new(e.name).with_name('name')]
+    entries << transform(e.type_expr).with_name('type') unless e.type_expr.nil?
+    entries << PN::Literal.new(true).with_name('splat') if e.captures_rest
+    entries << transform(e.value).with_name('value') unless e.value.nil?
+    PN::Map.new(entries).with_name('param')
+  end
+
+  def transform_ParenthesizedExpression(e)
+    PN::Call.new('paren', transform(e.expr))
+  end
+
+  def transform_PlanDefinition(e)
+    definition_to_pn(e, 'plan', nil, e.return_type)
+  end
+
+  def transform_Program(e)
+    transform(e.body)
+  end
+
+  def transform_QualifiedName(e)
+    PN::Call.new('qn', PN::Literal.new(e.value))
+  end
+
+  def transform_QualifiedReference(e)
+    PN::Call.new('qr', PN::Literal.new(e.cased_value))
+  end
+
+  def transform_RelationshipExpression(e)
+    binary_op(e, e.operator)
+  end
+
+  def transform_RenderExpression(e)
+    PN::Call.new('render', transform(e.expr))
+  end
+
+  def transform_RenderStringExpression(e)
+    PN::Literal.new(e.value).as_call('render-s')
+  end
+
+  def transform_ReservedWord(e)
+    PN::Literal.new(e.word).as_call('reserved')
+  end
+
+  def transform_ResourceBody(e)
+    PN::Map.new([
+      transform(e.title).with_name('title'),
+      transform(e.operations).with_name('ops')
+    ]).as_call('resource_body')
+  end
+
+  def transform_ResourceDefaultsExpression(e)
+    entries = [transform(e.type_ref).with_name('type'), transform(e.operations).with_name('ops')]
+    entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
+    PN::Map.new(entries).as_call('resource-defaults')
+  end
+
+  def transform_ResourceExpression(e)
+    entries = [
+      transform(e.type_name).with_name('type'),
+      PN::List.new(pn_array(e.bodies).map { |body| body[0] }).with_name('bodies')
+    ]
+    entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
+    PN::Map.new(entries).as_call('resource')
+  end
+
+  def transform_ResourceOverrideExpression(e)
+    entries = [transform(e.resources).with_name('resources'), transform(e.operations).with_name('ops')]
+    entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
+    PN::Map.new(entries).as_call('resource-override')
+  end
+
+  def transform_ResourceTypeDefinition(e)
+    definition_to_pn(e, 'define')
+  end
+
+  def transform_SelectorEntry(e)
+    PN::Call.new('=>', transform(e.matching_expr), transform(e.value_expr))
+  end
+
+  def transform_SelectorExpression(e)
+    PN::Call.new('?', transform(e.left_expr), transform(e.selectors))
+  end
+
+  def transform_SiteDefinition(e)
+    transform(e.body).as_call('site')
+  end
+
+  def transform_SubLocatedExpression(e)
+    transform(e.expr)
+  end
+
+  def transform_TextExpression(e)
+    PN::Call.new('str', transform(e.expr))
+  end
+
+  def transform_TypeAlias(e)
+    PN::Call.new('type-alias', PN::Literal.new(e.name), transform(e.type_expr))
+  end
+
+  def transform_TypeDefinition(e)
+    PN::Call.new('type-definition', PN::Literal.new(e.name), PN::Literal.new(e.parent), transform(e.body))
+  end
+
+  def transform_TypeMapping(e)
+    PN::Call.new('type-mapping', transform(e.type_expr), transform(e.mapping_expr))
+  end
+
+  def transform_UnaryMinusExpression(e)
+    if e.expr.is_a?(LiteralValue)
+      v = e.expr.value
+      if v.is_a?(Numeric)
+        return PN::Literal.new(-v)
+      end
+    end
+    PN::Call.new('-', transform(e.expr))
+  end
+
+  def transform_UnfoldExpression(e)
+    PN::Call.new('unfold', transform(e.expr))
+  end
+
+  def transform_UnlessExpression(e)
+    if_to_pn(e, 'unless')
+  end
+
+  def transform_VariableExpression(e)
+    ne = e.expr
+    PN::Call.new('var', ne.is_a?(Model::QualifiedName) ? PN::Literal.new(ne.value) : transform(ne))
+  end
+
+  def transform_VirtualQuery(e)
+    is_nop?(e.expr) ? PN::Call.new('virtual-query') : PN::Call.new('virtual-query', transform(e.expr))
+  end
+
+  def is_nop?(e)
+    e.nil? || e.is_a?(Nop)
+  end
+
+  def binary_op(e, op)
+    PN::Call.new(op, transform(e.left_expr), transform(e.right_expr))
+  end
+
+  def definition_to_pn(e, type_name, parent = nil, return_type = nil)
+    entries = [PN::Literal.new(e.name).with_name('name')]
+    entries << PN::Literal.new(parent).with_name('parent') unless parent.nil?
+    entries << parameters_entry(e.parameters) unless e.parameters.empty?
+    entries << block_as_entry('body', e.body) unless e.body.nil?
+    entries << transform(return_type).with_name('returns') unless return_type.nil?
+    PN::Map.new(entries).as_call(type_name)
+  end
+
+  def parameters_entry(parameters)
+    PN::Map.new(parameters.map do |p|
+      entries = []
+      entries << transform(p.type_expr).with_name('type') unless p.type_expr.nil?
+      entries << PN::Literal(true).with_name('splat') if p.captures_rest
+      entries << transform(p.value).with_name('value') unless p.value.nil?
+      PN::Map.new(entries).with_name(p.name)
+    end).with_name('params')
+  end
+
+  def block_as_entry(name, expr)
+    if expr.is_a?(BlockExpression)
+      transform(expr.statements).with_name(name)
+    else
+      transform([expr]).with_name(name)
+    end
+  end
+
+  def pn_array(a)
+    a.map { |e| transform(e) }
+  end
+
+  def call_to_pn(e, r, nr)
+    entries = [transform(e.functor_expr).with_name('functor'), transform(e.arguments).with_name('args')]
+    entries << transform(e.lambda).with_name('block') unless e.lambda.nil?
+    PN::Map.new(entries).as_call(e.rval_required ? r : nr)
+  end
+
+  def if_to_pn(e, name)
+    entries = [transform(e.test).with_name('test')]
+    entries << block_as_entry('then', e.then_expr) unless is_nop?(e.then_expr)
+    entries << block_as_entry('else', e.else_expr) unless is_nop?(e.else_expr)
+    PN::Map.new(entries).as_call(name)
+  end
+end
+
+end
+end

data/lib/puppet/pops/parser/egrammar.ra

@@ -530,7 +530,7 @@ application_expression
 capability_mapping
   : classname capability_kw classname LBRACE  attribute_operations endcomma RBRACE {
     result = Factory.CAPABILITY_MAPPING(val[1][:value],
-                                        Factory.QNAME(classname(val[0][:value])),
+                                        Factory.QREF(classname(val[0][:value])),
                                         classname(val[2][:value]), val[4])
     loc result, val[0], val[6]
     add_mapping(result)

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

@@ -2543,7 +2543,7 @@ module_eval(<<'.,.,', 'egrammar.ra', 524)
 module_eval(<<'.,.,', 'egrammar.ra', 531)
   def _reduce_154(val, _values, result)
         result = Factory.CAPABILITY_MAPPING(val[1][:value],
-                                        Factory.QNAME(classname(val[0][:value])),
+                                        Factory.QREF(classname(val[0][:value])),
                                         classname(val[2][:value]), val[4])
     loc result, val[0], val[6]
     add_mapping(result)