class Puppet::Parser::Compiler

# File lib/puppet/parser/compiler.rb, line 19
 def self.compile(node)
   # We get these from the environment and only cache them in a thread
   # variable for the duration of the compilation.  If nothing else is using
   # the thread, though, we can leave 'em hanging round with no ill effects,
   # and this is safer than cleaning them at the end and assuming that will
   # stick until the next entry to this function.
   Thread.current[:known_resource_types] = nil
   Thread.current[:env_module_directories] = nil

   # ...and we actually do the compile now we have caching ready.
   new(node).compile.to_resource
 rescue => detail
   message = "#{detail} on node #{node.name}"
   Puppet.log_exception(detail, message)
   raise Puppet::Error, message, detail.backtrace
end

# File lib/puppet/parser/compiler.rb, line 179
def initialize(node, options = {})
  @node = node
  set_options(options)
  initvars
end

# File lib/puppet/parser/compiler.rb, line 81
def add_class(name)
  @catalog.add_class(name) unless name == ""
end

# File lib/puppet/parser/compiler.rb, line 43
def add_override(override)
  # If possible, merge the override in immediately.
  if resource = @catalog.resource(override.ref)
    resource.merge(override)
  else
    # Otherwise, store the override for later; these
    # get evaluated in Resource#finish.
    @resource_overrides[override.ref] << override
  end
end

# File lib/puppet/parser/compiler.rb, line 55
def add_resource(scope, resource)
  @resources << resource

  # Note that this will fail if the resource is not unique.
  @catalog.add_resource(resource)

  if not resource.class? and resource[:stage]
    raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
  end

  # Stages should not be inside of classes.  They are always a
  # top-level container, regardless of where they appear in the
  # manifest.
  return if resource.stage?

  # This adds a resource to the class it lexically appears in in the
  # manifest.
  unless resource.class?
    return @catalog.add_edge(scope.resource, resource)
  end
end

# File lib/puppet/parser/compiler.rb, line 91
def compile
  # Set the client's parameters into the top scope.
  set_node_parameters
  create_settings_scope

  evaluate_main

  evaluate_ast_node

  evaluate_node_classes

  evaluate_generators

  finish

  fail_on_unevaluated

  @catalog
end

# File lib/puppet/parser/compiler.rb, line 114
def environment
  unless defined?(@environment)
    unless node.environment.is_a? Puppet::Node::Environment
      raise Puppet::DevError, "node #{node} has an invalid environment!"
    end
    @environment = node.environment
  end
  Puppet::Node::Environment.current = @environment
  @environment
end

# File lib/puppet/parser/compiler.rb, line 141
def evaluate_classes(classes, scope, lazy_evaluate = true, fqname = false)
  raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
  class_parameters = nil
  # if we are a param class, save the classes hash
  # and transform classes to be the keys
  if classes.class == Hash
    class_parameters = classes
    classes = classes.keys
  end
  classes.each do |name|
    # If we can find the class, then make a resource that will evaluate it.
    if klass = scope.find_hostclass(name, :assume_fqname => fqname)

      # If parameters are passed, then attempt to create a duplicate resource
      # so the appropriate error is thrown.
      if class_parameters
        resource = klass.ensure_in_catalog(scope, class_parameters[name] || {})
      else
        next if scope.class_scope(klass)
        resource = klass.ensure_in_catalog(scope)
      end

      # If they've disabled lazy evaluation (which the :include function does),
      # then evaluate our resource immediately.
      resource.evaluate unless lazy_evaluate
    else
      raise Puppet::Error, "Could not find class #{name} for #{node.name}"
    end
  end
end

# File lib/puppet/parser/compiler.rb, line 126
def evaluate_node_classes
  evaluate_classes(@node.classes, @node_scope || topscope)
end

# File lib/puppet/parser/compiler.rb, line 172
def evaluate_relationships
  @relationships.each { |rel| rel.evaluate(catalog) }
end

# File lib/puppet/parser/compiler.rb, line 187
def newscope(parent, options = {})
  parent ||= topscope
  scope = Puppet::Parser::Scope.new(self, options)
  scope.parent = parent
  scope
end

# File lib/puppet/parser/compiler.rb, line 195
def resource_overrides(resource)
  @resource_overrides[resource.ref]
end