puppet 3.4.3 → 3.5.0.rc1

data/lib/puppet/pops/binder/hiera2/config_checker.rb

@@ -1,68 +0,0 @@
-module Puppet::Pops::Binder::Hiera2
-
-  # Validates the consistency of a Hiera2::Config
-  class ConfigChecker
-
-    # Create an instance with a diagnostic producer that will receive the result during validation
-    # @param diangostics [DiagnosticProducer] The producer that will receive the diagnostic
-    def initialize(diagnostics)
-      @diagnostics = diagnostics
-    end
-
-    # Validate the consistency of the given data. Diagnostics will be emitted to the DiagnosticProducer
-    # that was set when this checker was created
-    #
-    # @param data [Object] The data read from the config file
-    # @param config_file [String] The full path of the file. Used in error messages
-    def validate(data, config_file)
-      if data.is_a?(Hash)
-        # If the version is missing, it is not meaningful to continue
-        return unless check_version(data['version'], config_file)
-        check_hierarchy(data['hierarchy'], config_file)
-        check_backends(data['backends'], config_file)
-      else
-        @diagnostics.accept(Issues::CONFIG_IS_NOT_HASH, config_file)
-      end
-    end
-
-    private
-
-    # Version is required and must be >= 2. A warning is issued if version > 2 as this checker is
-    # for version 2 only.
-    # @return [Boolean] false if it is meaningless to continue checking
-    def check_version(version, config_file)
-      if version.nil?
-        # This is not hiera2 compatible
-        @diagnostics.accept(Issues::MISSING_VERSION, config_file)
-        return false
-      end
-      unless version >= 2
-        @diagnostics.accept(Issues::WRONG_VERSION, config_file, :expected => 2, :actual => version)
-        return false
-      end
-      unless version == 2
-        # it may have a sane subset, hence a different error (configured as warning)
-        @diagnostics.accept(Issues::LATER_VERSION, config_file, :expected => 2, :actual => version)
-      end
-      return true
-    end
-
-    def check_hierarchy(hierarchy, config_file)
-      if !hierarchy.is_a?(Array) || hierarchy.empty?
-        @diagnostics.accept(Issues::MISSING_HIERARCHY, config_file)
-      else
-        hierarchy.each do |value|
-          unless value.is_a?(Array) && value.length() == 3
-            @diagnostics.accept(Issues::CATEGORY_MUST_BE_THREE_ELEMENT_ARRAY, config_file)
-          end
-        end
-      end
-    end
-
-    def check_backends(backends, config_file)
-      if !backends.is_a?(Array) || backends.empty?
-        @diagnostics.accept(Issues::MISSING_BACKENDS, config_file)
-      end
-    end
-  end
-end

data/lib/puppet/pops/binder/hiera2/diagnostic_producer.rb

@@ -1,36 +0,0 @@
-module Puppet::Pops::Binder::Hiera2
-  # Generates validation diagnostics
-  class Puppet::Pops::Binder::Hiera2::DiagnosticProducer
-    attr_reader :acceptor
-    def initialize(an_acceptor)
-      raise ArgumentError, "Not an acceptor" unless an_acceptor.is_a?(Puppet::Pops::Validation::Acceptor)
-      @acceptor = an_acceptor
-      @severity_producer = Puppet::Pops::Validation::SeverityProducer.new
-    end
-
-    def accept(issue, semantic, arguments={})
-      arguments[:semantic] ||= semantic
-      severity = severity_producer.severity(issue)
-      acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(severity, issue, nil, nil, arguments))
-    end
-
-    def errors?()
-      acceptor.errors?
-    end
-
-    def severity_producer
-      p = @severity_producer
-      p[Issues::UNRESOLVED_STRING_VARIABLE] = :warning
-
-      # Warning since if it does not blow up on anything else, a sane subset of later version was used
-      p[Issues::LATER_VERSION] = :warning
-
-      # Ignore MISSING_BACKENDS because a default will be provided
-      p[Issues::MISSING_BACKENDS] = :ignore
-
-      # Ignore MISSING_HIERARCHY because a default will be provided
-      p[Issues::MISSING_HIERARCHY] = :ignore
-      p
-    end
-  end
-end

data/lib/puppet/pops/binder/hiera2/issues.rb

@@ -1,67 +0,0 @@
-module Puppet::Pops::Binder::Hiera2::Issues
-  # (see Puppet::Pops::Issues#issue)
-  def self.issue (issue_code, *args, &block)
-    Puppet::Pops::Issues.issue(issue_code, *args, &block)
-  end
-
-  CONFIG_IS_NOT_HASH = issue :CONFIG_IS_NOT_HASH do
-    "The configuration file '#{semantic}' has no hash at the top level"
-  end
-
-  MISSING_HIERARCHY = issue :MISSING_HIERARCHY do
-    "The configuration file '#{semantic}' contains no hierarchy"
-  end
-
-  MISSING_BACKENDS = issue :MISSING_BACKENDS do
-    "The configuration file '#{semantic}' contains no backends"
-  end
-
-  CATEGORY_MUST_BE_THREE_ELEMENT_ARRAY = issue :CATEGORY_MUST_BE_THREE_ELEMENT_ARRAY do
-    "The configuration file '#{semantic}' has a malformed hierarchy (should consist of arrays with three string entries)"
-  end
-
-  CONFIG_FILE_NOT_FOUND = issue :CONFIG_FILE_NOT_FOUND do
-    "The configuration file '#{semantic}' does not exist"
-  end
-
-  CONFIG_FILE_SYNTAX_ERROR = issue :CONFIG_FILE_SYNTAX_ERROR do
-    "Unable to parse: #{semantic}"
-  end
-
-  CANNOT_LOAD_BACKEND = issue :CANNOT_LOAD_BACKEND, :key, :error do
-    "Backend '#{key}' in configuration file '#{semantic}' cannot be loaded: #{error}"
-  end
-
-  BACKEND_FILE_DOES_NOT_DEFINE_CLASS = issue :BACKEND_FILE_DOES_NOT_DEFINE_CLASS, :class_name do
-    "The file '#{semantic}' does not define class #{class_name}"
-  end
-
-  NOT_A_BACKEND_CLASS = issue :NOT_A_BACKEND_CLASS, :key, :class_name do
-    "Class #{class_name}, loaded using key #{key} in file '#{semantic}' is not a subclass of Backend"
-  end
-
-  METADATA_JSON_NOT_FOUND = issue :METADATA_JSON_NOT_FOUND do
-    "The metadata file '#{semantic}' does not exist"
-  end
-
-  UNSUPPORTED_STRING_EXPRESSION = issue :UNSUPPORTED_STRING_EXPRESSION, :expr do
-    "String '#{semantic}' contains an unsupported expression (type was #{expr.class.name})"
-  end
-
-  UNRESOLVED_STRING_VARIABLE = issue :UNRESOLVED_STRING_VARIABLE, :key do
-    "Variable '#{key}' found in string '#{semantic}' cannot be resolved"
-  end
-
-  MISSING_VERSION = issue :MISSING_VERSION do
-    "The configuration file '#{semantic}' does not have a version."
-  end
-
-  WRONG_VERSION = issue :WRONG_VERSION do
-    "The configuration file '#{semantic}' has the wrong version, expected: #{expected}, actual: #{actual}"
-  end
-
-  LATER_VERSION = issue :LATER_VERSION do
-    "The configuration file '#{semantic}' has a version that is newer (features may not work), expected: #{expected}, actual: #{actual}"
-  end
-
-end

data/lib/puppet/pops/binder/hiera2/json_backend.rb

@@ -1,18 +0,0 @@
-require 'json'
-
-# A Backend implementation capable of reading JSON syntax
-class Puppet::Pops::Binder::Hiera2::JsonBackend < Puppetx::Puppet::Hiera2Backend
-  def read_data(module_dir, source)
-    begin
-      source_file = File.join(module_dir, "#{source}.json")
-      JSON.parse(File.read(source_file))
-    rescue Errno::ENOTDIR
-      # This is OK, the file doesn't need to be present. Return an empty hash
-      {}
-    rescue Errno::ENOENT
-      # This is OK, the file doesn't need to be present. Return an empty hash
-      {}
-    end
-  end
-end
-

data/lib/puppet/pops/binder/hiera2/yaml_backend.rb

@@ -1,21 +0,0 @@
-# A Backend implementation capable of reading YAML syntax
-class Puppet::Pops::Binder::Hiera2::YamlBackend < Puppetx::Puppet::Hiera2Backend
-  def read_data(module_dir, source)
-    begin
-      source_file = File.join(module_dir, "#{source}.yaml")
-      # if file is present but empty or has only "---", YAML.load_file returns false,
-      # in which case fall back to returning an empty hash
-      YAML.load_file(source_file) || {}
-    rescue TypeError => e
-      # SafeYaml chokes when trying to load using utf-8 and the file is empty
-      raise e if File.size?(source_file)
-      {}
-    rescue Errno::ENOTDIR
-      # This is OK, the file doesn't need to be present. Return an empty hash
-      {}
-    rescue Errno::ENOENT
-      # This is OK, the file doesn't need to be present. Return an empty hash
-      {}
-    end
-  end
-end

data/lib/puppet/pops/binder/scheme_handler/confdir_hiera_scheme.rb

@@ -1,67 +0,0 @@
-# Similar to {Puppet::Pops::Binder::SchemeHandler::ModuleHieraScheme ModuleHieraScheme} but path is
-# relative to the `$confdir` instead of relative to a module root.
-#
-# Does not handle wild-cards.
-# @api public
-class Puppet::Pops::Binder::SchemeHandler::ConfdirHieraScheme < Puppetx::Puppet::BindingsSchemeHandler
-
-  # (Puppetx::Puppet::BindingsSchemeHandler.contributed_bindings)
-  #
-  def contributed_bindings(uri, scope, composer)
-    split_path = uri.path.split('/')
-    name = split_path[1]
-    confdir = composer.confdir
-    provider = Puppet::Pops::Binder::Hiera2::BindingsProvider.new(uri.to_s, File.join(confdir, uri.path), composer.acceptor)
-    provider.load_bindings(scope)
-  end
-
-  # This handler does not support wildcards.
-  # The given uri is simply returned in an array.
-  # @param uri [URI] the uri to expand
-  # @return [Array<URI>] the uri wrapped in an array
-  # @todo Handle optional and possibly hiera-1 hiera.yaml config file in the expected location (the same as missing)
-  # @api public
-  #
-  def expand_included(uri, composer)
-    result = []
-    if config_exist?(uri, composer)
-      result << uri unless is_ignored_hiera_version?(uri, composer)
-    else
-      result << uri unless is_optional?(uri)
-    end
-    result
-  end
-
-  # This handler does not support wildcards.
-  # The given uri is simply returned in an array.
-  # @param uri [URI] the uri to expand
-  # @return [Array<URI>] the uri wrapped in an array
-  # @api public
-  #
-  def expand_excluded(uri, composer)
-    [uri]
-  end
-
-  def config_exist?(uri, composer)
-    Puppet::FileSystem::File.exist?(File.join(composer.confdir, uri.path, 'hiera.yaml'))
-  end
-
-  # A hiera.yaml that exists, is readable, can be loaded, and does not have version >= 2 set is ignored.
-  # All other conditions are reported as 'not ignored' even if there are errors; these will be handled later
-  # as if the hiera.yaml is a hiera-2 file.
-  # @api private
-  def is_ignored_hiera_version?(uri, composer)
-    config_file = File.join(composer.confdir, uri.path, 'hiera.yaml')
-    begin
-      data = YAML.load_file(config_file)
-      if data.is_a?(Hash)
-        ver = data[:version] || data['version']
-        return ver.nil? || ver < 2
-      end
-    rescue Errno::ENOENT
-    rescue Errno::ENOTDIR
-    rescue ::SyntaxError => e
-    end
-    return false
-  end
-end

data/lib/puppet/pops/binder/scheme_handler/module_hiera_scheme.rb

@@ -1,92 +0,0 @@
-# The `module-hiera:` scheme uses the path to denote a directory relative to a module root
-# The path starts with the name of the module, or '*' to denote *any module*.
-#
-# @example All root hiera.yaml from all modules.
-#   module-hiera:/*
-#
-# @example The hiera.yaml from the module `foo`'s relative path `<foo root>/bar`.
-#   module-hiera:/foo/bar
-#
-class Puppet::Pops::Binder::SchemeHandler::ModuleHieraScheme < Puppetx::Puppet::BindingsSchemeHandler
-  # (Puppetx::Puppet::BindingsSchemeHandler.contributed_bindings)
-  # @api public
-  def contributed_bindings(uri, scope, composer)
-    split_path = uri.path.split('/')
-    name = split_path[1]
-    mod = composer.name_to_module[name]
-    provider = Puppet::Pops::Binder::Hiera2::BindingsProvider.new(uri.to_s, File.join(mod.path, split_path[ 2..-1 ]), composer.acceptor)
-    provider.load_bindings(scope)
-  end
-
-  # Expands URIs with wildcards and checks optionality.
-  # @param uri [URI] the uri to possibly expand
-  # @return [Array<URI>] the URIs to include
-  # @api public
-  #
-  def expand_included(uri, composer)
-    result = []
-    split_path = uri.path.split('/')
-    if split_path.size > 1 && split_path[-1].empty?
-      split_path.delete_at(-1)
-    end
-
-    # 0 = "", since a URI with a path must start with '/'
-    # 1 = '*' or the module name
-    case split_path[ 1 ]
-    when '*'
-      # create new URIs, one per module name that has a hiera.yaml file relative to its root
-      composer.name_to_module.each_pair do | name, mod |
-        if Puppet::FileSystem::File.exist?(File.join(mod.path, split_path[ 2..-1 ], 'hiera.yaml' ))
-          path_parts =["", name] + split_path[2..-1]
-          result << URI.parse('module-hiera:'+File.join(path_parts))
-        end
-      end
-    when nil
-      raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
-    else
-      # If uri has query that is empty, or the text 'optional' skip this uri if it does not exist
-      if query = uri.query()
-        if query == '' || query == 'optional'
-          if Puppet::FileSystem::File.exist?(File.join(mod.path, split_path[ 2..-1 ], 'hiera.yaml' ))
-            result << URI.parse('module-hiera:' + uri.path)
-          end
-        end
-      else
-        # assume it exists (do not give error since it may be excluded later)
-        result << URI.parse('module-hiera:' + File.join(split_path))
-      end
-    end
-    result
-  end
-
-  # Expands URIs with wildcards and checks optionality.
-  # @param uri [URI] the uri to possibly expand
-  # @return [Array<URI>] the URIs to exclude
-  # @api public
-  #
-  def expand_excluded(uri, composer)
-    result = []
-    split_path = uri.path.split('/')
-    if split_path.size > 1 && split_path[-1].empty?
-      split_path.delete_at(-1)
-    end
-
-    # 0 = "", since a URI with a path must start with '/'
-    # 1 = '*' or the module name
-    case split_path[ 1 ]
-    when '*'
-      # create new URIs, one per module name that has a hiera.yaml file relative to its root
-      composer.name_to_module.each_pair do | name, mod |
-        path_parts =["", mod.name] + split_path[2..-1]
-        result << URI.parse('module-hiera:'+File.join(path_parts))
-      end
-
-    when nil
-      raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
-    else
-      # create a clean copy (get rid of optional, fragments etc. and a trailing "/")
-      result << URI.parse('module-hiera:' + File.join(split_path))
-    end
-    result
-  end
-end

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

@@ -1,746 +0,0 @@
-# vim: syntax=ruby
-
-# Parser using the Pops model
-# This grammar is a half step between the current 3.1. grammar and egrammar.
-# FIXME! Keep as reference until egrammar is proven to work.
-
-class Puppet::Pops::Impl::Parser::Parser
-
-token STRING DQPRE DQMID DQPOST
-token LBRACK  RBRACK LBRACE RBRACE SYMBOL FARROW COMMA TRUE
-token FALSE EQUALS APPENDS LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
-token QMARK LPAREN RPAREN ISEQUAL GREATEREQUAL GREATERTHAN LESSTHAN
-token IF ELSE IMPORT DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
-token NAME SEMIC CASE DEFAULT AT 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
-
-prechigh
-  left DOT
-#  left LBRACE
-#  left LCOLLECT LLCOLLECT
-  right NOT
-  nonassoc UMINUS
-  left  IN MATCH NOMATCH
-  left  TIMES DIV
-  left  MINUS PLUS
-  left  LSHIFT RSHIFT
-  left  NOTEQUAL ISEQUAL
-  left  GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
-  left  AND
-  left  OR
-#  left  IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
-preclow
-
-rule
-# Produces [Model::BlockExpression, Model::Expression, nil] depending on multiple statements, single statement or empty
-program
-  : statements { result = Factory.block_or_expression(*val[0]) }
-  | nil
-
-# Change may have issues with nil; i.e. program is a sequence of nils/nops
-# Simplified from original which had validation for top level constructs - see statement rule
-# Produces Array<Model::Expression>
-statements
-  : statement            { result = [val[0]]}
-  | statements statement { result = val[0].push val[1] }
-
-# Removed validation construct regarding "top level statements" as it did not seem to catch all problems
-# and relied on a "top-level-ness" encoded in the abstract syntax tree objects
-#
-# The main list of valid statements
-# Produces Model::Expression
-#
-statement
-  : resource
-  | virtual_resource
-  | collection
-  | assignment
-  | casestatement
-  | if_expression
-  | unless_expression
-  | import
-  | call_named_function
-  | definition
-  | hostclass
-  | nodedef
-  | resource_override
-  | append
-  | relationship
-  | call_method_with_lambda
-
-keyword
- : AND
- | CASE
- | CLASS
- | DEFAULT
- | DEFINE
- | ELSE
- | ELSIF
- | IF
- | IN
- | IMPORT
- | INHERITS
- | NODE
- | OR
- | UNDEF
- | UNLESS
-
-# Produces Model::RelationshipExpression
-relationship
-  : relationship_side edge relationship_side { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
-  | relationship edge relationship_side      { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
-
-# Produces Model::Expression
-relationship_side
-  : resource
-  | resourceref
-  | collection
-  | variable
-  | quotedtext
-  | selector
-  | casestatement
-  | hasharrayaccesses
-
-# Produces String
-edge
-  : IN_EDGE
-  | OUT_EDGE
-  | IN_EDGE_SUB
-  | OUT_EDGE_SUB
-
-# Produces Model::CallNamedFunctionExpression
-call_named_function
-  : NAME LPAREN expressions RPAREN       { result = Factory.CALL_NAMED(val[0][:value], false, val[2]) ; loc result, val[0], val[3] }
-  | NAME LPAREN expressions COMMA RPAREN { result = Factory.CALL_NAMED(val[0][:value], false, val[2]) ; loc result, val[0], val[4] }            
-  | NAME LPAREN RPAREN                   { result = Factory.CALL_NAMED(val[0][:value], false, [])     ; loc result, val[0], val[2] }
-  | NAME func_call_args                  { result = Factory.CALL_NAMED(val[0][:value], false, val[1]) ; loc result, val[0] }
-
-call_method_with_lambda
-  : call_method        { result = val[0] }
-  | call_method lambda { result = val[0]; val[0].lambda = val[1] }
-  
-call_method
-  : named_access LPAREN expressions 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                           { result = Factory.CALL_METHOD(val[0], []); loc result, val[0] }
-
-named_access
-  : named_access_lval DOT NAME {
-      result = val[0].dot(Factory.fqn(val[2][:value]))
-      loc result, val[1], val[2]
-    }
-  
-# Obviously not ideal, it is not possible to use literal array or hash as lhs
-# These must be assigned to a variable - this is also an issue in other places
-#
-named_access_lval
-  : variable 
-  | hasharrayaccesses
-  | selector
-  | quotedtext
-  | call_named_rval_function
-    
-lambda
-  : LAMBDA lambda_parameter_list statements RBRACE {
-      result = Factory.LAMBDA(val[1], val[2])
-      loc result, val[0], val[3]
-    }
-  | LAMBDA lambda_parameter_list RBRACE {
-      result = Factory.LAMBDA(val[1], nil)
-      loc result, val[0], val[2]
-    }
-# Produces Array<Model::Parameter>
-lambda_parameter_list
-  : PIPE PIPE             { result = [] }
-  | PIPE parameters endcomma PIPE { result = val[1] }
-  
-# Produces Array<Model::Expression>
-func_call_args
-  : rvalue                      { result = [val[0]] }
-  | func_call_args COMMA rvalue { result = val[0].push(val[2]) }
-
-# Produces Array<Model::Expression>
-expressions
-  : expression                   { result = [val[0]] }
-  | expressions comma expression { result = val[0].push(val[2]) }
-
-
-# Produces [Model::ResourceExpression, Model::ResourceDefaultsExpression]
-resource
-  : classname LBRACE resourceinstances endsemi RBRACE {
-      result = Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
-      loc result, val[0], val[4]
-    }
-  | classname LBRACE attribute_operations endcomma RBRACE {
-      # This is a deprecated syntax.
-      # It also fails hard - TODO: create model and validate this case
-      error "All resource specifications require names"
-    }
-  | type LBRACE attribute_operations endcomma RBRACE {
-      # a defaults setting for a type
-      result = Factory.RESOURCE_DEFAULTS(val[0], val[2])
-      loc result, val[0], val[4]
-    }
-
-# Override a value set elsewhere in the configuration.
-# Produces Model::ResourceOverrideExpression
-resource_override
-  : resourceref LBRACE attribute_operations endcomma RBRACE {
-      @lexer.commentpop
-      result = Factory.RESOURCE_OVERRIDE(val[0], val[2])
-      loc result, val[0], val[4]
-    }
-
-# Exported and virtual resources; these don't get sent to the client
-# unless they get collected elsewhere in the db.
-# The original had validation here; checking if storeconfigs is on; this is moved to a validation step
-# Also, validation was performed if an attempt was made to virtualize or export a resource defaults
-# this is also now deferred to validation 
-# Produces [Model::ResourceExpression, Model::ResourceDefaultsExpression]
-virtual_resource
-  :  at resource { 
-       val[1].form = val[0] # :virtual, :exported, (or :regular)
-       result = val[1] 
-     }
-
-# Produces Symbol corresponding to resource form
-at
-  : AT    { result = :virtual  }
-  | AT AT { result = :exported }
-
-# A collection statement.  Currently supports no arguments at all, but eventually
-# will, I assume.
-#
-# Produces Model::CollectExpression
-#
-collection
-  : type collect_query LBRACE attribute_operations endcomma RBRACE {
-      @lexer.commentpop
-      result = Factory.COLLECT(val[0].value.downcase, val[1], val[3])
-      loc result, val[0], val[5]
-    }
-  | type collect_query {
-      result = Factory.COLLECT(val[0].value.downcase, 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] }
-
-# ORIGINAL COMMENT: A mini-language for handling collection comparisons.  This is organized
-#                   to avoid the need for precedence indications.
-# (New implementation is slightly different; and when finished, it may be possible to streamline the
-#  grammar - the difference is mostly in evaluation, not in grammar)
-#
-optional_query
-  : nil
-  | query
-
-# ORIGINAL: Had a weird list structure where AND and OR where at the same level, and hence, there was the
-#           need to keep track of where parenthesis were (to get order correct).
-# 
-# This is now not needed as AND has higher precedence than OR, and parenthesis are low in precedence
-
-query
-  : predicate_lval ISEQUAL  expression { result = (val[0] == val[2])  ; loc result, val[1] } 
-  | predicate_lval NOTEQUAL expression { result = (val[0].ne(val[2])) ; loc result, val[1] }
-  | LPAREN query RPAREN                { result = val[1] }
-  | query AND query                    { result = val[0].and(val[2]) ; loc result, val[1] }
-  | query OR  query                    { result = val[0].or(val[2])  ; loc result, val[1] }
-
-
-# Produces Model::VariableExpression, or Model::QualifiedName
-predicate_lval
-  : variable
-  | name
-
-resourceinst
-  : resourcename COLON attribute_operations endcomma { result = Factory.RESOURCE_BODY(val[0], val[2]) }
-
-resourceinstances
-  : resourceinst                         { result = [val[0]] }
-  | resourceinstances SEMIC resourceinst { result = val[0].push val[2] }
-
-
-resourcename
-  : quotedtext
-  | name
-  | type
-  | selector
-  | variable
-  | array
-  | hasharrayaccesses
-
-# Assignment, only assignment to variable is legal, but parser builds expression for [] = anyway to 
-# enable a better error message
-assignment
-  : VARIABLE EQUALS expression { result = Factory.var(Factory.fqn(val[0][:value])).set(val[2]) ; loc result, val[1] }
-  | hasharrayaccess EQUALS expression { result val[0].set(val[2]); loc result, val[1] }
-
-append
-  : VARIABLE APPENDS expression { result = Factory.var(val[0][:value]).plus_set(val[1]) ; loc result, val[1] }
-
-# Produces Array<Model::AttributeOperation>
-attribute_operations
-  :                                                { result = [] }
-  | attribute_operation                            { result = [val[0]] }
-  | attribute_operations COMMA attribute_operation { result = val[0].push(val[2]) }
-
-# Produces String
-attribute_name
-  : NAME 
-  | keyword 
-  | BOOLEAN
-
-# Several grammar issues here: the addparam did not allow keyword and booleans as names.
-# In this version, the wrong combinations are validated instead of producing syntax errors
-# (Can give nicer error message +> is not applicable to...)
-# WAT - Boolean as attribute name? 
-# 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]
-    }
-
-# Produces Model::CallNamedFunction
-call_named_rval_function
-  : NAME LPAREN expressions RPAREN { result = Factory.CALL_NAMED(val[0][:value], true, val[2]) ; loc result, val[0], val[3] }
-  | NAME LPAREN RPAREN             { result = Factory.CALL_NAMED(val[0][:value], true, []) ; loc result, val[0], val[2] }
-
-quotedtext
-  : STRING       { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
-  | 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] }
-text_expression : expression { result = Factory.TEXT(val[0]) }
-
-dqrval
-  : text_expression dqtail { result = [val[0]] + val[1] }
-  
-dqtail
-  : dqpost       { result = [val[0]] }
-  | dqmid dqrval  { result = [val[0]] + val[1] }
-
-
-# Reference to Resource (future also reference to other instances of other types than Resources).
-# First form (lower case name) is deprecated (deprecation message handled in validation). Note that
-# this requires use of token NAME since a rule call to name causes shift reduce conflict with
-# a function call NAME NAME (calling function with NAME as argument e.g. foo bar).
-#
-# Produces InstanceReference
-resourceref
-  : NAME LBRACK expressions RBRACK {
-  	  # Would want to use rule name here, but can't (need a NAME with higher precedence), so must
-  	  # create a QualifiedName instance here for NAME 
-      result = Factory.INSTANCE(Factory.QNAME_OR_NUMBER(val[0][:value]), val[2]);
-      loc result, val[0], val[2][-1]
-    }
-  | type LBRACK expressions RBRACK {
-      result = Factory.INSTANCE(val[0], val[2]); 
-      loc result, val[0], val[2][-1]
-    }
-
-# Changed from Puppet 3x where there is no else part on unless
-#
-unless_expression
-  : UNLESS expression LBRACE statements RBRACE unless_else {
-      @lexer.commentpop
-      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 {
-      @lexer.commentpop
-      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 {
-      @lexer.commentpop
-      result = Factory.block_or_expression(*val[2])
-      loc result, val[0], val[3]
-    }
-  | ELSE LBRACE RBRACE {
-      @lexer.commentpop
-  	  result = nil # don't think a nop is needed here either
-    }
-
-# Produces Model::IfExpression
-if_expression
-  : IF if_expression_part {
-      result = val[1]
-    }
-
-# Produces Model::IfExpression
-if_expression_part
-  : expression LBRACE statements RBRACE else {
-      @lexer.commentpop
-      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_expression_part { result = val[1] }
-  | ELSE LBRACE statements RBRACE {
-      @lexer.commentpop
-      result = Factory.block_or_expression(*val[2])
-      loc result, val[0], val[3]
-    }
-  | ELSE LBRACE RBRACE {
-      @lexer.commentpop
-  	  result = nil # don't think a nop is needed here either
-    }
-
-# Produces Model::Expression
-expression
-  : rvalue
-  | hash
-  | expression IN expression           { result = val[0].in val[2]  ; loc result, val[1] }
-  | expression MATCH match_rvalue      { result = val[0] =~  val[2] ; loc result, val[1] }
-  | expression NOMATCH match_rvalue    { 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 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] }
-  | 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] }
-  | LPAREN expression RPAREN           { result = val[1]            ;                    }
-  | call_method_with_lambda 
-
-match_rvalue
-  : regex
-  | quotedtext
-  
-# Produces Model::CaseExpression
-casestatement
-  : CASE expression LBRACE case_options RBRACE {
-      @lexer.commentpop
-      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
-  : case_values COLON LBRACE statements RBRACE {
-      @lexer.commentpop
-      result = Factory.WHEN(val[0], val[3])
-      loc result, val[1], val[4]
-    }
-  | case_values COLON LBRACE RBRACE {
-      @lexer.commentpop
-      result = Factory.WHEN(val[0], nil)
-      loc result, val[1], val[3]
-    }
-
-# Produces Array<Expression> mostly literals
-case_values
-  : selectable                   { result = [val[0]] }
-  | case_values COMMA selectable { result = val[0].push val[2] }
-
-# Produces Model::SelectorExpression
-selector
-  : selectable QMARK selector_entries { result = val[0].select(*val[2]) ; loc result, val[1] }
-
-# Produces Array<Model::SelectorEntry>
-selector_entries
-  : selector_entry { result = [val[0]] }
-  | LBRACE selector_entry_list endcomma RBRACE {
-      @lexer.commentpop
-      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
-selector_entry
-  : selectable FARROW rvalue { result = Factory.MAP(val[0], val[2]) ; loc result, val[1] }
-
-# Produces Model::Expression (most of the literals)
-selectable
-  : name
-  | type
-  | quotedtext
-  | variable
-  | call_named_rval_function
-  | boolean
-  | undef
-  | hasharrayaccess
-  | default
-  | regex
-
-  
-
-# Produces nil (noop)
-import
-  : IMPORT strings {
-      error "Import not supported in this version of the parser", \
-          :line => stmt.context[:line], :file => stmt.context[:file]
-      result = nil
-  }
-
-# IMPORT (T.B DEPRECATED IN PUPPET WHEN IT HAS BEEN FIGURED OUT HOW TO SUPPORT
-# THE THINGS IMPORTS ARE USED FOR.
-# BOLDLY DECIDED TO SKIP THIS COMPLETELY IN THIS IMPLEMENTATION - will trigger an error
-#
-# These are only used for importing, no interpolation
-string
-  : STRING       { result = [val[0][:value]] }
-
-strings
-  :  string
-  |  strings COMMA string { result = val[0].push val[2] }
-
-# Produces Model::Definition
-definition
-  : DEFINE classname parameter_list LBRACE statements RBRACE {
-      @lexer.commentpop
-      result = Factory.DEFINITION(classname(val[1][:value]), val[2], val[4])
-      loc result, val[0], val[5]
-      @lexer.indefine = false
-    }
-  | DEFINE classname parameter_list LBRACE RBRACE {
-      @lexer.commentpop
-      result = Factory.DEFINITION(classname(val[1][:value]), val[2], nil)
-      loc result, val[0], val[4]
-      @lexer.indefine = false
-    }
-
-# ORIGINAL COMMENT: Our class gets defined in the parent namespace, not our own. 
-#    WAT ??! This is way odd; should get its complete name, classnames do not nest
-#    Seems like the call to classname makes use of the name scope
-#    (This is uneccesary, since the parent name is known when evaluating)
-#
-# Produces Model::HostClassDefinition
-#
-hostclass
-  : CLASS classname parameter_list classparent LBRACE statements RBRACE {
-      @lexer.commentpop
-      @lexer.namepop
-      result = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5])
-      loc result, val[0], val[6]
-    }
-  | CLASS classname parameter_list classparent LBRACE RBRACE {
-      @lexer.commentpop
-      @lexer.namepop
-      result = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), nil)
-      loc result, val[0], val[5]
-      }
-
-# Produces Model::NodeDefinition
-nodedef
-  : NODE hostnames nodeparent LBRACE statements RBRACE {
-      @lexer.commentpop
-      result = Factory.NODE(val[1], val[2], val[4])
-      loc result, val[0], val[5]
-    }
-  | NODE hostnames nodeparent LBRACE RBRACE {
-      @lexer.commentpop
-      result = Factory.NODE(val[1], val[2], nil)
-      loc result, val[0], val[4]
-    }
-
-# String result
-classname
-  : NAME  { result = val[0] }
-  | CLASS { result = val[0] }
-
-# 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
-  : nodename                 { result = [result] }
-  | hostnames COMMA nodename { result = val[0].push(val[2]) }
-
-# Produces Model::LiteralExpression
-#
-nodename
-  : hostname
-
-# Produces a LiteralExpression (string, :default, or regexp)
-hostname
-  : NAME    { result = Factory.fqn(val[0][:value]); loc result, val[0] }
-  | STRING  { result = Factory.literal(val[0][:value]); loc result, val[0] }
-  | DEFAULT { result = Factory.literal(:default); loc result, val[0] }
-  | regex
-
-
-# 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
-  : 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] }
-
-# Produces Expression, since hostname is an Expression
-nodeparent
-  : nil
-  | INHERITS hostname { result = val[1] }
-
-# 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
-
-rvalue
-  : quotedtext
-  | name
-  | type
-  | boolean
-  | selector
-  | variable
-  | array
-  | hasharrayaccesses
-  | resourceref
-  | call_named_rval_function
-  | undef
-
-array
-  : LBRACK expressions       RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[2] }
-  | LBRACK expressions COMMA 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
-  : key FARROW expression { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
-
-key
-  : NAME       { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
-  | quotedtext { result = val[0] }
-
-# NOTE: Limitation that LHS is a variable, means that it is not possible to do foo(10)[2] without
-# using an intermediate variable
-#
-hasharrayaccess
-  : variable LBRACK expression RBRACK { result = val[0][val[2]]; loc result, val[0], val[3] }
-
-hasharrayaccesses
-  : hasharrayaccess
-  | hasharrayaccesses LBRACK expression RBRACK { result = val[0][val[2]] ; loc result, val[1], val[3] }
-
-# Produces Model::VariableExpression
-variable : VARIABLE { result = Factory.fqn(val[0][:value]).var ; loc result, val[0] }
-undef    : UNDEF    { result = Factory.literal(:undef); loc result, val[0] }
-name     : NAME     { result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0] }
-type     : CLASSREF { result = Factory.QREF(val[0][:value])  ; loc result, val[0] }
-
-default
-  : DEFAULT { result = Factory.literal(:default); loc result, val[0] }
-
-boolean
-  # Assumes lexer produces a Boolean value for booleans, or this will go wrong (e.g. produce. LiteralString)
-  : BOOLEAN { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
-
-regex
-  : REGEX { result = Factory.literal(val[0][:value]); loc result, val[0] }
-
-# ---Special markers & syntactic sugar
-
-# WAT !!!! this means array can be [1=>2=>3], func (1=>2=>3), and other retarded constructs
-# TODO: Remove the FARROW (investigate if there is any validity)
-comma
-  : FARROW
-  | COMMA
-
-endcomma
-  : #
-  | COMMA { result = nil }
-
-endsemi
-  : #
-  | SEMIC
-
-nil
-  : { result = nil}
-
-## Empty list - not really needed? TODO: Check if this can be removed
-#empty_list
-#  : { result = [] }
-
-end
-
----- header ----
-require 'puppet'
-require 'puppet/util/loadedfile'
-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: