class Object

# File lib/puppet/type/file.rb, line 304
def self.[](path)
  return nil unless path
  super(path.gsub(/\/+/, '/').sub(/\/$/, ''))
end

# File lib/puppet/type/zone.rb, line 63
def self.alias_state(values)
  values.each do |k,v|
    fsm.alias_state(k,v)
  end
end

# File lib/puppet/provider/group/aix.rb, line 27
def self.attribute_ignore
  []
end

# File lib/puppet/provider/package/pkgutil.rb, line 63
def self.availlist
  output = pkguti ["-a"]

  list = output.split("\n").collect do |line|
    next if line =~ /^common\s+package/  # header of package list
    next if noise?(line)

    if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
      { :alias => $1, :name => $2, :avail => $3 }
    else
      Puppet.warning "Cannot match %s" % line
    end
  end.reject { |h| h.nil? }
end

# File lib/puppet/provider/package/blastwave.rb, line 35
def self.blastlist(hash)
  command = ["-c"]

  command << hash[:justme] if hash[:justme]

  output = Puppet::Util.withenv(:PAGER => "/usr/bin/cat") { pkgget command }

  list = output.split("\n").collect do |line|
    next if line =~ /^#/
    next if line =~ /^WARNING/
    next if line =~ /localrev\s+remoterev/

    blastsplit(line)
  end.reject { |h| h.nil? }

  if hash[:justme]
    return list[0]
  else
    list.reject! { |h|
      h[:ensure] == :absent
    }
    return list
  end

end

# File lib/puppet/provider/package/blastwave.rb, line 62
def self.blastsplit(line)
  if line =~ /\s*(\S+)\s+((\[Not installed\])|(\S+))\s+(\S+)/
    hash = {}
    hash[:name] = $1
    hash[:ensure] = if $2 == "[Not installed]"
      :absent
    else
      $2
    end
    hash[:avail] = $5

    hash[:avail] = hash[:ensure] if hash[:avail] == "SAME"

    # Use the name method, so it works with subclasses.
    hash[:provider] = self.name

    return hash
  else
    Puppet.warning "Cannot match #{line}"
    return nil
  end
end

# File lib/puppet/provider/package/pip.rb, line 38
def self.cmd
  case Facter.value(:osfamily)
    when "RedHat"
      "pip-python"
    else
      "pip"
  end
end

# File lib/puppet/provider/user/directoryservice.rb, line 201
def self.convert_binary_to_xml(plist_data)
  Puppet.debug('Converting binary plist to XML')
  Puppet.debug('Executing: \plutil -convert xml1 -o - -\')
  IO.popen('plutil -convert xml1 -o - -', mode='r+') do |io|
    io.write plist_data
    io.close_write
    @converted_plist = io.read
  end
  Puppet.debug('Converting XML values to a hash.')
  Plist::parse_xml(@converted_plist)
end

# File lib/puppet/provider/user/directoryservice.rb, line 188
def self.convert_xml_to_binary(plist_data)
  Puppet.debug('Converting XML plist to binary')
  Puppet.debug('Executing: \plutil -convert binary1 -o - -\')
  IO.popen('plutil -convert binary1 -o - -', mode='r+') do |io|
    io.write Plist::Emit.dump(plist_data)
    io.close_write
    @converted_plist = io.read
  end
  @converted_plist
end

# File lib/puppet/provider/service/daemontools.rb, line 84
def self.daemondir
  self.defpath
end

# File lib/puppet/provider/zone/solaris.rb, line 49
def self.def_multiprop(var, &conf)
  define_method(var.to_s) do |v|
    o = properties[var]
    return '' if o.nil? or o == :absent
    o.join(' ')
  end
  define_method('%s=' % var.to_s) do |v|
    setconfig self.send( ('%s_conf'% var).intern, v)
  end
  define_method('%s_conf' % var.to_s) do |v|
    multi_conf(var, v, &conf)
  end
end

# File lib/puppet/provider/zone/solaris.rb, line 40
def self.def_prop(var, str)
  define_method('%s_conf' % var.to_s) do |v|
    str % v
  end
  define_method('%s=' % var.to_s) do |v|
    setconfig self.send( ('%s_conf'% var).intern, v)
  end
end

# File lib/puppet/provider/service/bsd.rb, line 16
def self.defpath
  superclass.defpath
end

# File lib/puppet/reports/store.rb, line 52
def self.destroy(host)
  validate_host(host)

  dir = File.join(Puppet[:reportdir], host)

  if File.exists?(dir)
    Dir.entries(dir).each do |file|
      next if ['.','..'].include?(file)
      file = File.join(dir, file)
      File.unlink(file) if File.file?(file)
    end
    Dir.rmdir(dir)
  end
end

# File lib/puppet/provider/user/directoryservice.rb, line 40
def self.ds_to_ns_attribute_map
  {
    'RecordName'       => :name,
    'PrimaryGroupID'   => :gid,
    'NFSHomeDirectory' => :home,
    'UserShell'        => :shell,
    'UniqueID'         => :uid,
    'RealName'         => :comment,
    'Password'         => :password,
    'GeneratedUID'     => :guid,
    'IPAddress'        => :ip_address,
    'ENetAddress'      => :en_address,
    'GroupMembership'  => :members,
  }
end

# File lib/puppet/provider/package/portage.rb, line 130
def self.eix_result_fields
  [:category, :name, :ensure, :version_available, :vendor, :description]
end

# File lib/puppet/provider/package/portage.rb, line 126
def self.eix_result_format
  /^(\S+)\s+(\S+)\s+\[(\S*)\]\s+\[(\S*)\]\s+(\S+)\s+(.*)$/
end

# File lib/puppet/provider/package/portage.rb, line 138
def self.eix_search_arguments
  ["--nocolor", "--pure-packages", "--format",self.eix_search_format]
end

# File lib/puppet/provider/package/portage.rb, line 122
def self.eix_search_format
  "'<category> <name> [<installedversions:LASTVERSION>] [<bestversion:LASTVERSION>] <homepage> <description>'"
end

# File lib/puppet/provider/package/portage.rb, line 134
def self.eix_version_format
  "{last}<version>{}"
end

# File lib/puppet/provider/package/blastwave.rb, line 15
def self.extended(mod)
  unless command(:pkgget) != "pkg-get"
    raise Puppet::Error,
      "The pkg-get command is missing; blastwave packaging unavailable"
  end

  unless FileTest.exists?("/var/pkg-get/admin")
    Puppet.notice "It is highly recommended you create '/var/pkg-get/admin'."
    Puppet.notice "See /var/pkg-get/admin-fullauto"
  end
end

# File lib/puppet/type/zone.rb, line 58
def self.fsm
  return @fsm if @fsm
  @fsm = StateMachine.new
end

# File lib/puppet/provider/package/gem.rb, line 15
def self.gemlist(options)
  gem_list_command = [command(:gemcmd), "list"]

  if options[:local]
    gem_list_command << "--local"
  else
    gem_list_command << "--remote"
  end
  if options[:source]
    gem_list_command << "--source" << options[:source]
  end
  if name = options[:justme]
    gem_list_command << name + "$"
  end

  begin
    list = execute(gem_list_command).lines.
      map {|set| gemsplit(set) }.
      reject {|x| x.nil? }
  rescue Puppet::ExecutionFailure => detail
    raise Puppet::Error, "Could not list gems: #{detail}"
  end

  if options[:justme]
    return list.shift
  else
    return list
  end
end

# File lib/puppet/provider/package/gem.rb, line 45
def self.gemsplit(desc)
  # `gem list` when output console has a line like:
  # *** LOCAL GEMS ***
  # but when it's not to the console that line
  # and all blank lines are stripped
  # so we don't need to check for them

  if desc =~ /^(\S+)\s+\((.+)\)/
    name = $1
    versions = $2.split(/,\s*/)
    {
      :name     => name,
      :ensure   => versions,
      :provider => :gem
    }
  else
    Puppet.warning "Could not match #{desc}" unless desc.chomp.empty?
    nil
  end
end

# File lib/puppet/provider/user/directoryservice.rb, line 98
def self.generate_attribute_hash(input_hash)
  attribute_hash = {}
  input_hash.keys.each do |key|
    ds_attribute = key.sub("dsAttrTypeStandard:", "")
    next unless ds_to_ns_attribute_map.keys.include?(ds_attribute)
    ds_value = input_hash[key]
    case ds_to_ns_attribute_map[ds_attribute]
      when :gid, :uid
        # OS X stores objects like uid/gid as strings.
        # Try casting to an integer for these cases to be
        # consistent with the other providers and the group type
        # validation
        begin
          ds_value = Integer(ds_value[0])
        rescue ArgumentError
          ds_value = ds_value[0]
        end
      else ds_value = ds_value[0]
    end
    attribute_hash[ds_to_ns_attribute_map[ds_attribute]] = ds_value
  end
  attribute_hash[:ensure]         = :present
  attribute_hash[:provider]       = :directoryservice
  attribute_hash[:shadowhashdata] = get_attribute_from_dscl('Users', attribute_hash[:name], 'ShadowHashData')

  ##############
  # Get Groups #
  ##############
  groups_array = []
  get_list_of_groups.each do |group|
    if group["dsAttrTypeStandard:GroupMembership"] and group["dsAttrTypeStandard:GroupMembership"].include?(attribute_hash[:name])
      groups_array << group["dsAttrTypeStandard:RecordName"][0]
    end

    if group["dsAttrTypeStandard:GroupMembers"] and group["dsAttrTypeStandard:GroupMembers"].include?(attribute_hash[:guid])
      groups_array << group["dsAttrTypeStandard:RecordName"][0]
    end
  end
  attribute_hash[:groups] = groups_array.uniq.sort.join(',')

  ################################
  # Get Password/Salt/Iterations #
  ################################
  if (Puppet::Util::Package.versioncmp(get_os_version, '10.7') == -1)
    attribute_hash[:password] = get_sha1(attribute_hash[:guid])
  else
    if attribute_hash[:shadowhashdata].empty?
      attribute_hash[:password] = '*'
    else
      embedded_binary_plist = get_embedded_binary_plist(attribute_hash[:shadowhashdata])
      if embedded_binary_plist['SALTED-SHA512']
        attribute_hash[:password] = get_salted_sha512(embedded_binary_plist)
      else
        attribute_hash[:password]   = get_salted_sha512_pbkdf2('entropy', embedded_binary_plist)
        attribute_hash[:salt]       = get_salted_sha512_pbkdf2('salt', embedded_binary_plist)
        attribute_hash[:iterations] = get_salted_sha512_pbkdf2('iterations', embedded_binary_plist)
      end
    end
  end

  attribute_hash
end

# File lib/puppet/provider/user/directoryservice.rb, line 90
def self.get_all_users
  Plist.parse_xml(dscl '-plist', '.', 'readall', '/Users')
end

# File lib/puppet/provider/user/directoryservice.rb, line 174
def self.get_attribute_from_dscl(path, username, keyname)
  Plist.parse_xml(dscl '-plist', '.', 'read', "/#{path}/#{username}", keyname)
end

# File lib/puppet/provider/user/directoryservice.rb, line 181
def self.get_embedded_binary_plist(shadow_hash_data)
  embedded_binary_plist = Array(shadow_hash_data['dsAttrTypeNative:ShadowHashData'][0].delete(' ')).pack('H*')
  convert_binary_to_xml(embedded_binary_plist)
end

# File lib/puppet/provider/user/directoryservice.rb, line 167
def self.get_list_of_groups
  @groups ||= Plist.parse_xml(dscl '-plist', '.', 'readall', '/Groups')
end

# File lib/puppet/provider/service/launchd.rb, line 202
def self.get_macosx_version_major
  return @macosx_version_major if @macosx_version_major
  begin
    # Make sure we've loaded all of the facts
    Facter.loadfacts

    product_version_major = Facter.value(:macosx_productversion_major)

    fail("#{product_version_major} is not supported by the launchd provider") if %w{10.0 10.1 10.2 10.3 10.4}.include?(product_version_major)
    @macosx_version_major = product_version_major
    return @macosx_version_major
  rescue Puppet::ExecutionFailure => detail
    fail("Could not determine OS X version: #{detail}")
  end
end

# File lib/puppet/provider/user/directoryservice.rb, line 161
def self.get_os_version
  @os_version ||= Facter.value(:macosx_productversion_major)
end

# File lib/puppet/provider/user/directoryservice.rb, line 215
def self.get_salted_sha512(embedded_binary_plist)
  embedded_binary_plist['SALTED-SHA512'].string.unpack("H*")[0]
end

# File lib/puppet/provider/user/directoryservice.rb, line 223
def self.get_salted_sha512_pbkdf2(field, embedded_binary_plist)
  case field
  when 'salt', 'entropy'
    embedded_binary_plist['SALTED-SHA512-PBKDF2'][field].string.unpack('H*').first
  when 'iterations'
    Integer(embedded_binary_plist['SALTED-SHA512-PBKDF2'][field])
  else
    raise Puppet::Error, 'Puppet has tried to read an incorrect value from the ' +
         "SALTED-SHA512-PBKDF2 hash. Acceptable fields are 'salt', " +
         "'entropy', or 'iterations'."
  end
end

# File lib/puppet/provider/service/init.rb, line 27
def self.get_services(defpath, exclude=[])
  defpath = [defpath] unless defpath.is_a? Array
  instances = []
  defpath.each do |path|
    unless FileTest.directory?(path)
      Puppet.debug "Service path #{path} does not exist"
      next
    end

    check = [:ensure]

    check << :enable if public_method_defined? :enabled?

    Dir.entries(path).each do |name|
      fullpath = File.join(path, name)
      next if name =~ /^\./
      next if exclude.include? name
      next if not FileTest.executable?(fullpath)
      next if not is_init?(fullpath)
      instances << new(:name => name, :path => path, :hasstatus => true)
    end
  end
  instances
end

# File lib/puppet/provider/user/directoryservice.rb, line 238
def self.get_sha1(guid)
  password_hash = nil
  password_hash_file = "#{password_hash_dir}/#{guid}"
  if File.exists?(password_hash_file) and File.file?(password_hash_file)
    raise Puppet::Error, "Could not read password hash file at #{password_hash_file}" if not File.readable?(password_hash_file)
    f = File.new(password_hash_file)
    password_hash = f.read
    f.close
  end
  password_hash
end

# File lib/puppet/provider/user/aix.rb, line 149
def self.groupname_by_id(gid)
  groupname=nil
  execute(lsgroupscmd("ALL")).each_line { |entry|
    attrs = self.parse_attr_list(entry, nil)
    if attrs and attrs.include? :id and gid == attrs[:id].to_i
      groupname = entry.split(" ")[0]
    end
  }
  groupname
end

# File lib/puppet/provider/package/macports.rb, line 39
def self.hash_from_line(line, regex, fields)
  hash = {}
  if match = regex.match(line)
    fields.zip(match.captures) { |field, value|
      hash[field] = value
    }
    hash[:provider] = self.name
    return hash
  end
  nil
end

# File lib/puppet/provider/cron/crontab.rb, line 80
  def self.header
%Q{# HEADER: This file was autogenerated at #{Time.now} by puppet.
# HEADER: While it can still be managed manually, it is definitely not recommended.
# HEADER: Note particularly that the comments starting with 'Puppet Name' should
# HEADER: not be deleted, as doing so could cause duplicate cron jobs.\n}
  end

# File lib/puppet/provider/package/pkgutil.rb, line 16
def self.healthcheck()
  unless FileTest.exists?("/var/opt/csw/pkgutil/admin")
    Puppet.notice "It is highly recommended you create '/var/opt/csw/pkgutil/admin'."
    Puppet.notice "See /var/opt/csw/pkgutil"
  end

  correct_wgetopts = false
  [ "/opt/csw/etc/pkgutil.conf", "/etc/opt/csw/pkgutil.conf" ].each do |confpath|
    File.open(confpath) do |conf|
      conf.each_line {|line| correct_wgetopts = true if line =~ /^\s*wgetopts\s*=.*(-nv|-q|--no-verbose|--quiet)/ }
    end
  end
  if ! correct_wgetopts
    Puppet.notice "It is highly recommended that you set 'wgetopts=-nv' in your pkgutil.conf."
  end
end

# File lib/puppet/provider/package/pkg.rb, line 38
def self.ifo_flag(flags)
  (
    case flags[0..0]
    when 'i'
      {:status => 'installed'}
    when '-'
      {:status => 'known'}
    else
      raise ArgumentError, 'Unknown format %s: %s[%s]' % [self.name, flags, flags[0..0]]
    end
  ).merge(
    case flags[1..1]
    when 'f'
      {:ensure => 'held'}
    when '-'
      {}
    else
      raise ArgumentError, 'Unknown format %s: %s[%s]' % [self.name, flags, flags[1..1]]
    end
  )
end

# File lib/puppet/provider/package/appdmg.rb, line 42
def self.installapp(source, name, orig_source)
  appname = File.basename(source);
  ditto "--rsrc", source, "/Applications/#{appname}"
  File.open("/var/db/.puppet_appdmg_installed_#{name}", "w") do |t|
    t.print "name: '#{name}'\n"
    t.print "source: '#{orig_source}'\n"
  end
end

# File lib/puppet/provider/package/pkgdmg.rb, line 46
def self.installpkg(source, name, orig_source)
  installer "-pkg", source, "-target", "/"
  # Non-zero exit status will throw an exception.
  File.open("/var/db/.puppet_pkgdmg_installed_#{name}", "w") do |t|
    t.print "name: '#{name}'\n"
    t.print "source: '#{orig_source}'\n"
  end
end

# File lib/puppet/provider/package/appdmg.rb, line 51
def self.installpkgdmg(source, name)
  unless source =~ /\.dmg$/
    self.fail "Mac OS X PKG DMG's must specify a source string ending in .dmg"
  end
  require 'open-uri'
  require 'facter/util/plist'
  cached_source = source
  tmpdir = Dir.mktmpdir
  begin
    if %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ cached_source
      cached_source = File.join(tmpdir, name)
      begin
        curl "-o", cached_source, "-C", "-", "-k", "-L", "-s", "--url", source
        Puppet.debug "Success: curl transfered [#{name}]"
      rescue Puppet::ExecutionFailure
        Puppet.debug "curl did not transfer [#{name}].  Falling back to slower open-uri transfer methods."
        cached_source = source
      end
    end

    open(cached_source) do |dmg|
      xml_str = hdiutil "mount", "-plist", "-nobrowse", "-readonly", "-mountrandom", "/tmp", dmg.path
        ptable = Plist::parse_xml xml_str
        # JJM Filter out all mount-paths into a single array, discard the rest.
        mounts = ptable['system-entities'].collect { |entity|
          entity['mount-point']
        }.select { |mountloc|; mountloc }
        begin
          mounts.each do |fspath|
            Dir.entries(fspath).select { |f|
              f =~ /\.app$/
            }.each do |pkg|
              installapp("#{fspath}/#{pkg}", name, source)
            end
          end
        ensure
          hdiutil "eject", mounts[0]
        end
    end
  ensure
    FileUtils.remove_entry_secure(tmpdir, force=true)
  end
end

# File lib/puppet/provider/package/apple.rb, line 24
def self.instance_by_name
  Dir.entries("/Library/Receipts").find_all { |f|
    f =~ /\.pkg$/
  }.collect { |f|
    name = f.sub(/\.pkg/, '')
    yield name if block_given?

    name
  }
end

# File lib/puppet/provider/group/windows_adsi.rb, line 51
def self.instances
  Puppet::Util::ADSI::Group.map { |g| new(:ensure => :present, :name => g.name) }
end

# File lib/puppet/provider/package/appdmg.rb, line 26
def self.instances_by_name
  Dir.entries("/var/db").find_all { |f|
    f =~ /^\.puppet_appdmg_installed_/
  }.collect do |f|
    name = f.sub(/^\.puppet_appdmg_installed_/, '')
    yield name if block_given?
    name
  end
end

# File lib/puppet/provider/service/init.rb, line 136
def self.is_init?(script = initscript)
  !File.symlink?(script) || File.readlink(script) != "/lib/init/upstart-job"
end

# File lib/puppet/provider/service/launchd.rb, line 154
def self.job_list
  @job_list = Hash.new
  begin
    output = launchctl :list
    raise Puppet::Error.new("launchctl list failed to return any data.") if output.nil?
    output.split("\n").each do |line|
      @job_list[line.split(/\s/).last] = :running
    end
  rescue Puppet::ExecutionFailure
    raise Puppet::Error.new("Unable to determine status of #{resource[:name]}")
  end
  @job_list
end

# File lib/puppet/provider/service/launchd.rb, line 119
def self.jobsearch(label=nil)
  @label_to_path_map ||= {}
  if @label_to_path_map.empty?
    launchd_paths.each do |path|
      return_globbed_list_of_file_paths(path).each do |filepath|
        job = read_plist(filepath)
        next if job.nil?
        if job.has_key?("Label")
          if job["Label"] == label
            return { label => filepath }
          else
            @label_to_path_map[job["Label"]] = filepath
          end
        else
          Puppet.warning("The #{filepath} plist does not contain a 'label' key; " +
                       "Puppet is skipping it")
          next
        end
      end
    end
  end

  if label
    if @label_to_path_map.has_key? label
      return { label => @label_to_path_map[label] }
    else
      raise Puppet::Error.new("Unable to find launchd plist for job: #{label}")
    end
  else
    @label_to_path_map
  end
end

# File lib/puppet/provider/service/launchd.rb, line 73
def self.launchd_overrides
  "/var/db/launchd.db/com.apple.launchd/overrides.plist"
end

# File lib/puppet/provider/service/launchd.rb, line 60
def self.launchd_paths
  [
    "/Library/LaunchAgents",
    "/Library/LaunchDaemons",
    "/System/Library/LaunchAgents",
    "/System/Library/LaunchDaemons"
  ]
end

# File lib/puppet/provider/zone/solaris.rb, line 10
def self.line2hash(line)
  fields = [:id, :name, :ensure, :path, :uuid, :brand, :iptype]
  properties = Hash[fields.zip(line.split(':'))]

  del_id = [:brand, :uuid]
  # Configured but not installed zones do not have IDs
  del_id << :id if properties[:id] == "-"
  del_id.each { |p| properties.delete(p) }

  properties[:ensure] = properties[:ensure].intern
  properties[:iptype] = 'exclusive' if properties[:iptype] == 'excl'

  properties
end

# File lib/puppet/provider/package/freebsd.rb, line 14
def self.listcmd
  command(:pkginfo)
end

# File lib/puppet/provider/interface/cisco.rb, line 9
def self.lookup(device, name)
  interface = nil
  device.command do |ng|
    interface = device.interface(name)
  end
  interface
end

# File lib/puppet/provider/cron/crontab.rb, line 88
def self.match(record, resources)
  resources.each do |name, resource|
    # Match the command first, since it's the most important one.
    next unless record[:target] == resource.value(:target)
    next unless record[:command] == resource.value(:command)

    # Then check the @special stuff
    if record[:special]
      next unless resource.value(:special) == record[:special]
    end

    # Then the normal fields.
    matched = true
    record_type(record[:record_type]).fields.each do |field|
      next if field == :command
      next if field == :special
      if record[field] and ! resource.value(field)
        #Puppet.info "Cron is missing %s: %s and %s" %
        #    [field, record[field].inspect, resource.value(field).inspect]
        matched = false
        break
      end

      if ! record[field] and resource.value(field)
        #Puppet.info "Hash is missing %s: %s and %s" %
        #    [field, resource.value(field).inspect, record[field].inspect]
        matched = false
        break
      end

      # Yay differing definitions of absent.
      next if (record[field] == :absent and resource.value(field) == "*")

      # Everything should be in the form of arrays, not the normal text.
      next if (record[field] == resource.value(field))
      #Puppet.info "Did not match %s: %s vs %s" %
      #    [field, resource.value(field).inspect, record[field].inspect]
      matched = false
      break
    end
    return resource if matched
  end

  false
end

# File lib/puppet/util/log/destinations.rb, line 49
def self.match?(obj)
  Puppet::Util.absolute_path?(obj)
end

# File lib/puppet/provider/mcx/mcxcontent.rb, line 62
def self.mcxexport(ds_type, ds_name)
  ds_t = TypeMap[ds_type]
  ds_n = ds_name.to_s
  ds_path = "/Local/Default/#{ds_t}/#{ds_n}"
  dscl 'localhost', '-mcxexport', ds_path
end

# File lib/puppet/provider/mount/parsed.rb, line 89
def self.mountinstances
  # XXX: Will not work for mount points that have spaces in path (does fstab support this anyways?)
  regex = case Facter.value(:osfamily) 
    when "Darwin"
      / on (?:\/private\/var\/automount)?(\S*)/
    when "Solaris", "HP-UX"
      /^(\S*) on /
    when "AIX"
      /^(?:\S*\s+\S+\s+)(\S+)/
    else
      / on (\S*)/
  end
  instances = []
  mount_output = mountcmd.split("\n")
  if mount_output.length >= 2 and mount_output[1] =~ /^[- \t]*$/
    # On some OSes (e.g. AIX) mount output begins with a header line
    # followed by a line consisting of dashes and whitespace.
    # Discard these two lines.
    mount_output[0..1] = []
  end
  mount_output.each do |line|
    if match = regex.match(line) and name = match.captures.first
      instances << {:name => name, :mounted => :yes} # Only :name is important here
    else
      raise Puppet::Error, "Could not understand line #{line} from mount output"
    end
  end
  instances
end

# File lib/puppet/provider/group/ldap.rb, line 38
def self.name2id(group)
  return nil unless result = manager.search("cn=#{group}") and result.length > 0

  # Only use the first result.
  group = result[0]
  gid = group[:gid][0]
end

# File lib/puppet/provider/package/sun.rb, line 28
def self.namemap(hash)
  Namemap.keys.inject({}) do |hsh,k|
    hsh.merge(Namemap[k] => hash[k])
  end
end

# File lib/puppet/provider/package/rpm.rb, line 124
def self.nevra_to_hash(line)
  line.chomp!
  hash = {}
  NEVRA_FIELDS.zip(line.split) { |f, v| hash[f] = v }
  hash[:provider] = self.name
  hash[:ensure] = "#{hash[:version]}-#{hash[:release]}"
  hash
end

# File lib/puppet/provider/interface/cisco.rb, line 17
def initialize(device, *args)
  super
end

# File lib/puppet/provider/package/pkgutil.rb, line 115
def self.noise?(line)
  true if line =~ /^#/
  true if line =~ /^Checking integrity / # use_gpg
  true if line =~ /^gpg: /               # gpg verification
  true if line =~ /^=+> /                # catalog fetch
  true if line =~ /\d+:\d+:\d+ URL:/     # wget without -q
  false
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 253
def self.normalized_date(date_string)
  date = Date.parse("#{date_string}")
  "#{date.year}-#{date.month}-#{date.day}"
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 258
def self.normalized_time(time_string)
  Time.parse("#{time_string}").strftime('%H:%M')
end

# File lib/puppet/provider/user/directoryservice.rb, line 56
def self.ns_to_ds_attribute_map
  @ns_to_ds_attribute_map ||= ds_to_ns_attribute_map.invert
end

# File lib/puppet/provider/package/pip.rb, line 16
def self.parse(line)
  if line.chomp =~ /^([^=]+)==([^=]+)$/
    {:ensure => $2, :name => $1, :provider => name}
  else
    nil
  end
end

# File lib/puppet/provider/package/macports.rb, line 33
def self.parse_info_query_line(line)
  regex = /(\S+)\s+(\S+)/
  fields = [:version, :revision]
  hash_from_line(line, regex, fields)
end

# File lib/puppet/provider/package/macports.rb, line 27
def self.parse_installed_query_line(line)
  regex = /(\S+)\s+@(\S+)_(\d+).*\(active\)/
  fields = [:name, :ensure, :revision]
  hash_from_line(line, regex, fields)
end

# File lib/puppet/provider/package/dpkg.rb, line 40
def self.parse_line(line)
  if match = self::REGEX.match(line)
    hash = {}

    self::FIELDS.zip(match.captures) { |field,value|
      hash[field] = value
    }

    hash[:provider] = self.name

    if hash[:status] == 'not-installed'
      hash[:ensure] = :purged
    elsif ['config-files', 'half-installed', 'unpacked', 'half-configured'].include?(hash[:status])
      hash[:ensure] = :absent
    end
    hash[:ensure] = :held if hash[:desired] == 'hold'
  else
    Puppet.warning "Failed to match dpkg-query line #{line.inspect}"
    return nil
  end

  hash
end

# File lib/puppet/provider/ssh_authorized_key/parsed.rb, line 71
def self.parse_options(options)
  result = []
  scanner = StringScanner.new(options)
  while !scanner.eos?
    scanner.skip(/[ \t]*/)
    # scan a long option
    if out = scanner.scan(/[-a-z0-9A-Z_]+=\".*?\"/) or out = scanner.scan(/[-a-z0-9A-Z_]+/)
      result << out
    else
      # found an unscannable token, let's abort
      break
    end
    # eat a comma
    scanner.skip(/[ \t]*,[ \t]*/)
  end
  result
end

# File lib/puppet/provider/package/pkgin.rb, line 12
def self.parse_pkgin_line(package, force_status=nil)

  # e.g.
  #   vim-7.2.446 =        Vim editor (vi clone) without GUI
  match, name, version, status = *package.match(/(\S+)-(\S+)(?: (=|>|<))?\s+.+$/)
  if match
    ensure_status = if force_status
      force_status
    elsif status
      :present
    else
      :absent
    end

    {
      :name     => name,
      :ensure   => ensure_status,
      :provider => :pkgin
    }
  end
end

# File lib/puppet/provider/package/sun.rb, line 34
def self.parse_pkginfo(out)
  # collect all the lines with : in them, and separate them out by ^$
  pkgs = []
  pkg = {}
  out.each_line do |line|
    case line.chomp
    when /^\s*$/
      pkgs << pkg unless pkg.empty?
      pkg = {}
    when /^\s*([^:]+):\s+(.+)$/
      pkg[$1] = $2
    end
  end
  pkgs << pkg unless pkg.empty?
  pkgs
end

# File lib/puppet/provider/package/pkgutil.rb, line 87
def self.parse_pkglist(output, hash = {})
  output = output.split("\n")

  if output[-1] == "Not in catalog"
    Puppet.warning "Package not in pkgutil catalog: %s" % hash[:justme]
    return nil
  end

  list = output.collect do |line|
    next if line =~ /installed\s+catalog/  # header of package list
    next if noise?(line)

    pkgsplit(line)
  end.reject { |h| h.nil? }

  if hash[:justme]
    # Single queries may have been for an alias so return the name requested
    if list.any?
      list[-1][:name] = hash[:justme]
      return list[-1]
    end
  else
    list.reject! { |h| h[:ensure] == :absent }
    return list
  end
end

# File lib/puppet/provider/user/directoryservice.rb, line 480
def self.password_hash_dir
  '/var/db/shadow/hash'
end

# File lib/puppet/provider/package/pkg.rb, line 78
def self.pkg_state(state)
  case state
  when /installed/
    {:status => 'installed'}
  when /known/
    {:status => 'known'}
  else
    raise ArgumentError, 'Unknown format %s: %s' % [self.name, state]
  end
end

# File lib/puppet/provider/package/aix.rb, line 77
def self.pkglist(hash = {})
  cmd = [command(:lslpp), "-qLc"]

  if name = hash[:pkgname]
    cmd << name
  end

  begin
    list = execute(cmd).scan(/^[^#][^:]*:([^:]*):([^:]*)/).collect { |n,e|
      { :name => n, :ensure => e, :provider => self.name }
    }
  rescue Puppet::ExecutionFailure => detail
    if hash[:pkgname]
      return nil
    else
      raise Puppet::Error, "Could not list installed Packages: #{detail}"
    end
  end

  if hash[:pkgname]
    return list.shift
  else
    return list
  end
end

# File lib/puppet/provider/package/pkgutil.rb, line 125
def self.pkgsplit(line)
  if line =~ /\s*(\S+)\s+(\S+)\s+(.*)/
    hash = {}
    hash[:name] = $1
    hash[:ensure] = if $2 == "notinst"
      :absent
    else
      $2
    end
    hash[:avail] = $3

    if hash[:avail] =~ /^SAME\s*$/
      hash[:avail] = hash[:ensure]
    end

    # Use the name method, so it works with subclasses.
    hash[:provider] = self.name

    return hash
  else
    Puppet.warning "Cannot match %s" % line
    return nil
  end
end

# File lib/puppet/provider/macauthorization/macauthorization.rb, line 64
def populate_rules_rights
  auth_plist = Plist::parse_xml(AuthDB)
  raise Puppet::Error.new("Cannot parse: #{AuthDB}") if not auth_plist
  self.rights = auth_plist["rights"].dup
  self.rules = auth_plist["rules"].dup
  self.parsed_auth_db = self.rights.dup
  self.parsed_auth_db.merge!(self.rules.dup)
end

# File lib/puppet/provider/macauthorization/macauthorization.rb, line 51
def prefetch(resources)
  self.populate_rules_rights
end

# File lib/puppet/provider/cron/crontab.rb, line 135
def self.prefetch_hook(records)
  name = nil
  envs = nil
  result = records.each { |record|
    case record[:record_type]
    when :comment
      if record[:name]
        name = record[:name]
        record[:skip] = true

        # Start collecting env values
        envs = []
      end
    when :environment
      # If we're collecting env values (meaning we're in a named cronjob),
      # store the line and skip the record.
      if envs
        envs << record[:line]
        record[:skip] = true
      end
    when :blank
      # nothing
    else
      if name
        record[:name] = name
        name = nil
      end
      if envs.nil? or envs.empty?
        record[:environment] = :absent
      else
        # Collect all of the environment lines, and mark the records to be skipped,
        # since their data is included in our crontab record.
        record[:environment] = envs

        # And turn off env collection again
        envs = nil
      end
    end
  }.reject { |record| record[:skip] }
  result
end

# File lib/puppet/provider/service/launchd.rb, line 182
def self.read_plist(path)
  begin
    Plist::parse_xml(plutil('-convert', 'xml1', '-o', '/dev/stdout', path))
  rescue Puppet::ExecutionFailure => detail
    Puppet.warning("Cannot read file #{path}; Puppet is skipping it. \n" +
                   "Details: #{detail}")
    return nil
  end
end

# File lib/puppet/provider/service/launchd.rb, line 108
def self.return_globbed_list_of_file_paths(path)
  array_of_files = Dir.glob(File.join(path, '*')).collect do |filepath|
    File.file?(filepath) ? filepath : nil
  end
  array_of_files.compact
end

# File lib/puppet/type/zone.rb, line 69
def self.seqvalue(name, hash)
  fsm.insert_state(name, hash)
  self.newvalue name
end

# File lib/puppet/provider/package/aix.rb, line 20
def self.srclistcmd(source)
  [ command(:installp), "-L", "-d", source ]
end

# File lib/puppet/type/zone.rb, line 85
def self.state_sequence(first, second)
  fsm.sequence(first, second)
end

# File lib/puppet/util/log/destinations.rb, line 2
def self.suitable?(obj)
  Puppet.features.syslog?
end

# File lib/puppet/type/file.rb, line 36
def self.title_patterns
  [ [ /^(.*?)\/*\Z/, [ [ :path ] ] ] ]
end

# File lib/puppet/provider/cron/crontab.rb, line 177
def self.to_file(records)
  text = super
  # Apparently Freebsd will "helpfully" add a new TZ line to every
  # single cron line, but not in all cases (e.g., it doesn't do it
  # on my machine).  This is my attempt to fix it so the TZ lines don't
  # multiply.
  if text =~ /(^TZ=.+\n)/
    tz = $1
    text.sub!(tz, '')
    text = tz + text
  end
  text
end

# File lib/puppet/provider/package/windows.rb, line 37
def self.to_hash(pkg)
  {
    :name     => pkg.name,
    # we're not versionable, so we can't set the ensure
    # parameter to the currently installed version
    :ensure   => :installed,
    :provider => :windows
  }
end

# File lib/puppet/provider/package/pkg.rb, line 68
def self.ufoxi_flag(flags)
  {}
end

# File lib/puppet/type/component.rb, line 16
def [](param)
  return super if self.class.valid_parameter?(param)
  @extra_parameters[param.to_sym]
end

# File lib/puppet/type/component.rb, line 23
def []=(param, value)
  return super if self.class.valid_parameter?(param)
  @extra_parameters[param.to_sym] = value
end

# File lib/puppet/type/resources.rb, line 77
def able_to_ensure_absent?(resource)
    resource[:ensure] = :absent
rescue ArgumentError, Puppet::Error => detail
    err "The 'ensure' attribute on #{self[:name]} resources does not accept 'absent' as a value"
    false
end

# File lib/puppet/provider/zone/solaris.rb, line 130
def add_cmd(cmd)
  @cmds = [] if @cmds.nil?
  @cmds << cmd
end

# File lib/puppet/provider/service/upstart.rb, line 328
def add_default_start_to(text)
  text + "\nstart on runlevel [2,3,4,5]"
end

# File lib/puppet/provider/user/user_role_add.rb, line 31
def add_properties
  cmd = []
  Puppet::Type.type(:user).validproperties.each do |property|
    #skip the password because we can't create it with the solaris useradd
    next if [:ensure, :password, :password_min_age, :password_max_age].include?(property)
    # 1680 Now you can set the hashed passwords on solaris:lib/puppet/provider/user/user_role_add.rb
    # the value needs to be quoted, mostly because -c might
    # have spaces in it
    if value = @resource.should(property) and value != ""
      if property == :keys
        cmd += build_keys_cmd(value)
      else
        cmd << flag(property) << value
      end
    end
  end
  cmd
end

# File lib/puppet/provider/group/aix.rb, line 69
def addcmd(extra_attrs = [])
  # Here we use the @resource.to_hash to get the list of provided parameters
  # Puppet does not call to self.<parameter>= method if it does not exists.
  #
  # It gets an extra list of arguments to add to the user.
  [self.class.command(:add) ] +
    self.get_ia_module_args +
    self.hash2args(@resource.to_hash) +
    extra_attrs + [@resource[:name]]
end

# File lib/puppet/provider/maillist/mailman.rb, line 31
def aliases
  mailman = self.class.command(:mailman)
  name = self.name.downcase
  aliases = {name => "| #{mailman} post #{name}"}
  %w{admin bounces confirm join leave owner request subscribe unsubscribe}.each do |address|
    aliases["#{name}-#{address}"] = "| #{mailman} #{address} #{name}"
  end
  aliases
end

# File lib/puppet/face/help.rb, line 135
def all_application_summaries()
  Puppet::Application.available_application_names.sort.inject([]) do |result, appname|
    next result if exclude_from_docs?(appname)

    if (is_face_app?(appname))
      begin
        face = Puppet::Face[appname, :current]
        result << [appname, face.summary]
      rescue Puppet::Error => detail
        result << [ "! #{appname}", "! Subcommand unavailable due to error. Check error logs." ]
      end
    else
      result << [appname, horribly_extract_summary_from(appname)]
    end
  end
end

# File lib/puppet/type/cron.rb, line 256
def alpha
  %w{sunday monday tuesday wednesday thursday friday saturday}
end

# File lib/puppet/type/file.rb, line 382
def ancestors
  ancestors = Pathname.new(self[:path]).enum_for(:ascend).map(&:to_s)
  ancestors.delete(self[:path])
  ancestors
end

# File lib/puppet/provider/package/aptitude.rb, line 11
def aptget(*args)
  args.flatten!
  # Apparently aptitude hasn't always supported a -q flag.
  args.delete("-q") if args.include?("-q")
  args.delete("--force-yes") if args.include?("--force-yes")
  output = aptitude(*args)

  # Yay, stupid aptitude doesn't throw an error when the package is missing.
  if args.include?(:install) and output =~ /Couldn't find any package/
    raise Puppet::Error.new(
      "Could not find package #{self.name}"
    )
  end
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 56
def arguments
  task.parameters
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 151
def arguments=(value)
  task.parameters = value
end

# File lib/puppet/type/file.rb, line 314
def asuser
  if self.should(:owner) and ! self.should(:owner).is_a?(Symbol)
    writeable = Puppet::Util::SUIDManager.asuser(self.should(:owner)) {
      FileTest.writable?(::File.dirname(self[:path]))
    }

    # If the parent directory is writeable, then we execute
    # as the user in question.  Otherwise we'll rely on
    # the 'owner' property to do things.
    asuser = self.should(:owner) if writeable
  end

  asuser
end

# File lib/puppet/provider/group/aix.rb, line 118
def attributes
  filter_attributes(getosinfo(refresh = false))
end

# File lib/puppet/provider/group/aix.rb, line 122
def attributes=(attr_hash)
  #self.class.validate(param, value)
  param = :attributes
  cmd = modifycmd({param => filter_attributes(attr_hash)})
  if cmd
    begin
      execute(cmd)
    rescue Puppet::ExecutionFailure  => detail
      raise Puppet::Error, "Could not set #{param} on #{@resource.class.name}[#{@resource.name}]: #{detail}"
    end
  end
end

# File lib/puppet/provider/macauthorization/macauthorization.rb, line 288
def auth_type
  if resource.should(:auth_type) != nil
    return resource.should(:auth_type)
  elsif self.exists?
    # this is here just for ralsh, so it can work out what type it is.
    if self.class.rights.has_key?(resource[:name])
      return :right
    elsif self.class.rules.has_key?(resource[:name])
      return :rule
    else
      raise Puppet::Error.new("#{resource[:name]} is unknown type.")
    end
  else
    raise Puppet::Error.new("auth_type required for new resources.")
  end
end

# File lib/puppet/provider/macauthorization/macauthorization.rb, line 305
def auth_type=(value)
  @property_hash[:auth_type] = value
end

# File lib/puppet/provider/user/user_role_add.rb, line 109
def auths
  user_attributes[:auths] if user_attributes
end

# File lib/puppet/provider/user/directoryservice.rb, line 584
def base64_decode_string(value)
  Base64.decode64([[value].pack("H*")].pack("m").strip)
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 393
def bitfield_from_days(days)
  bitfield = 0

  days = [days] unless days.is_a?(Array)
  days.each do |day|
    # The special "day" of 'last' is represented by day "number"
    # 32. 'last' has the special meaning of "the last day of the
    # month", no matter how many days there are in the month.
    day = 32 if day == 'last'

    integer_day = Integer(day)
    self.fail "Day must be specified as an integer in the range 1-31, or as 'last'" unless integer_day = day.to_f and integer_day.between?(1,32)

    bitfield |= 1 << integer_day - 1
  end

  bitfield
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 412
def bitfield_from_days_of_week(days_of_week)
  bitfield = 0

  days_of_week = [days_of_week] unless days_of_week.is_a?(Array)
  days_of_week.each do |day_of_week|
    bitfield |= day_of_week_name_to_constant(day_of_week)
  end

  bitfield
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 379
def bitfield_from_months(months)
  bitfield = 0

  months = [months] unless months.is_a?(Array)
  months.each do |month|
    integer_month = Integer(month) rescue nil
    self.fail 'Month must be specified as an integer in the range 1-12' unless integer_month == month.to_f and integer_month.between?(1,12)

    bitfield |= scheduler_months[integer_month - 1]
  end

  bitfield
end

# File lib/puppet/type/file.rb, line 329
def bucket
  return @bucket if @bucket

  backup = self[:backup]
  return nil unless backup
  return nil if backup =~ /^\./

  unless catalog or backup == "puppet"
    fail "Can not find filebucket for backups without a catalog"
  end

  unless catalog and filebucket = catalog.resource(:filebucket, backup) or backup == "puppet"
    fail "Could not find filebucket #{backup} specified in backup"
  end

  return default_bucket unless filebucket

  @bucket = filebucket.bucket

  @bucket
end

# File lib/puppet/provider/user/user_role_add.rb, line 137
def build_keys_cmd(keys_hash)
  cmd = []
  keys_hash.each do |k,v|
    cmd << "-K" << "#{k}=#{v}"
  end
  cmd
end

# File lib/puppet/provider/zpool/zpool.rb, line 69
def build_named(name)
  if prop = @resource[name.intern]
    [name] + prop.collect { |p| p.split(' ') }.flatten
  else
    []
  end
end

# File lib/puppet/provider/zpool/zpool.rb, line 83
def build_vdevs
  if disk = @resource[:disk]
    disk.collect { |d| d.split(' ') }.flatten
  elsif mirror = @resource[:mirror]
    ["mirror"] +  mirror
  elsif raidz = @resource[:raidz]
    [raidzarity] + raidz
  end
end

# File lib/puppet/type/augeas.rb, line 201
def change_to_s(currentvalue, newvalue)
  "executed successfully"
end

# File lib/puppet/type/resources.rb, line 67
def check(resource)
  @checkmethod ||= "#{self[:name]}_check"
  @hascheck ||= respond_to?(@checkmethod)
  if @hascheck
    return send(@checkmethod, resource)
  else
    return true
  end
end

# File lib/puppet/provider/user/useradd.rb, line 29
def check_allow_dup
  @resource.allowdupe? ? ["-o"] : []
end

# File lib/puppet/provider/user/useradd.rb, line 43
def check_manage_expiry
  cmd = []
  if @resource[:expiry]
    cmd << "-e #{@resource[:expiry]}"
  end

  cmd
end

# File lib/puppet/provider/user/useradd.rb, line 33
def check_manage_home
  cmd = []
  if @resource.managehome?
    cmd << "-m"
  elsif Facter.value(:osfamily) == 'RedHat'
    cmd << "-M"
  end
  cmd
end

# File lib/puppet/provider/package/msi.rb, line 98
def check_result(hr)
  operation = resource[:ensure] == :absent ? 'uninstall' : 'install'

  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa368542(v=vs.85).aspx
  case hr
  when 0
    # yeah
  when 194
    warning("The package requested a reboot to finish the operation.")
  when 1641
    warning("The package #{operation}ed successfully and the system is rebooting now.")
  when 3010
    warning("The package #{operation}ed successfully, but the system must be rebooted.")
  else
    raise Puppet::Util::Windows::Error.new("Failed to #{operation}", hr)
  end
end

# File lib/puppet/provider/user/useradd.rb, line 52
def check_system_users
  if self.class.system_users? and resource.system?
    ["-r"]
  else
    []
  end
end

# File lib/puppet/provider/exec/posix.rb, line 15
def checkexe(command)
  exe = extractexe(command)

  if File.expand_path(exe) == exe
    if !File.exists?(exe)
      raise ArgumentError, "Could not find command '#{exe}'"
    elsif !File.file?(exe)
      raise ArgumentError, "'#{exe}' is a #{File.ftype(exe)}, not a file"
    elsif !File.executable?(exe)
      raise ArgumentError, "'#{exe}' is not executable"
    end
    return
  end

  if resource[:path]
    Puppet::Util.withenv :PATH => resource[:path].join(File::PATH_SEPARATOR) do
      return if which(exe)
    end
  end

  # 'which' will only return the command if it's executable, so we can't
  # distinguish not found from not executable
  raise ArgumentError, "Could not find command '#{exe}'"
end

# File lib/puppet/provider/package/apt.rb, line 25
def checkforcdrom
  have_cdrom = begin
                 !!(File.read("/etc/apt/sources.list") =~ /^[^#]*cdrom:/)
               rescue
                 # This is basically pathological...
                 false
               end

  if have_cdrom and @resource[:allowcdrom] != :true
    raise Puppet::Error,
      "/etc/apt/sources.list contains a cdrom source; not installing.  Use 'allowcdrom' to override this failure."
  end
end

# File lib/puppet/util/metaid.rb, line 17
def class_def(name, &blk)
  class_eval { define_method name, &blk }
end

# File lib/puppet/face/node/clean.rb, line 80
def clean_cached_facts(node)
  Puppet::Node::Facts.indirection.destroy(node)
  Puppet.info "#{node}'s facts removed"
end

# File lib/puppet/face/node/clean.rb, line 86
def clean_cached_node(node)
  Puppet::Node.indirection.destroy(node)
  Puppet.info "#{node}'s cached node removed"
end

# File lib/puppet/face/node/clean.rb, line 69
def clean_cert(node)
  if Puppet::SSL::CertificateAuthority.ca?
    Puppet::Face[:ca, :current].revoke(node)
    Puppet::Face[:ca, :current].destroy(node)
    Puppet.info "#{node} certificates removed from ca"
  else
    Puppet.info "Not managing #{node} certs as this host is not a CA"
  end
end

# File lib/puppet/face/node/clean.rb, line 92
def clean_reports(node)
  Puppet::Transaction::Report.indirection.destroy(node)
  Puppet.info "#{node}'s reports removed"
end

# File lib/puppet/face/node/clean.rb, line 98
def clean_storeconfigs(node, do_unexport=false)
  return unless Puppet[:storeconfigs] && Puppet.features.rails?
  require 'puppet/rails'
  Puppet::Rails.connect
  unless rails_node = Puppet::Rails::Host.find_by_name(node)
    Puppet.notice "No entries found for #{node} in storedconfigs."
    return
  end

  if do_unexport
    unexport(rails_node)
    Puppet.notice "Force #{node}'s exported resources to absent"
    Puppet.warning "Please wait until all other hosts have checked out their configuration before finishing the cleanup with:"
    Puppet.warning "$ puppet node clean #{node}"
  else
    rails_node.destroy
    Puppet.notice "#{node} storeconfigs removed"
  end
end

# File lib/puppet/face/node/clean.rb, line 60
def cleanup(node, unexport)
  clean_cert(node)
  clean_cached_facts(node)
  clean_cached_node(node)
  clean_reports(node)
  clean_storeconfigs(node, unexport)
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 43
def clear_task
  @task       = nil
  @triggers   = nil
end

# File lib/puppet/util/log/destinations.rb, line 6
def close
  Syslog.close
end

# File lib/puppet/provider/augeas/augeas.rb, line 194
def close_augeas
  if @aug
    @aug.close
    debug("Closed the augeas connection")
    @aug = nil
  end
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 52
def command
  task.application_name
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 147
def command=(value)
  task.application_name = value
end

# File lib/puppet/provider/user/windows_adsi.rb, line 57
def comment
  user['Description']
end

# File lib/puppet/provider/user/windows_adsi.rb, line 61
def comment=(value)
  user['Description'] = value
end

# File lib/puppet/provider/service/upstart.rb, line 293
def comment_start_block_in(text)
  parens = 0
  text.lines.map do |line|
    if line.match(START_ON) || parens > 0
      # If there are more opening parens than closing parens, we need to comment out a multiline 'start on' stanza
      parens += unbalanced_parens_on(remove_trailing_comments_from(line))
      "#" + line
    else
      line
    end
  end.join('')
end

# File lib/puppet/provider/zone/solaris.rb, line 317
def config_status
  config = getconfig
  result = {}

  result[:autoboot] = config[:autoboot] ? config[:autoboot].intern : :true
  result[:pool] = config[:pool]
  result[:shares] = config[:shares]
  if dir = config["inherit-pkg-dir"]
    result[:inherit] = dir.collect { |dirs| dirs[:dir] }
  end
  if datasets = config["dataset"]
    result[:dataset] = datasets.collect { |dataset| dataset[:name] }
  end
  result[:iptype] = config[:'ip-type'] if config[:'ip-type']
  if net = config["net"]
    result[:ip] = net.collect do |params|
      if params[:defrouter]
        "#{params[:physical]}:#{params[:address]}:#{params[:defrouter]}"
      elsif params[:address]
        "#{params[:physical]}:#{params[:address]}"
      else
        params[:physical]
      end
    end
  end

  result
end

# File lib/puppet/provider/zone/solaris.rb, line 112
def configure
  self.fail "Path is required" unless @resource[:path]
  arr = ["create -b #{@resource[:create_args]}"]

  # Then perform all of our configuration steps.  It's annoying
  # that we need this much internal info on the resource.
  self.resource.properties.each do |property|
    next unless my_properties.include? property.name
    method = (property.name.to_s + '_conf').intern
    arr << self.send(method ,@resource[property.name]) unless property.safe_insync?(properties[property.name])
  end
  setconfig(arr.join("\n"))
end

# File lib/puppet/provider/mcx/mcxcontent.rb, line 91
def content
  ds_parms = get_dsparams

  self.class.mcxexport(ds_parms[:ds_type], ds_parms[:ds_name])
end

# File lib/puppet/provider/mcx/mcxcontent.rb, line 97
def content=(value)
  # dscl localhost -mcximport
  ds_parms = get_dsparams

  mcximport(ds_parms[:ds_type], ds_parms[:ds_name], resource[:content])
end

# File lib/puppet/type/tidy.rb, line 112
def convert(unit, multi)
  if num = AgeConvertors[unit]
    return num * multi
  else
    self.fail "Invalid age unit '#{unit}'"
  end
end

# File lib/puppet/provider/macauthorization/macauthorization.rb, line 214
def convert_plist_to_native_attributes(propertylist)
  # This mainly converts the keys from the puppet attributes to the
  # 'native' ones, but also enforces that the keys are all Strings
  # rather than Symbols so that any merges of the resultant Hash are
  # sane. The exception is booleans, where we coerce to a proper bool
  # if they come in as a symbol.
  newplist = {}
  propertylist.each_pair do |key, value|
    next if key == :ensure     # not part of the auth db schema.
    next if key == :auth_type  # not part of the auth db schema.
    case value
    when true, :true
      value = true
    when false, :false
      value = false
    end
    new_key = key
    if PuppetToNativeAttributeMap.has_key?(key)
      new_key = PuppetToNativeAttributeMap[key].to_s
    elsif not key.is_a?(String)
      new_key = key.to_s
    end
    newplist[new_key] = value
  end
  newplist
end

# File lib/puppet/provider/group/windows_adsi.rb, line 23
def create
  @group = Puppet::Util::ADSI::Group.create(@resource[:name])
  @group.commit

  self.members = @resource[:members]
end

# File lib/puppet/provider/user/directoryservice.rb, line 494
def create_new_user(username)
  dscl '.', '-create',  "/Users/#{username}"
end

# File lib/puppet/provider/user/user_role_add.rb, line 97
def create_role
  if exists? and !is_role?
    run(transition("role"), "transition user to")
  else
    run(addcmd, "create role")
  end
end

# File lib/puppet/provider/zpool/zpool.rb, line 59
def current_pool
  @current_pool = process_zpool_data(get_pool_data) unless (defined?(@current_pool) and @current_pool)
  @current_pool
end

# File lib/puppet/provider/service/daemontools.rb, line 111
def daemon
  File.join(resource[:path], resource[:name])
end

# File lib/puppet/util/monkey_patches.rb, line 80
def daemonize
  raise NotImplementedError, "Kernel.daemonize is too dangerous, please don't try to use it."
end

# File lib/puppet/util/instrumentation/listeners/log.rb, line 24
def data
  @last_logs.synchronize {
    @last_logs.dup
  }
end

# File lib/puppet/network/formats.rb, line 123
def data_to_instance(klass, data)
  if data.is_a?(Hash) and d = data['data']
    data = d
  end
  return data if data.is_a?(klass)
  klass.from_pson(data)
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 514
def day_of_week_constant_to_name(constant)
  case constant
  when Win32::TaskScheduler::SUNDAY;    'sun'
  when Win32::TaskScheduler::MONDAY;    'mon'
  when Win32::TaskScheduler::TUESDAY;   'tues'
  when Win32::TaskScheduler::WEDNESDAY; 'wed'
  when Win32::TaskScheduler::THURSDAY;  'thurs'
  when Win32::TaskScheduler::FRIDAY;    'fri'
  when Win32::TaskScheduler::SATURDAY;  'sat'
  end
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 526
def day_of_week_name_to_constant(name)
  case name
  when 'sun';   Win32::TaskScheduler::SUNDAY
  when 'mon';   Win32::TaskScheduler::MONDAY
  when 'tues';  Win32::TaskScheduler::TUESDAY
  when 'wed';   Win32::TaskScheduler::WEDNESDAY
  when 'thurs'; Win32::TaskScheduler::THURSDAY
  when 'fri';   Win32::TaskScheduler::FRIDAY
  when 'sat';   Win32::TaskScheduler::SATURDAY
  end
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 435
def days_from_bitfield(bitfield)
  days = []

  i = 0
  while bitfield > 0
    if bitfield & 1 > 0
      # Day 32 has the special meaning of "the last day of the
      # month", no matter how many days there are in the month.
      days << (i == 31 ? 'last' : i + 1)
    end

    bitfield = bitfield >> 1
    i += 1
  end

  days
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 453
def days_of_week_from_bitfield(bitfield)
  days_of_week = []

  scheduler_days_of_week.each do |day_of_week|
    if bitfield & day_of_week != 0
      days_of_week << day_of_week_constant_to_name(day_of_week)
    end
  end

  days_of_week
end

# File lib/puppet/network/formats.rb, line 73
def decode(yaml)
  requiring_zlib do
    YAML.safely_load(Zlib::Inflate.inflate(Base64.decode64(yaml)))
  end
end

# File lib/puppet/type/file.rb, line 351
def default_bucket
  Puppet::Type.type(:filebucket).mkdefaultbucket.bucket
end

# File lib/puppet/provider/group/windows_adsi.rb, line 34
def delete
  Puppet::Util::ADSI::Group.delete(@resource[:name])
end

# File lib/puppet/provider/group/aix.rb, line 89
def deletecmd
  [self.class.command(:delete)] +
    self.get_ia_module_args +
    [@resource[:name]]
end

# File lib/puppet/type/tidy.rb, line 205
def depthfirst?
  true
end

# File lib/puppet/provider/macauthorization/macauthorization.rb, line 99
def destroy
  # We explicitly delete here rather than in the flush method.
  case resource[:auth_type]
  when :right
    destroy_right
  when :rule
    destroy_rule
  else
    raise Puppet::Error.new("Must specify auth_type when destroying.")
  end
end

# File lib/puppet/provider/macauthorization/macauthorization.rb, line 134
def destroy_right
  security "authorizationdb", :remove, resource[:name]
end

# File lib/puppet/provider/macauthorization/macauthorization.rb, line 138
def destroy_rule
  authdb = Plist::parse_xml(AuthDB)
  authdb_rules = authdb["rules"].dup
  if authdb_rules[resource[:name]]
    begin
      authdb["rules"].delete(resource[:name])
      Plist::Emit.save_plist(authdb, AuthDB)
    rescue Errno::EACCES => e
      raise Puppet::Error.new("Error saving #{AuthDB}: #{e}")
    end
  end
end

# File lib/puppet/provider/ssh_authorized_key/parsed.rb, line 35
def dir_perm
  0700
end

# File lib/puppet/provider/service/bsd.rb, line 21
def disable
  rcfile = File.join(rcconf_dir, @model[:name])
  File.delete(rcfile) if File.exists?(rcfile)
end

# File lib/puppet/provider/service/upstart.rb, line 261
def disable_post_0_9_0(over_text)
  write_script_to(overscript, ensure_disabled_with_manual(over_text))
end

# File lib/puppet/provider/service/upstart.rb, line 252
def disable_pre_0_6_7(script_text)
  disabled_script = comment_start_block_in(script_text)
  write_script_to(initscript, disabled_script)
end

# File lib/puppet/provider/service/upstart.rb, line 257
def disable_pre_0_9_0(script_text)
  write_script_to(initscript, ensure_disabled_with_manual(script_text))
end

# File lib/puppet/provider/augeas/augeas.rb, line 422
def do_execute_changes
  commands = parse_commands(resource[:changes])
  commands.each do |cmd_array|
    fail("invalid command #{cmd_array.join[" "]}") if cmd_array.length < 2
    command = cmd_array[0]
    cmd_array.shift
    begin
      case command
        when "set"
          debug("sending command '#{command}' with params #{cmd_array.inspect}")
          rv = aug.set(cmd_array[0], cmd_array[1])
          fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
        when "setm"
          if aug.respond_to?(command)
            debug("sending command '#{command}' with params #{cmd_array.inspect}")
            rv = aug.setm(cmd_array[0], cmd_array[1], cmd_array[2])
            fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
          else
            fail("command '#{command}' not supported in installed version of ruby-augeas")
          end
        when "rm", "remove"
          debug("sending command '#{command}' with params #{cmd_array.inspect}")
          rv = aug.rm(cmd_array[0])
          fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
        when "clear"
          debug("sending command '#{command}' with params #{cmd_array.inspect}")
          rv = aug.clear(cmd_array[0])
          fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
        when "clearm"
          # Check command exists ... doesn't currently in ruby-augeas 0.4.1
          if aug.respond_to?(command)
            debug("sending command '#{command}' with params #{cmd_array.inspect}")
            rv = aug.clearm(cmd_array[0], cmd_array[1])
            fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
          else
            fail("command '#{command}' not supported in installed version of ruby-augeas")
          end
        when "insert", "ins"
          label = cmd_array[0]
          where = cmd_array[1]
          path = cmd_array[2]
          case where
            when "before"; before = true
            when "after"; before = false
            else fail("Invalid value '#{where}' for where param")
          end
          debug("sending command '#{command}' with params #{[label, where, path].inspect}")
          rv = aug.insert(path, label, before)
          fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
        when "defvar"
          debug("sending command '#{command}' with params #{cmd_array.inspect}")
          rv = aug.defvar(cmd_array[0], cmd_array[1])
          fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
        when "defnode"
          debug("sending command '#{command}' with params #{cmd_array.inspect}")
          rv = aug.defnode(cmd_array[0], cmd_array[1], cmd_array[2])
          fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (!rv)
        when "mv", "move"
          debug("sending command '#{command}' with params #{cmd_array.inspect}")
          rv = aug.mv(cmd_array[0], cmd_array[1])
          fail("Error sending command '#{command}' with params #{cmd_array.inspect}") if (rv == -1)
        else fail("Command '#{command}' is not supported")
      end
    rescue SystemExit,NoMemoryError
      raise
    rescue Exception => e
      fail("Error sending command '#{command}' with params #{cmd_array.inspect}/#{e.message}")
    end
  end
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 262
def dummy_time_trigger
  now = Time.now

  {
    'flags'                   => 0,
    'random_minutes_interval' => 0,
    'end_day'                 => 0,
    "end_year"                => 0,
    "trigger_type"            => 0,
    "minutes_interval"        => 0,
    "end_month"               => 0,
    "minutes_duration"        => 0,
    'start_year'              => now.year,
    'start_month'             => now.month,
    'start_day'               => now.day,
    'start_hour'              => now.hour,
    'start_minute'            => now.min,
    'trigger_type'            => Win32::TaskScheduler::ONCE,
  }
end

# File lib/puppet/provider/service/bsd.rb, line 36
def enable
  Dir.mkdir(rcconf_dir) if not File.exists?(rcconf_dir)
  rcfile = File.join(rcconf_dir, @model[:name])
  open(rcfile, 'w') { |f| f << "%s_enable=\"YES\"\n" % @model[:name] }
end

# File lib/puppet/provider/service/upstart.rb, line 238
def enable_post_0_9_0(script_text, over_text)
  over_text = remove_manual_from(over_text)

  if enabled_post_0_9_0?(script_text, over_text) == :false
    if script_text.match(START_ON)
      over_text << extract_start_on_block_from(script_text)
    else
      over_text << "\nstart on runlevel [2,3,4,5]"
    end
  end

  write_script_to(overscript, over_text)
end

# File lib/puppet/provider/service/upstart.rb, line 220
def enable_pre_0_9_0(text)
  # We also need to remove any manual stanzas to ensure that it is enabled
  text = remove_manual_from(text)

  if enabled_pre_0_9_0?(text) == :false
    enabled_script =
      if text.match(COMMENTED_START_ON)
        uncomment_start_block_in(text)
      else
        add_default_start_to(text)
      end
  else
    enabled_script = text
  end

  write_script_to(initscript, enabled_script)
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 48
def enabled
  task.flags & Win32::TaskScheduler::DISABLED == 0 ? :true : :false
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 159
def enabled=(value)
  if value == :true
    task.flags = task.flags & ~Win32::TaskScheduler::DISABLED
  else
    task.flags = task.flags | Win32::TaskScheduler::DISABLED
  end
end

# File lib/puppet/provider/service/bsd.rb, line 27
def enabled?
  rcfile = File.join(rcconf_dir, @model[:name])
  return :true if File.exists?(rcfile)

  :false
end

# File lib/puppet/provider/service/upstart.rb, line 197
def enabled_post_0_9_0?(script_text, over_text)
  # This version has manual stanzas and override files
  # So we check to see if an uncommented start on or manual stanza is the last one in the
  # conf file and any override files. The last one in the file wins.
  enabled = :false

  script_text.each_line do |line|
    if line.match(START_ON)
      enabled = :true
    elsif line.match(MANUAL)
      enabled = :false
    end
  end
  over_text.each_line do |line|
    if line.match(START_ON)
      enabled = :true
    elsif line.match(MANUAL)
      enabled = :false
    end
  end if over_text
  enabled
end

# File lib/puppet/provider/service/upstart.rb, line 173
def enabled_pre_0_6_7?(script_text)
  # Upstart version < 0.6.7 means no manual stanza.
  if script_text.match(START_ON)
    return :true
  else
    return :false
  end
end

# File lib/puppet/provider/service/upstart.rb, line 182
def enabled_pre_0_9_0?(script_text)
  # Upstart version < 0.9.0 means no override files
  # So we check to see if an uncommented start on or manual stanza is the last one in the file
  # The last one in the file wins.
  enabled = :false
  script_text.each_line do |line|
    if line.match(START_ON)
      enabled = :true
    elsif line.match(MANUAL)
      enabled = :false
    end
  end
  enabled
end

# File lib/puppet/network/formats.rb, line 67
def encode(text)
  requiring_zlib do
    Base64.encode64(Zlib::Deflate.deflate(text, Zlib::BEST_COMPRESSION))
  end
end

# File lib/puppet/provider/service/upstart.rb, line 332
def ensure_disabled_with_manual(text)
  remove_manual_from(text) + "\nmanual"
end

# File lib/puppet/face/node/clean.rb, line 146
def environment
  @environment ||= Puppet::Node::Environment.new
end

# File lib/puppet/face/help.rb, line 116
def erb(name)
  template = (Pathname(__FILE__).dirname + "help" + name)
  erb = ERB.new(template.read, nil, '-')
  erb.filename = template.to_s
  return erb
end

# File lib/puppet/provider/service/freebsd.rb, line 16
def error(msg)
  raise Puppet::Error, msg
end

# File lib/puppet/type/file.rb, line 370
def eval_generate
  return [] unless self.recurse?

  recurse
  #recurse.reject do |resource|
  #    catalog.resource(:file, resource[:path])
  #end.each do |child|
  #    catalog.add_resource child
  #    catalog.relationship_graph.add_edge self, child
  #end
end

# File lib/puppet/face/help.rb, line 175
def exclude_from_docs?(appname)
  %w{face_base indirection_base}.include? appname
end

# File lib/puppet/provider/package/pkg.rb, line 186
def exec_cmd(*cmd)
  output = Puppet::Util::Execution.execute(cmd, :failonfail => false, :combine => true)
  {:out => output, :exit => $CHILD_STATUS.exitstatus}
end

# File lib/puppet/provider/selboolean/getsetsebool.rb, line 36
def execoutput (cmd)
  output = ''
  begin
    execpipe(cmd) do |out|
      output = out.readlines.join('').chomp!
    end
  rescue Puppet::ExecutionFailure
    raise Puppet::ExecutionFailure, output.split("\n")[0]
  end
  output
end

# File lib/puppet/provider/augeas/augeas.rb, line 400
def execute_changes
  # Workaround Augeas bug where changing the save mode doesn't trigger a
  # reload of the previously saved file(s) when we call Augeas#load
  @aug.match("/augeas/events/saved").each do |file|
    @aug.rm("/augeas#{@aug.get(file)}/mtime")
  end

  # Reload augeas, and execute the changes for real
  set_augeas_save_mode(SAVE_OVERWRITE) if versioncmp(get_augeas_version, "0.3.6") >= 0
  @aug.load
  do_execute_changes
      unless @aug.save
        print_put_errors
        fail("Save failed with return code #{success}, see debug")
      end

  :executed
ensure
  close_augeas
end

# File lib/puppet/type/file.rb, line 357
def exist?
  stat ? true : false
end

# File lib/puppet/provider/group/windows_adsi.rb, line 30
def exists?
  Puppet::Util::ADSI::Group.exists?(@resource[:name])
end

# File lib/puppet/provider/package/msi.rb, line 91
def exit_status
  $CHILD_STATUS.exitstatus
end

# File lib/puppet/provider/user/pw.rb, line 89
def expiry
  expiry = self.get(:expiry)
  expiry = :absent if expiry == 0

  if expiry != :absent
    t = Time.at(expiry)
    expiry = "%4d-%02d-%02d" % [t.year, t.month, t.mday]
  end

  expiry
end

# File lib/puppet/provider/user/aix.rb, line 201
def expiry_from_attr(value)
  if value =~ /(..)(..)(..)(..)(..)/
    #d= DateTime.parse("20#{$5}-#{$1}-#{$2} #{$3}:#{$4}")
    #expiry_date = d.strftime("%Y-%m-%d %H:%M")
    #expiry_date = d.strftime("%Y-%m-%d")
    expiry_date = "20#{$5}-#{$1}-#{$2}"
  else
    Puppet.warn("Could not convert AIX expires date '#{value}' on #{@resource.class.name}[#{@resource.name}]")          unless value == '0'
    expiry_date = :absent
  end
  expiry_date
end

# File lib/puppet/provider/user/aix.rb, line 190
def expiry_to_attr(value)
  # For chuser the expires parameter is a 10-character string in the MMDDhhmmyy format
  # that is,"%m%d%H%M%y"
  newdate = '0'
  if value.is_a? String and value!="0000-00-00"
    d = DateTime.parse(value, "%Y-%m-%d %H:%M")
    newdate = d.strftime("%m%d%H%M%y")
  end
  newdate
end

# File lib/puppet/provider/service/upstart.rb, line 318
def extract_start_on_block_from(text)
  parens = 0
  text.lines.map do |line|
    if line.match(START_ON) || parens > 0
      parens += unbalanced_parens_on(remove_trailing_comments_from(line))
      line
    end
  end.join('')
end

# File lib/puppet/type/file.rb, line 755
def fail_if_checksum_is_wrong(path, content_checksum)
  newsum = parameter(:checksum).sum_file(path)
  return if [:absent, nil, content_checksum].include?(newsum)

  self.fail "File written to disk did not match checksum; discarding changes (#{content_checksum} vs #{newsum})"
end

# File lib/puppet/provider/ssh_authorized_key/parsed.rb, line 39
def file_perm
  0600
end

# File lib/puppet/provider/group/aix.rb, line 108
def filter_attributes(hash)
  # Return only not managed attributtes.
  hash.select {
      |k,v| !self.class.attribute_mapping_from.include?(k) and
              !self.class.attribute_ignore.include?(k)
    }.inject({}) {
      |hash, array| hash[array[0]] = array[1]; hash
    }
end

# File lib/puppet/type/file.rb, line 363
def finish
  # Look up our bucket, if there is one
  bucket
  super
end

# File lib/puppet/provider/package/fink.rb, line 18
def finkcmd(*args)
  fink(*args)
end

# File lib/puppet/provider/group/windows_adsi.rb, line 39
def flush
  @group.commit if @group
end

# File lib/puppet/provider/user/directoryservice.rb, line 539
def flush_dscl_cache
  dscacheutil '-flushcache'
end

# File lib/puppet/provider/macauthorization/macauthorization.rb, line 151
def flush_right
  # first we re-read the right just to make sure we're in sync for
  # values that weren't specified in the manifest. As we're supplying
  # the whole plist when specifying the right it seems safest to be
  # paranoid given the low cost of quering the db once more.
  cmds = []
  cmds << :security << "authorizationdb" << "read" << resource[:name]
  output = execute(cmds, :failonfail => false, :combine => false)
  current_values = Plist::parse_xml(output)
  current_values ||= {}
  specified_values = convert_plist_to_native_attributes(@property_hash)

  # take the current values, merge the specified values to obtain a
  # complete description of the new values.
  new_values = current_values.merge(specified_values)
  set_right(resource[:name], new_values)
end

# File lib/puppet/provider/macauthorization/macauthorization.rb, line 169
def flush_rule
  authdb = Plist::parse_xml(AuthDB)
  authdb_rules = authdb["rules"].dup
  current_values = {}
  current_values = authdb_rules[resource[:name]] if authdb_rules[resource[:name]]
  specified_values = convert_plist_to_native_attributes(@property_hash)
  new_values = current_values.merge(specified_values)
  set_rule(resource[:name], new_values)
end

# File lib/puppet/type/resources.rb, line 86
def generate
  return [] unless self.purge?
  resource_type.instances.
    reject { |r| catalog.resource_refs.include? r.ref }.
    select { |r| check(r) }.
    select { |r| r.class.validproperty?(:ensure) }.
    select { |r| able_to_ensure_absent?(r) }.
    each { |resource|
      @parameters.each do |name, param|
        resource[name] = param.value if param.metaparam?
      end

      # Mark that we're purging, so transactions can handle relationships
      # correctly
      resource.purging
    }
end