puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/parser/code_merger.rb

@@ -0,0 +1,17 @@
+
+class Puppet::Pops::Parser::CodeMerger
+
+  # Concatenates the logic in the array of parse results into one parse result.
+  # @return Puppet::Parser::AST::BlockExpression
+  #
+  def concatenate(parse_results)
+    # this is a bit brute force as the result is already 3x ast with wrapped 4x content
+    # this could be combined in a more elegant way, but it is only used to process a handful of files
+    # at the beginning of a puppet run. TODO: Revisit for Puppet 4x when there is no 3x ast at the top.
+    #
+    children = parse_results.select {|x| !x.nil? && x.code}.reduce([]) do |memo, parsed_class|
+      memo << parsed_class.code
+    end
+    Puppet::Parser::AST::BlockExpression.new(:children => children)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/parser/egrammar.ra

@@ -0,0 +1,757 @@
+# vim: syntax=ruby
+
+# Parser using the Pops model, expression based
+
+class Puppet::Pops::Parser::Parser
+
+token STRING DQPRE DQMID DQPOST
+token WORD
+token LBRACK  RBRACK LBRACE RBRACE SYMBOL FARROW COMMA TRUE
+token FALSE EQUALS APPENDS DELETES LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
+token QMARK LPAREN RPAREN ISEQUAL GREATEREQUAL GREATERTHAN LESSTHAN
+token IF ELSE
+token DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
+token NAME SEMIC CASE DEFAULT AT ATAT LCOLLECT RCOLLECT CLASSREF
+token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
+token MATCH NOMATCH REGEX IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
+token IN UNLESS PIPE
+token LAMBDA SELBRACE
+token NUMBER
+token HEREDOC SUBLOCATE
+token RENDER_STRING RENDER_EXPR EPP_START EPP_END EPP_END_TRIM
+token FUNCTION
+token PRIVATE ATTR TYPE
+token LOW
+
+prechigh
+  left  HIGH
+  left  SEMIC
+  left  PIPE
+  left  LPAREN
+  left  RPAREN
+  left  DOT
+  nonassoc EPP_START
+  left  LBRACK LISTSTART
+  left  RBRACK
+  left  QMARK
+  left  LCOLLECT LLCOLLECT
+  right NOT
+  nonassoc SPLAT
+  nonassoc UMINUS
+  left  IN
+  left  MATCH NOMATCH
+  left  TIMES DIV MODULO
+  left  MINUS PLUS
+  left  LSHIFT RSHIFT
+  left  NOTEQUAL ISEQUAL
+  left  GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
+  left  AND
+  left  OR
+  left  LBRACE
+  left  SELBRACE
+  left  RBRACE
+  right AT ATAT
+  right APPENDS DELETES EQUALS
+  left  IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
+  left  FARROW
+  left  COMMA
+  nonassoc RENDER_EXPR
+  nonassoc RENDER_STRING
+  left  LOW
+preclow
+
+rule
+# Produces [Model::Program] with a body containing what was parsed
+program
+  : statements     { result = create_program(Factory.block_or_expression(*val[0])) }
+  | epp_expression { result = create_program(Factory.block_or_expression(*val[0])) }
+  |                { result = create_empty_program() }
+
+# Produces a semantic model (non validated, but semantically adjusted).
+statements
+  : syntactic_statements { result = transform_calls(val[0]) }
+
+# Collects sequence of elements into a list that the statements rule can transform
+# (Needed because language supports function calls without parentheses around arguments).
+# Produces Array<Model::Expression>
+#
+syntactic_statements
+  : syntactic_statement                            { result = [val[0]]}
+  | syntactic_statements SEMIC syntactic_statement { result = val[0].push val[2] }
+  | syntactic_statements syntactic_statement       { result = val[0].push val[1] }
+
+# Produce a single expression or Array of expression
+# This exists to handle multiple arguments to non parenthesized function call. If e is expression,
+# the a program can consists of e [e,e,e] where the first may be a name of a function to call.
+#
+syntactic_statement
+  : assignment                             =LOW { result = val[0] }
+  | syntactic_statement COMMA assignment   =LOW { result = aryfy(val[0]).push(val[1]).push(val[2]) }
+
+# Assignment (is right recursive since assignment is right associative)
+assignment
+  : relationship =LOW
+  | relationship EQUALS  assignment         { result = val[0].set(val[2])      ; loc result, val[1] }
+  | relationship APPENDS assignment         { result = val[0].plus_set(val[2]) ; loc result, val[1] }
+  | relationship DELETES assignment         { result = val[0].minus_set(val[2]); loc result, val[1] }
+
+assignments
+  : assignment                              { result = [val[0]] }
+  | assignments COMMA assignment            { result = val[0].push(val[2]) }
+
+relationship
+  : resource =LOW
+  | relationship IN_EDGE      resource      { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
+  | relationship IN_EDGE_SUB  resource      { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
+  | relationship OUT_EDGE     resource      { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
+  | relationship OUT_EDGE_SUB resource      { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
+
+#-- RESOURCE
+#
+resource
+  : expression = LOW
+
+    #---VIRTUAL
+  | AT resource {
+      result = val[1]
+      unless Factory.set_resource_form(result, :virtual)
+        # This is equivalent to a syntax error - additional semantic restrictions apply
+        error val[0], "Virtual (@) can only be applied to a Resource Expression"
+      end
+      # relocate the result
+      loc result, val[0], val[1]
+    }
+
+    #---EXPORTED
+  | ATAT resource {
+      result = val[1]
+      unless Factory.set_resource_form(result, :exported)
+        # This is equivalent to a syntax error - additional semantic restrictions apply
+        error val[0], "Exported (@@) can only be applied to a Resource Expression"
+      end
+      # relocate the result
+      loc result, val[0], val[1]
+    }
+
+    #---RESOURCE TITLED 3x and 4x
+  | resource LBRACE expression COLON attribute_operations additional_resource_bodies RBRACE {
+      bodies = [Factory.RESOURCE_BODY(val[2], val[4])] + val[5]
+      result = Factory.RESOURCE(val[0], bodies)
+      loc result, val[0], val[6]
+    }
+
+    #---CLASS RESOURCE
+  | CLASS LBRACE resource_bodies endsemi RBRACE {
+        result = Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
+        loc result, val[0], val[4]
+    }
+
+    # --RESOURCE 3X Expression
+    #   Handles both 3x overrides and defaults (i.e. single resource_body without title colon)
+    #   Slated for possible deprecation since it requires transformation and mix static/evaluation check
+    #
+  | resource LBRACE attribute_operations endcomma RBRACE {
+       result = case Factory.resource_shape(val[0])
+       when :resource, :class
+        # This catches deprecated syntax.
+        # 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])
+          error val[1], "Syntax error resource body without title or hash with +>"
+        end
+        tmp
+      when :defaults
+        Factory.RESOURCE_DEFAULTS(val[0], val[2])
+      when :override
+        # This was only done for override in original - TODO should it be here at all
+        Factory.RESOURCE_OVERRIDE(val[0], val[2])
+      else
+        error val[0], "Expression is not valid as a resource, resource-default, or resource-override"
+      end
+     loc result, val[0], val[4]
+    }
+
+  resource_body
+    : expression COLON attribute_operations endcomma { result = Factory.RESOURCE_BODY(val[0], val[2]) }
+
+  resource_bodies
+    : resource_body                         =HIGH { result = [val[0]] }
+    | resource_bodies SEMIC resource_body   =HIGH { result = val[0].push val[2] }
+
+  # This is a rule for the intermediate state where RACC has seen enough tokens to understand that
+  # what is expressed is a Resource Expression, it now has to get to the finishing line
+  #
+  additional_resource_bodies
+    : endcomma                         { result = [] }
+    | endcomma SEMIC                   { result = [] }
+    | endcomma SEMIC resource_bodies endsemi { result = val[2] }
+
+#-- EXPRESSION
+#
+expression
+  : primary_expression
+  | call_function_expression
+  | expression LBRACK       expressions RBRACK =LBRACK { result = val[0][*val[2]]         ; loc result, val[0], val[3] }
+  | expression IN           expression                 { result = val[0].in val[2]        ; loc result, val[1] }
+  | expression MATCH        expression                 { result = val[0] =~  val[2]       ; loc result, val[1] }
+  | expression NOMATCH      expression                 { result = val[0].mne val[2]       ; loc result, val[1] }
+  | expression PLUS         expression                 { result = val[0] +   val[2]       ; loc result, val[1] }
+  | expression MINUS        expression                 { result = val[0] -   val[2]       ; loc result, val[1] }
+  | expression DIV          expression                 { result = val[0] /   val[2]       ; loc result, val[1] }
+  | expression TIMES        expression                 { result = val[0] *   val[2]       ; loc result, val[1] }
+  | expression MODULO       expression                 { result = val[0] %   val[2]       ; loc result, val[1] }
+  | expression LSHIFT       expression                 { result = val[0] <<  val[2]       ; loc result, val[1] }
+  | expression RSHIFT       expression                 { result = val[0] >>  val[2]       ; loc result, val[1] }
+  |            MINUS        expression         =UMINUS { result = val[1].minus()          ; loc result, val[0] }
+  |            TIMES        expression         =SPLAT  { result = val[1].unfold()         ; loc result, val[0] }
+  | expression NOTEQUAL     expression                 { result = val[0].ne  val[2]       ; loc result, val[1] }
+  | expression ISEQUAL      expression                 { result = val[0] ==  val[2]       ; loc result, val[1] }
+  | expression GREATERTHAN  expression                 { result = val[0] >   val[2]       ; loc result, val[1] }
+  | expression GREATEREQUAL expression                 { result = val[0] >=  val[2]       ; loc result, val[1] }
+  | expression LESSTHAN     expression                 { result = val[0] <   val[2]       ; loc result, val[1] }
+  | expression LESSEQUAL    expression                 { result = val[0] <=  val[2]       ; loc result, val[1] }
+  |            NOT          expression                 { result = val[1].not              ; loc result, val[0] }
+  | expression AND          expression                 { result = val[0].and val[2]       ; loc result, val[1] }
+  | expression OR           expression                 { result = val[0].or  val[2]       ; loc result, val[1] }
+  | expression QMARK selector_entries                  { result = val[0].select(*val[2])  ; loc result, val[0] }
+  |            LPAREN       assignment RPAREN          { result = val[1].paren()          ; loc result, val[0] }
+
+
+#---EXPRESSIONS
+#   (i.e. "argument list")
+#
+# This expression list can not contain function calls without parentheses around arguments
+# Produces Array<Model::Expression>
+#
+expressions
+  : expression                   { result = [val[0]] }
+  | expressions COMMA expression { result = val[0].push(val[2]) }
+
+primary_expression
+  : variable
+  | call_method_with_lambda_expression
+  | collection_expression
+  | case_expression
+  | if_expression
+  | unless_expression
+  | definition_expression
+  | hostclass_expression
+  | node_definition_expression
+  | epp_render_expression
+  | reserved_word
+  | array
+  | hash
+  | regex
+  | quotedtext
+  | type
+  | NUMBER       { result = Factory.NUMBER(val[0][:value])          ; loc result, val[0] }
+  | BOOLEAN      { result = Factory.literal(val[0][:value])         ; loc result, val[0] }
+  | DEFAULT      { result = Factory.literal(:default)               ; loc result, val[0] }
+  | UNDEF        { result = Factory.literal(:undef)                 ; loc result, val[0] }
+  | NAME         { result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0] }
+
+
+#---CALL FUNCTION
+#
+# 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]
+    }
+  | expression LPAREN RPAREN {
+      result = Factory.CALL_NAMED(val[0], true, [])
+      loc result, val[0], val[2]
+    }
+  | expression LPAREN assignments endcomma RPAREN lambda {
+      result = Factory.CALL_NAMED(val[0], true, val[2])
+      loc result, val[0], val[4]
+      result.lambda = val[5]
+    }
+  | expression LPAREN RPAREN  lambda {
+      result = Factory.CALL_NAMED(val[0], true, [])
+      loc result, val[0], val[2]
+      result.lambda = val[3]
+    }
+
+#---CALL METHOD
+#
+call_method_with_lambda_expression
+  : call_method_expression         =LOW { result = val[0] }
+  | call_method_expression lambda       { result = val[0]; val[0].lambda = val[1] }
+
+  call_method_expression
+    : named_access LPAREN assignments RPAREN { result = Factory.CALL_METHOD(val[0], val[2]); loc result, val[1], val[3] }
+    | named_access LPAREN RPAREN             { result = Factory.CALL_METHOD(val[0], []); loc result, val[1], val[3] }
+    | named_access =LOW                      { result = Factory.CALL_METHOD(val[0], []); loc result, val[0] }
+
+  named_access
+    : expression DOT NAME {
+        result = val[0].dot(Factory.fqn(val[2][:value]))
+        loc result, val[1], val[2]
+      }
+
+#---LAMBDA
+#
+lambda
+  : lambda_parameter_list lambda_rest {
+      result = Factory.LAMBDA(val[0][:value], val[1][:value])
+      loc result, val[0][:start], val[1][:end]
+    }
+
+lambda_rest
+  : LBRACE statements RBRACE  { result = {:end => val[2], :value =>val[1] } }
+  | LBRACE RBRACE             { result = {:end => val[1], :value => nil } }
+
+
+lambda_parameter_list
+  : PIPE PIPE                     { result = {:start => val[0], :value => [] } }
+  | PIPE parameters endcomma PIPE { result = {:start => val[0], :value => val[1] } }
+
+#---CONDITIONALS
+
+#--IF
+#
+if_expression
+  : IF if_part {
+      result = val[1]
+      loc(result, val[0], val[1])
+    }
+
+  # Produces Model::IfExpression
+  if_part
+    : expression LBRACE statements RBRACE else {
+        result = Factory.IF(val[0], Factory.block_or_expression(*val[2]), val[4])
+        loc(result, val[0], (val[4] ? val[4] : val[3]))
+      }
+    | expression LBRACE RBRACE else {
+        result = Factory.IF(val[0], nil, val[3])
+        loc(result, val[0], (val[3] ? val[3] : val[2]))
+      }
+
+  # Produces [Model::Expression, nil] - nil if there is no else or elsif part
+  else
+    : # nothing
+    | ELSIF if_part {
+        result = val[1]
+        loc(result, val[0], val[1])
+      }
+    | ELSE LBRACE statements RBRACE {
+        result = Factory.block_or_expression(*val[2])
+        loc result, val[0], val[3]
+      }
+    | ELSE LBRACE RBRACE {
+        result = nil # don't think a nop is needed here either
+      }
+
+#--UNLESS
+#
+unless_expression
+  : UNLESS expression LBRACE statements RBRACE unless_else {
+      result = Factory.UNLESS(val[1], Factory.block_or_expression(*val[3]), val[5])
+      loc result, val[0], val[4]
+    }
+  | UNLESS expression LBRACE RBRACE unless_else {
+      result = Factory.UNLESS(val[1], nil, nil)
+      loc result, val[0], val[4]
+    }
+
+  # Different from else part of if, since "elsif" is not supported, but 'else' is
+  #
+  # Produces [Model::Expression, nil] - nil if there is no else or elsif part
+  unless_else
+    : # nothing
+    | ELSE LBRACE statements RBRACE {
+        result = Factory.block_or_expression(*val[2])
+        loc result, val[0], val[3]
+      }
+    | ELSE LBRACE RBRACE {
+        result = nil # don't think a nop is needed here either
+      }
+
+#--- CASE EXPRESSION
+#
+case_expression
+  : CASE expression LBRACE case_options RBRACE {
+      result = Factory.CASE(val[1], *val[3])
+      loc result, val[0], val[4]
+    }
+
+  # Produces Array<Model::CaseOption>
+  case_options
+    : case_option               { result = [val[0]] }
+    | case_options case_option  { result = val[0].push val[1] }
+
+  # Produced Model::CaseOption (aka When)
+  case_option
+    : expressions COLON LBRACE options_statements RBRACE {
+        result = Factory.WHEN(val[0], val[3]); loc result, val[1], val[4]
+      }
+
+  options_statements
+    : nil
+    | statements
+
+  # This special construct is required or racc will produce the wrong result when the selector entry
+  # LHS is generalized to any expression (LBRACE looks like a hash). Thus it is not possible to write
+  # a selector with a single entry where the entry LHS is a hash.
+  # The SELBRACE token is a LBRACE that follows a QMARK, and this is produced by the lexer with a lookback
+  # Produces Array<Model::SelectorEntry>
+  #
+  selector_entries
+    : selector_entry
+    | SELBRACE selector_entry_list endcomma RBRACE {
+        result = val[1]
+      }
+
+  # Produces Array<Model::SelectorEntry>
+  selector_entry_list
+    : selector_entry                           { result = [val[0]] }
+    | selector_entry_list COMMA selector_entry { result = val[0].push val[2] }
+
+  # Produces a Model::SelectorEntry
+  # This FARROW wins over FARROW in Hash
+  selector_entry
+    : expression FARROW expression { result = Factory.MAP(val[0], val[2]) ; loc result, val[1] }
+
+#---COLLECTION
+#
+# A Collection is a predicate applied to a set of objects with an implied context (used variables are
+# attributes of the object.
+# i.e. this is equivalent to source.select(QUERY).apply(ATTRIBUTE_OPERATIONS)
+#
+collection_expression
+  : expression collect_query LBRACE attribute_operations endcomma RBRACE {
+      result = Factory.COLLECT(val[0], val[1], val[3])
+      loc result, val[0], val[5]
+    }
+  | expression collect_query =LOW {
+      result = Factory.COLLECT(val[0], val[1], [])
+      loc result, val[0], val[1]
+    }
+
+  collect_query
+    : LCOLLECT  optional_query RCOLLECT  { result = Factory.VIRTUAL_QUERY(val[1])   ; loc result, val[0], val[2] }
+    | LLCOLLECT optional_query RRCOLLECT { result = Factory.EXPORTED_QUERY(val[1])  ; loc result, val[0], val[2] }
+
+  optional_query
+    : nil
+    | expression
+
+#---ATTRIBUTE OPERATIONS (Not an expression)
+#
+attribute_operations
+  :                                                { result = [] }
+  | attribute_operation                            { result = [val[0]] }
+  | attribute_operations COMMA attribute_operation { result = val[0].push(val[2]) }
+
+  # Produces String
+  # QUESTION: Why is BOOLEAN valid as an attribute name?
+  #
+  attribute_name
+    : NAME
+    | keyword
+#    | BOOLEAN
+
+  # In this version, illegal combinations are validated instead of producing syntax errors
+  # (Can give nicer error message "+> is not applicable to...")
+  # Produces Model::AttributeOperation
+  #
+  attribute_operation
+    : attribute_name FARROW expression {
+        result = Factory.ATTRIBUTE_OP(val[0][:value], :'=>', val[2])
+        loc result, val[0], val[2]
+      }
+    | attribute_name PARROW expression {
+        result = Factory.ATTRIBUTE_OP(val[0][:value], :'+>', val[2])
+        loc result, val[0], val[2]
+      }
+  | TIMES FARROW expression {
+      result = Factory.ATTRIBUTES_OP(val[2]) ; loc result, val[0], val[2]
+   }
+
+#---DEFINE
+#
+# Produces Model::Definition
+#
+definition_expression
+  : DEFINE classname parameter_list LBRACE opt_statements RBRACE {
+      result = add_definition(Factory.DEFINITION(classname(val[1][:value]), val[2], val[4]))
+      loc result, val[0], val[5]
+      # New lexer does not keep track of this, this is done in validation
+      if @lexer.respond_to?(:'indefine=')
+        @lexer.indefine = false
+      end
+    }
+
+#---HOSTCLASS
+#
+# Produces Model::HostClassDefinition
+#
+hostclass_expression
+  : CLASS stacked_classname parameter_list classparent LBRACE opt_statements RBRACE {
+      # Remove this class' name from the namestack as all nested classes have been parsed
+      namepop
+      result = add_definition(Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5]))
+      loc result, val[0], val[6]
+    }
+
+  # Record the classname so nested classes gets a fully qualified name at parse-time
+  # This is a separate rule since racc does not support intermediate actions.
+  #
+  stacked_classname
+    : classname { namestack(val[0][:value]) ; result = val[0] }
+
+  opt_statements
+    : statements
+    | nil
+
+  # Produces String, name or nil result
+  classparent
+    : nil
+    | INHERITS classnameordefault { result = val[1] }
+
+  # Produces String (this construct allows a class to be named "default" and to be referenced as
+  # the parent class.
+  # TODO: Investigate the validity
+  # Produces a String (classname), or a token (DEFAULT).
+  #
+  classnameordefault
+    : classname
+    | DEFAULT
+
+#---NODE
+#
+# Produces Model::NodeDefinition
+#
+node_definition_expression
+  : NODE hostnames endcomma nodeparent LBRACE statements RBRACE {
+      result = add_definition(Factory.NODE(val[1], val[3], val[5]))
+      loc result, val[0], val[6]
+    }
+  | NODE hostnames endcomma nodeparent LBRACE RBRACE {
+      result = add_definition(Factory.NODE(val[1], val[3], nil))
+      loc result, val[0], val[5]
+    }
+
+  # Hostnames is not a list of names, it is a list of name matchers (including a Regexp).
+  # (The old implementation had a special "Hostname" object with some minimal validation)
+  #
+  # Produces Array<Model::LiteralExpression>
+  #
+  hostnames
+    : hostname                 { result = [result] }
+    | hostnames COMMA hostname { result = val[0].push(val[2]) }
+
+  # Produces a LiteralExpression (string, :default, or regexp)
+  # String with interpolation is validated for better error message
+  hostname
+    : dotted_name
+    | quotedtext
+    | DEFAULT     { result = Factory.literal(:default); loc result, val[0] }
+    | regex
+
+  dotted_name
+    : name_or_number   { result = Factory.literal(val[0][:value]); loc result, val[0] }
+    | dotted_name DOT name_or_number { result = Factory.concat(val[0], '.', val[2][:value]); loc result, val[0], val[2] }
+
+  name_or_number
+    : NAME
+    | NUMBER
+
+  # Produces Expression, since hostname is an Expression
+  nodeparent
+    : nil
+    | INHERITS hostname { result = val[1] }
+
+#---FUNCTION DEFINITION
+#
+#function_definition
+  # For now the function word will just be reserved, in the future it will
+  # produce a function definition
+  # FUNCTION classname parameter_list LBRACE opt_statements RBRACE {
+  #   result = add_definition(Factory.FUNCTION(val[1][:value], val[2], val[4]))
+  #   loc result, val[0], val[5]
+  # }
+
+#---NAMES AND PARAMETERS COMMON TO SEVERAL RULES
+#   Produces String
+#   TODO: The error that "class" is not a valid classname is bad - classname rule is also used for other things
+classname
+  : NAME
+  | CLASS { error val[0], "'class' is not a valid classname" }
+
+# Produces Array<Model::Parameter>
+parameter_list
+  : nil                               { result = [] }
+  | LPAREN  RPAREN                    { result = [] }
+  | LPAREN parameters endcomma RPAREN { result = val[1] }
+
+# Produces Array<Model::Parameter>
+parameters
+  : parameter                  { result = [val[0]] }
+  | parameters COMMA parameter { result = val[0].push(val[2]) }
+
+# Produces Model::Parameter
+parameter
+  : untyped_parameter
+  | typed_parameter
+
+untyped_parameter
+  : regular_parameter
+  | splat_parameter
+
+regular_parameter
+  : VARIABLE EQUALS expression { result = Factory.PARAM(val[0][:value], val[2]) ; loc result, val[0] }
+  | VARIABLE                   { result = Factory.PARAM(val[0][:value]); loc result, val[0] }
+
+splat_parameter
+  : TIMES regular_parameter { result = val[1]; val[1].captures_rest() }
+
+typed_parameter
+  : parameter_type untyped_parameter { val[1].type_expr(val[0]) ; result = val[1] }
+
+parameter_type
+  : type { result = val[0] }
+  | type LBRACK expressions RBRACK { result = val[0][*val[2]] ; loc result, val[0], val[3] }
+
+#--VARIABLE
+#
+variable
+  : VARIABLE { result = Factory.fqn(val[0][:value]).var ; loc result, val[0] }
+
+#---RESERVED WORDS
+#
+reserved_word
+  : FUNCTION  { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
+  | 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] }
+
+#---LITERALS (dynamic and static)
+#
+
+array
+  : LISTSTART assignments endcomma  RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
+  | LISTSTART                       RBRACK { result = Factory.literal([]) ; loc result, val[0] }
+  | LBRACK    assignments endcomma  RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
+  | LBRACK                          RBRACK { result = Factory.literal([]) ; loc result, val[0] }
+
+hash
+  : LBRACE hashpairs RBRACE       { result = Factory.HASH(val[1]); loc result, val[0], val[2] }
+  | LBRACE hashpairs COMMA RBRACE { result = Factory.HASH(val[1]); loc result, val[0], val[3] }
+  | LBRACE RBRACE                 { result = Factory.literal({}) ; loc result, val[0], val[3] }
+
+  hashpairs
+    : hashpair                 { result = [val[0]] }
+    | hashpairs COMMA hashpair { result = val[0].push val[2] }
+
+  hashpair
+    : assignment FARROW assignment { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
+
+quotedtext
+  : string
+  | dq_string
+  | heredoc
+
+string
+  : STRING  { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
+  | WORD    { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
+
+dq_string       : dqpre dqrval           { result = Factory.string(val[0], *val[1]) ; loc result, val[0], val[1][-1] }
+dqpre           : DQPRE                  { result = Factory.literal(val[0][:value]); loc result, val[0] }
+dqpost          : DQPOST                 { result = Factory.literal(val[0][:value]); loc result, val[0] }
+dqmid           : DQMID                  { result = Factory.literal(val[0][:value]); loc result, val[0] }
+dqrval          : text_expression dqtail { result = [val[0]] + val[1] }
+text_expression : assignment             { result = Factory.TEXT(val[0]) }
+
+dqtail
+  : dqpost        { result = [val[0]] }
+  | dqmid dqrval  { result = [val[0]] + val[1] }
+
+heredoc
+  : HEREDOC sublocated_text  { result = Factory.HEREDOC(val[0][:value], val[1]); loc result, val[0] }
+
+sublocated_text
+  : SUBLOCATE string    { result = Factory.SUBLOCATE(val[0], val[1]); loc result, val[0] }
+  | SUBLOCATE dq_string { result = Factory.SUBLOCATE(val[0], val[1]); loc result, val[0] }
+
+epp_expression
+  : EPP_START epp_parameters_list optional_statements { result = Factory.EPP(val[1], val[2]); loc result, val[0] }
+
+optional_statements
+  :
+  | statements
+
+epp_parameters_list
+  :                                  =LOW{ result = nil }
+  | PIPE PIPE                        { result = [] }
+  | PIPE parameters endcomma PIPE    { result = val[1] }
+
+epp_render_expression
+  : RENDER_STRING                  { result = Factory.RENDER_STRING(val[0][:value]); loc result, val[0] }
+  | RENDER_EXPR expression epp_end { result = Factory.RENDER_EXPR(val[1]); loc result, val[0], val[2] }
+  | RENDER_EXPR LBRACE statements RBRACE epp_end { result = Factory.RENDER_EXPR(Factory.block_or_expression(*val[2])); loc result, val[0], val[4] }
+
+epp_end
+  : EPP_END
+  | EPP_END_TRIM
+
+type     : CLASSREF { result = Factory.QREF(val[0][:value])  ; loc result, val[0] }
+
+regex
+  : REGEX { result = Factory.literal(val[0][:value]); loc result, val[0] }
+
+#---MARKERS, SPECIAL TOKENS, SYNTACTIC SUGAR, etc.
+
+endcomma
+  : #
+  | COMMA { result = nil }
+
+endsemi
+  : #
+  | SEMIC
+
+keyword
+  : AND
+  | CASE
+  | CLASS
+  | DEFAULT
+  | DEFINE
+  | ELSE
+  | ELSIF
+  | IF
+  | IN
+  | INHERITS
+  | NODE
+  | OR
+  | UNDEF
+  | UNLESS
+  | TYPE
+  | ATTR
+  | FUNCTION
+  | PRIVATE
+
+nil
+  : { result = nil}
+
+end
+
+---- header ----
+require 'puppet'
+require 'puppet/pops'
+
+module Puppet
+  class ParseError < Puppet::Error; end
+  class ImportError < Racc::ParseError; end
+  class AlreadyImportedError < ImportError; end
+end
+
+---- inner ----
+
+# Make emacs happy
+# Local Variables:
+# mode: ruby
+# End: