class Puppet::Pops::Model::AstTreeDumper

_dump_ParameterArray(o) click to toggle source

Puppet AST encodes a parameter as a one or two slot Array. This is not a polymorph dump method.

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 281
def _dump_ParameterArray o
  if o.size == 2
    ["=", o[0], do_dump(o[1])]
  else
    o[0]
  end
end

dump_ASTArray(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 124
def dump_ASTArray o
  ["[]"] + o.children.collect {|x| do_dump(x)}
end

dump_ASTHash(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 128
  def dump_ASTHash o
    ["{}"] + o.value.sort_by{|k,v| k.to_s}.collect {|x| [do_dump(x[0]), do_dump(x[1])]}
#    ["{}"] + o.value.collect {|x| [do_dump(x[0]), do_dump(x[1])]}
  end

dump_ArithmeticOperator(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 36
def dump_ArithmeticOperator o
  [o.operator.to_s, do_dump(o.lval), do_dump(o.rval)]
end

dump_Array(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 120
def dump_Array o
  o.collect {|e| do_dump(e) }
end

dump_BlockExpression(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 193
def dump_BlockExpression o
  ["block"] + o.children.collect {|x| do_dump(x) }
end

dump_Boolean(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 93
def dump_Boolean o
  o.to_s
end

dump_BooleanOperator(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 97
def dump_BooleanOperator o
  operator = o.operator == 'and' ? '&&' : '||'
  [operator, do_dump(o.lval), do_dump(o.rval)]
end

dump_CaseOpt(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 327
def dump_CaseOpt o
  result = ["when"]
  result << o.value.collect {|x| do_dump(x) }
  # A bit of trickery to get it into the same shape as Pops output
  if is_nop?(o.statements)
    result << ["then", []]  # Puppet AST has a nop if there is no body
  else
    result << ["then", do_dump(o.statements) ]
  end
  result
end

dump_CaseStatement(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 319
def dump_CaseStatement o
  result = ["case", do_dump(o.test), :indent]
  o.options.each do |s|
    result << :break << do_dump(s)
  end
  result << :dedent
end

dump_CollExpr(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 77
def dump_CollExpr o
  operator = case o.oper
  when 'and'
    '&&'
  when 'or'
    '||'
  else
    o.oper
  end
  [operator, do_dump(o.test1), do_dump(o.test2)]
end

dump_Collection(o) click to toggle source

The AST Collection knows about exported or virtual query, not the query.

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 60
def dump_Collection o
  result = ["collect", do_dump(o.type), :indent, :break]
  if o.form == :virtual
    q = ["<| |>"]
  else
    q = ["<<| |>>"]
  end
  q << do_dump(o.query) unless is_nop?(o.query)
  q <<  :indent
  result << q
  o.override do |ao|
    result << :break << do_dump(ao)
  end
  result += [:dedent, :dedent ]
  result
end

dump_ComparisonOperator(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 89
def dump_ComparisonOperator o
  [o.operator.to_s, do_dump(o.lval), do_dump(o.rval)]
end

dump_Concat(o) click to toggle source

Interpolated strings are shown as (cat seg0 seg1 … segN)

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 198
def dump_Concat o
  ["cat"] + o.value.collect {|x| x.is_a?(AST::String) ? " "+do_dump(x) : ["str", do_dump(x)]}
end

dump_Default(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 160
def dump_Default o
  ":default"
end

dump_Definition(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 240
def dump_Definition o
  # ok, this is even crazier that Hostclass. The name of the define does not have an accessor
  # and some things are in the context (but not the name). Parameters are called arguments and they
  # are in a Ruby Array where each parameter is an array of 1 or 2 elements.
  #
  context = o.context
  name = o.instance_variable_get("@name")
  args = context[:arguments]
  code = context[:code]
  result = ["define", name]
  result << ["parameters"] + args.collect {|p| _dump_ParameterArray(p) } if args && args.size() > 0
  if is_nop?(code)
    result << []
  else
    result << do_dump(code)
  end
  result
end

dump_Expression(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 28
def dump_Expression(o)
  "(pops-expression #{Puppet::Pops::Model::ModelTreeDumper.new().dump(o.value)})"
end

dump_Factory(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 32
def dump_Factory o
  do_dump(o.current)
end

dump_Function(o) click to toggle source

Produces (invoke name args…) when not required to produce an rvalue, and (call name args … ) otherwise.

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 302
def dump_Function o
  # somewhat ugly as Function hides its "ftype" instance variable
  result = [o.instance_variable_get("@ftype") == :rvalue ? "call" : "invoke", do_dump(o.name)]
  o.arguments.collect {|a| result << do_dump(a) }
  result << do_dump(o.pblock) if o.pblock
  result
end

dump_HashOrArrayAccess(o) click to toggle source

x prints as (slice x y)

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 54
def dump_HashOrArrayAccess o
  var = o.variable.is_a?(String) ? "$#{o.variable}" : do_dump(o.variable)
  ["slice", var, do_dump(o.key)]
end

dump_HostName(o) click to toggle source

Hostname is tricky, it is either a bare word, a string, or default, or regular expression Least evil, all strings except default are quoted

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 45
def dump_HostName o
  result = do_dump o.value
  unless o.value.is_a? AST::Regex
    result = result == "default" ? ":default" : "'#{result}'"
  end
  result
end

dump_Hostclass(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 202
def dump_Hostclass o
  # ok, this is kind of crazy stuff in the AST, information in a context instead of in AST, and
  # parameters are in a Ruby Array with each parameter being an Array...
  #
  context = o.context
  args = context[:arguments]
  parent = context[:parent]
  result = ["class", o.name]
  result << ["inherits", parent] if parent
  result << ["parameters"] + args.collect {|p| _dump_ParameterArray(p) } if args && args.size() > 0
  if is_nop?(o.code)
    result << []
  else
    result << do_dump(o.code)
  end
  result
end

dump_IfStatement(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 289
def dump_IfStatement o
  result = ["if", do_dump(o.test), :indent, :break,
    ["then", :indent, do_dump(o.statements), :dedent]]
  result +=
  [:break,
    ["else", :indent, do_dump(o.else), :dedent],
    :dedent] unless is_nop? o.else
  result
end

dump_InOperator(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 102
def dump_InOperator o
  ["in", do_dump(o.lval), do_dump(o.rval)]
end

dump_Lambda(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 149
def dump_Lambda o
  result = ["lambda"]
  result << ["parameters"] + o.parameters.collect {|p| _dump_ParameterArray(p) } if o.parameters.size() > 0
  if o.children == []
    result << [] # does not have a lambda body
  else
    result << do_dump(o.children)
  end
  result
end

dump_LiteralFloat(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 11
def dump_LiteralFloat o
  o.value.to_s
end

dump_LiteralInteger(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 15
def dump_LiteralInteger o
  case o.radix
  when 10
    o.value.to_s
  when 8
    "0%o" % o.value
  when 16
    "0x%X" % o.value
  else
    "bad radix:" + o.value.to_s
  end
end

dump_MatchOperator(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 133
def dump_MatchOperator o
  [o.operator.to_s, do_dump(o.lval), do_dump(o.rval)]
end

dump_MethodCall(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 310
def dump_MethodCall o
  # somewhat ugly as Method call (does the same as function) and hides its "ftype" instance variable
  result = [o.instance_variable_get("@ftype") == :rvalue ? "call-method" : "invoke-method",
    [".", do_dump(o.receiver), do_dump(o.name)]]
  o.arguments.collect {|a| result << do_dump(a) }
  result << do_dump(o.lambda) if o.lambda
  result
end

dump_Minus(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 189
def dump_Minus o
  ['-', do_dump(o.value)]
end

dump_Name(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 220
def dump_Name o
  o.value
end

dump_NilClass(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 177
def dump_NilClass o
  "()"
end

dump_Node(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 224
def dump_Node o
  context = o.context
  parent = context[:parent]
  code = context[:code]

  result = ["node"]
  result << ["matches"] + o.names.collect {|m| do_dump(m) }
  result << ["parent", do_dump(parent)] if !is_nop?(parent)
  if is_nop?(code)
    result << []
  else
    result << do_dump(code)
  end
  result
end

dump_Nop(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 173
def dump_Nop o
  ":nop"
end

dump_Not(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 181
def dump_Not o
  ['!', dump(o.value)]
end

dump_Object(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 379
def dump_Object o
  ['dev-error-no-polymorph-dump-for:', o.class.to_s, o.to_s]
end

dump_Regex(o) click to toggle source

Note this is Regex (the AST kind), not Ruby Regexp

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 169
def dump_Regex o
  "/#{o.value.source}/"
end

dump_Relationship(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 39
def dump_Relationship o
  [o.arrow.to_s, do_dump(o.left), do_dump(o.right)]
end

dump_Resource(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 357
def dump_Resource o
  if o.exported
    form = 'exported-'
  elsif o.virtual
    form = 'virtual-'
  else
    form = ''
  end
  result = [form+"resource", do_dump(o.type), :indent]
  o.instances.each do |b|
    result << :break << do_dump(b)
  end
  result << :dedent
  result
end

dump_ResourceDefaults(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 348
def dump_ResourceDefaults o
  result = ["resource-defaults", do_dump(o.type), :indent]
  o.parameters.each do |p|
    result << :break << do_dump(p)
  end
  result << :dedent
  result
end

dump_ResourceInstance(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 339
def dump_ResourceInstance o
  result = [do_dump(o.title), :indent]
  o.parameters.each do |p|
    result << :break << do_dump(p)
  end
  result << :dedent
  result
end

dump_ResourceOverride(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 269
def dump_ResourceOverride o
  result = ["override", do_dump(o.object), :indent]
  o.parameters.each do |p|
    result << :break << do_dump(p)
  end
  result << :dedent
  result
end

dump_ResourceParam(o) click to toggle source

Produces (name => expr) or (name +> expr)

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 115
def dump_ResourceParam o
  operator = o.add ? "+>" : "=>"
  [do_dump(o.param), operator, do_dump(o.value)]
end

dump_ResourceReference(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 259
def dump_ResourceReference o
  result = ["slice", do_dump(o.type)]
  if o.title.children.size == 1
    result << do_dump(o.title[0])
  else
    result << do_dump(o.title.children)
  end
  result
end

dump_Selector(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 373
def dump_Selector o
  values = o.values
  values = [values] unless values.instance_of? AST::ASTArray or values.instance_of? Array
  ["?", do_dump(o.param)] + values.collect {|x| do_dump(x) }
end

dump_String(o) click to toggle source

Dump a Ruby String in single quotes unless it is a number.

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 138
def dump_String o

  if o.is_a? String
    o               # A Ruby String, not quoted
  elsif Puppet::Pops::Utils.to_n(o.value)
    o.value         # AST::String that is a number without quotes
  else
    "'#{o.value}'"  # AST::String that is not a number
  end
end

dump_Undef(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 164
def dump_Undef o
  ":undef"
end

dump_VarDef(o) click to toggle source

$x = … $x += …

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 109
def dump_VarDef o
  operator = o.append ? "+=" : "="
  [operator, '$' + do_dump(o.name), do_dump(o.value)]
end

dump_Variable(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 185
def dump_Variable o
  "$#{dump(o.value)}"
end

is_nop?(o) click to toggle source

# File lib/puppet/pops/model/ast_tree_dumper.rb, line 383
def is_nop? o
  o.nil? || o.is_a?(Model::Nop) || o.is_a?(AST::Nop)
end

Constants

Public Instance Methods