puppet 3.1.1 → 3.2.0.rc1

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

@@ -0,0 +1,75 @@
+# 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
+  def initialize
+    @@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
+  end
+
+  # Produces a label for the given objects type/operator without article.
+  def label o
+   @@label_visitor.visit(o)
+  end
+
+  def label_Factory o                     ; label(o.current)                    end
+  def label_Array o                       ; "Array Object"                      end
+  def label_LiteralNumber o               ; "Literal Number"                    end
+  def label_ArithmeticExpression o        ; "'#{o_operator}' expression"        end
+  def label_AccessExpression o            ; "'[]' expression"                   end
+  def label_MatchExpression o             ; "'#{o.operator}' expression"        end
+  def label_CollectExpression o           ; label(o.query)                      end
+  def label_ExportedQuery o               ; "Exported Query"                    end
+  def label_VirtualQuery o                ; "Virtual Query"                     end
+  def label_QueryExpression o             ; "Collect Query"                     end
+  def label_ComparisonExpression o        ; "'#{o.operator}' expression"        end
+  def label_AndExpression o               ; "'and' expression"                  end
+  def label_OrExpression o                ; "'or' expression"                   end
+  def label_InExpression o                ; "'in' expression"                   end
+  def label_ImportExpression o            ; "'import' expression"               end
+  def label_InstanceReferences o          ; "Resource Reference"                end
+  def label_AssignmentExpression o        ; "'#{o.operator}' expression"        end
+  def label_AttributeOperation o          ; "'#{o.operator}' expression"        end
+  def label_LiteralList o                 ; "Array Expression"                  end
+  def label_LiteralHash o                 ; "Hash Expression"                   end
+  def label_KeyedEntry o                  ; "Hash Entry"                        end
+  def label_LiteralBoolean o              ; "Boolean"                           end
+  def label_LiteralString o               ; "String"                            end
+  def label_LiteralText o                 ; "Text in Interpolated String"       end
+  def label_LambdaExpression o            ; "Lambda"                            end
+  def label_LiteralDefault o              ; "'default' expression"              end
+  def label_LiteralUndef o                ; "'undef' expression"                end
+  def label_LiteralRegularExpression o    ; "Regular Expression"                end
+  def label_Nop o                         ; "Nop Expression"                    end
+  def label_NamedAccessExpression o       ; "'.' expression"                    end
+  def label_NilClass o                    ; "Nil Object"                        end
+  def label_NotExpression o               ; "'not' expression"                  end
+  def label_VariableExpression o          ; "Variable"                          end
+  def label_TextExpression o              ; "Expression in Interpolated String" end
+  def label_UnaryMinusExpression o        ; "Unary Minus"                       end
+  def label_BlockExpression o             ; "Block Expression"                  end
+  def label_ConcatenatedString o          ; "Double Quoted String"              end
+  def label_HostClassDefinition o         ; "Host Class Definition"             end
+  def label_NodeDefinition o              ; "Node Definition"                   end
+  def label_ResourceTypeDefinition o      ; "'define' expression"               end
+  def label_ResourceOverrideExpression o  ; "Resource Override"                 end
+  def label_Parameter o                   ; "Parameter Definition"              end
+  def label_ParenthesizedExpression o     ; "Parenthesized Expression"          end
+  def label_IfExpression o                ; "'if' statement"                    end
+  def label_UnlessExpression o            ; "'unless' Statement"                end
+  def label_CallNamedFunctionExpression o ; "Function Call"                     end
+  def label_CallMethodExpression o        ; "Method call"                       end
+  def label_CaseExpression o              ; "'case' statement"                  end
+  def label_CaseOption o                  ; "Case Option"                       end
+  def label_RelationshipExpression o      ; "'#{o.operator}' expression"        end
+  def label_ResourceBody o                ; "Resource Instance Definition"      end
+  def label_ResourceDefaultsExpression o  ; "Resource Defaults Expression"      end
+  def label_ResourceExpression o          ; "Resource Statement"                end
+  def label_SelectorExpression o          ; "Selector Expression"               end
+  def label_SelectorEntry o               ; "Selector Option"                   end
+  def label_String o                      ; "Ruby String"                       end
+  def label_Object o                      ; "Ruby Object"                       end
+  def label_QualifiedName o               ; "Name"                              end
+  def label_QualifiedReference o          ; "Type Name"                         end
+
+end

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

@@ -0,0 +1,352 @@
+# Dumps a Pops::Model in reverse polish notation; i.e. LISP style
+# The intention is to use this for debugging output
+# TODO: BAD NAME - A DUMP is a Ruby Serialization
+#
+class Puppet::Pops::Model::ModelTreeDumper < Puppet::Pops::Model::TreeDumper
+  def dump_Array o
+    o.collect {|e| do_dump(e) }
+  end
+
+  def dump_LiteralNumber 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
+
+  def dump_LiteralValue o
+    o.value.to_s
+  end
+
+  def dump_Factory o
+    do_dump(o.current)
+  end
+
+  def dump_ArithmeticExpression o
+    [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
+  end
+
+  # x[y] prints as (slice x y)
+  def dump_AccessExpression o
+    if o.keys.size <= 1
+      ["slice", do_dump(o.left_expr), do_dump(o.keys[0])]
+    else
+      ["slice", do_dump(o.left_expr), do_dump(o.keys)]
+    end
+  end
+
+  def dump_MatchesExpression o
+    [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
+  end
+
+  def dump_CollectExpression o
+    result = ["collect", do_dump(o.type_expr), :indent, :break, do_dump(o.query), :indent]
+    o.operations do |ao|
+      result << :break << do_dump(ao)
+    end
+    result += [:dedent, :dedent ]
+    result
+  end
+
+  def dump_ExportedQuery o
+    result = ["<<| |>>"]
+    result += dump_QueryExpression(o) unless is_nop?(o.expr)
+    result
+  end
+
+  def dump_VirtualQuery o
+    result = ["<| |>"]
+    result += dump_QueryExpression(o) unless is_nop?(o.expr)
+    result
+  end
+
+  def dump_QueryExpression o
+    [do_dump(o.expr)]
+  end
+
+  def dump_ComparisonExpression o
+    [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
+  end
+
+  def dump_AndExpression o
+    ["&&", do_dump(o.left_expr), do_dump(o.right_expr)]
+  end
+
+  def dump_OrExpression o
+    ["||", do_dump(o.left_expr), do_dump(o.right_expr)]
+  end
+
+  def dump_InExpression o
+    ["in", do_dump(o.left_expr), do_dump(o.right_expr)]
+  end
+
+  def dump_ImportExpression o
+    ["import"] + o.files.collect {|f| do_dump(f) }
+  end
+
+  def dump_InstanceReferences o
+    ["instances", do_dump(o.type_name)] + o.names.collect {|n| do_dump(n) }
+  end
+
+  def dump_AssignmentExpression o
+    [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
+  end
+
+  # Produces (name => expr) or (name +> expr)
+  def dump_AttributeOperation o
+    [o.attribute_name, o.operator, do_dump(o.value_expr)]
+  end
+
+  def dump_LiteralList o
+    ["[]"] + o.values.collect {|x| do_dump(x)}
+  end
+
+  def dump_LiteralHash o
+    ["{}"] + o.entries.collect {|x| do_dump(x)}
+  end
+
+  def dump_KeyedEntry o
+    [do_dump(o.key), do_dump(o.value)]
+  end
+
+  def dump_MatchExpression o
+    [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
+  end
+
+  def dump_LiteralString o
+    "'#{o.value}'"
+  end
+
+  def dump_LiteralText o
+    o.value
+  end
+
+  def dump_LambdaExpression o
+    result = ["lambda"]
+    result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
+    if o.body
+      result << do_dump(o.body)
+    else
+      result << []
+    end
+    result
+  end
+
+  def dump_LiteralDefault o
+    ":default"
+  end
+
+  def dump_LiteralUndef o
+    ":undef"
+  end
+
+  def dump_LiteralRegularExpression o
+    "/#{o.value.source}/"
+  end
+
+  def dump_Nop o
+    ":nop"
+  end
+
+  def dump_NamedAccessExpression o
+    [".", do_dump(o.left_expr), do_dump(o.right_expr)]
+  end
+
+  def dump_NilClass o
+    "()"
+  end
+
+  def dump_NotExpression o
+    ['!', dump(o.expr)]
+  end
+
+  def dump_VariableExpression o
+    "$#{dump(o.expr)}"
+  end
+
+  # Interpolation (to string) shown as (str expr)
+  def dump_TextExpression o
+    ["str", do_dump(o.expr)]
+  end
+
+  def dump_UnaryMinusExpression o
+    ['-', do_dump(o.expr)]
+  end
+
+  def dump_BlockExpression o
+    ["block"] + o.statements.collect {|x| do_dump(x) }
+  end
+
+  # Interpolated strings are shown as (cat seg0 seg1 ... segN)
+  def dump_ConcatenatedString o
+    ["cat"] + o.segments.collect {|x| do_dump(x)}
+  end
+
+  def dump_HostClassDefinition o
+    result = ["class", o.name]
+    result << ["inherits", o.parent_class] if o.parent_class
+    result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
+    if o.body
+      result << do_dump(o.body)
+    else
+      result << []
+    end
+    result
+  end
+
+  def dump_NodeDefinition o
+    result = ["node"]
+    result << ["matches"] + o.host_matches.collect {|m| do_dump(m) }
+    result << ["parent", do_dump(o.parent)] if o.parent
+    if o.body
+      result << do_dump(o.body)
+    else
+      result << []
+    end
+    result
+  end
+
+  def dump_ResourceTypeDefinition o
+    result = ["define", o.name]
+    result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
+    if o.body
+      result << do_dump(o.body)
+    else
+      result << []
+    end
+    result
+  end
+
+  def dump_ResourceOverrideExpression o
+    result = ["override", do_dump(o.resources), :indent]
+    o.operations.each do |p|
+      result << :break << do_dump(p)
+    end
+    result << :dedent
+    result
+  end
+
+  # Produces parameters as name, or (= name value)
+  def dump_Parameter o
+    if o.value
+      ["=", o.name, do_dump(o.value)]
+    else
+      o.name
+    end
+  end
+
+  def dump_ParenthesizedExpression o
+    do_dump(o.expr)
+  end
+
+  def dump_IfExpression o
+    result = ["if", do_dump(o.test), :indent, :break,
+      ["then", :indent, do_dump(o.then_expr), :dedent]]
+    result +=
+    [:break,
+      ["else", :indent, do_dump(o.else_expr), :dedent],
+      :dedent] unless is_nop? o.else_expr
+    result
+  end
+
+  def dump_UnlessExpression o
+    result = ["unless", do_dump(o.test), :indent, :break,
+      ["then", :indent, do_dump(o.then_expr), :dedent]]
+    result +=
+    [:break,
+      ["else", :indent, do_dump(o.else_expr), :dedent],
+      :dedent] unless is_nop? o.else_expr
+    result
+  end
+
+  # Produces (invoke name args...) when not required to produce an rvalue, and
+  # (call name args ... ) otherwise.
+  #
+  def dump_CallNamedFunctionExpression o
+    result = [o.rval_required ? "call" : "invoke", do_dump(o.functor_expr)]
+    o.arguments.collect {|a| result << do_dump(a) }
+    result
+  end
+
+  #    def dump_CallNamedFunctionExpression o
+  #      result = [o.rval_required ? "call" : "invoke", do_dump(o.functor_expr)]
+  #      o.arguments.collect {|a| result << do_dump(a) }
+  #      result
+  #    end
+
+  def dump_CallMethodExpression o
+    result = [o.rval_required ? "call-method" : "invoke-method", do_dump(o.functor_expr)]
+    o.arguments.collect {|a| result << do_dump(a) }
+    result << do_dump(o.lambda) if o.lambda
+    result
+  end
+
+  def dump_CaseExpression o
+    result = ["case", do_dump(o.test), :indent]
+    o.options.each do |s|
+      result << :break << do_dump(s)
+    end
+    result << :dedent
+  end
+
+  def dump_CaseOption o
+    result = ["when"]
+    result << o.values.collect {|x| do_dump(x) }
+    result << ["then", do_dump(o.then_expr) ]
+    result
+  end
+
+  def dump_RelationshipExpression o
+    [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
+  end
+
+  def dump_ResourceBody o
+    result = [do_dump(o.title), :indent]
+    o.operations.each do |p|
+      result << :break << do_dump(p)
+    end
+    result << :dedent
+    result
+  end
+
+  def dump_ResourceDefaultsExpression o
+    result = ["resource-defaults", do_dump(o.type_ref), :indent]
+    o.operations.each do |p|
+      result << :break << do_dump(p)
+    end
+    result << :dedent
+    result
+  end
+
+  def dump_ResourceExpression o
+    form = o.form == :regular ? '' : o.form.to_s + "-"
+    result = [form+"resource", do_dump(o.type_name), :indent]
+    o.bodies.each do |b|
+      result << :break << do_dump(b)
+    end
+    result << :dedent
+    result
+  end
+
+  def dump_SelectorExpression o
+    ["?", do_dump(o.left_expr)] + o.selectors.collect {|x| do_dump(x) }
+  end
+
+  def dump_SelectorEntry o
+    [do_dump(o.matching_expr), "=>", do_dump(o.value_expr)]
+  end
+
+  def dump_Object o
+    [o.class.to_s, o.to_s]
+  end
+
+  def is_nop? o
+    o.nil? || o.is_a?(Puppet::Pops::Model::Nop)
+  end
+end

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

@@ -0,0 +1,59 @@
+# Base class for formatted textual dump of a "model"
+#
+class Puppet::Pops::Model::TreeDumper
+  attr_accessor :indent_count
+  def initialize initial_indentation = 0
+    @@dump_visitor ||= Puppet::Pops::Visitor.new(nil,"dump",0,0)
+    @indent_count = initial_indentation
+  end
+
+  def dump(o)
+    format(do_dump(o))
+  end
+
+  def do_dump(o)
+    @@dump_visitor.visit_this(self, o)
+  end
+
+  def indent
+    "  " * indent_count
+  end
+
+  def format(x)
+    result = ""
+    parts = format_r(x)
+    parts.each_index do |i|
+      if i > 0
+        # separate with space unless previous ends with whitepsace or (
+        result << ' ' if parts[i] != ")" && parts[i-1] !~ /.*(?:\s+|\()$/ && parts[i] !~ /\s+/
+      end
+      result << parts[i]
+    end
+    result
+  end
+
+  def format_r(x)
+    result = []
+    case x
+    when :break
+      result << "\n" + indent
+    when :indent
+      @indent_count += 1
+    when :dedent
+      @indent_count -= 1
+    when Array
+      result << '('
+      result += x.collect {|a| format_r(a) }.flatten
+      result << ')'
+    when Symbol
+      result << x.to_s # Allows Symbols in arrays e.g. ["text", =>, "text"]
+    else
+      result << x
+    end
+    result
+  end
+
+  def is_nop? o
+    o.nil? || o.is_a?(Puppet::Pops::Model::Nop)
+  end
+end