class Puppet::Parser::Resource

# File lib/puppet/parser/resource.rb, line 117
def initialize(*args)
  raise ArgumentError, "Resources require a hash as last argument" unless args.last.is_a? Hash
  raise ArgumentError, "Resources require a scope" unless args.last[:scope]
  super

  @source ||= scope.source
end

# File lib/puppet/parser/resource.rb, line 31
def self.relationship_parameter?(name)
  @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
  @relationship_names.include?(name)
end

# File lib/puppet/parser/resource.rb, line 41
def [](param)
  param = param.intern
  if param == :title
    return self.title
  end
  if @parameters.has_key?(param)
    @parameters[param].value
  else
    nil
  end
end

# File lib/puppet/parser/resource.rb, line 64
def add_edge_to_stage
  return unless self.class?

  unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
    raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
  end

  self[:stage] ||= stage.title unless stage.title == :main
  catalog.add_edge(stage, self)
end

# File lib/puppet/parser/resource.rb, line 53
def eachparam
  @parameters.each do |name, param|
    yield param
  end
end

# File lib/puppet/parser/resource.rb, line 76
def evaluate
  return if evaluated?
  @evaluated = true
  if klass = resource_type and ! builtin_type?
    finish
    evaluated_code = klass.evaluate_code(self)

    return evaluated_code
  elsif builtin?
    devfail "Cannot evaluate a builtin type (#{type})"
  else
    self.fail "Cannot find definition #{type}"
  end
end

# File lib/puppet/parser/resource.rb, line 39
def evaluated?;  !!@evaluated;  end

# File lib/puppet/parser/resource.rb, line 93
def exported=(value)
  if value
    @virtual = true
    @exported = value
  else
    @exported = value
  end
end

# File lib/puppet/parser/resource.rb, line 104
def finish
  return if finished?
  @finished = true
  add_defaults
  add_scope_tags
  validate
end

# File lib/puppet/parser/resource.rb, line 113
def finished?
  @finished
end

# File lib/puppet/parser/resource.rb, line 126
def isomorphic?
  if builtin_type?
    return resource_type.isomorphic?
  else
    return true
  end
end

# File lib/puppet/parser/resource.rb, line 136
def merge(resource)
  # Test the resource scope, to make sure the resource is even allowed
  # to override.
  unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
    raise Puppet::ParseError.new("Only subclasses can override parameters", resource.line, resource.file)
  end
  # Some of these might fail, but they'll fail in the way we want.
  resource.parameters.each do |name, param|
    override_parameter(param)
  end
end

# File lib/puppet/parser/resource.rb, line 151
def metaparam_compatibility_mode?
  Puppet.deprecation_warning "metaparam_compatibility_mode? is obsolete since < 0.25 clients are really, really not supported any more"
  false
end

# File lib/puppet/parser/resource.rb, line 156
def name
  self[:name] || self.title
end

# File lib/puppet/parser/resource.rb, line 38
def override?;   !!@override;   end

# File lib/puppet/parser/resource.rb, line 166
def set_parameter(param, value = nil)
  if ! value.nil?
    param = Puppet::Parser::Resource::Param.new(
      :name => param, :value => value, :source => self.source
    )
  elsif ! param.is_a?(Puppet::Parser::Resource::Param)
    raise ArgumentError, "Received incomplete information - no value provided for parameter #{param}"
  end

  tag(*param.value) if param.name == :tag

  # And store it in our parameter hash.
  @parameters[param.name] = param
end

# File lib/puppet/parser/resource.rb, line 182
def to_hash
  @parameters.inject({}) do |hash, ary|
    param = ary[1]
    # Skip "undef" values.
    hash[param.name] = param.value if param.value != :undef
    hash
  end
end

# File lib/puppet/parser/resource.rb, line 195
def to_resource
  result = Puppet::Resource.new(type, title)

  to_hash.each do |p, v|
    if v.is_a?(Puppet::Resource)
      v = Puppet::Resource.new(v.type, v.title)
    elsif v.is_a?(Array)
      # flatten resource references arrays
      v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
      v = v.collect do |av|
        av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
        av
      end
    end

    # If the value is an array with only one value, then
    # convert it to a single value.  This is largely so that
    # the database interaction doesn't have to worry about
    # whether it returns an array or a string.
    result[p] = if v.is_a?(Array) and v.length == 1
                  v[0]
                else
                  v
                end
  end

  result.file = self.file
  result.line = self.line
  result.exported = self.exported
  result.virtual = self.virtual
  result.tag(*self.tags)

  result
end

# File lib/puppet/parser/resource.rb, line 37
def translated?; !!@translated; end