# but requires the 'backports' gem (which is used in other places in fpm)
    return Enumerator.new { |y| Find.find(staging_path) { |path| y << path } } \
      .select { |path| path != staging_path } \
      .select { |path| is_leaf.call(path) } \
      .collect { |path| path[staging_path.length + 1.. -1] }
  end # def files
 
  def template_dir
    File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "templates"))
  end

  def template(path)
    template_path = File.join(template_dir, path)
    template_code = File.read(template_path)
    @logger.info("Reading template", :path => template_path)
    erb = ERB.new(template_code, nil, "-")
    erb.filename = template_path
    return erb
  end # def template

  option "--changelog", "FILEPATH", "Add changelog from FILEPATH contents" do |file|
    File.read(File.expand_path(file))
  end

  option "--sign", :flag, "Pass --sign to rpmbuild"

  option "--auto-add-directories", :flag, "Auto add directories not part of filesystem"

  private

  def rpm_file_entry(file)
    return file unless attributes[:rpm_use_file_permissions?]

    stat = File.stat( file.gsub(/\"/, '') )
    user = Etc.getpwuid(stat.uid).name

      "--define", "_topdir #{build_path}",
      "--define", "_sourcedir #{build_path}",
      "--define", "_rpmdir #{build_path}/RPMS",
    ]

    args += ["--sign"] if attributes[:rpm_sign?]

    if attributes[:rpm_auto_add_directories?]
      fs_dirs_list = File.join(template_dir, "rpm", "filesystem_list")
      fs_dirs = File.readlines(fs_dirs_list).reject { |x| x =~ /^\s*#/}.map { |x| x.chomp }

      Find.find(staging_path) do |path|
        next if path == staging_path
        if File.directory? path
          add_path = path.gsub(/^#{staging_path}/,'')
          self.directories << add_path if not fs_dirs.include? add_path
        end
      end
    else
      self.directories = self.directories.map { |x| File.join(self.prefix, x) }
      alldirs = []
      self.directories.each do |path|
        Find.find(File.join(staging_path, path)) do |subpath|
          if File.directory? subpath
            alldirs << subpath.gsub(/^#{staging_path}/, '')
          end
        end
      end
      self.directories = alldirs
    end

    self.config_files = self.config_files.map { |x| File.join(self.prefix, x) }

    (attributes[:rpm_rpmbuild_define] or []).each do |define|
      args += ["--define", define]
    end

    rpmspec = template("rpm.erb").result(binding)
    specfile = File.join(build_path("SPECS"), "#{name}.spec")
    File.write(specfile, rpmspec)

<%   end -%>
<% end -%>

%files
%defattr(-,<%= attributes[:rpm_user] %>,<%= attributes[:rpm_group] %>,-)
<%# Output config files and then regular files. -%>
<% config_files.each do |path| -%>
%config(noreplace) <%= path %>
<% end -%>
<%# list directories %>
<% directories.each do |path| -%>
%dir <%= rpm_file_entry(path) %>






<% end -%>
<%# list only files, not directories? -%>
<%= 
  # Reject config files already listed or parent directories, then prefix files
  # with "/", then make sure paths with spaces are quoted. I hate rpm so much.

  # 'files' here is the method FPM::Package#files.
  # The 'files' section of rpm can be 
  # Replace [ with [\[] to make rpm not use globs
  # Replace * with [*] to make rpm not use globs
  # Replace ? with [?] to make rpm not use globs
  # Replace % with [%] to make rpm not expand macros
  files.collect { |f| "/#{f}" } \
    .reject { |f| config_files.include?(f) } \
    .reject { |f| directories.include?(f) } \
    .collect { |f| f[/\s/] and "\"#{f}\"" or f } \
    .collect { |f| f.gsub("[", "[\\[]") } \
    .collect { |f| f.gsub("*", "[*]") } \
    .collect { |f| f.gsub("?", "[?]") } \
    .collect { |f| f.gsub("%", "[%]") } \
    .map { |f| rpm_file_entry(f) } \
    .join("\n")
    #.collect { |f| File.join(prefix, f) } \
%>

%changelog
<%= attributes[:rpm_changelog] %>