class Puppet::Provider::ParsedFile

# File lib/puppet/provider/parsedfile.rb, line 78
def self.backup_target(target)
  return nil unless target_object(target).respond_to?(:backup)

  @backup_stats ||= {}
  return nil if @backup_stats[target] == @records.object_id

  target_object(target).backup
  @backup_stats[target] = @records.object_id
end

# File lib/puppet/provider/parsedfile.rb, line 22
def self.clean(hash)
  newhash = hash.dup
  [:record_type, :on_disk].each do |p|
    newhash.delete(p) if newhash.include?(p)
  end

  newhash
end

# File lib/puppet/provider/parsedfile.rb, line 31
def self.clear
  @target_objects.clear
  @records.clear
end

# File lib/puppet/provider/parsedfile.rb, line 36
def self.filetype
  @filetype ||= Puppet::Util::FileType.filetype(:flat)
end

# File lib/puppet/provider/parsedfile.rb, line 40
def self.filetype=(type)
  if type.is_a?(Class)
    @filetype = type
  elsif klass = Puppet::Util::FileType.filetype(type)
    @filetype = klass
  else
    raise ArgumentError, "Invalid filetype #{type}"
  end
end

# File lib/puppet/provider/parsedfile.rb, line 53
def self.flush(record)
  # Make sure this record is on the list to be flushed.
  unless record[:on_disk]
    record[:on_disk] = true
    @records << record

    # If we've just added the record, then make sure our
    # target will get flushed.
    modified(record[:target] || default_target)
  end

  return unless defined?(@modified) and ! @modified.empty?

  flushed = []
  @modified.sort { |a,b| a.to_s <=> b.to_s }.uniq.each do |target|
    Puppet.debug "Flushing #{@resource_type.name} provider target #{target}"
    flush_target(target)
    flushed << target
  end

  @modified.reject! { |t| flushed.include?(t) }
end

# File lib/puppet/provider/parsedfile.rb, line 89
def self.flush_target(target)
  backup_target(target)

  records = target_records(target).reject { |r|
    r[:ensure] == :absent
  }
  target_object(target).write(to_file(records))
end

# File lib/puppet/provider/parsedfile.rb, line 100
  def self.header
%Q{# HEADER: This file was autogenerated at #{Time.now}
# HEADER: by puppet.  While it can still be managed manually, it
# HEADER: is definitely not recommended.\n}
  end

# File lib/puppet/provider/parsedfile.rb, line 107
def self.initvars
  @records = []
  @target_objects = {}

  @target = nil

  # Default to flat files
  @filetype ||= Puppet::Util::FileType.filetype(:flat)
  super
end

# File lib/puppet/provider/parsedfile.rb, line 119
def self.instances
  targets.collect do |target|
    prefetch_target(target)
  end.flatten.reject { |r| skip_record?(r) }.collect do |record|
    new(record)
  end
end

# File lib/puppet/provider/parsedfile.rb, line 189
def self.match_providers_with_resources(resources)
  return unless resources
  matchers = resources.dup
  @records.each do |record|
    # Skip things like comments and blank lines
    next if skip_record?(record)

    if name = record[:name] and resource = resources[name]
      resource.provider = new(record)
    elsif respond_to?(:match)
      if resource = match(record, matchers)
        # Remove this resource from circulation so we don't unnecessarily try to match
        matchers.delete(resource.title)
        record[:name] = resource[:name]
        resource.provider = new(record)
      end
    end
  end
end

# File lib/puppet/provider/parsedfile.rb, line 128
  def self.mk_resource_methods
    [resource_type.validproperties, resource_type.parameters].flatten.each do |attr|
      attr = attr.intern
      define_method(attr) do
#                if @property_hash.empty?
#                    # Note that this swaps the provider out from under us.
#                    prefetch
#                    if @resource.provider == self
#                        return @property_hash[attr]
#                    else
#                        return @resource.provider.send(attr)
#                    end
#                end
        # If it's not a valid field for this record type (which can happen
        # when different platforms support different fields), then just
        # return the should value, so the resource shuts up.
        if @property_hash[attr] or self.class.valid_attr?(self.class.name, attr)
          @property_hash[attr] || :absent
        else
          if defined?(@resource)
            @resource.should(attr)
          else
            nil
          end
        end
      end

      define_method(attr.to_s + "=") do |val|
        mark_target_modified
        @property_hash[attr] = val
      end
    end
  end

# File lib/puppet/provider/parsedfile.rb, line 170
def self.modified(target)
  @modified ||= []
  @modified << target unless @modified.include?(target)
end

# File lib/puppet/provider/parsedfile.rb, line 346
def initialize(record)
  super

  # The 'record' could be a resource or a record, depending on how the provider
  # is initialized.  If we got an empty property hash (probably because the resource
  # is just being initialized), then we want to set up some defualts.
  @property_hash = self.class.record?(resource[:name]) || {:record_type => self.class.name, :ensure => :absent} if @property_hash.empty?
end

# File lib/puppet/provider/parsedfile.rb, line 182
def self.prefetch(resources = nil)
  # Reset the record list.
  @records = prefetch_all_targets(resources)

  match_providers_with_resources(resources)
end

# File lib/puppet/provider/parsedfile.rb, line 209
def self.prefetch_all_targets(resources)
  records = []
  targets(resources).each do |target|
    records += prefetch_target(target)
  end
  records
end

# File lib/puppet/provider/parsedfile.rb, line 218
def self.prefetch_target(target)
  target_records = retrieve(target).each do |r|
    r[:on_disk] = true
    r[:target] = target
    r[:ensure] = :present
  end

  target_records = prefetch_hook(target_records) if respond_to?(:prefetch_hook)

  raise Puppet::DevError, "Prefetching #{target} for provider #{self.name} returned nil" unless target_records

  target_records
end

# File lib/puppet/provider/parsedfile.rb, line 233
def self.record?(name)
  return nil unless @records
  @records.find { |r| r[:name] == name }
end

# File lib/puppet/provider/parsedfile.rb, line 163
def self.resource_type=(resource)
  super
  mk_resource_methods
end

# File lib/puppet/provider/parsedfile.rb, line 240
def self.retrieve(path)
  # XXX We need to be doing something special here in case of failure.
  text = target_object(path).read
  if text.nil? or text == ""
    # there is no file
    return []
  else
    # Set the target, for logging.
    old = @target
    begin
      @target = path
      return self.parse(text)
    rescue Puppet::Error => detail
      detail.file = @target
      raise detail
    ensure
      @target = old
    end
  end
end

# File lib/puppet/provider/parsedfile.rb, line 263
def self.skip_record?(record)
  record_type(record[:record_type]).text?
end

# File lib/puppet/provider/parsedfile.rb, line 268
def self.target_object(target)
  @target_objects[target] ||= filetype.new(target)

  @target_objects[target]
end

# File lib/puppet/provider/parsedfile.rb, line 275
def self.target_records(target)
  @records.find_all { |r| r[:target] == target }
end

# File lib/puppet/provider/parsedfile.rb, line 281
def self.targets(resources = nil)
  targets = []
  # First get the default target
  raise Puppet::DevError, "Parsed Providers must define a default target" unless self.default_target
  targets << self.default_target

  # Then get each of the file objects
  targets += @target_objects.keys

  # Lastly, check the file from any resource instances
  if resources
    resources.each do |name, resource|
      if value = resource.should(:target)
        targets << value
      end
    end
  end

  targets.uniq.compact
end

# File lib/puppet/provider/parsedfile.rb, line 302
def self.to_file(records)
  text = super
  header + text
end

# File lib/puppet/provider/parsedfile.rb, line 307
def create
  @resource.class.validproperties.each do |property|
    if value = @resource.should(property)
      @property_hash[property] = value
    end
  end
  mark_target_modified
  (@resource.class.name.to_s + "_created").intern
end

# File lib/puppet/provider/parsedfile.rb, line 317
def destroy
  # We use the method here so it marks the target as modified.
  self.ensure = :absent
  (@resource.class.name.to_s + "_deleted").intern
end

# File lib/puppet/provider/parsedfile.rb, line 323
def exists?
  !(@property_hash[:ensure] == :absent or @property_hash[:ensure].nil?)
end

# File lib/puppet/provider/parsedfile.rb, line 328
def flush
  # Make sure we've got a target and name set.

  # If the target isn't set, then this is our first modification, so
  # mark it for flushing.
  unless @property_hash[:target]
    @property_hash[:target] = @resource.should(:target) || self.class.default_target
    self.class.modified(@property_hash[:target])
  end
  @resource.class.key_attributes.each do |attr|
    @property_hash[attr] ||= @resource[attr]
  end

  self.class.flush(@property_hash)

  #@property_hash = {}
end

# File lib/puppet/provider/parsedfile.rb, line 356
def prefetch
  raise Puppet::DevError, "Somehow got told to prefetch with no resource set" unless @resource
  self.class.prefetch(@resource[:name] => @resource)
end

# File lib/puppet/provider/parsedfile.rb, line 361
def record_type
  @property_hash[:record_type]
end