puppet 0.25.5 → 2.6.0

data/lib/puppet/type/ssh_authorized_key.rb

@@ -1,103 +1,99 @@
 module Puppet
-    newtype(:ssh_authorized_key) do
-        @doc = "Manages SSH authorized keys. Currently only type 2 keys are
-        supported."
+  newtype(:ssh_authorized_key) do
+    @doc = "Manages SSH authorized keys. Currently only type 2 keys are
+    supported."
 
-        ensurable
+    ensurable
 
-        newparam(:name) do
-            desc "The SSH key comment. This attribute is currently used as a
-            system-wide primary key and therefore has to be unique."
+    newparam(:name) do
+      desc "The SSH key comment. This attribute is currently used as a
+      system-wide primary key and therefore has to be unique."
 
-            isnamevar
-        end
+      isnamevar
+    end
 
-        newproperty(:type) do
-            desc "The encryption type used: ssh-dss or ssh-rsa."
+    newproperty(:type) do
+      desc "The encryption type used: ssh-dss or ssh-rsa."
 
-            newvalue("ssh-dss")
-            newvalue("ssh-rsa")
+      newvalue("ssh-dss")
+      newvalue("ssh-rsa")
 
-            aliasvalue(:dsa, "ssh-dss")
-            aliasvalue(:rsa, "ssh-rsa")
-        end
-
-        newproperty(:key) do
-            desc "The key itself; generally a long string of hex digits."
-        end
+      aliasvalue(:dsa, "ssh-dss")
+      aliasvalue(:rsa, "ssh-rsa")
+    end
 
-        newproperty(:user) do
-            desc "The user account in which the SSH key should be installed.
-            The resource will automatically depend on this user."
-        end
+    newproperty(:key) do
+      desc "The key itself; generally a long string of hex digits."
+    end
 
-        newproperty(:target) do
-            desc "The absolute filename in which to store the SSH key. This
-            property is optional and should only be used in cases where keys
-            are stored in a non-standard location (ie not in
-            ~user/.ssh/authorized_keys)."
+    newproperty(:user) do
+      desc "The user account in which the SSH key should be installed.
+      The resource will automatically depend on this user."
+    end
 
-            defaultto :absent
+    newproperty(:target) do
+      desc "The absolute filename in which to store the SSH key. This
+      property is optional and should only be used in cases where keys
+      are stored in a non-standard location (ie not in
+      ~user/.ssh/authorized_keys)."
 
-            def should
-                if defined? @should and @should[0] != :absent
-                    return super
-                end
+      defaultto :absent
 
-                return nil unless user = resource[:user]
+      def should
+        return super if defined?(@should) and @should[0] != :absent
 
-                begin
-                    return File.expand_path("~%s/.ssh/authorized_keys" % user)
-                rescue
-                    Puppet.debug "The required user is not yet present on the system"
-                    return nil
-                end
-            end
+        return nil unless user = resource[:user]
 
-            def insync?(is)
-                is == should
-            end
+        begin
+          return File.expand_path("~#{user}/.ssh/authorized_keys")
+        rescue
+          Puppet.debug "The required user is not yet present on the system"
+          return nil
         end
+      end
 
-        newproperty(:options, :array_matching => :all) do
-            desc "Key options, see sshd(8) for possible values. Multiple values
-                  should be specified as an array."
-
-            defaultto do :absent end
-
-            def is_to_s(value)
-                if value == :absent or value.include?(:absent)
-                    super
-                else
-                    value.join(",")
-                end
-            end
-
-            def should_to_s(value)
-                if value == :absent or value.include?(:absent)
-                    super
-                else
-                    value.join(",")
-                end
-            end
+      def insync?(is)
+        is == should
+      end
+    end
+
+    newproperty(:options, :array_matching => :all) do
+      desc "Key options, see sshd(8) for possible values. Multiple values
+        should be specified as an array."
+
+      defaultto do :absent end
+
+      def is_to_s(value)
+        if value == :absent or value.include?(:absent)
+          super
+        else
+          value.join(",")
         end
+      end
 
-        autorequire(:user) do
-            if should(:user)
-                should(:user)
-            end
+      def should_to_s(value)
+        if value == :absent or value.include?(:absent)
+          super
+        else
+          value.join(",")
         end
+      end
+    end
+
+    autorequire(:user) do
+      should(:user) if should(:user)
+    end
 
-        validate do
-            # Go ahead if target attribute is defined
-            return if @parameters[:target].shouldorig[0] != :absent
+    validate do
+      # Go ahead if target attribute is defined
+      return if @parameters[:target].shouldorig[0] != :absent
 
-            # Go ahead if user attribute is defined
-            return if @parameters.include?(:user)
+      # Go ahead if user attribute is defined
+      return if @parameters.include?(:user)
 
-            # If neither target nor user is defined, this is an error
-            raise Puppet::Error, "Attribute 'user' or 'target' is mandatory"
-        end
+      # If neither target nor user is defined, this is an error
+      raise Puppet::Error, "Attribute 'user' or 'target' is mandatory"
     end
+  end
 end
 

data/lib/puppet/type/sshkey.rb

@@ -1,74 +1,70 @@
 module Puppet
-    newtype(:sshkey) do
-        @doc = "Installs and manages ssh host keys.  At this point, this type
-            only knows how to install keys into /etc/ssh/ssh_known_hosts, and
-            it cannot manage user authorized keys yet."
+  newtype(:sshkey) do
+    @doc = "Installs and manages ssh host keys.  At this point, this type
+      only knows how to install keys into /etc/ssh/ssh_known_hosts, and
+      it cannot manage user authorized keys yet."
 
-        ensurable
+    ensurable
 
-        newproperty(:type) do
-            desc "The encryption type used.  Probably ssh-dss or ssh-rsa."
+    newproperty(:type) do
+      desc "The encryption type used.  Probably ssh-dss or ssh-rsa."
 
-            newvalue("ssh-dss")
-            newvalue("ssh-rsa")
-            aliasvalue(:dsa, "ssh-dss")
-            aliasvalue(:rsa, "ssh-rsa")
-        end
+      newvalue("ssh-dss")
+      newvalue("ssh-rsa")
+      aliasvalue(:dsa, "ssh-dss")
+      aliasvalue(:rsa, "ssh-rsa")
+    end
 
-        newproperty(:key) do
-            desc "The key itself; generally a long string of hex digits."
-        end
+    newproperty(:key) do
+      desc "The key itself; generally a long string of hex digits."
+    end
 
-        # FIXME This should automagically check for aliases to the hosts, just
-        # to see if we can automatically glean any aliases.
-        newproperty(:host_aliases) do
-           desc 'Any aliases the host might have.  Multiple values must be
-                specified as an array.  Note that this property is not the same as
-                the "alias" metaparam; use this property to add aliases to a host
-                on disk, and "alias" to aliases for use in your Puppet scripts.'
+    # FIXME This should automagically check for aliases to the hosts, just
+    # to see if we can automatically glean any aliases.
+    newproperty(:host_aliases) do
+      desc 'Any aliases the host might have.  Multiple values must be
+        specified as an array.  Note that this property is not the same as
+        the "alias" metaparam; use this property to add aliases to a host
+        on disk, and "alias" to aliases for use in your Puppet scripts.'
 
-            attr_accessor :meta
+      attr_accessor :meta
 
-            def insync?(is)
-                is == @should
-            end
-            # We actually want to return the whole array here, not just the first
-            # value.
-            def should
-                if defined? @should
-                    return @should
-                else
-                    return nil
-                end
-            end
+      def insync?(is)
+        is == @should
+      end
+      # We actually want to return the whole array here, not just the first
+      # value.
+      def should
+        defined?(@should) ? @should : nil
+      end
 
-            validate do |value|
-                if value =~ /\s/
-                    raise Puppet::Error, "Aliases cannot include whitespace"
-                end
-                if value =~ /,/
-                    raise Puppet::Error, "Aliases cannot include whitespace"
-                end
-            end
+      validate do |value|
+        if value =~ /\s/
+          raise Puppet::Error, "Aliases cannot include whitespace"
         end
+        if value =~ /,/
+          raise Puppet::Error, "Aliases cannot include whitespace"
+        end
+      end
+    end
 
-        newparam(:name) do
-            desc "The host name that the key is associated with."
+    newparam(:name) do
+      desc "The host name that the key is associated with."
 
-            isnamevar
-        end
+      isnamevar
+    end
 
-        newproperty(:target) do
-            desc "The file in which to store the ssh key.  Only used by
-                the ``parsed`` provider."
+    newproperty(:target) do
+      desc "The file in which to store the ssh key.  Only used by
+        the ``parsed`` provider."
 
-            defaultto { if @resource.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
-                    @resource.class.defaultprovider.default_target
-                else
-                    nil
-                end
-            }
+      defaultto { if @resource.class.defaultprovider.ancestors.include?(Puppet::Provider::ParsedFile)
+        @resource.class.defaultprovider.default_target
+        else
+          nil
         end
+      }
     end
+  end
 end
 

data/lib/puppet/type/stage.rb

@@ -0,0 +1,18 @@
+Puppet::Type.newtype(:stage) do
+  desc "A resource type for specifying run stages.  The actual stage should
+  be specified on resources::
+    class { foo: stage => pre }
+
+  And you must manually control stage order::
+
+    stage { pre: before => Stage[main] }
+
+  You automatically get a 'main' stage created, and by default all resources
+  get inserted into that stage.
+
+  You can only set stages on class resources, not normal builtin resources."
+
+  newparam :name do
+    desc "The name of the stage. This will be used as the 'stage' for each resource."
+  end
+end

data/lib/puppet/type/tidy.rb

@@ -1,341 +1,330 @@
 Puppet::Type.newtype(:tidy) do
-    require 'puppet/file_serving/fileset'
-
-    @doc = "Remove unwanted files based on specific criteria.  Multiple
-        criteria are OR'd together, so a file that is too large but is not
-        old enough will still get tidied.
-
-        If you don't specify either 'age' or 'size', then all files will
-        be removed.
-
-        This resource type works by generating a file resource for every file
-        that should be deleted and then letting that resource perform the
-        actual deletion.
-        "
-
-    newparam(:path) do
-        desc "The path to the file or directory to manage.  Must be fully
-            qualified."
-        isnamevar
+  require 'puppet/file_serving/fileset'
+
+  @doc = "Remove unwanted files based on specific criteria.  Multiple
+    criteria are OR'd together, so a file that is too large but is not
+    old enough will still get tidied.
+
+    If you don't specify either 'age' or 'size', then all files will
+    be removed.
+
+    This resource type works by generating a file resource for every file
+    that should be deleted and then letting that resource perform the
+    actual deletion.
+    "
+
+  newparam(:path) do
+    desc "The path to the file or directory to manage.  Must be fully
+      qualified."
+    isnamevar
+  end
+
+  newparam(:recurse) do
+    desc "If target is a directory, recursively descend
+      into the directory looking for files to tidy."
+
+    newvalues(:true, :false, :inf, /^[0-9]+$/)
+
+    # Replace the validation so that we allow numbers in
+    # addition to string representations of them.
+    validate { |arg| }
+    munge do |value|
+      newval = super(value)
+      case newval
+      when :true, :inf; true
+      when :false; false
+      when Integer, Fixnum, Bignum; value
+      when /^\d+$/; Integer(value)
+      else
+        raise ArgumentError, "Invalid recurse value #{value.inspect}"
+      end
+    end
+  end
+
+  newparam(:matches) do
+    desc "One or more (shell type) file glob patterns, which restrict
+      the list of files to be tidied to those whose basenames match
+      at least one of the patterns specified. Multiple patterns can
+      be specified using an array.
+
+      Example::
+
+          tidy { \"/tmp\":
+            age => \"1w\",
+            recurse => 1,
+            matches => [ \"[0-9]pub*.tmp\", \"*.temp\", \"tmpfile?\" ]
+          }
+
+      This removes files from \/tmp if they are one week old or older,
+      are not in a subdirectory and match one of the shell globs given.
+
+      Note that the patterns are matched against the basename of each
+      file -- that is, your glob patterns should not have any '/'
+      characters in them, since you are only specifying against the last
+      bit of the file.
+
+      Finally, note that you must now specify a non-zero/non-false value
+      for recurse if matches is used, as matches only apply to files found
+      by recursion (there's no reason to use static patterns match against
+      a statically determined path).  Requiering explicit recursion clears
+      up a common source of confusion."
+
+    # Make sure we convert to an array.
+    munge do |value|
+      fail "Tidy can't use matches with recurse 0, false, or undef" if "#{@resource[:recurse]}" =~ /^(0|false|)$/
+      [value].flatten
     end
 
-    newparam(:recurse) do
-        desc "If target is a directory, recursively descend
-            into the directory looking for files to tidy."
-
-        newvalues(:true, :false, :inf, /^[0-9]+$/)
-
-        # Replace the validation so that we allow numbers in
-        # addition to string representations of them.
-        validate { |arg| }
-        munge do |value|
-            newval = super(value)
-            case newval
-            when :true, :inf; true
-            when :false; false
-            when Integer, Fixnum, Bignum; value
-            when /^\d+$/; Integer(value)
-            else
-                raise ArgumentError, "Invalid recurse value %s" % value.inspect
-            end
-        end
+    # Does a given path match our glob patterns, if any?  Return true
+    # if no patterns have been provided.
+    def tidy?(path, stat)
+      basename = File.basename(path)
+      flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
+      return(value.find {|pattern| File.fnmatch(pattern, basename, flags) } ? true : false)
+    end
+  end
+
+  newparam(:backup) do
+    desc "Whether tidied files should be backed up.  Any values are passed
+      directly to the file resources used for actual file deletion, so use
+      its backup documentation to determine valid values."
+  end
+
+  newparam(:age) do
+    desc "Tidy files whose age is equal to or greater than
+      the specified time.  You can choose seconds, minutes,
+      hours, days, or weeks by specifying the first letter of any
+      of those words (e.g., '1w').
+
+      Specifying 0 will remove all files."
+
+    @@ageconvertors = {
+      :s => 1,
+      :m => 60
+    }
+
+    @@ageconvertors[:h] = @@ageconvertors[:m] * 60
+    @@ageconvertors[:d] = @@ageconvertors[:h] * 24
+    @@ageconvertors[:w] = @@ageconvertors[:d] * 7
+
+    def convert(unit, multi)
+      if num = @@ageconvertors[unit]
+        return num * multi
+      else
+        self.fail "Invalid age unit '#{unit}'"
+      end
     end
 
-    newparam(:matches) do
-        desc "One or more (shell type) file glob patterns, which restrict
-            the list of files to be tidied to those whose basenames match
-            at least one of the patterns specified. Multiple patterns can
-            be specified using an array.
-
-            Example::
-
-                    tidy { \"/tmp\":
-                        age => \"1w\",
-                        recurse => 1,
-                        matches => [ \"[0-9]pub*.tmp\", \"*.temp\", \"tmpfile?\" ]
-                    }
-
-            This removes files from \/tmp if they are one week old or older,
-            are not in a subdirectory and match one of the shell globs given.
-
-            Note that the patterns are matched against the basename of each 
-            file -- that is, your glob patterns should not have any '/' 
-            characters in them, since you are only specifying against the last 
-            bit of the file.
-            
-            Finally, note that you must now specify a non-zero/non-false value 
-            for recurse if matches is used, as matches only apply to files found
-            by recursion (there's no reason to use static patterns match against 
-            a statically determined path).  Requiering explicit recursion clears
-            up a common source of confusion."
-
-        # Make sure we convert to an array.
-        munge do |value|
-            fail "Tidy can't use matches with recurse 0, false, or undef" if "#{@resource[:recurse]}" =~ /^(0|false|)$/
-            [value].flatten
-        end
-
-        # Does a given path match our glob patterns, if any?  Return true
-        # if no patterns have been provided.
-        def tidy?(path, stat)
-            basename = File.basename(path)
-            flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
-            return true if value.find {|pattern| File.fnmatch(pattern, basename, flags) }
-            return false
-        end
+    def tidy?(path, stat)
+      # If the file's older than we allow, we should get rid of it.
+      (Time.now.to_i - stat.send(resource[:type]).to_i) > value
     end
 
-    newparam(:backup) do
-        desc "Whether tidied files should be backed up.  Any values are passed
-            directly to the file resources used for actual file deletion, so use
-            its backup documentation to determine valid values."
+    munge do |age|
+      unit = multi = nil
+      case age
+      when /^([0-9]+)(\w)\w*$/
+        multi = Integer($1)
+        unit = $2.downcase.intern
+      when /^([0-9]+)$/
+        multi = Integer($1)
+        unit = :d
+      else
+        self.fail "Invalid tidy age #{age}"
+      end
+
+      convert(unit, multi)
+    end
+  end
+
+  newparam(:size) do
+    desc "Tidy files whose size is equal to or greater than
+      the specified size.  Unqualified values are in kilobytes, but
+      *b*, *k*, and *m* can be appended to specify *bytes*, *kilobytes*,
+      and *megabytes*, respectively.  Only the first character is
+      significant, so the full word can also be used."
+
+    @@sizeconvertors = {
+      :b => 0,
+      :k => 1,
+      :m => 2,
+      :g => 3
+    }
+
+    def convert(unit, multi)
+      if num = @@sizeconvertors[unit]
+        result = multi
+        num.times do result *= 1024 end
+        return result
+      else
+        self.fail "Invalid size unit '#{unit}'"
+      end
     end
 
-    newparam(:age) do
-        desc "Tidy files whose age is equal to or greater than
-            the specified time.  You can choose seconds, minutes,
-            hours, days, or weeks by specifying the first letter of any
-            of those words (e.g., '1w').
-
-            Specifying 0 will remove all files."
-
-        @@ageconvertors = {
-            :s => 1,
-            :m => 60
-        }
-
-        @@ageconvertors[:h] = @@ageconvertors[:m] * 60
-        @@ageconvertors[:d] = @@ageconvertors[:h] * 24
-        @@ageconvertors[:w] = @@ageconvertors[:d] * 7
-
-        def convert(unit, multi)
-            if num = @@ageconvertors[unit]
-                return num * multi
-            else
-                self.fail "Invalid age unit '%s'" % unit
-            end
-        end
-
-        def tidy?(path, stat)
-            # If the file's older than we allow, we should get rid of it.
-            if (Time.now.to_i - stat.send(resource[:type]).to_i) > value
-                return true
-            else
-                return false
-            end
-        end
-
-        munge do |age|
-            unit = multi = nil
-            case age
-            when /^([0-9]+)(\w)\w*$/
-                multi = Integer($1)
-                unit = $2.downcase.intern
-            when /^([0-9]+)$/
-                multi = Integer($1)
-                unit = :d
-            else
-                self.fail "Invalid tidy age %s" % age
-            end
-
-            convert(unit, multi)
-        end
+    def tidy?(path, stat)
+      stat.size >= value
     end
 
-    newparam(:size) do
-        desc "Tidy files whose size is equal to or greater than
-            the specified size.  Unqualified values are in kilobytes, but
-            *b*, *k*, and *m* can be appended to specify *bytes*, *kilobytes*,
-            and *megabytes*, respectively.  Only the first character is
-            significant, so the full word can also be used."
-
-        @@sizeconvertors = {
-            :b => 0,
-            :k => 1,
-            :m => 2,
-            :g => 3
-        }
-
-        def convert(unit, multi)
-            if num = @@sizeconvertors[unit]
-                result = multi
-                num.times do result *= 1024 end
-                return result
-            else
-                self.fail "Invalid size unit '%s'" % unit
-            end
-        end
-
-        def tidy?(path, stat)
-            if stat.size >= value
-                return true
-            else
-                return false
-            end
-        end
-
-        munge do |size|
-            case size
-            when /^([0-9]+)(\w)\w*$/
-                multi = Integer($1)
-                unit = $2.downcase.intern
-            when /^([0-9]+)$/
-                multi = Integer($1)
-                unit = :k
-            else
-                self.fail "Invalid tidy size %s" % age
-            end
-
-            convert(unit, multi)
-        end
+    munge do |size|
+      case size
+      when /^([0-9]+)(\w)\w*$/
+        multi = Integer($1)
+        unit = $2.downcase.intern
+      when /^([0-9]+)$/
+        multi = Integer($1)
+        unit = :k
+      else
+        self.fail "Invalid tidy size #{age}"
+      end
+
+      convert(unit, multi)
     end
+  end
 
-    newparam(:type) do
-        desc "Set the mechanism for determining age."
+  newparam(:type) do
+    desc "Set the mechanism for determining age."
 
-        newvalues(:atime, :mtime, :ctime)
+    newvalues(:atime, :mtime, :ctime)
 
-        defaultto :atime
-    end
+    defaultto :atime
+  end
 
-    newparam(:rmdirs, :boolean => true) do
-        desc "Tidy directories in addition to files; that is, remove
-            directories whose age is older than the specified criteria.
-            This will only remove empty directories, so all contained
-            files must also be tidied before a directory gets removed."
+  newparam(:rmdirs, :boolean => true) do
+    desc "Tidy directories in addition to files; that is, remove
+      directories whose age is older than the specified criteria.
+      This will only remove empty directories, so all contained
+      files must also be tidied before a directory gets removed."
 
-        newvalues :true, :false
-    end
+    newvalues :true, :false
+  end
 
-    # Erase PFile's validate method
-    validate do
-    end
+  # Erase PFile's validate method
+  validate do
+  end
 
-    def self.instances
-        []
-    end
+  def self.instances
+    []
+  end
 
-    @depthfirst = true
+  @depthfirst = true
 
-    def initialize(hash)
-        super
+  def initialize(hash)
+    super
 
-        # only allow backing up into filebuckets
-        unless self[:backup].is_a? Puppet::Network::Client.dipper
-            self[:backup] = false
-        end
-    end
+    # only allow backing up into filebuckets
+    self[:backup] = false unless self[:backup].is_a? Puppet::FileBucket::Dipper
+  end
 
-    # Make a file resource to remove a given file.
-    def mkfile(path)
-        # Force deletion, so directories actually get deleted.
-        Puppet::Type.type(:file).new :path => path, :backup => self[:backup], :ensure => :absent, :force => true
-    end
+  # Make a file resource to remove a given file.
+  def mkfile(path)
+    # Force deletion, so directories actually get deleted.
+    Puppet::Type.type(:file).new :path => path, :backup => self[:backup], :ensure => :absent, :force => true
+  end
 
-    def retrieve
-        # Our ensure property knows how to retrieve everything for us.
-        if obj = @parameters[:ensure]
-            return obj.retrieve
-        else
-            return {}
-        end
+  def retrieve
+    # Our ensure property knows how to retrieve everything for us.
+    if obj = @parameters[:ensure]
+      return obj.retrieve
+    else
+      return {}
     end
+  end
 
-    # Hack things a bit so we only ever check the ensure property.
-    def properties
-        []
-    end
+  # Hack things a bit so we only ever check the ensure property.
+  def properties
+    []
+  end
 
-    def eval_generate
-        []
-    end
+  def eval_generate
+    []
+  end
 
-    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 %s" % 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::Reference.new(:file, path)
-            else
-                resource[:require] = [Puppet::Resource::Reference.new(:file, path)]
-            end
-        end
+  def generate
+    return [] unless stat(self[:path])
 
-        return result
+    case self[:recurse]
+    when Integer, Fixnum, Bignum, /^\d+$/
+      parameter = { :recurse => true, :recurselimit => self[:recurse] }
+    when true, :true, :inf
+      parameter = { :recurse => true }
     end
 
-    # Does a given path match our glob patterns, if any?  Return true
-    # if no patterns have been provided.
-    def matches?(path)
-        return true unless self[:matches]
-
-        basename = File.basename(path)
-        flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
-        if self[:matches].find {|pattern| File.fnmatch(pattern, basename, flags) }
-            return true
-        else
-            debug "No specified patterns match %s, not tidying" % path
-            return false
-        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
 
-    # Should we remove the specified file?
-    def tidy?(path)
-        return false unless stat = self.stat(path)
+    result
+  end
+
+  # Does a given path match our glob patterns, if any?  Return true
+  # if no patterns have been provided.
+  def matches?(path)
+    return true unless self[:matches]
+
+    basename = File.basename(path)
+    flags = File::FNM_DOTMATCH | File::FNM_PATHNAME
+    if self[:matches].find {|pattern| File.fnmatch(pattern, basename, flags) }
+      return true
+    else
+      debug "No specified patterns match #{path}, not tidying"
+      return false
+    end
+  end
 
-        return false if stat.ftype == "directory" and ! rmdirs?
+  # Should we remove the specified file?
+  def tidy?(path)
+    return false unless stat = self.stat(path)
 
-        # The 'matches' parameter isn't OR'ed with the other tests --
-        # it's just used to reduce the list of files we can match.
-        return false if param = parameter(:matches) and ! param.tidy?(path, stat)
+    return false if stat.ftype == "directory" and ! rmdirs?
 
-        tested = false
-        [:age, :size].each do |name|
-            next unless param = parameter(name)
-            tested = true
-            return true if param.tidy?(path, stat)
-        end
+    # The 'matches' parameter isn't OR'ed with the other tests --
+    # it's just used to reduce the list of files we can match.
+    return false if param = parameter(:matches) and ! param.tidy?(path, stat)
 
-        # If they don't specify either, then the file should always be removed.
-        return true unless tested
-        return false
+    tested = false
+    [:age, :size].each do |name|
+      next unless param = parameter(name)
+      tested = true
+      return true if param.tidy?(path, stat)
     end
 
-    def stat(path)
-        begin
-            File.lstat(path)
-        rescue Errno::ENOENT => error
-            info "File does not exist"
-            return nil
-        rescue Errno::EACCES => error
-            warning "Could not stat; permission denied"
-            return nil
-        end
+    # If they don't specify either, then the file should always be removed.
+    return true unless tested
+    false
+  end
+
+  def stat(path)
+    begin
+      File.lstat(path)
+    rescue Errno::ENOENT => error
+      info "File does not exist"
+      return nil
+    rescue Errno::EACCES => error
+      warning "Could not stat; permission denied"
+      return nil
     end
+  end
 end