puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/loader/simple_environment_loader.rb

@@ -0,0 +1,20 @@
+# SimpleEnvironmentLoader
+# ===
+# This loader does not load anything and it is populated by the bootstrapping logic that loads
+# the site.pp or equivalent for an environment. It does not restrict the names of what it may contain,
+# and what is loaded here overrides any child loaders (modules).
+#
+class Puppet::Pops::Loader::SimpleEnvironmentLoader < Puppet::Pops::Loader::BaseLoader
+
+  attr_accessor :private_loader
+
+  # Never finds anything, everything "loaded" is set externally
+  def find(typed_name)
+    nil
+  end
+
+  def to_s()
+    "(SimpleEnvironmentLoader '#{loader_name}')"
+  end
+
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/loader/static_loader.rb

@@ -0,0 +1,79 @@
+  # Static Loader contains constants, basic data types and other types required for the system
+  # to boot.
+  #
+class Puppet::Pops::Loader::StaticLoader < Puppet::Pops::Loader::Loader
+
+  attr_reader :loaded
+  def initialize
+    @loaded = {}
+    create_logging_functions()
+  end
+
+  def load_typed(typed_name)
+    load_constant(typed_name)
+  end
+
+  def get_entry(typed_name)
+    load_constant(typed_name)
+  end
+
+  def find(name)
+    # There is nothing to search for, everything this loader knows about is already available
+    nil
+  end
+
+  def parent
+    nil # at top of the hierarchy
+  end
+
+  def to_s()
+    "(StaticLoader)"
+  end
+  private
+
+  def load_constant(typed_name)
+    @loaded[typed_name]
+  end
+
+  private
+
+  # Creates a function for each of the specified log levels
+  #
+  def create_logging_functions()
+    Puppet::Util::Log.levels.each do |level|
+
+      fc = Puppet::Functions.create_function(level) do
+        # create empty dispatcher to stop it from complaining about missing method since
+        # an override of :call is made instead of using dispatch.
+        dispatch(:log) { }
+
+        # Logs per the specified level, outputs formatted information for arrays, hashes etc.
+        # Overrides the implementation in Function that uses dispatching. This is not needed here
+        # since it accepts 0-n Object.
+        #
+        define_method(:call) do |scope, *vals|
+          # NOTE: 3x, does this: vals.join(" ")
+          # New implementation uses the evaluator to get proper formatting per type
+          # TODO: uses a fake scope (nil) - fix when :scopes are available via settings
+          mapped = vals.map {|v| Puppet::Pops::Evaluator::EvaluatorImpl.new.string(v, nil) }
+
+          # Bypass Puppet.<level> call since it picks up source from "self" which is not applicable in the 4x
+          # Function API.
+          # TODO: When a function can obtain the file, line, pos of the call merge those in (3x supports
+          #       options :file, :line. (These were never output when calling the 3x logging functions since
+          #       3x scope does not know about the calling location at that detailed level, nor do they
+          #       appear in a report to stdout/error when included). Now, the output simply uses scope (like 3x)
+          #       as this is good enough, but does not reflect the true call-stack, but is a rough estimate
+          #       of where the logging call originates from).
+          #
+          Puppet::Util::Log.create({:level => level, :source => scope, :message => mapped.join(" ")})
+        end
+      end
+
+      typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, level)
+      # TODO:closure scope is fake (an empty hash) - waiting for new global scope to be available via lookup of :scopes
+      func = fc.new({},self)
+      @loaded[ typed_name ] = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, func, __FILE__)
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/loader/uri_helper.rb

@@ -0,0 +1,22 @@
+module Puppet::Pops::Loader::UriHelper
+  # Raises an exception if specified gem can not be located
+  #
+  def path_for_uri(uri, subdir='lib')
+    case uri.scheme
+    when "gem"
+      begin
+        spec = Gem::Specification.find_by_name(uri.hostname)
+        # if path given append that, else append given subdir
+        File.join(spec.gem_dir, uri.path.empty?() ? subdir : uri.path)
+      rescue StandardError => e
+        raise "TODO TYPE: Failed to located gem #{uri}. #{e.message}"
+      end
+    when "file"
+      File.join(uri.path, subdir)
+    when nil
+      File.join(uri.path, subdir)
+    else
+      raise "Not a valid scheme for a loader: #{uri.scheme}. Use a 'file:' (or just a path), or 'gem://gemname[/path]"
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/loaders.rb

@@ -0,0 +1,231 @@
+class Puppet::Pops::Loaders
+  class LoaderError < Puppet::Error; end
+
+  attr_reader :static_loader
+  attr_reader :puppet_system_loader
+  attr_reader :public_environment_loader
+  attr_reader :private_environment_loader
+
+  def initialize(environment)
+    # The static loader can only be changed after a reboot
+    @@static_loader ||= Puppet::Pops::Loader::StaticLoader.new()
+
+    # Create the set of loaders
+    # 1. Puppet, loads from the "running" puppet - i.e. bundled functions, types, extension points and extensions
+    #    Does not change without rebooting the service running puppet.
+    #
+    @@puppet_system_loader ||= create_puppet_system_loader()
+
+    # 2. Environment loader - i.e. what is bound across the environment, may change for each setup
+    #    TODO: loaders need to work when also running in an agent doing catalog application. There is no
+    #    concept of environment the same way as when running as a master (except when doing apply).
+    #    The creation mechanisms should probably differ between the two.
+    #
+    @private_environment_loader = create_environment_loader(environment)
+
+    # 3. module loaders are set up from the create_environment_loader, they register themselves
+  end
+
+  # Clears the cached static and puppet_system loaders (to enable testing)
+  #
+  def self.clear
+    @@static_loader = nil
+    @@puppet_system_loader = nil
+  end
+
+  def static_loader
+    @@static_loader
+  end
+
+  def puppet_system_loader
+    @@puppet_system_loader
+  end
+
+  def public_loader_for_module(module_name)
+    md = @module_resolver[module_name] || (return nil)
+    # Note, this loader is not resolved until there is interest in the visibility of entities from the
+    # perspective of something contained in the module. (Many request may pass through a module loader
+    # without it loading anything.
+    # See {#private_loader_for_module}, and not in {#configure_loaders_for_modules}
+    md.public_loader
+  end
+
+  def private_loader_for_module(module_name)
+    md = @module_resolver[module_name] || (return nil)
+    # Since there is interest in the visibility from the perspective of entities contained in the
+    # module, it must be resolved (to provide this visibility).
+    # See {#configure_loaders_for_modules}
+    unless md.resolved?
+      @module_resolver.resolve(md)
+    end
+    md.private_loader
+  end
+
+  private
+
+  def create_puppet_system_loader()
+    Puppet::Pops::Loader::ModuleLoaders.system_loader_from(static_loader, self)
+  end
+
+  def create_environment_loader(environment)
+    # This defines where to start parsing/evaluating - the "initial import" (to use 3x terminology)
+    # Is either a reference to a single .pp file, or a directory of manifests. If the environment becomes
+    # a module and can hold functions, types etc. then these are available across all other modules without
+    # them declaring this dependency - it is however valuable to be able to treat it the same way
+    # bindings and other such system related configuration.
+
+    # This is further complicated by the many options available:
+    # - The environment may not have a directory, the code comes from one appointed 'manifest' (site.pp)
+    # - The environment may have a directory and also point to a 'manifest'
+    # - The code to run may be set in settings (code)
+
+    # Further complication is that there is nothing specifying what the visibility is into
+    # available modules. (3x is everyone sees everything).
+    # Puppet binder currently reads confdir/bindings - that is bad, it should be using the new environment support.
+
+    # The environment is not a namespace, so give it a nil "module_name"
+    module_name = nil
+    loader_name = "environment:#{environment.name}"
+    loader = Puppet::Pops::Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
+
+    # An environment has a module path even if it has a null loader
+    configure_loaders_for_modules(loader, environment)
+    # modules should see this loader
+    @public_environment_loader = loader
+
+    # Code in the environment gets to see all modules (since there is no metadata for the environment)
+    # but since this is not given to the module loaders, they can not load global code (since they can not
+    # have prior knowledge about this
+    loader = Puppet::Pops::Loader::DependencyLoader.new(loader, "environment", @module_resolver.all_module_loaders())
+
+    # The module loader gets the private loader via a lazy operation to look up the module's private loader.
+    # This does not work for an environment since it is not resolved the same way.
+    # TODO: The EnvironmentLoader could be a specialized loader instead of using a ModuleLoader to do the work.
+    #       This is subject to future design - an Environment may move more in the direction of a Module.
+    @public_environment_loader.private_loader = loader
+    loader
+  end
+
+  def configure_loaders_for_modules(parent_loader, environment)
+    @module_resolver = mr = ModuleResolver.new()
+    environment.modules.each do |puppet_module|
+      # Create data about this module
+      md = LoaderModuleData.new(puppet_module)
+      mr[puppet_module.name] = md
+      md.public_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(parent_loader, self, md.name, md.path)
+    end
+    # NOTE: Do not resolve all modules here - this is wasteful if only a subset of modules / functions are used
+    #       The resolution is triggered by asking for a module's private loader, since this means there is interest
+    #       in the visibility from that perspective.
+    #       If later, it is wanted that all resolutions should be made up-front (to capture errors eagerly, this
+    #       can be introduced (better for production), but may be irritating in development mode.
+  end
+
+  # =LoaderModuleData
+  # Information about a Module and its loaders.
+  # TODO: should have reference to real model element containing all module data; this is faking it
+  # TODO: Should use Puppet::Module to get the metadata (as a hash) - a somewhat blunt instrument, but that is
+  #       what is available with a reasonable API.
+  #
+  class LoaderModuleData
+
+    attr_accessor :state
+    attr_accessor :public_loader
+    attr_accessor :private_loader
+    attr_accessor :resolutions
+
+    # The Puppet::Module this LoaderModuleData represents in the loader configuration
+    attr_reader :puppet_module
+
+    # @param puppet_module [Puppet::Module] the module instance for the module being represented
+    #
+    def initialize(puppet_module)
+      @state = :initial
+      @puppet_module = puppet_module
+      @resolutions = []
+      @public_loader = nil
+      @private_loader = nil
+    end
+
+    def name
+      @puppet_module.name
+    end
+
+    def version
+      @puppet_module.version
+    end
+
+    def path
+      @puppet_module.path
+    end
+
+    def resolved?
+      @state == :resolved
+    end
+
+    def restrict_to_dependencies?
+      @puppet_module.has_metadata?
+    end
+
+    def unmet_dependencies?
+      @puppet_module.unmet_dependencies.any?
+    end
+
+    def dependency_names
+      @puppet_module.dependencies_as_modules.collect(&:name)
+    end
+  end
+
+  # Resolves module loaders - resolution of model dependencies is done by Puppet::Module
+  #
+  class ModuleResolver
+
+    def initialize()
+      @index = {}
+      @all_module_loaders = nil
+    end
+
+    def [](name)
+      @index[name]
+    end
+
+    def []=(name, module_data)
+      @index[name] = module_data
+    end
+
+    def all_module_loaders
+      @all_module_loaders ||= @index.values.map {|md| md.public_loader }
+    end
+
+    def resolve(module_data)
+      if module_data.resolved?
+        return
+      else
+        module_data.private_loader =
+          if module_data.restrict_to_dependencies?
+            create_loader_with_only_dependencies_visible(module_data)
+          else
+            create_loader_with_all_modules_visible(module_data)
+          end
+      end
+    end
+
+    private
+
+    def create_loader_with_all_modules_visible(from_module_data)
+      Puppet.debug("ModuleLoader: module '#{from_module_data.name}' has unknown dependencies - it will have all other modules visible")
+
+      Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, all_module_loaders())
+    end
+
+    def create_loader_with_only_dependencies_visible(from_module_data)
+      if from_module_data.unmet_dependencies?
+        Puppet.warning("ModuleLoader: module '#{from_module_data.name}' has unresolved dependencies"+
+          " - it will only see those that are resolved."+
+          " Use 'puppet module list --tree' to see information about modules")
+      end
+      dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
+      Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/pops/model/ast_transformer.rb

@@ -0,0 +1,643 @@
+require 'puppet/parser/ast'
+
+# The receiver of `import(file)` calls; once per imported file, or nil if imports are ignored
+#
+# Transforms a Pops::Model to classic Puppet AST.
+# TODO: Documentation is currently skipped completely (it is only used for Rdoc)
+#
+class Puppet::Pops::Model::AstTransformer
+  AST = Puppet::Parser::AST
+  Model = Puppet::Pops::Model
+
+  attr_reader :importer
+  def initialize(source_file = "unknown-file", importer=nil)
+    @@transform_visitor ||= Puppet::Pops::Visitor.new(nil,"transform",0,0)
+    @@query_transform_visitor ||= Puppet::Pops::Visitor.new(nil,"query",0,0)
+    @@hostname_transform_visitor ||= Puppet::Pops::Visitor.new(nil,"hostname",0,0)
+    @importer = importer
+    @source_file = source_file
+  end
+
+  # Initialize klass from o (location) and hash (options to created instance).
+  # The object o is used to compute a source location. It may be nil. Source position is merged into
+  # the given options (non surgically). If o is non-nil, the first found source position going up
+  # the containment hierarchy is set. I.e. callers should pass nil if a source position is not wanted
+  # or known to be unobtainable for the object.
+  #
+  # @param o [Object, nil] object from which source position / location is obtained, may be nil
+  # @param klass [Class<Puppet::Parser::AST>] the ast class to create an instance of
+  # @param hash [Hash] hash with options for the class to create
+  #
+  def ast(o, klass, hash={})
+    # create and pass hash with file and line information
+    klass.new(merge_location(hash, o))
+  end
+
+  # THIS IS AN EXPENSIVE OPERATION
+  # The 3x AST requires line, pos etc. to be recorded directly in the AST nodes and this information
+  # must be computed.
+  # (Newer implementation only computes the information that is actually needed; typically when raising an
+  # exception).
+  #
+  def merge_location(hash, o)
+    if o
+      pos = {}
+      source_pos = Puppet::Pops::Utils.find_closest_positioned(o)
+      if source_pos
+        pos[:line] = source_pos.line
+        pos[:pos]  = source_pos.pos
+      end
+      pos[:file] = @source_file if @source_file
+      hash = hash.merge(pos)
+    end
+    hash
+  end
+
+  # Transforms pops expressions into AST 3.1 statements/expressions
+  def transform(o)
+    begin
+    @@transform_visitor.visit_this(self,o)
+    rescue StandardError => e
+      loc_data = {}
+      merge_location(loc_data, o)
+      raise Puppet::ParseError.new("Error while transforming to Puppet 3 AST: #{e.message}", 
+        loc_data[:file], loc_data[:line], loc_data[:pos], e)
+    end
+  end
+
+  # Transforms pops expressions into AST 3.1 query expressions
+  def query(o)
+    @@query_transform_visitor.visit_this(self, o)
+  end
+
+  # Transforms pops expressions into AST 3.1 hostnames
+  def hostname(o)
+    @@hostname_transform_visitor.visit_this(self, o)
+  end
+
+  def transform_LiteralFloat(o)
+    # Numbers are Names in the AST !! (Name a.k.a BareWord)
+    ast o, AST::Name, :value => o.value.to_s
+  end
+
+  def transform_LiteralInteger(o)
+    s = 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
+
+    # Numbers are Names in the AST !! (Name a.k.a BareWord)
+    ast o, AST::Name, :value => s
+  end
+
+  # Transforms all literal values to string (override for those that should not be AST::String)
+  #
+  def transform_LiteralValue(o)
+    ast o, AST::String, :value => o.value.to_s
+  end
+
+  def transform_LiteralBoolean(o)
+    ast o, AST::Boolean, :value => o.value
+  end
+
+  def transform_Factory(o)
+    transform(o.current)
+  end
+
+  def transform_ArithmeticExpression(o)
+    ast o, AST::ArithmeticOperator2, :lval => transform(o.left_expr), :rval=>transform(o.right_expr),
+    :operator => o.operator.to_s
+  end
+
+  def transform_Array(o)
+    ast nil, AST::ASTArray, :children => o.collect {|x| transform(x) }
+  end
+
+  # Puppet AST only allows:
+  # * variable[expression] => Hasharray Access
+  # * NAME [expressions] => Resource Reference(s)
+  # * type [epxressions] => Resource Reference(s)
+  # * HashArrayAccesses[expression] => HasharrayAccesses
+  #
+  # i.e. it is not possible to do `func()[3]`, `[1,2,3][$x]`, `{foo=>10, bar=>20}[$x]` etc. since
+  # LHS is not an expression
+  #
+  # Validation for 3.x semantics should validate the illegal cases. This transformation may fail,
+  # or ignore excess information if the expressions are not correct.
+  # This means that the transformation does not have to evaluate the lhs to detect the target expression.
+  #
+  # Hm, this seems to have changed, the LHS (variable) is evaluated if evaluateable, else it is used as is.
+  #
+  def transform_AccessExpression(o)
+    case o.left_expr
+    when Model::QualifiedName
+      ast o, AST::ResourceReference, :type => o.left_expr.value, :title => transform(o.keys)
+
+    when Model::QualifiedReference
+      ast o, AST::ResourceReference, :type => o.left_expr.value, :title => transform(o.keys)
+
+    when Model::VariableExpression
+      ast o, AST::HashOrArrayAccess, :variable => transform(o.left_expr), :key => transform(o.keys()[0])
+
+    else
+      ast o, AST::HashOrArrayAccess, :variable => transform(o.left_expr), :key => transform(o.keys()[0])
+    end
+  end
+
+  # Puppet AST has a complicated structure
+  # LHS can not be an expression, it must be a type (which is downcased).
+  # type = a downcased QualifiedName
+  #
+  def transform_CollectExpression(o)
+    raise "LHS is not a type" unless o.type_expr.is_a? Model::QualifiedReference
+    type = o.type_expr.value().downcase()
+    args = { :type => type }
+
+    # This somewhat peculiar encoding is used by the 3.1 AST.
+    query = transform(o.query)
+    if query.is_a? Symbol
+      args[:form] =  query
+    else
+      args[:form] = query.form
+      args[:query] = query
+      query.type = type
+    end
+
+    if o.operations.size > 0
+      args[:override] = transform(o.operations)
+    end
+    ast o, AST::Collection, args
+  end
+
+  def transform_EppExpression(o)
+    # TODO: Not supported in 3x TODO_EPP
+    parameters = o.parameters.collect {|p| transform(p) }
+    args = { :parameters => parameters }
+    args[:children] = transform(o.body) unless is_nop?(o.body)
+    Puppet::Parser::AST::Epp.new(merge_location(args, o))
+  end
+
+  def transform_ExportedQuery(o)
+    if is_nop?(o.expr)
+      result = :exported
+    else
+      result = query(o.expr)
+      result.form = :exported
+    end
+    result
+  end
+
+  def transform_VirtualQuery(o)
+    if is_nop?(o.expr)
+      result = :virtual
+    else
+      result = query(o.expr)
+      result.form = :virtual
+    end
+    result
+  end
+
+  # Ensures transformation fails if a 3.1 non supported object is encountered in a query expression
+  #
+  def query_Object(o)
+    raise "Not a valid expression in a collection query: "+o.class.name
+  end
+
+  # Puppet AST only allows == and !=, and left expr is restricted, but right value is an expression
+  #
+  def query_ComparisonExpression(o)
+    if [:'==', :'!='].include? o.operator
+      ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => o.operator.to_s, :test2 => transform(o.right_expr)
+    else
+      raise "Not a valid comparison operator in a collection query: " + o.operator.to_s
+    end
+  end
+
+  def query_AndExpression(o)
+    ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => 'and', :test2 => query(o.right_expr)
+  end
+
+  def query_OrExpression(o)
+    ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => 'or', :test2 => query(o.right_expr)
+  end
+
+  def query_ParenthesizedExpression(o)
+    result = query(o.expr) # produces CollExpr
+    result.parens = true
+    result
+  end
+
+  def query_VariableExpression(o)
+    transform(o)
+  end
+
+  def query_QualifiedName(o)
+    transform(o)
+  end
+
+  def query_LiteralNumber(o)
+    transform(o) # number to string in correct radix
+  end
+
+  def query_LiteralString(o)
+    transform(o)
+  end
+
+  def query_LiteralBoolean(o)
+    transform(o)
+  end
+
+  def transform_QualifiedName(o)
+    ast o, AST::Name, :value => o.value
+  end
+
+  def transform_QualifiedReference(o)
+    ast o, AST::Type, :value => o.value
+  end
+
+  def transform_ComparisonExpression(o)
+    ast o, AST::ComparisonOperator, :operator => o.operator.to_s, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
+  end
+
+  def transform_AndExpression(o)
+    ast o, AST::BooleanOperator, :operator => 'and', :lval => transform(o.left_expr), :rval => transform(o.right_expr)
+  end
+
+  def transform_OrExpression(o)
+    ast o, AST::BooleanOperator, :operator => 'or', :lval => transform(o.left_expr), :rval => transform(o.right_expr)
+  end
+
+  def transform_InExpression(o)
+    ast o, AST::InOperator, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
+  end
+
+  # Assignment in AST 3.1 is to variable or hasharray accesses !!! See Bug #16116
+  def transform_AssignmentExpression(o)
+    args = {:value => transform(o.right_expr) }
+    case o.operator
+    when :'+='
+      args[:append] = true
+    when :'='
+    else
+      raise "The operator #{o.operator} is not supported by Puppet 3."
+    end
+
+    args[:name] = case o.left_expr
+    when Model::VariableExpression
+      ast o, AST::Name, {:value => o.left_expr.expr.value }
+    when Model::AccessExpression
+      transform(o.left_expr)
+    else
+      raise "LHS is not an expression that can be assigned to"
+    end
+    ast o, AST::VarDef, args
+  end
+
+  # Produces (name => expr) or (name +> expr)
+  def transform_AttributeOperation(o)
+    args = { :value => transform(o.value_expr) }
+    args[:add] = true if o.operator == :'+>'
+    args[:param] = o.attribute_name
+    ast o, AST::ResourceParam, args
+  end
+
+  def transform_LiteralList(o)
+    # Uses default transform of Ruby Array to ASTArray
+    transform(o.values)
+  end
+
+  # Literal hash has strange behavior in Puppet 3.1. See Bug #19426, and this implementation is bug
+  # compatible
+  def transform_LiteralHash(o)
+    if o.entries.size == 0
+      ast o, AST::ASTHash, {:value=> {}}
+    else
+      value = {}
+      o.entries.each {|x| value.merge! transform(x) }
+      ast o, AST::ASTHash, {:value=> value}
+    end
+  end
+
+  # Transforms entry into a hash (they are later merged with strange effects: Bug #19426).
+  # Puppet 3.x only allows:
+  # * NAME
+  # * quotedtext
+  # As keys (quoted text can be an interpolated string which is compared as a key in a less than satisfactory way).
+  #
+  def transform_KeyedEntry(o)
+    value = transform(o.value)
+    key = case o.key
+    when Model::QualifiedName
+      o.key.value
+    when Model::LiteralString
+      transform o.key
+    when Model::LiteralNumber
+      transform o.key
+    when Model::ConcatenatedString
+      transform o.key
+    else
+      raise "Illegal hash key expression of type (#{o.key.class})"
+    end
+    {key => value}
+  end
+
+  def transform_MatchExpression(o)
+    ast o, AST::MatchOperator, :operator => o.operator.to_s, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
+  end
+
+  def transform_LiteralString(o)
+    ast o, AST::String, :value => o.value
+  end
+
+  def transform_LambdaExpression(o)
+    astargs = { :parameters => o.parameters.collect {|p| transform(p) } }
+    astargs.merge!({ :children => transform(o.body) }) if o.body         # do not want children if it is nil/nop
+    ast o, AST::Lambda, astargs
+  end
+
+  def transform_LiteralDefault(o)
+    ast o, AST::Default, :value => :default
+  end
+
+  def transform_LiteralUndef(o)
+    ast o, AST::Undef, :value => :undef
+  end
+
+  def transform_LiteralRegularExpression(o)
+    ast o, AST::Regex, :value => o.value
+  end
+
+  def transform_Nop(o)
+    ast o, AST::Nop
+  end
+
+  # In the 3.1. grammar this is a hash that is merged with other elements to form a method call
+  # Also in 3.1. grammar there are restrictions on the LHS (that are only there for grammar issues).
+  #
+  def transform_NamedAccessExpression(o)
+    receiver = transform(o.left_expr)
+    name = o.right_expr
+    raise "Unacceptable function/method name" unless name.is_a? Model::QualifiedName
+    {:receiver => receiver, :name => name.value}
+  end
+
+  def transform_NilClass(o)
+    ast o, AST::Nop, {}
+  end
+
+  def transform_NotExpression(o)
+    ast o, AST::Not, :value => transform(o.expr)
+  end
+
+  def transform_VariableExpression(o)
+    # assumes the expression is a QualifiedName
+    ast o, AST::Variable, :value => o.expr.value
+  end
+
+  # In Puppet 3.1, the ConcatenatedString is responsible for the evaluation and stringification of
+  # expression segments. Expressions and Strings are kept in an array.
+  def transform_TextExpression(o)
+    transform(o.expr)
+  end
+
+  def transform_UnaryMinusExpression(o)
+    ast o, AST::Minus, :value => transform(o.expr)
+  end
+
+  # Puppet 3.1 representation of a BlockExpression is an AST::Array - this makes it impossible to differentiate
+  # between a LiteralArray and a Sequence. (Should it return the collected array, or the last expression?)
+  # (A BlockExpression has now been introduced in the AST to solve this).
+  #
+  def transform_BlockExpression(o)
+    children = []
+    # remove nops resulting from import
+    o.statements.each {|s| r = transform(s); children << r unless is_nop?(r) }
+    ast o, AST::BlockExpression, :children => children  # o.statements.collect {|s| transform(s) }
+  end
+
+  # Interpolated strings are kept in an array of AST (string or other expression).
+  def transform_ConcatenatedString(o)
+    ast o, AST::Concat, :value => o.segments.collect {|x| transform(x)}
+  end
+
+  def transform_HostClassDefinition(o)
+    parameters = o.parameters.collect {|p| transform(p) }
+    args = {
+      :arguments => parameters,
+      :parent => o.parent_class,
+    }
+    args[:code] = transform(o.body) unless is_nop?(o.body)
+    Puppet::Parser::AST::Hostclass.new(o.name, merge_location(args, o))
+  end
+
+  def transform_HeredocExpression(o)
+    # TODO_HEREDOC Not supported in 3x
+    args = {:syntax=> o.syntax(), :expr => transform(o.text_expr()) }
+    Puppet::Parser::AST::Heredoc.new(merge_location(args, o))
+  end
+
+  def transform_NodeDefinition(o)
+    # o.host_matches are expressions, and 3.1 AST requires special object AST::HostName
+    # where a HostName is one of NAME, STRING, DEFAULT or Regexp - all of these are strings except regexp
+    #
+    args = {
+      :code => transform(o.body)
+    }
+    args[:parent] = hostname(o.parent) unless is_nop?(o.parent)
+    if(args[:parent].is_a?(Array))
+      raise "Illegal expression - unacceptable as a node parent"
+    end
+    Puppet::Parser::AST::Node.new(hostname(o.host_matches), merge_location(args, o))
+  end
+
+  # Transforms Array of host matching expressions into a (Ruby) array of AST::HostName
+  def hostname_Array(o)
+    o.collect {|x| ast x, AST::HostName, :value => hostname(x) }
+  end
+
+  def hostname_LiteralValue(o)
+    return o.value
+  end
+
+  def hostname_QualifiedName(o)
+    return o.value
+  end
+
+  def hostname_LiteralNumber(o)
+    transform(o) # Number to string with correct radix
+  end
+
+  def hostname_LiteralDefault(o)
+    return 'default'
+  end
+
+  def hostname_LiteralRegularExpression(o)
+    ast o, AST::Regex, :value => o.value
+  end
+
+  def hostname_Object(o)
+    raise "Illegal expression - unacceptable as a node name"
+  end
+
+  def transform_RelationshipExpression(o)
+    Puppet::Parser::AST::Relationship.new(transform(o.left_expr), transform(o.right_expr), o.operator.to_s, merge_location({}, o))
+  end
+
+  def transform_RenderStringExpression(o)
+    # TODO_EPP Not supported in 3x
+    ast o, AST::RenderString, :value => o.value
+  end
+
+  def transform_RenderExpression(o)
+    # TODO_EPP Not supported in 3x
+    ast o, AST::RenderExpression, :value => transform(o.expr)
+  end
+
+  def transform_ResourceTypeDefinition(o)
+    parameters = o.parameters.collect {|p| transform(p) }
+    args = { :arguments => parameters }
+    args[:code] = transform(o.body) unless is_nop?(o.body)
+
+    Puppet::Parser::AST::Definition.new(o.name, merge_location(args, o))
+  end
+
+  # Transformation of ResourceOverrideExpression is slightly more involved than a straight forward
+  # transformation.
+  # A ResourceOverrideExppression has "resources" which should be an AccessExpression
+  # on the form QualifiedName[expressions], or QualifiedReference[expressions] to be valid.
+  # It also has a set of attribute operations.
+  #
+  # The AST equivalence is an AST::ResourceOverride with a ResourceReference as its LHS, and
+  # a set of Parameters.
+  # ResourceReference has type as a string, and the expressions representing
+  # the "titles" to be an ASTArray.
+  #
+  def transform_ResourceOverrideExpression(o)
+    raise "Unsupported transformation - use the new evaluator"
+  end
+
+  # Parameter is a parameter in a definition of some kind.
+  # It is transformed to an array on the form `[name]´, or `[name, value]´.
+  def transform_Parameter(o)
+    if o.value
+      [o.name, transform(o.value)]
+    else
+      [o.name]
+    end
+  end
+
+  # For non query expressions, parentheses can be dropped in the resulting AST.
+  def transform_ParenthesizedExpression(o)
+    transform(o.expr)
+  end
+
+  def transform_Program(o)
+    transform(o.body)
+  end
+
+  def transform_IfExpression(o)
+    args = { :test => transform(o.test), :statements => transform(o.then_expr) }
+    args[:else] = transform(o.else_expr) # Tests say Nop should be there (unless is_nop? o.else_expr), probably not needed
+    ast o, AST::IfStatement, args
+  end
+
+  # Unless is not an AST object, instead an AST::IfStatement is used with an AST::Not around the test
+  #
+  def transform_UnlessExpression(o)
+    args = { :test => ast(o, AST::Not, :value => transform(o.test)),
+      :statements => transform(o.then_expr) }
+    # AST 3.1 does not allow else on unless in the grammar, but it is ok since unless is encoded as an if !x
+    args.merge!({:else => transform(o.else_expr)}) unless is_nop?(o.else_expr)
+    ast o, AST::IfStatement, args
+  end
+
+  # Puppet 3.1 AST only supports calling a function by name (it is not possible to produce a function
+  # that is then called).
+  # rval_required (for an expression)
+  # functor_expr (lhs - the "name" expression)
+  # arguments - list of arguments
+  #
+  def transform_CallNamedFunctionExpression(o)
+    name = o.functor_expr
+    raise "Unacceptable expression for name of function" unless name.is_a? Model::QualifiedName
+    args = {
+      :name => name.value,
+      :arguments => transform(o.arguments),
+      :ftype => o.rval_required ? :rvalue : :statement
+    }
+    args[:pblock] = transform(o.lambda) if o.lambda
+    ast o, AST::Function, args
+  end
+
+  # Transformation of CallMethodExpression handles a NamedAccessExpression functor and
+  # turns this into a 3.1 AST::MethodCall.
+  #
+  def transform_CallMethodExpression(o)
+    name = o.functor_expr
+    raise "Unacceptable expression for name of function" unless name.is_a? Model::NamedAccessExpression
+    # transform of NamedAccess produces a hash, add arguments to it
+    astargs = transform(name).merge(:arguments => transform(o.arguments))
+    astargs.merge!(:lambda => transform(o.lambda)) if o.lambda # do not want a Nop as the lambda
+    ast o, AST::MethodCall, astargs
+
+  end
+
+  def transform_CaseExpression(o)
+    # Expects expression, AST::ASTArray of AST
+    ast o, AST::CaseStatement, :test => transform(o.test), :options => transform(o.options)
+  end
+
+  def transform_CaseOption(o)
+    ast o, AST::CaseOpt, :value => transform(o.values), :statements => transform(o.then_expr)
+  end
+
+  def transform_ResourceBody(o)
+    raise "Unsupported transformation - use the new evaluator"
+  end
+
+  def transform_ResourceDefaultsExpression(o)
+    raise "Unsupported transformation - use the new evaluator"
+  end
+
+  # Transformation of ResourceExpression requires calling a method on the resulting
+  # AST::Resource if it is virtual or exported
+  #
+  def transform_ResourceExpression(o)
+    raise "Unsupported transformation - use the new evaluator"
+  end
+
+  # Transformation of SelectorExpression is limited to certain types of expressions.
+  # This is probably due to constraints in the old grammar rather than any real concerns.
+  def transform_SelectorExpression(o)
+    case o.left_expr
+    when Model::CallNamedFunctionExpression
+    when Model::AccessExpression
+    when Model::VariableExpression
+    when Model::ConcatenatedString
+    else
+      raise "Unacceptable select expression" unless o.left_expr.kind_of? Model::Literal
+    end
+    ast o, AST::Selector, :param => transform(o.left_expr), :values => transform(o.selectors)
+  end
+
+  def transform_SelectorEntry(o)
+    ast o, AST::ResourceParam, :param => transform(o.matching_expr), :value => transform(o.value_expr)
+  end
+
+  def transform_Object(o)
+    raise "Unacceptable transform - found an Object without a rule: #{o.class}"
+  end
+
+  # Nil, nop
+  # Bee bopp a luh-lah, a bop bop boom.
+  #
+  def is_nop?(o)
+    o.nil? || o.is_a?(Model::Nop)
+  end
+end