class Object

# 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 100
def able_to_ensure_absent?(resource)
    resource[:ensure] = :absent
rescue ArgumentError, Puppet::Error
    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 129
def add_cmd(cmd)
  @cmds = [] if @cmds.nil?
  @cmds << cmd
end

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

# File lib/puppet/provider/zfs/zfs.rb, line 13
def add_properties
  properties = []
  Puppet::Type.type(:zfs).validproperties.each do |property|
    next if property == :ensure
    if value = @resource[property] and value != ""
      properties << "-o" << "#{property}=#{value}"
    end
  end
  properties
end

# File lib/puppet/vendor/semantic/spec/unit/semantic/dependency_spec.rb, line 147
def add_source_modules(name, versions, deps = {})
  versions = Array(versions)
  releases = versions.map { |ver| create_release(source, name, ver, deps) }
  source.stub(:fetch).with(name).and_return(modules[name].concat(releases))
end

# File lib/puppet/provider/group/groupadd.rb, line 67
def addcmd
  if @resource.forcelocal?
    cmd = [command(:localadd)]
    @custom_environment = Puppet::Util::Libuser.getenv
  else
    cmd = [command(:add)]
  end

  if gid = @resource.should(:gid)
    unless gid == :absent
      cmd << flag(:gid) << gid
    end
  end
  cmd += check_allow_dup
  cmd << "-r" if @resource.system? and self.class.system_groups?
  cmd << @resource[:name]
  cmd
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 136
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
        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 282
def alpha
  %w{sunday monday tuesday wednesday thursday friday saturday}
end

# File lib/puppet/type/file.rb, line 463
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 52
def arguments
  task.parameters
end

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

# File lib/puppet/provider/user/directoryservice.rb, line 482
def assert_full_pbkdf2_password
  missing = [:password, :salt, :iterations].select { |parameter| @resource[parameter].nil? }

  if !missing.empty?
     raise Puppet::Error, "OS X versions > 10\.7 use PBKDF2 password hashes, which requires all three of salt, iterations, and password hash. This resource is missing: #{missing.join(', ')}."
  end
end

# File lib/puppet/functions/assert_type.rb, line 33
def assert_type(type, value)
  unless Puppet::Pops::Types::TypeCalculator.instance?(type,value)
    inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value)
    if block_given?
      # Give the inferred type to allow richer comparisson in the given block (if generalized
      # information is lost).
      #
      value = yield(type, inferred_type)
    else
      # Do not give all the details - i.e. format as Integer, instead of Integer[n, n] for exact value, which
      # is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output.
      #
      actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
      raise Puppet::ParseError, "assert_type(): Expected type #{type} does not match actual: #{actual}"
    end
  end
  value
end

# File lib/puppet/functions/assert_type.rb, line 55
def assert_type_s(type_string, value, &proc)
  t = Puppet::Pops::Types::TypeParser.new.parse(type_string)
  block_given? ? assert_type(t, value, &proc) : assert_type(t, value)
end

# File lib/puppet/functions/each.rb, line 104
def asserted_enumerable(obj)
  unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
    raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
  end
  enum
end

# File lib/puppet/functions/slice.rb, line 102
def asserted_slice_serving_size(pblock, slice_size)
  if pblock
    arity = pblock.arity
    serving_size = arity < 0 ? slice_size : arity
  else
    serving_size = 1
  end
  if serving_size == 0
    raise ArgumentError, "slice(): block must define at least one parameter. Block has 0."
  end
  unless serving_size == 1 || serving_size == slice_size
    raise ArgumentError, "slice(): block must define one parameter, or " +
      "the same number of parameters as the given size of the slice (#{slice_size}). Block has #{serving_size}; "+
    pblock.parameter_names.join(', ')
  end
  serving_size
end

# File lib/puppet/type/file.rb, line 397
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(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}", detail.backtrace
    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 110
def auths
  user_attributes[:auths] if user_attributes
end

# File lib/puppet/type/file.rb, line 873
def backup_existing
  unless perform_backup
    raise Puppet::Error, "Could not back up; will not replace"
  end
end

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

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 411
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 430
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 397
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 412
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 138
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 88
def build_vdevs
  if disk = @resource[:disk]
    disk.collect { |d| d.split(' ') }.flatten
  elsif mirror = @resource[:mirror]
    handle_multi_arrays("mirror", mirror)
  elsif raidz = @resource[:raidz]
    handle_multi_arrays(raidzarity, raidz)
  end
end

# File lib/puppet/type/file.rb, line 832
def can_backup?(type)
  if type == "directory" and not force?
    # (#18110) Directories cannot be removed without :force, so it doesn't
    # make sense to back them up.
    false
  else
    true
  end
end

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

# File lib/puppet/type/resources.rb, line 90
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/group/groupadd.rb, line 52
def check_allow_dup
  # We have to manually check for duplicates when using libuser
  # because by default duplicates are allowed.  This check is
  # to ensure consistent behaviour of the useradd provider when
  # using both useradd and luseradd
  if not @resource.allowdupe? and @resource.forcelocal?
     if @resource.should(:gid) and findgroup('gid', @resource.should(:gid).to_s)
         raise(Puppet::Error, "GID #{@resource.should(:gid).to_s} already exists, use allowdupe to force group creation")
     end
  elsif @resource.allowdupe? and not @resource.forcelocal?
     return ["-o"]
  end
  []
end

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

  cmd
end

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

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

  case hr
  when self.class::ERROR_SUCCESS
    # yeah
  when self.class::ERROR_SUCCESS_REBOOT_INITIATED
    warning("The package #{operation}ed successfully and the system is rebooting now.")
  when self.class::ERROR_SUCCESS_REBOOT_REQUIRED
    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 145
def check_system_users
  if self.class.system_users? and resource.system?
    ["-r"]
  else
    []
  end
end

# File lib/puppet/provider/user/useradd.rb, line 117
def check_valid_shell
  unless File.exists?(@resource.should(:shell))
    raise(Puppet::Error, "Shell #{@resource.should(:shell)} must exist")
  end
  unless File.executable?(@resource.should(:shell).to_s)
    raise(Puppet::Error, "Shell #{@resource.should(:shell)} must be executable")
  end
end

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

  if absolute_path?(exe)
    if !Puppet::FileSystem.exist?(exe)
      raise ArgumentError, "Could not find command '#{exe}'"
    elsif !File.file?(exe)
      raise ArgumentError, "'#{exe}' is a #{File.ftype(exe)}, not a file"
    end
    return
  end

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

  raise ArgumentError, "Could not find command '#{exe}'"
end

# File lib/puppet/provider/package/apt.rb, line 29
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 39
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 193
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 48
def command
  task.application_name
end

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

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

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

# File lib/puppet/provider/service/upstart.rb, line 305
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 316
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 111
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 114
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/zfs/zfs.rb, line 24
def create
  zfs *([:create] + add_properties + [@resource[:name]])
end

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

# File lib/puppet/vendor/semantic/spec/unit/semantic/dependency_spec.rb, line 5
def create_release(source, name, version, deps = {})
  Semantic::Dependency::ModuleRelease.new(
    source,
    name,
    Semantic::Version.parse(version),
    Hash[deps.map { |k, v| [k, Semantic::VersionRange.parse(v) ] }]
  )
end

# File lib/puppet/provider/user/user_role_add.rb, line 98
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/yumrepo/inifile.rb, line 300
def current_section
  self.class.section(self.name)
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 64
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 20
def data
  @last_logs.dup
end

# File lib/puppet/network/formats.rb, line 41
def data_to_instance(klass, data)
  return data if data.is_a?(klass)

  unless data.is_a? Hash
    raise Puppet::Network::FormatHandler::FormatError, "Serialized YAML did not contain a valid instance of #{klass}"
  end

  klass.from_data_hash(data)
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 532
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 544
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 453
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 471
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 107
def decode(data)
  Zlib::Inflate.inflate(Base64.decode64(data))
end

# File lib/puppet/provider/service/src.rb, line 49
def default_action
  "once"
end

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

# File lib/puppet/provider/service/openbsd.rb, line 256
def default_disabled?
  line = File.readlines(self.class.rcconf).find {|l| l =~ /#{rcvar_name}/ }
  self.class.parse_rc_line(line) == 'NO'
end

# File lib/puppet/provider/service/src.rb, line 45
def default_runlevel
  "2"
end

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

  @deleted = true
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/yumrepo/inifile.rb, line 266
def descr
  if ! @property_hash.has_key?(:descr)
    @property_hash[:descr] = current_section['name']
  end
  value = @property_hash[:descr]
  value.nil? ? :absent : value
end

# File lib/puppet/provider/yumrepo/inifile.rb, line 274
def descr=(value)
  value = (value == :absent ? nil : value)
  current_section['name'] = value
  @property_hash[:descr] = value
end

# File lib/puppet/provider/zfs/zfs.rb, line 28
def destroy
  zfs(:destroy, @resource[:name])
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}", e)
    end
  end
end

# File lib/puppet/provider/package/nim.rb, line 258
def determine_latest_version(showres_output, package_name)
  packages = parse_showres_output(showres_output)
  unless packages.has_key?(package_name)
    return nil
  end
  if (packages[package_name].count == 1)
    version = packages[package_name].keys[0]
    return packages[package_name][version], nil
  else
    versions = packages[package_name].keys
    latest_version = (versions.sort { |a, b| Puppet::Util::Package.versioncmp(b, a) })[0]
    return packages[package_name][latest_version], latest_version
  end
end

# File lib/puppet/provider/package/nim.rb, line 273
def determine_package_type(showres_output, package_name, version)
  packages = parse_showres_output(showres_output)
  unless (packages.has_key?(package_name) and packages[package_name].has_key?(version))
    return nil
  end
  packages[package_name][version]
end

# File lib/puppet/type/file/checksum.rb, line 40
def digest_algorithm
  value || Puppet[:digest_algorithm].to_sym
end

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

# File lib/puppet/provider/service/systemd.rb, line 24
def disable
  output = systemctl(:disable, @resource[:name])
rescue Puppet::ExecutionFailure
  raise Puppet::Error, "Could not disable #{self.name}: #{output}", $!.backtrace
end

# File lib/puppet/provider/service/upstart.rb, line 273
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 264
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 269
def disable_pre_0_9_0(script_text)
  write_script_to(initscript, ensure_disabled_with_manual(script_text))
end

# File lib/puppet/provider/package/yum.rb, line 178
def disablerepo
  scan_options(resource[:install_options], '--disablerepo')
end

# File lib/puppet/provider/augeas/augeas.rb, line 439
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/functions/match.rb, line 97
def do_match(s, regexp)
  if result = regexp.match(s)
    result.to_a
  end
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 257
def dummy_time_trigger
  now = Time.now
  {
    'flags'                   => 0,
    'random_minutes_interval' => 0,
    'end_day'                 => 0,
    'end_year'                => 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/face/parser.rb, line 124
def dump_parse(source, filename, options, show_filename = true)
  output = ""
  dumper = Puppet::Pops::Model::ModelTreeDumper.new
  evaluating_parser = Puppet::Pops::Parser::EvaluatingParser.new
  begin
    if options[:validate]
      parse_result = evaluating_parser.parse_string(source, filename)
    else
      # side step the assert_and_report step
      parse_result = evaluating_parser.parser.parse_string(source)
    end
    if show_filename
      output << "--- #{filename}"
    end
    output << dumper.dump(parse_result) << "\n"
  rescue Puppet::ParseError => detail
    if show_filename
      Puppet.err("--- #{filename}")
    end
    Puppet.err(detail.message)
    ""
  end
end

# File lib/puppet/provider/service/systemd.rb, line 49
def enable
  output = systemctl("enable", @resource[:name])
rescue Puppet::ExecutionFailure
  raise Puppet::Error, "Could not enable #{self.name}: #{output}", $!.backtrace
end

# File lib/puppet/provider/service/upstart.rb, line 250
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 232
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 44
def enabled
  task.flags & Win32::TaskScheduler::DISABLED == 0 ? :true : :false
end

# File lib/puppet/provider/scheduled_task/win32_taskscheduler.rb, line 155
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/systemd.rb, line 30
def enabled?
  begin
    systemctl("is-enabled", @resource[:name])
  rescue Puppet::ExecutionFailure
    return :false
  end

  :true
end

# File lib/puppet/provider/service/upstart.rb, line 209
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 185
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 194
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/provider/package/yum.rb, line 174
def enablerepo
  scan_options(resource[:install_options], '--enablerepo')
end

# File lib/puppet/network/formats.rb, line 111
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 344
def ensure_disabled_with_manual(text)
  remove_manual_from(text) + "\nmanual"
end

# File lib/puppet/functions/match.rb, line 56
def enumerable_match(array, pattern)
  array.map {|s| match(s, pattern) }
end

# File lib/puppet/face/node/clean.rb, line 146
def environment
  @environment ||= Puppet.lookup(:current_environment)
end

# File lib/puppet/functions/epp.rb, line 50
def epp(scope, path, parameters = nil)
  Puppet::Pops::Evaluator::EppEvaluator.epp(scope, path, scope.compiler.environment, parameters)
end

# File lib/puppet/face/help.rb, line 117
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 457
def eval_generate
  return [] unless self.recurse?

  recurse
end

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

# File lib/puppet/provider/package/pkg.rb, line 197
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], $!.backtrace
  end
  output
end

# File lib/puppet/provider/augeas/augeas.rb, line 417
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, see debug")
  end

  :executed
ensure
  close_augeas
end

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

# File lib/puppet/provider/service/launchd.rb, line 227
def exists?
  Puppet.debug("Puppet::Provider::Launchd:Ensure for #{@property_hash[:name]}: #{@property_hash[:ensure]}")
  @property_hash[:ensure] != :absent
end

# File lib/puppet/provider/user/pw.rb, line 86
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 203
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 192
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 330
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/provider/service/freebsd.rb, line 31
def extract_value_name(name, rc_index, regex, regex_index)
  value_name = self.rcvar[rc_index]
  self.error("No #{name} name found in rcvar") if value_name.nil?
  value_name = value_name.gsub!(regex, regex_index)
  self.error("#{name} name is empty") if value_name.nil?
  self.debug("#{name} name is #{value_name}")
  value_name
end

# File lib/puppet/type/file.rb, line 885
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/file/windows.rb, line 91
def file
  @file ||= Puppet::FileSystem.pathname(resource[:path])
end

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

# File lib/puppet/functions/filter.rb, line 73
def filter_Enumerable_1(enumerable)
  result = []
  index = 0
  enum = asserted_enumerable(enumerable)
  begin
    loop do
      it = enum.next
      if yield(it) == true
        result << it
      end
    end
  rescue StopIteration
  end
  result
end

# File lib/puppet/functions/filter.rb, line 89
def filter_Enumerable_2(enumerable)
  result = []
  index = 0
  enum = asserted_enumerable(enumerable)
  begin
    loop do
      it = enum.next
      if yield(index, it) == true
        result << it
      end
      index += 1
    end
  rescue StopIteration
  end
  result
end

# File lib/puppet/functions/filter.rb, line 59
def filter_Hash_1(hash)
  result = hash.select {|x, y| yield([x, y]) == true }
  # Ruby 1.8.7 returns Array
  result = Hash[result] unless result.is_a? Hash
  result
end

# File lib/puppet/functions/filter.rb, line 66
def filter_Hash_2(hash)
  result = hash.select {|x, y| yield(x, y) == true }
  # Ruby 1.8.7 returns Array
  result = Hash[result] unless result.is_a? Hash
  result
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/provider/group/groupadd.rb, line 30
def findgroup(key, value)
  group_file = "/etc/group"
  group_keys = ['group_name', 'password', 'gid', 'user_list']
  index = group_keys.index(key)
  File.open(group_file) do |f|
    f.each_line do |line|
       group = line.split(":")
       if group[index] == value
           f.close
           return group
       end
    end
  end
  false
end

# File lib/puppet/provider/user/useradd.rb, line 57
def finduser(key, value)
  passwd_file = "/etc/passwd"
  passwd_keys = ['account', 'password', 'uid', 'gid', 'gecos', 'directory', 'shell']
  index = passwd_keys.index(key)
  File.open(passwd_file) do |f|
    f.each_line do |line|
       user = line.split(":")
       if user[index] == value
           f.close
           return user
       end
    end
  end
  false
end

# File lib/puppet/type/file.rb, line 450
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/service/openbsd.rb, line 286
def flags
  @property_hash[:flags]
end

# File lib/puppet/provider/service/openbsd.rb, line 290
def flags=(value)
  @property_hash[:flags] = value
end

# File lib/puppet/provider/service/openbsd.rb, line 294
def flush
  debug "Flusing resource for #{self.name}"

  # Here we load the contents of the rc.conf.local file into the contents
  # variable, modify it if needed, and then compare that to the original.  If
  # they are different, we write it out.

  original = load_rcconf_local_array()
  content = original

  debug @property_hash.inspect

  if resource[:enable] == :true
    #set_flags(resource[:flags])
    content = set_content_flags(content, resource[:flags])

    # We need only add append the resource name to the pkg_scripts if the
    # package is not found in the base system.

    if not in_base?
      content = set_content_scripts(content,pkg_scripts_append())
    end
  elsif resource[:enable] == :false

    # By virtue of being excluded from the base system, all packages are
    # disabled by default and need not be set in the rc.conf.local at all.

    if not in_base?
      content = remove_content_flags(content)
      content = set_content_scripts(content,pkg_scripts_remove())
    else
      if default_disabled?
        content = remove_content_flags(content)
      else
        content = set_content_flags(content, "NO")
      end
    end
  end

  # Make sure to append a newline to the end of the file
  unless content[-1] == ""
    content << ""
  end
  output = content.join("\n")

  # Write the contents only if necessary, and only once
  write_rc_contents(self.class.rcconf_local(), output)
end

# File lib/puppet/provider/user/directoryservice.rb, line 553
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/vendor/semantic/spec/unit/semantic/dependency_spec.rb, line 168
def foo(range)
  subject('foo' => range).map { |x| x.last }
end

# File lib/puppet/functions/each.rb, line 80
def foreach_Enumerable_1(enumerable)
  enum = asserted_enumerable(enumerable)
    begin
      loop { yield(enum.next) }
    rescue StopIteration
    end
  # produces the receiver
  enumerable
end

# File lib/puppet/functions/each.rb, line 90
def foreach_Enumerable_2(enumerable)
  enum = asserted_enumerable(enumerable)
  index = 0
  begin
    loop do
      yield(index, enum.next)
      index += 1
    end
  rescue StopIteration
  end
  # produces the receiver
  enumerable
end

# File lib/puppet/functions/each.rb, line 62
def foreach_Hash_1(hash)
  enumerator = hash.each_pair
  hash.size.times do
    yield(enumerator.next)
  end
  # produces the receiver
  hash
end

# File lib/puppet/functions/each.rb, line 71
def foreach_Hash_2(hash)
  enumerator = hash.each_pair
  hash.size.times do
    yield(*enumerator.next)
  end
  # produces the receiver
  hash
end

# File lib/puppet/util/log/destinations.rb, line 122
def format(msg)
  # logstash_event format is documented at
  # https://logstash.jira.com/browse/LOGSTASH-675

  data = {}
  data = msg.to_hash
  data['version'] = 1
  data['@timestamp'] = data['time']
  data.delete('time')

  data
end

# File lib/puppet/type/tidy.rb, line 236
def generate
  return [] unless stat(self[:path])

  case self[:recurse]
  when Integer, Fixnum, Bignum, /^\d+$/
    parameter = { :recurse => true, :recurselimit => self[:recurse] }
  when true, :true, :inf
    parameter = { :recurse => true }
  end

  if parameter
    files = Puppet::FileServing::Fileset.new(self[:path], parameter).files.collect do |f|
      f == "." ? self[:path] : ::File.join(self[:path], f)
    end
  else
    files = [self[:path]]
  end
  result = files.find_all { |path| tidy?(path) }.collect { |path| mkfile(path) }.each { |file| notice "Tidying #{file.ref}" }.sort { |a,b| b[:path] <=> a[:path] }

  # No need to worry about relationships if we don't have rmdirs; there won't be
  # any directories.
  return result unless rmdirs?

  # Now make sure that all directories require the files they contain, if all are available,
  # so that a directory is emptied before we try to remove it.
  files_by_name = result.inject({}) { |hash, file| hash[file[:path]] = file; hash }

  files_by_name.keys.sort { |a,b| b <=> b }.each do |path|
    dir = ::File.dirname(path)
    next unless resource = files_by_name[dir]
    if resource[:require]
      resource[:require] << Puppet::Resource.new(:file, path)
    else
      resource[:require] = [Puppet::Resource.new(:file, path)]
    end
  end

  result
end

# File lib/puppet/provider/group/aix.rb, line 98
def get_arguments(key, value, mapping, objectinfo)
  # In the case of attributes, return a list of key=vlaue
  if key == :attributes
    raise Puppet::Error, "Attributes must be a list of pairs key=value on #{@resource.class.name}[#{@resource.name}]"          unless value and value.is_a? Hash
    return value.select { |k,v| true }.map { |pair| pair.join("=") }
  end
  super(key, value, mapping, objectinfo)
end

# File lib/puppet/provider/augeas/augeas.rb, line 318
def get_augeas_version
  @aug.get("/augeas/version") || ""
end

# File lib/puppet/provider/mcx/mcxcontent.rb, line 158
def get_dsparams
  ds_type = resource[:ds_type]
  ds_type ||= parse_type(resource[:name])
  raise MCXContentProviderException unless TypeMap.keys.include? ds_type.to_sym

  ds_name = resource[:ds_name]
  ds_name ||= parse_name(resource[:name])

  {
    :ds_type => ds_type.to_sym,
    :ds_name => ds_name,
  }
end

# File lib/puppet/provider/group/aix.rb, line 51
def get_ia_module_args
  if @resource[:ia_load_module]
    ["-R", @resource[:ia_load_module].to_s]
  else
    []
  end
end

# File lib/puppet/provider/augeas/augeas.rb, line 301
def get_load_path(resource)
  load_path = []

  # Permits colon separated strings or arrays
  if resource[:load_path]
    load_path = [resource[:load_path]].flatten
    load_path.map! { |path| path.split(/:/) }
    load_path.flatten!
  end

  if Puppet::FileSystem.exist?("#{Puppet[:libdir]}/augeas/lenses")
    load_path << "#{Puppet[:libdir]}/augeas/lenses"
  end

  load_path.join(":")
end

# File lib/puppet/provider/zpool/zpool.rb, line 50
def get_pool_data
  # http://docs.oracle.com/cd/E19082-01/817-2271/gbcve/index.html
  # we could also use zpool iostat -v mypool for a (little bit) cleaner output
  out = execute("zpool status #{@resource[:pool]}", :failonfail => false, :combine => false)
  zpool_data = out.lines.select { |line| line.index("\t") == 0 }.collect { |l| l.strip.split("\s")[0] }
  zpool_data.shift
  zpool_data
end

# File lib/puppet/provider/yumrepo/inifile.rb, line 282
def get_property(property)
  if ! @property_hash.has_key?(property)
    @property_hash[property] = current_section[property.to_s]
  end
  value = @property_hash[property]
  value.nil? ? :absent : value
end

# File lib/puppet/provider/user/directoryservice.rb, line 565
def get_shadow_hash_data(users_plist)
  if users_plist['ShadowHashData']
    password_hash_plist  = users_plist['ShadowHashData'][0].string
    self.class.convert_binary_to_xml(password_hash_plist)
  else
    false
  end
end

# File lib/puppet/provider/service/debian.rb, line 57
def get_start_link_count
  Dir.glob("/etc/rc*.d/S??#{@resource[:name]}").length
end

# File lib/puppet/provider/user/directoryservice.rb, line 557
def get_users_plist(username)
  # This method will retrieve the data stored in a user's plist and
  # return it as a native Ruby hash.
  Plist::parse_xml(plutil('-convert', 'xml1', '-o', '/dev/stdout', "#{users_plist_dir}/#{username}.plist"))
end

# File lib/puppet/provider/package/openbsd.rb, line 179
def get_version
  execpipe([command(:pkginfo), "-I", @resource[:name]]) do |process|
    # our regex for matching pkg_info output
    regex = /^(.*)-(\d[^-]*)[-]?(\w*)(.*)$/
    master_version = 0
    version = -1

    process.each_line do |line|
      if match = regex.match(line.split[0])
        # now we return the first version, unless ensure is latest
        version = match.captures[1]
        return version unless @resource[:ensure] == "latest"

        master_version = version unless master_version > version
      end
    end

    return master_version unless master_version == 0
    return '' if version == -1
    raise Puppet::Error, "#{version} is not available for this package"
  end
rescue Puppet::ExecutionFailure
  return nil
end

# File lib/puppet/provider/zone/solaris.rb, line 215
def getconfig
  output = zonecfg :info

  name = nil
  current = nil
  hash = {}
  output.split("\n").each do |line|
    case line
    when /^(\S+):\s*$/
      name = $1
      current = nil # reset it
    when /^(\S+):\s*(\S+)$/
      hash[$1.intern] = $2
    when /^\s+(\S+):\s*(.+)$/
      if name
        hash[name] ||= []
        unless current
          current = {}
          hash[name] << current
        end
        current[$1.intern] = $2
      else
        err "Ignoring '#{line}'"
      end
    else
      debug "Ignoring zone output '#{line}'"
    end
  end

  hash
end

# File lib/puppet/provider/service/base.rb, line 16
def getpid
  @resource.fail "Either stop/status commands or a pattern must be specified" unless @resource[:pattern]
  ps = Facter["ps"].value
  @resource.fail "You must upgrade Facter to a version that includes 'ps'" unless ps and ps != ""
  regex = Regexp.new(@resource[:pattern])
  self.debug "Executing '#{ps}'"
  IO.popen(ps) { |table|
    table.each_line { |line|
      if regex.match(line)
        self.debug "Process matched: #{line}"
        ary = line.sub(/^\s+/, '').split(/\s+/)
        return ary[1]
      end
    }
  }

  nil
end

# File lib/puppet/provider/group/windows_adsi.rb, line 96
def gid
  Puppet::Util::Windows::SID.name_to_sid(@resource[:name])
end

# File lib/puppet/provider/group/windows_adsi.rb, line 100
def gid=(value)
  fail "gid is read-only"
end

# File lib/puppet/provider/user/aix.rb, line 186
def gid_from_attr(value)
  groupid_by_name(value)
end

# File lib/puppet/provider/user/aix.rb, line 181
def gid_to_attr(value)
  verify_group(value)
end

# File lib/puppet/provider/group/windows_adsi.rb, line 62
def group
  @group ||= Puppet::Util::Windows::ADSI::Group.new(@resource[:name])
end

# File lib/puppet/provider/user/ldap.rb, line 111
def group2id(group)
  Puppet::Type.type(:group).provider(:ldap).name2id(group)
end

# File lib/puppet/provider/file/windows.rb, line 55
def group=(should)
  begin
    set_group(should, resolved_path)
  rescue => detail
    raise Puppet::Error, "Failed to set group to '#{should}': #{detail}", detail.backtrace
  end
end

# File lib/puppet/provider/user/ldap.rb, line 117
def group_manager
  Puppet::Type.type(:group).provider(:ldap).manager
end

# File lib/puppet/provider/user/ldap.rb, line 121
def group_properties(values)
  if values.empty? or values == :absent
    {:ensure => :present}
  else
    {:ensure => :present, :members => values}
  end
end

# File lib/puppet/provider/user/aix.rb, line 163
def groupid_by_name(groupname)
  attrs = self.parse_attr_list(execute(lsgroupscmd(groupname)).split("\n")[0], nil)
  attrs ? attrs[:id].to_i : nil
end

# File lib/puppet/provider/user/aix.rb, line 151
def 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/user/ldap.rb, line 55
def groups
  # We want to cache the current result, so we know if we
  # have to remove old values.
  unless @property_hash[:groups]
    unless result = group_manager.search("memberUid=#{name}")
      return @property_hash[:groups] = :absent
    end

    return @property_hash[:groups] = result.collect { |r| r[:name] }.sort.join(",")
  end
  @property_hash[:groups]
end

# File lib/puppet/provider/user/directoryservice.rb, line 342
def groups=(value)
  guid = self.class.get_attribute_from_dscl('Users', @resource.name, 'GeneratedUID')['dsAttrTypeStandard:GeneratedUID'][0]
  groups_to_add = value.split(',') - groups.split(',')
  groups_to_add.each do |group|
    merge_attribute_with_dscl('Groups', group, 'GroupMembership', @resource.name)
    merge_attribute_with_dscl('Groups', group, 'GroupMembers', guid)
  end
end

# File lib/puppet/provider/user/useradd.rb, line 228
def groups?
  !!@resource[:groups]
end

# File lib/puppet/util/log/destinations.rb, line 27
def handle(msg)
  # XXX Syslog currently has a bug that makes it so you
  # cannot log a message with a '%' in it.  So, we get rid
  # of them.
  if msg.source == "Puppet"
    msg.to_s.split("\n").each do |line|
      @syslog.send(msg.level, line.gsub("%", '%%'))
    end
  else
    msg.to_s.split("\n").each do |line|
      @syslog.send(msg.level, "(%s) %s" % [msg.source.to_s.gsub("%", ""),
          line.gsub("%", '%%')
        ]
      )
    end
  end
end

# File lib/puppet/provider/zpool/zpool.rb, line 83
def handle_multi_arrays(prefix, array)
  array.collect{ |a| [prefix] +  a.split(' ') }.flatten
end

# File lib/puppet/provider/service/launchd.rb, line 198
def has_macosx_plist_overrides?
  # (#11593) Remove support for OS X 10.4 & earlier
  # leaving this as is because 10.5 still didn't have plist support
  return self.class.get_os_version > 9
end

# File lib/puppet/provider/mcx/mcxcontent.rb, line 106
def has_mcx?
  !content.empty?
end

# File lib/puppet/provider/service/init.rb, line 91
def hasstatus=(value)
  case value
  when true, "true"; @parameters[:hasstatus] = true
  when false, "false"; @parameters[:hasstatus] = false
  else
    raise Puppet::Error, "Invalid 'hasstatus' value #{value.inspect}"
  end
end

# File lib/puppet/provider/package/dpkg.rb, line 148
def hold
  self.install
  Tempfile.open('puppet_dpkg_set_selection') do |tmpfile|
    tmpfile.write("#{@resource[:name]} hold\n")
    tmpfile.flush
    execute([:dpkg, "--set-selections"], :failonfail => false, :combine => false, :stdinfile => tmpfile.path.to_s)
  end
end

# File lib/puppet/provider/user/windows_adsi.rb, line 72
def home
  user['HomeDirectory']
end

# File lib/puppet/provider/user/windows_adsi.rb, line 76
def home=(value)
  user['HomeDirectory'] = value
end

# File lib/puppet/face/help.rb, line 153
def horribly_extract_summary_from(appname)
  begin
    help = Puppet::Application[appname].help.split("\n")
    # Now we find the line with our summary, extract it, and return it.  This
    # depends on the implementation coincidence of how our pages are
    # formatted.  If we can't match the pattern we expect we return the empty
    # string to ensure we don't blow up in the summary. --daniel 2011-04-11
    while line = help.shift do
      if md = /^puppet-#{appname}\([^\)]+\) -- (.*)$/.match(line) then
        return md[1]
      end
    end
  rescue Exception
    # Damn, but I hate this: we just ignore errors here, no matter what
    # class they are.  Meh.
  end
  return ''
end

# File lib/puppet/reports/rrdgraph.rb, line 23
def hostdir
  @hostdir ||= File.join(Puppet[:rrddir], self.host)
end

# File lib/puppet/reports/rrdgraph.rb, line 27
def htmlfile(type, graphs, field)
  file = File.join(hostdir, "#{type}.html")
  File.open(file, "w") do |of|
    of.puts "<html><head><title>#{type.capitalize} graphs for #{host}</title></head><body>"

    graphs.each do |graph|
      if field == :first
        name = graph.sub(/-\w+.png/, '').capitalize
      else
        name = graph.sub(/\w+-/, '').sub(".png", '').capitalize
      end
      of.puts "<img src=#{graph}><br>"
    end
    of.puts "</body></html>"
  end

  file
end

# File lib/puppet/provider/file/windows.rb, line 21
def id2name(id)
  if Puppet::Util::Windows::SID.valid_sid?(id)
    Puppet::Util::Windows::SID.sid_to_name(id)
  else
    id
  end
end

# File lib/puppet/provider/package/sun.rb, line 125
def if_have_value(prefix, value)
  if value
    [prefix, value]
  else
    []
  end
end

# File lib/puppet/functions/import.rb, line 4
def import(*args)
  raise Puppet::Pops::SemanticError.new(Puppet::Pops::Issues::DISCONTINUED_IMPORT)
end

# File lib/puppet/provider/service/openbsd.rb, line 250
def in_base?
  script = File.readlines(self.class.rcconf).find {|s| s =~ /^#{rcvar_name}/ }
  !script.nil?
end

# File lib/puppet/provider/package/sun.rb, line 64
def info2hash(device = nil)
  args = ['-l']
  args << '-d' << device if device
  args << @resource[:name]
  begin
    pkgs = self.class.parse_pkginfo(pkginfo(*args))
    errmsg = case pkgs.size
      when 0
        'No message'
      when 1
         pkgs[0]['ERROR']
    end
    return self.class.namemap(pkgs[0]) if errmsg.nil?
    # according to commit 41356a7 some errors do not raise an exception
    # so eventhough pkginfo passed, we have to check the actual output
    raise Puppet::Error, "Unable to get information about package #{@resource[:name]} because of: #{errmsg}"
  rescue Puppet::ExecutionFailure
    return {:ensure => :absent}
  end
end

# File lib/puppet/provider/service/redhat.rb, line 51
def initscript
  raise Puppet::Error, "Do not directly call the init script for '#{@resource[:name]}'; use 'service' instead"
end

# File lib/puppet/functions/inline_epp.rb, line 84
def inline_epp(scope, template, parameters = nil)
  Puppet::Pops::Evaluator::EppEvaluator.inline_epp(scope, template, parameters)
end

# File lib/puppet/provider/package/yum.rb, line 96
def install
  wanted = @resource[:name]
  # If not allowing virtual packages, do a query to ensure a real package exists
  unless @resource.allow_virtual?
    yum *['-d', '0', '-e', '0', '-y', install_options, :list, wanted].compact
  end

  should = @resource.should(:ensure)
  self.debug "Ensuring => #{should}"
  operation = :install

  case should
  when true, false, Symbol
    # pass
    should = nil
  else
    # Add the package version
    wanted += "-#{should}"
    is = self.query
    if is && Puppet::Util::Package.versioncmp(should, is[:ensure]) < 0
      self.debug "Downgrading package #{@resource[:name]} from version #{is[:ensure]} to #{should}"
      operation = :downgrade
    end
  end

  args = ["-d", "0", "-e", "0", "-y", install_options, operation, wanted].compact
  yum *args


  # If a version was specified, query again to see if it is a matching version
  if should
    is = self.query
    raise Puppet::Error, "Could not find package #{self.name}" unless is

    # FIXME: Should we raise an exception even if should == :latest
    # and yum updated us to a version other than @param_hash[:ensure] ?
    raise Puppet::Error, "Failed to update to version #{should}, got version #{is[:ensure]} instead" if should != is[:ensure]
  end
end

# File lib/puppet/provider/package/pacman.rb, line 57
def install_from_file
  source = @resource[:source]
  begin
    source_uri = URI.parse source
  rescue => detail
    self.fail Puppet::Error, "Invalid source '#{source}': #{detail}", detail
  end

  source = case source_uri.scheme
  when nil then source
  when /https?/ then source
  when /ftp/ then source
  when /file/ then source_uri.path
  when /puppet/
    fail "puppet:// URL is not supported by pacman"
  else
    fail "Source #{source} is not supported by pacman"
  end
  pacman "--noconfirm", "--noprogressbar", "-Sy"
  pacman "--noconfirm", "--noprogressbar", "-U", source
end

# File lib/puppet/provider/package/pacman.rb, line 42
def install_from_repo
  if yaourt?
    cmd = %w{--noconfirm}
    cmd += install_options if @resource[:install_options]
    cmd << "-S" << @resource[:name]
    yaourt *cmd
  else
    cmd = %w{--noconfirm --noprogressbar}
    cmd += install_options if @resource[:install_options]
    cmd << "-Sy" << @resource[:name]
    pacman *cmd
  end
end

# File lib/puppet/provider/package/gem.rb, line 132
def install_options
  join_options(resource[:install_options])
end

# File lib/puppet/vendor/semantic/spec/unit/semantic/dependency/graph_node_spec.rb, line 24
def instance(*args)
  name = args.first.name unless args.empty?
  klass.new(name || 'unnamed', *args)
end

# File lib/puppet/type/cron.rb, line 333
def insync?(is)
  if is.is_a? Array
    return is.sort == @should.sort
  else
    return is == @should
  end
end

# File lib/puppet/network/formats.rb, line 7
def intern(klass, text)
  data = MessagePack.unpack(text)
  return data if data.is_a?(klass)
  klass.from_data_hash(data)
end

# File lib/puppet/network/formats.rb, line 13
def intern_multiple(klass, text)
  MessagePack.unpack(text).collect do |data|
    klass.from_data_hash(data)
  end
end

# File lib/puppet/functions/defined.rb, line 76
def is_defined(scope, *vals)
  vals.any? do |val|
    case val
    when String
      if val =~ /^\$(.+)$/
        scope.exist?($1)
      else
        case val
        when ''
          next nil
        when 'main'
          # Find the main class (known as ''), it does not have to be in the catalog
          scope.find_hostclass('')
        else
          # Find a resource type, definition or class definition
          scope.find_resource_type(val) || scope.find_definition(val) || scope.find_hostclass(val)
          #scope.compiler.findresource(:class, val)
        end
      end
    when Puppet::Resource
      # Find instance of given resource type and title that is in the catalog
      scope.compiler.findresource(val.type, val.title)

    when Puppet::Pops::Types::PResourceType
      raise ArgumentError, 'The given resource type is a reference to all kind of types' if val.type_name.nil?
      if val.title.nil?
        scope.find_builtin_resource_type(val.type_name) || scope.find_definition(val.type_name)
      else
        scope.compiler.findresource(val.type_name, val.title)
      end

    when Puppet::Pops::Types::PHostClassType
      raise  ArgumentError, 'The given class type is a reference to all classes' if val.class_name.nil?
      scope.compiler.findresource(:class, val.class_name)

    when Puppet::Pops::Types::PType
      case val.type
      when Puppet::Pops::Types::PResourceType
        # It is most reasonable to take Type[File] and Type[File[foo]] to mean the same as if not wrapped in a Type
        # Since the difference between File and File[foo] already captures the distinction of type vs instance.
        is_defined(scope, val.type)

      when Puppet::Pops::Types::PHostClassType
        # Interpreted as asking if a class (and nothing else) is defined without having to be included in the catalog
        # (this is the same as asking for just the class' name, but with the added certainty that it cannot be a defined type.
        #
        raise  ArgumentError, 'The given class type is a reference to all classes' if val.type.class_name.nil?
        scope.find_hostclass(val.type.class_name)
      end
    else
      raise ArgumentError, "Invalid argument of type '#{val.class}' to 'defined'"
    end
  end
end

# File lib/puppet/face/help.rb, line 184
def is_face_app?(appname)
  clazz = Puppet::Application.find(appname)

  clazz.ancestors.include?(Puppet::Application::FaceBase)
end

# File lib/puppet/provider/augeas/augeas.rb, line 201
def is_numeric?(s)
  case s
  when Fixnum
    true
  when String
    s.match(/\A[+-]?\d+?(\.\d+)?\Z/) == nil ? false : true
  else
    false
  end
end

# File lib/puppet/provider/user/user_role_add.rb, line 64
def is_role?
  user_attributes and user_attributes[:type] == "role"
end

# File lib/puppet/type/cron.rb, line 341
def is_to_s(newvalue)
  if newvalue
    if newvalue.is_a?(Array)
      newvalue.join(",")
    else
      newvalue
    end
  else
    nil
  end
end

# File lib/puppet/provider/service/upstart.rb, line 169
def is_upstart?(script = initscript)
  Puppet::FileSystem.exist?(script) && script.match(/\/etc\/init\/\S+\.conf/)
end