bolt 0.19.1 → 0.20.0

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

@@ -1,132 +0,0 @@
-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 ModelLabelProvider
-  include LabelProvider
-
-  def initialize
-    @@label_visitor ||= Visitor.new(self,"label",0,0)
-  end
-
-  # Produces a label for the given objects type/operator without article.
-  # If a Class is given, its name is used as label
-  #
-  def label o
-    @@label_visitor.visit_this_0(self, o)
-  end
-
-  def label_Factory o                     ; label(o.model)                      end
-  def label_Array o                       ; "Array"                             end
-  def label_LiteralInteger o              ; "Literal Integer"                   end
-  def label_LiteralFloat o                ; "Literal Float"                     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_EppExpression o               ; "Epp Template"                      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_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_TrueClass o                   ; "Boolean"                           end
-  def label_FalseClass o                  ; "Boolean"                           end
-  def label_LiteralString o               ; "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                    ; "Undef Value"                       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_UnfoldExpression o            ; "Unfold"                            end
-  def label_BlockExpression o             ; "Block Expression"                  end
-  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_PlanDefinition o              ; "Plan 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
-  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_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
-  def label_RenderExpression o            ; "Epp Interpolated Expression"       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_Integer o                     ; "Integer"                           end
-  def label_Fixnum o                      ; "Integer"                           end
-  def label_Bignum o                      ; "Integer"                           end
-  def label_Float o                       ; "Float"                             end
-  def label_String o                      ; "String"                            end
-  def label_Regexp o                      ; "Regexp"                            end
-  def label_Object o                      ; "Object"                            end
-  def label_Hash o                        ; "Hash"                              end
-  def label_QualifiedName o               ; "Name"                              end
-  def label_QualifiedReference o          ; "Type-Name"                         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
-      "#{o} Resource-Reference"
-    else
-      "#{o}-Type"
-    end
-  end
-
-  def label_Resource o
-    'Resource Statement'
-  end
-
-
-  def label_Class o
-    if o <= Types::PAnyType
-      simple_name = o.name.split('::').last
-      simple_name[1..-5] + "-Type"
-    else
-      n = o.name
-      n.nil? ? 'Anonymous Class' : n
-    end
-  end
-end
-end
-end

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

@@ -1,467 +0,0 @@
-# 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_LiteralFloat o
-    o.value.to_s
-  end
-
-  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
-
-  def dump_LiteralValue o
-    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)
-  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
-
-  # 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_EppExpression o
-    result = ["epp"]
-#    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_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_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_AttributesOperation o
-    ['* =>', do_dump(o.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_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
-      result << []
-    end
-    result
-  end
-
-  def dump_LiteralDefault o
-    ":default"
-  end
-
-  def dump_LiteralUndef o
-    ":undef"
-  end
-
-  def dump_LiteralRegularExpression o
-    Puppet::Pops::Types::StringConverter.convert(o.value, '%p')
-  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_UnfoldExpression o
-    ['unfold', do_dump(o.expr)]
-  end
-
-  def dump_BlockExpression o
-    result = ["block", :indent]
-    o.statements.each {|x| result << :break; result << do_dump(x) }
-    result << :dedent << :break
-    result
-  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_HeredocExpression(o)
-    ["@(#{o.syntax})", :indent, :break, do_dump(o.text_expr), :dedent, :break]
-  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_PlanDefinition o
-    result = ["plan", 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_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_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]
-    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_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 + '-'
-    result = [form+'override', do_dump(o.resources), :indent]
-    o.operations.each do |p|
-      result << :break << do_dump(p)
-    end
-    result << :dedent
-    result
-  end
-
-  def dump_ReservedWord o
-    [ 'reserved', o.word ]
-  end
-
-  # Produces parameters as name, or (= name value)
-  def dump_Parameter o
-    name_prefix = o.captures_rest ? '*' : ''
-    name_part = "#{name_prefix}#{o.name}"
-    if o.value && o.type_expr
-      ["=t", do_dump(o.type_expr), name_part, do_dump(o.value)]
-    elsif o.value
-      ["=", name_part, do_dump(o.value)]
-    elsif o.type_expr
-      ["t", do_dump(o.type_expr), name_part]
-    else
-      name_part
-    end
-  end
-
-  def dump_ParenthesizedExpression o
-    do_dump(o.expr)
-  end
-
-  # Hides that Program exists in the output (only its body is shown), the definitions are just
-  # references to contained classes, resource types, and nodes
-  def dump_Program(o)
-    dump(o.body)
-  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 << do_dump(o.lambda) if o.lambda
-    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_RenderStringExpression o
-    ["render-s", " '#{o.value}'"]
-  end
-
-  def dump_RenderExpression o
-    ["render", do_dump(o.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
-    form = o.form == 'regular' ? '' : o.form + '-'
-    result = [form+'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 + '-'
-    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_SubLocatedExpression o
-    ["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
-
-  def is_nop? o
-    o.nil? || o.is_a?(Puppet::Pops::Model::Nop)
-  end
-end