fpm 0.3.11 → 0.4.0pre1

data/CHANGELIST

@@ -1,3 +1,18 @@
+0.4.0 (???)
+  - Complete rewrite of pretty much everything.
+    * Otherwise, the 'fpm' command functionality should be the same
+    * Please let me know if something broke!
+  - Now has an API (see examples/api directory)
+  - Also has a proper test suite
+  - Add --license and --vendor settings (via Pieter Loubser)
+  - python support: try to name python packages sanely. Some pypi packages
+    are literally called 'python-foo' so make sure we generate packages named
+    'python-foo' and not 'python-python-foo' (via Thomas Meson)
+  - rpm support: Add --rpm-rpmbuild-define for passing a --define flag to rpmbuild
+    (via Naresh V)
+  TODO(sissel): PEAR
+  - PHP pear source support (fpm -s pear ...) (via Andrew Gaffney)
+
 0.3.10 (Oct 10, 2011)
   - Allow taking a list of files/inputs on stdin with '-' or with the --inputs
     flag. (Matt Patterson)

data/bin/fpm

@@ -1,21 +1,8 @@
 #!/usr/bin/env ruby
-#
 
 require "rubygems"
 $: << File.join(File.dirname(__FILE__), "..", "lib")
 require "fpm"
-require "fpm/program"
+require "fpm/command"
 
-if $DEBUG
-  module Kernel
-    alias :orig_system :system
-    def system(*args)
-      p :system => args
-      orig_system(*args)
-    end
-  end
-end
-
-program = FPM::Program.new
-ret = program.run(ARGV)
-exit(ret.nil? ? 0 : ret)
+exit(FPM::Command.run || 0)

data/lib/fpm.rb

@@ -1,15 +1,8 @@
 require "fpm/namespace"
-require "fpm/builder"
 
 require "fpm/package"
-require "fpm/target/deb"
-require "fpm/target/rpm"
-require "fpm/target/solaris"
-require "fpm/target/puppet"
-
-require "fpm/source"
-require "fpm/source/dir"
-require "fpm/source/gem"
-require "fpm/source/python"
-require "fpm/source/rpm"
-require "fpm/source/tar"
+require "fpm/package/dir"
+require "fpm/package/gem"
+require "fpm/package/deb"
+require "fpm/package/rpm"
+require "fpm/package/python"

data/lib/fpm/command.rb

@@ -0,0 +1,323 @@
+require "rubygems"
+require "fpm/namespace"
+require "fpm/util"
+require "clamp"
+require "ostruct"
+require "fpm"
+
+if $DEBUG
+  Cabin::Channel.get(Kernel).subscribe($stdout)
+  Cabin::Channel.get(Kernel).level = :debug
+end
+
+Dir[File.join(File.dirname(__FILE__), "package", "*.rb")].each do |plugin|
+  Cabin::Channel.get(Kernel).info("Loading plugin", :path => plugin)
+  require plugin
+end
+
+
+# The main fpm command entry point.
+class FPM::Command < Clamp::Command
+  include FPM::Util
+
+  option "-t", "OUTPUT_TYPE",
+    "the type of package you want to create (deb, rpm, solaris, etc)",
+    :attribute_name => :output_type
+  option "-s", "INPUT_TYPE",
+    "the package type to use as input (gem, rpm, python, etc)",
+    :attribute_name => :input_type
+  option "-C", "CHDIR",
+    "Change directory to here before searching for files",
+    :attribute_name => :chdir
+  option "--prefix", "PREFIX",
+    "A path to prefix files with when building the target package. This may " \
+    "be necessary for all input packages. For example, the 'gem' type will" \
+    "prefix with your gem directory automatically."
+  option ["-p", "--package"], "OUTPUT",
+    "The package file path to output.", :default => "NAME-FULLVERSION.ARCH.TYPE"
+  option ["-n", "--name"], "NAME", "The name to give to the package"
+  option "--verbose", :flag, "Enable verbose output"
+  option "--debug", :flag, "Enable debug output"
+  option ["-v", "--version"], "VERSION", "The version to give to the package"
+  option "--iteration", "ITERATION",
+    "The iteration to give to the package. RPM calls this the 'release'. " \
+    "FreeBSD calls it 'PORTREVISION'. Debian calls this 'debian_revision'",
+    :default => "1"
+  option "--epoch", "EPOCH",
+    "The epoch value for this package. RPM and Debian calls this 'epoch'. " \
+    "FreeBSD calls this 'PORTEPOCH'", :default => "1"
+  option "--license", "LICENSE",
+    "(optional) license name for this package"
+  option "--vendor", "VENDOR",
+    "(optional) vendor name for this package"
+  option "--category", "CATEGORY",
+    "(optional) category this package belongs to", :default => "none"
+  option ["-d", "--depends"], "DEPENDENCY",
+    "A dependency. This flag can be specified multiple times. Value is " \
+    "usually in the form of: -d 'name' or -d 'name > version'",
+    :default => [], :attribute_name => :dependencies do |val|
+    # Clamp doesn't support multivalue flags (ie; specifying -d multiple times)
+    # so we can hack around it with this trickery.
+    @dependencies ||= []
+    @dependencies << val
+  end # -d / --depends
+  option "--provides", "PROVIDES",
+    "What this package provides (usually a name)" do |val|
+    @provides ||= []
+    @provides << val
+  end # --provides
+  option "--conflicts", "CONFLICTS",
+    "Other packages/versions this package conflicts with" do |val|
+    @conflicts ||= []
+    @conflicts << val
+  end # --conflicts
+  option "--replaces", "REPLACES",
+    "Other packages/versions this package replaces" do |val|
+    @replaces ||= []
+    @replaces << val
+  end # --replaces
+  option "--config-files", "CONFIG_FILES",
+    "Mark a file in the package as being a config file. This uses 'conffiles'" \
+    " in debs and %config in rpm." do |val|
+    @config_files ||= []
+    @config_files << val
+  end # --config-files
+  option ["-a", "--architecture"], "ARCHITECTURE",
+    "The architecture name. Usually matches 'uname -m'. For automatic values," \
+    " you can use '-a all' or '-a native'. These two strings will be " \
+    "translated into the correct value for your platform and target package type."
+  option ["-m", "--maintainer"], "MAINTAINER",
+    "The maintainer of this package.",
+    :default => "<#{ENV["USER"]}@#{Socket.gethostname}>"
+  option ["-S", "--package-name-suffix"], "PACKAGE_NAME_SUFFIX",
+    "a name suffix to append to package and dependencies."
+  option ["-e", "--edit"], :flag,
+    "Edit the package spec before building."
+  option ["-x", "--exclude"], "EXCLUDE_PATTERN",
+    "Exclude paths matching pattern (shell wildcard globs valid here)" do |val|
+    @exclude_pattern ||= []
+    @exclude_pattern << val
+  end # -x / --exclude
+  option "--post-install", "FILE",
+    "a script to be run after package installation",
+    :attribute_name => :after_install do |val|
+    File.expand_path(val) # Get the full path to the script
+  end # --post-install
+  option "--pre-install", "FILE",
+    "a script to be run before package installation",
+    :attribute_name => :before_install do |val|
+    File.expand_path(val) # Get the full path to the script
+  end # --pre-install
+  # TODO(sissel): Name the flag --post-remove for clarity
+  option "--post-uninstall", "FILE",
+    "a script to be run after package removal",
+    :attribute_name => :after_remove do |val|
+    File.expand_path(val) # Get the full path to the script
+  end # --post-uninstall
+  # TODO(sissel): Name the flag --pre-remove for clarity
+  option "--pre-uninstall", "FILE",
+    "a script to be run before package removal",
+    :attribute_name => :before_remove do |val|
+    File.expand_path(val) # Get the full path to the script
+  end # --pre-uninstall
+  option "--description", "DESCRIPTION", "Add a description for this package.",
+    :default => "no description"
+  option "--url", "URI", "Add a url for this package.",
+    :default => "http://example.com/no-uri-given"
+  option "--inputs", "INPUTS_PATH",
+    "The path to a file containing a newline-separated list of " \
+    "files and dirs to use as input."
+  parameter "[ARGS] ...",
+    "Inputs to the source package type. For the 'dir' type, this is the files" \
+    " and directories you want to include in the package. For others, like " \
+    "'gem', it specifies the packages to download and use as the gem input",
+    :attribute_name => :args
+
+  # package-level settings
+  def settings
+    @settings ||= {}
+  end
+
+  FPM::Package.types.each do |name, klass|
+    klass.apply_options(self)
+  end
+
+  # TODO(sissel): expose 'option' and 'parameter' junk to FPM::Package and subclasses.
+  # Apply those things to this command.
+  #
+  # Add extra flags from plugins
+  #FPM::Package::Gem.flags(FPM::Flags.new(opts, "gem", "gem only"), @settings)
+  #FPM::Package::Python.flags(FPM::Flags.new(opts, "python", "python only"),
+                            #@settings)
+  #FPM::Package::Deb.flags(FPM::Flags.new(opts, "deb", "deb only"), @settings)
+  #FPM::Package::Rpm.flags(FPM::Flags.new(opts, "rpm", "rpm only"), @settings)
+  
+  # A new FPM::Command
+  def initialize(*args)
+    super(*args)
+    @conflicts = []
+    @replaces = []
+    @provides = []
+    @dependencies = []
+    @config_files = []
+  end # def initialize
+
+  # Execute this command. See Clamp::Command#execute and Clamp's documentation
+  def execute
+    @logger = Cabin::Channel.get
+    @logger.subscribe(STDOUT)
+    @logger.level = :warn
+    validator = Validator.new(self)
+    if !validator.ok?
+      validator.messages.each do |message|
+        @logger.warn(message)
+      end
+
+      @logger.fatal("Fix the above problems, and you'll be rolling packages in no time!")
+      return 1
+    end
+
+    input_class = FPM::Package.types[input_type]
+    output_class = FPM::Package.types[output_type]
+
+    @logger.level = :info if verbose? # --verbose
+    @logger.level = :debug if debug? # --debug
+
+    input = input_class.new
+
+    # Merge in package settings. 
+    # The 'settings' stuff comes in from #apply_options, which goes through
+    # all the options defined in known packages and puts them into our command.
+    # Flags in packages defined as "--foo-bar" become named "--<packagetype>-foo-bar"
+    # They are stored in 'settings' as :gem_foo_bar.
+    input.attributes ||= {}
+
+    # Iterate over all the options
+    self.class.declared_options.each do |option|
+      with(option.attribute_name) do |attr|
+        # clamp makes option attributes available as accessor methods
+        # do --foo-bar is available as 'foo_bar'
+        # make these available as package attributes.
+        input.attributes[attr.to_sym] = send(attr) if respond_to?(attr)
+      end
+    end
+    
+    args.each do |arg| 
+      input.input(arg) 
+    end
+
+    # Override package settings if they are not the default flag values
+    # the below proc essentially does:
+    #
+    # if someflag != default_someflag
+    #   input.someflag = someflag
+    # end
+    set = proc do |object, attribute|
+      # if the package's attribute is currently nil *or* the flag setting for this
+      # attribute is non-default, use the value.
+      if object.send(attribute).nil? || send(attribute) != send("default_#{attribute}")
+        @logger.info("Setting from flags: #{attribute}=#{send(attribute)}")
+        object.send("#{attribute}=", send(attribute))
+      end
+    end
+    set.call(input, :architecture)
+    set.call(input, :category)
+    set.call(input, :description)
+    set.call(input, :epoch)
+    set.call(input, :iteration)
+    set.call(input, :license)
+    set.call(input, :maintainer)
+    set.call(input, :name)
+    set.call(input, :url)
+    set.call(input, :vendor)
+    set.call(input, :version)
+    set.call(input, :architecture)
+
+    input.conflicts += conflicts
+    input.dependencies += dependencies
+    input.provides += provides
+    input.replaces += replaces
+
+    input.scripts[:before_install] = before_install # --pre-install
+    input.scripts[:after_install] = after_install # --post-install
+    input.scripts[:before_remove] = before_remove # --pre-uninstall
+    input.scripts[:after_remove] = after_remove # --post-uninstall
+    
+    # Convert to the output type
+    output = input.convert(output_class)
+
+    # Write the output somewhere
+    output.output(output.to_s(package))
+    return 0
+  ensure
+    input.cleanup unless input.nil?
+    output.cleanup unless output.nil?
+  end # def execute
+
+  # A simple flag validator
+  #
+  # The goal of this class is to ensure the flags and arguments given
+  # are a valid configuration.
+  class Validator
+    include FPM::Util
+    private
+
+    def initialize(command)
+      @command = command
+      @valid = true
+      @messages = []
+
+      validate
+    end # def initialize
+
+    def ok?
+      return @valid
+    end # def ok?
+
+    def validate
+      # Make sure the user has passed '-s' and '-t' flags
+      mandatory(@command.input_type,
+                "Missing required -s flag. What package source did you want?")
+      mandatory(@command.output_type,
+                "Missing required -t flag. What package output did you want?")
+
+      # Verify the types requested are valid
+      types = FPM::Package.types.keys.sort
+      with(@command.input_type) do |val|
+        next if val.nil?
+        mandatory(FPM::Package.types.include?(val),
+                  "Invalid input package -s flag) type #{val.inspect}. " \
+                  "Expected one of: #{types.join(", ")}")
+      end
+
+      with(@command.output_type) do |val|
+        next if val.nil?
+        mandatory(FPM::Package.types.include?(val),
+                  "Invalid output package (-t flag) type #{val.inspect}. " \
+                  "Expected one of: #{types.join(", ")}")
+      end
+
+      mandatory(@command.args.any?,
+                "No parameters given. You need to pass additional command " \
+                "arguments so that I know what you want to build packages " \
+                "from. For example, for '-s dir' you would pass a list of " \
+                "files and directories. For '-s gem' you would pass a one" \
+                " or more gems to package from. As a full example, this " \
+                "will make an rpm of the 'json' rubygem: " \
+                "`fpm -s gem -t rpm json`")
+    end # def validate
+
+    def mandatory(value, message)
+      if value.nil? or !value
+        @messages << message
+        @valid = false
+      end
+    end # def mandatory
+
+    def messages
+      return @messages
+    end # def messages
+
+    public(:initialize, :ok?, :messages)
+  end # class Validator
+end # class FPM::Program

data/lib/fpm/errors.rb

@@ -1,3 +1,4 @@
 require "fpm/namespace"
 
+# Raised if a package is configured in an unsupported way
 class FPM::InvalidPackageConfiguration < StandardError; end

data/lib/fpm/namespace.rb

@@ -1,13 +1,4 @@
+# The FPM namespace
 module FPM
-  module Target; end # TODO(sissel): Make this the 'package' ?
-  DIRS = {
-    :templates => File.expand_path(
-      File.join(
-        File.dirname(__FILE__),
-        '..',
-        '..',
-        'templates'
-      )
-    )
-  }
+  class Package; end
 end

data/lib/fpm/package.rb

@@ -1,9 +1,20 @@
 require "fpm/namespace"
+require "fpm/util"
 require "socket" # for Socket.gethostname
-require "logger"
-require "find" # for Find.find (directory walking)
+require "cabin"
+require "tmpdir"
 
+# This class is the parent of all packages.
+# If you want to implement an FPM package type, you'll inherit from this.
+#
+# There are 
 class FPM::Package
+  include FPM::Util
+  include Cabin::Inspectable
+
+  # This class is raised if there's something wrong with a setting in the package.
+  class InvalidArgument < StandardError; end
+
   # The name of this package
   attr_accessor :name
 
@@ -19,13 +30,19 @@ class FPM::Package
   #   Debian calls this 'release' and is the last '-NUMBER' in the version
   #   RedHat has this as 'Release' in the .spec file
   #   FreeBSD calls this 'PORTREVISION'
-  # If left unpicked, it defaults to 1.
+  #
+  # Iteration can be nil. If nil, the fpm package implementation is expected
+  # to handle any default value that should be instead.
   attr_accessor :iteration
 
   # Who maintains this package? This could be the upstream author
   # or the package maintainer. You pick.
   attr_accessor :maintainer
 
+  # A identifier representing the vendor. Any string is fine.
+  # This is usually who produced the software.
+  attr_accessor :vendor
+
   # URL for this package.
   # Could be the homepage. Could be the download url. You pick.
   attr_accessor :url
@@ -66,116 +83,254 @@ class FPM::Package
   # Array of configuration files
   attr_accessor :config_files
 
-	# target-specific settings
-	attr_accessor :settings
-
-  def initialize(source, params={})
-    @source = source
-    @logger = Logger.new(STDERR)
-    @logger.level = $DEBUG ? Logger::DEBUG : Logger::WARN
-
-    @name = source[:name] # || fail
-
-    # Default version is 1.0 in case nobody told us a specific version.
-    @version = source[:version] || "1.0"
-    @epoch = source[:epoch]
-
-    @dependencies = source[:dependencies] || []
-    # Iteration can be nil. If nil, the fpm package implementation is expected
-    # to handle any default value that should be instead.
-    @iteration = source[:iteration]
-    @url = source[:url] || "http://nourlgiven.example.com/no/url/given"
-    @category = source[:category] || "default"
-    @license = source[:license] || "unknown"
-    #@maintainer = source[:maintainer] || "<#{ENV["USER"]}@#{Socket.gethostname}>"
-    @maintainer = source[:maintainer]
-
-    # Default maintainer if none given.
-    if @maintainer.nil? or @maintainer.empty?
-      # Reference
-      # http://www.debian.org/doc/manuals/maint-guide/first.en.html
-      # http://wiki.debian.org/DeveloperConfiguration
-      # https://github.com/jordansissel/fpm/issues/37
-      if ENV.include?("DEBEMAIL") and ENV.include?("DEBFULLNAME")
-        # Use DEBEMAIL and DEBFULLNAME as the default maintainer if available.
-        @maintainer = "#{ENV["DEBFULLNAME"]} <#{ENV["DEBEMAIL"]}>"
-      else
-        # TODO(sissel): Maybe support using 'git config' for a default as well?
-        # git config --get user.name, etc can be useful.
-        #
-        # Otherwise default to user@currenthost
-        @maintainer = "<#{ENV["USER"]}@#{Socket.gethostname}>"
-      end
+  # Any other attributes specific to this package.
+  # This is where you'd put rpm, deb, or other specific attributes.
+  attr_accessor :attributes
+
+  private
+
+  def initialize
+    @logger = Cabin::Channel.get
+
+    # Attributes for this specific package 
+    @attributes = {}
+
+    # Reference
+    # http://www.debian.org/doc/manuals/maint-guide/first.en.html
+    # http://wiki.debian.org/DeveloperConfiguration
+    # https://github.com/jordansissel/fpm/issues/37
+    if ENV.include?("DEBEMAIL") and ENV.include?("DEBFULLNAME")
+      # Use DEBEMAIL and DEBFULLNAME as the default maintainer if available.
+      @maintainer = "#{ENV["DEBFULLNAME"]} <#{ENV["DEBEMAIL"]}>"
+    else
+      # TODO(sissel): Maybe support using 'git config' for a default as well?
+      # git config --get user.name, etc can be useful.
+      #
+      # Otherwise default to user@currenthost
+      @maintainer = "<#{ENV["USER"]}@#{Socket.gethostname}>"
     end
 
-    # If @architecture is nil, the target package should provide a default.
-    # Special 'architecture' values include "all" (aka rpm's noarch, debian's all)
-    # Another special includes "native" which will be the current platform's arch.
-    @architecture = source[:architecture]
-    @description = source[:description] || "no description given"
-    @provides = source[:provides] || []
-    @replaces = source[:replaces] || []
-    @conflicts = source[:conflicts] || []
-    @scripts = source[:scripts]
-    @config_files = source[:config_files] || []
-
-    # Target-specific settings, mirrors :settings metadata in FPM::Source
-    @settings = params[:settings] || {}
-  end # def initialize
+    @name = nil
+    @architecture = "all"
+    @description = "no description given"
+    @version = nil
+    @epoch = nil
+    @iteration = nil
+    @url = nil
+    @category = "default"
+    @license = "unknown"
+    @vendor = "none"
 
-  # nobody needs md5sums by default.
-  def needs_md5sums
-    false
-  end # def needs_md5sums
+    @provides = []
+    @conflicts = []
+    @replaces = []
+    @dependencies = []
+    @scripts = {}
+    @config_files = []
 
-  # TODO [Jay]: make this better...?
+    staging_path
+    build_path
+  end # def initialize
+
+  # Get the 'type' for this instance.
+  #
+  # For FPM::Package::ABC, this returns 'abc'
   def type
-    self.class.name.split(':').last.downcase
+    self.class.type
   end # def type
 
-  def template(path=nil)
-    path ||= "#{type}.erb"
-    @logger.info("Reading template: #{path}")
-    tpl = File.read("#{FPM::DIRS[:templates]}/#{path}")
-    return ERB.new(tpl, nil, "-")
-  end # def template
+  # Convert this package to a new package type
+  def convert(klass)
+    @logger.info("Converting #{self.type} to #{klass.type}")
+    pkg = klass.new
+    pkg.cleanup_staging # purge any directories that may have been created by klass.new
 
-  def render_spec
-    # find all files in paths given.
-    paths = []
-    @source.paths.each do |path|
-      Find.find(path) { |p| paths << p }
+    # copy other bits
+    ivars = [
+      :@architecture, :@attributes, :@category, :@config_files, :@conflicts,
+      :@dependencies, :@description, :@epoch, :@iteration, :@license, :@maintainer,
+      :@name, :@provides, :@replaces, :@scripts, :@url, :@vendor, :@version,
+      :@config_files, :@staging_path
+    ]
+    ivars.each do |ivar|
+      #@logger.debug("Copying ivar", :ivar => ivar, :value => instance_variable_get(ivar),
+                    #:from => self.type, :to => pkg.type)
+      pkg.instance_variable_set(ivar, instance_variable_get(ivar))
     end
-    #@logger.info(:paths => paths.sort)
-    template.result(binding)
-  end # def render_spec
-
-  # Default specfile generator just makes one specfile, whatever that is for
-  # this package.
-  def generate_specfile(builddir)
-    File.open(specfile(builddir), "w") do |f|
-      f.puts render_spec
+
+    pkg.converted_from(self.class)
+    return pkg
+  end # def convert
+
+  # This method is invoked on a package when it has been covered to a new
+  # package format. The purpose of this method is to do any extra conversion
+  # steps, like translating dependency conditions, etc.
+  def converted_from(origin)
+    # nothing to do by default. Subclasses may implement this.
+    # See the RPM package class for an example.
+  end # def converted
+
+  # Add a new source to this package.
+  # The exact behavior depends on the kind of package being managed.
+  #
+  # For instance: 
+  #
+  # * for FPM::Package::Dir, << expects a path to a directory or files.
+  # * for FPM::Package::RPM, << expects a path to an rpm.
+  #
+  # The idea is that you can keep pumping in new things to a package
+  # for later conversion or output.
+  #
+  # Implementations are expected to put files relevant to the 'input' in the
+  # staging_path
+  def input(thing_to_input)
+    raise NotImplementedError.new("#{self.class.name} does not yet support " \
+                                  "reading #{self.type} packages")
+  end # def input
+
+  # Output this package to the given path.
+  def output(path)
+    raise NotImplementedError.new("#{self.class.name} does not yet support " \
+                                  "creating #{self.type} packages")
+  end # def output
+
+  def staging_path(path=nil)
+    @staging_path ||= ::Dir.mktmpdir(File.join(::Dir.pwd, "package-#{type}-staging"))
+
+    if path.nil?
+      return @staging_path
+    else
+      return File.join(@staging_path, path)
     end
-  end # def generate_specfile
+  end # def staging_path
+
+  def build_path(path=nil)
+    @build_path ||= ::Dir.mktmpdir(File.join(::Dir.pwd, "package-#{type}-build"))
 
-  def default_output
-    if iteration
-      "#{name}-#{version}-#{iteration}.#{architecture}.#{type}"
+    if path.nil?
+      return @build_path
     else
-      "#{name}-#{version}.#{architecture}.#{type}"
+      return File.join(@build_path, path)
+    end
+  end # def build_path
+
+  # Clean up any temporary storage used by this class.
+  def cleanup
+    cleanup_staging
+    cleanup_build
+  end # def cleanup
+
+  def cleanup_staging
+    if File.directory?(staging_path)
+      @logger.debug("Cleaning up staging path", :path => staging_path)
+      FileUtils.rm_r(staging_path) 
     end
-  end # def default_output
+  end # def cleanup_staging
 
-  def fixpath(path)
-    if path[0,1] != "/"
-      path = File.join(@source.root, path)
+  def cleanup_build
+    if File.directory?(build_path)
+      @logger.debug("Cleaning up build path", :path => build_path)
+      FileUtils.rm_r(build_path) 
     end
-    return path if File.symlink?(path)
-    @logger.info(:fixpath => path)
-    realpath = Pathname.new(path).realpath.to_s
-    re = Regexp.new("^#{Regexp.escape(@source.root)}")
-    realpath.gsub!(re, "")
-    @logger.info(:fixpath_result => realpath)
-    return realpath
-  end # def fixpath
+  end # def cleanup_build
+
+  # List all files in the staging_path
+  #
+  # The paths will all be relative to staging_path and will not include that
+  # path.
+  def files
+    # Find will print the path you're searching first, so skip it and return
+    # the rest. Also trim the leading path such that '#{staging_path}/' is removed
+    # from the path before returning.
+    return Find.find(staging_path) \
+      .select { |path| path != staging_path } \
+      .collect { |path| path[staging_path.length + 1.. -1] }
+  end # def files
+ 
+  def template(path)
+    require "erb"
+    template_dir = File.join(File.dirname(__FILE__), "..", "..", "templates")
+    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
+
+  def to_s(fmt="NAME.TYPE")
+    fullversion = version.to_s
+    fullversion += "-#{iteration}" if iteration
+    return fmt.gsub("ARCH", architecture.to_s) \
+      .gsub("NAME", name.to_s) \
+      .gsub("FULLVERSION", fullversion) \
+      .gsub("VERSION", version.to_s) \
+      .gsub("EPOCH", epoch.to_s)
+      .gsub("TYPE", type.to_s)
+  end # def to_s
+
+  class << self
+    # This method is invoked when subclass occurs.
+    # 
+    # Lets us track all known FPM::Package subclasses
+    def inherited(klass)
+      @subclasses ||= {}
+      @subclasses[klass.name.gsub(/.*:/, "").downcase] = klass
+    end # def self.inherited
+
+    # Get a list of all known package subclasses
+    def types
+      return @subclasses
+    end # def self.types
+
+    # This allows packages to define flags for the fpm command line
+    def option(flag, param, help, options={}, &block)
+      @options ||= []
+      if !flag.is_a?(Array)
+        flag = [flag]
+      end
+
+      flag = flag.collect { |f| "--#{type}-#{f.gsub(/^--/, "")}" }
+      help = "(#{type} only) #{help}"
+      @options << [flag, param, help, options, block]
+    end # def options
+
+    # Apply the options for this package on the clamp command
+    #
+    # Package flags become attributes '{type}-flag'
+    #
+    # So if you have:
+    #
+    #     class Foo < FPM::Package
+    #       option "--bar-baz" ...
+    #     end
+    #
+    # The attribute value for --foo-bar-baz will be :foo_bar_baz"
+    def apply_options(clampcommand)
+      @options ||= []
+      @options.each do |args|
+        flag, param, help, options, block = args
+        clampcommand.option(flag, param, help, options) do |value|
+          # This is run in the scope of FPM::Command
+          value = block.call(value) unless block.nil?
+          # flag is an array, use the first flag as the attribute name
+          attr = flag.first[2..-1].gsub(/-+/, "_").to_sym
+          settings[attr] = value
+        end
+      end
+    end # def apply_options
+
+    # Get the type of this package class.
+    #
+    # For "Foo::Bar::BAZ" this will return "baz"
+    def type
+      self.name.split(':').last.downcase
+    end # def self.type
+  end # class << self
+
+  # General public API
+  public(:type, :initialize, :convert, :input, :output, :to_s, :cleanup, :files)
+
+  # Package internal public api
+  public(:cleanup_staging, :cleanup_build, :staging_path, :converted_from)
 end # class FPM::Package