pallet 1.2.1 → 1.5.0

data/CHANGELOG

@@ -1,3 +1,45 @@
+pallet (1.5.0)
+
+  Release Notes:
+
+    This is largely a development release. Those wanting fully-featured
+    package building should use the latest stable release (1.2.1). Some
+    features of 1.2.1 are not currently supported, due to the complete
+    rework of the build process for Debian packages.
+
+    If building an individual Debian file for personal use and
+    publishing, "rake package:deb" will put the Debian package into
+    "pkg/#{project-name}-#{version}-{arch}.deb".
+
+    If building for upload to a Debian repository, the command
+    "rake package:deb:clean" will create the Debian build directory
+    ready for packaging. "dpkg-buildpackage -rfakeroot" will then
+    generate the Debian binary and source packages, as well as a
+    .changes file.
+
+  Improvements:
+
+    * Debian packaging rebuilt from scratch. No longer dependent on
+      debhelper and less dependent on a Debian environment
+    * Debian packages support Suggests, Recommends, and all other
+      package associations
+    * debian directory no longer blown away unless it's explicitly
+      managed by pallet (through use of a debian/.pallet-stamp flag)
+   
+  Regressions:
+
+    * Debian packages no longer support crontabs, init.d scripts, and
+      other niceties that came for "free" with debhelper
+    * no longer truly supports building of Debian packages that use
+      compiled binaries; shared library dependencies and a few other
+      things are no longer handled, that debhelper did
+    * the Debian .changes file and other artefacts of building a source
+      package are no longer generated
+
+  Bugfixes:
+
+    * Debian packages are built in pkg, like other package types.
+
 pallet (1.2.1)
 
   Improvements:

data/README

@@ -0,0 +1,55 @@
+=Pallet
+
+* Author: Stephen Touset
+* Website: http://pallet.rubyforge.org
+* Rubyforge page: http://rubyforge.org/projects/pallet/ 
+* SVN: svn://rubyforge.org/var/svn/pallet/trunk
+
+See COPYRIGHT for distribution terms.
+
+==Description
+
+A Rakefile-based tool to easily build different package types (such as .deb, .gem) from the same source. Currently builds Debian packages and Ruby Gems, but is trivially extensible to provide support for other packaging formats (.tar.gz, .rpm, etc.).
+
+==Usage
+
+Include the pallet library in a new or existing Rakefile for your project. Start by including the pallet library in your Rakefile and defining project information that will be used in both the gem and deb rake packaging task options:
+
+  require 'pallet'
+
+  Pallet.new('projectname', "0.0.1") do |p|
+    p.author  = 'Your Name'
+    p.email   = 'your@email.com'
+    p.summary = 'Summary of your project'
+  end
+
+Within the pallet block you can specify options for the gem and deb rake packaging tasks:
+
+  ...
+  p.packages << Pallet::Gem.new(p) do |gem|
+    gem.depends = ['rake']
+    gem.requirements = ['fakeroot', 'dpkg-dev']
+    gem.files.include FileList['share/**/*']
+  end
+  
+  p.packages << Pallet::Deb.new(p) do |deb|   
+    deb.architecture = 'all'
+    deb.depends      = ['rake', 'fakeroot', 'dpkg-dev']
+    deb.files        = [InstallSpec['lib',   '/usr/lib/ruby/1.8'],
+    InstallSpec['data', '/usr/share'],
+    InstallSpec['docs', '/usr/share/docs'],]
+    deb.commands.document = 'rake doc'
+  end
+  ...
+
+You should follow the installation policies of your distro when you package a .deb for public use.
+
+==Hacking
+
+Please feel free to contribute code to improve Pallet! Some areas that need attention:
+
+* More package types (tar.gz, .rpm, etc.)
+* A pallet rakefile generator
+* Integration with other rakefile tools.
+
+Contact Stephen Touset <stephen@ nospam @ touset.org> with diffs or inquiries. 

data/lib/installer.rb

@@ -0,0 +1,106 @@
+require 'fileutils'
+
+class Installer
+
+  attr_accessor :src, :dest
+  attr_accessor :user, :group
+  attr_accessor :mode, :dmode
+
+  # Initializes the installer. Will install files in _src_ to _dest_,
+  # using the options provided. Allowed options are _user_ (the file
+  # owner), _group_ (the group owner), and _mode_. If none are provided
+  # user and group default to +root+, and the mode defaults to the
+  # file's current permissions on the filesystem. _dmode_ is the mode
+  # for any directories created.
+  #
+  # If no block is provided, the Installer will glob all files in _src_.
+  # If a block is provided, it must return a list of files (scoped to
+  # the _src_ directory) that will be installed.
+  #
+  # All files copied will maintain their directory structure under the
+  # _src_ given. _src_ and _dest_ default to the current working
+  # directory, if not given.
+  #
+  # Examples:
+  #
+  #   # 'foo/**/*' => 'bar'
+  #   Installer.new('foo', 'bar')
+  #
+  #   # 'foo/*.rb' => 'bar'
+  #   Installer.new('foo', 'bar') { FileList['*.rb'] }
+  #
+  #   # 'foo/bar/**/*' => 'baz/bar'
+  #   Installer.new('foo', 'baz') { FileList['bar/**/*'] }
+  #
+  def initialize(src = '.', dest = '.', options = {}, &block)
+
+    self.src   = src
+    self.dest  = dest
+
+    self.user  = options[:user]  || 'root'
+    self.group = options[:group] || 'root'
+    self.mode  = options[:mode]
+    self.dmode = options[:dmode]
+
+    @block = block || lambda { FileList['**/*'] }
+    
+ end
+
+  # Installs the files specified during initialization to 
+  def install(prefix)
+    
+    ##############################################
+    # Begin sadly misplace bit of code
+    #   - We do this section here, since not all files may have been
+    #   - generated by the time of initialization
+    ##############################################
+
+    files = []
+    src   = self.src
+    dest  = File.join(prefix, self.dest)
+
+    if File.directory?(src)
+      # let the user specify files from within that directory, otherwise
+      # assume a complete glob
+      FileUtils.chdir(src) { files = @block.call.to_a }
+    else
+      # src is an individual file
+      src, files = File.dirname(self.src), File.basename(self.src)
+    end
+
+    # check for special files like device nodes
+    specials = files.map {|f| File.join(src, f) }.find_all do |f|
+      !File.file?(f) and !File.directory?(f)
+    end
+
+    raise ArgumentError, "special files #{specials.join ', '} are not allowed" \
+      unless specials.empty?
+
+    ##############################################
+    # End sadly misplaced bit of code
+    ##############################################
+ 
+    # split into files and dirs, so we can handle directory permissions
+    # correctly
+    files, dirs = files.partition {|f| File.file?(File.join(src, f)) }
+
+    # make sure the parent directory gets created
+    FileUtils.mkdir_p(dest) unless File.directory?(dest)
+
+    # sorting by length is an "easy" way of making sure parent
+    # directories are handled first
+    dirs.sort_by {|dir| dir.length }.each do |dir|
+      FileUtils.mkdir(File.join(dest, dir), :mode => dmode) \
+        unless File.directory?(File.join(dest, dir))
+      FileUtils.chown(user, group, dest)
+    end
+
+    # install the files into their proper place
+    files.each do |file|
+      FileUtils.install(File.join(src, file), File.join(dest, file), :mode => mode)
+      FileUtils.chown(user, group, File.join(dest, file))
+    end
+
+  end
+
+end

data/lib/pallet.rb

@@ -1,15 +1,15 @@
 require 'rubygems'
 require 'rake'
 
-require 'pallet/deb'
-require 'pallet/gem'
-require 'install_spec'
+require 'installer'
 
 class Pallet
 
-  VERSION      = '1.2.1'
+  VERSION      = '1.5.0'
   NAMESPACE    = 'package'
 
+  PACKAGE_DIR  = 'pkg'
+
   # The name of the project.
   attr_accessor :name
  
@@ -54,8 +54,9 @@ class Pallet
     self.description = ''
     self.packages    = []
     
-    # let block continue initialization
-    yield self if block_given?
+    # let block continue initialization, don't bother testing for
+    # block_given? since we need a block
+    yield self
     
     # check that we have _some_ package to build
     if packages.empty?
@@ -85,7 +86,9 @@ class Pallet
       task :clean
 
       desc 'Clean up all package files'
-      task :clobber
+      task :clobber do
+        rm_r PACKAGE_DIR, :force => true
+      end
 
       # define a task for all supported packages
       self.packages.each do |package|
@@ -106,4 +109,11 @@ class Pallet
 
 end
 
-require 'dependencies'
+class String
+  def margin(indicator = '|')
+    gsub(/^\s*#{Regexp.escape(indicator)}/, '')
+  end
+end
+
+require 'pallet/deb'
+require 'pallet/gem'

data/lib/pallet/deb.rb

@@ -1,311 +1,430 @@
-class Pallet
+require 'find'
 
+class Pallet::Deb
+
+  # The name the generated rake task will use. Defaults to 'deb'.
+  attr_accessor :task_name
+
+  # A list of prerequisite tasks that will be completed before the
+  # packaging task starts.
+  attr_accessor :prerequisites
+
+  # An array of Debian build dependencies needed in order to build the
+  # package for this project. Will always include any dependencies
+  # implied by pallet.
+  attr_accessor :build_depends
+
+  # An array of Debian dependencies.
+  attr_accessor :depends
+
+  # An array of Debian recommended packages.
+  attr_accessor :recommends
+
+  # An array of Debian suggested packages.
+  attr_accessor :suggests
+
+  # An array of Debian conflicting packages.
+  attr_accessor :conflicts
+
+  # An array of Debian features this package provides.
+  attr_accessor :provides
+
+  # An array of Debian packages this package enhances.
+  attr_accessor :enhances
+
+  # A hash with each key being a file glob, and each value being the
+  # destination directory of files matching that glob. Do not include
+  # files specified in +changelog+, +copyright+, +docs+, +scripts+, or
   #
-  # = Pallet::Deb
-  #
-  # Automatic builder for Debian packages. Lets users automagically
-  # build a deb after specifying a few customizations.
-  #
-  # == Usage
-  #
-  # At a bare minimum, users must specify lists of files, and where to
-  # place them. The syntax for doing so is not obvious, so we will
-  # demonstrate by example.
+  # TODO: flesh out meaning
   #
-  # To create a Debian package, moving everything under 'lib/' to
-  # '/usr/lib/ruby/1.8/', everything in 'bin/' to '/usr/bin/', and all
-  # documentation under 'doc/' to the Debian default documentation
-  # directory, under the subdirectory HTML, you would write the
-  # following:
+  attr_accessor :files
+
+  # An enumerable object containing a list of all project documentation
+  # to include in the Debian package. If a directory is specified in the
+  # list, all files under that directory will be included as
+  # documentation. TODO: blah
+  attr_accessor :docs
+
+  # TODO: yeah...
+  attr_accessor :configs
+
+  # A hash pointing to the location of scripts the Debian package should
+  # include. # TODO: flesh this out
+  attr_accessor :scripts
+
+  # The machine architecture the package can be built to support.
+  # Defaults to 'all', which indicates that the project is
+  # machine-independent. Should be changed to 'any' if the project
+  # requires compilation to machine language, but should run on any
+  # architecture.
+  attr_accessor :architecture
+
+  # The location on the filesystem of the Debian-style project
+  # changelog. One will be created for you if it is not specified.
+  attr_accessor :changelog
+
+  # The location of the package's copyright. Must be present.
+  attr_accessor :copyright
+
+  # The urgency of the package. Defaults to 'low'.
+  attr_accessor :urgency
+
+  # The section the package has been classified into. Defaults to
+  # 'misc'. See the Debian Policy Manual for more information.
+  attr_accessor :section
+
+  # The distribution this package should be installed in. Defaults to
+  # 'unstable'.
+  attr_accessor :distribution
+
+  # The priority level of the package. Defaults to 'extra'.
+  attr_accessor :priority
+
+  # The latest version of the Debian policy we're compliant with.
+  POLICY_VERSION = '3.7.2.2'
+
+  # Location of the source package et al.
+  BUILD_DIR   = 'debian'
+
+  # Filesystem location of template files
+  TEMPLATE_LOCATION = [
+    File.join(File.dirname(__FILE__), *%w{.. .. share debian}),
+    File.join(*%w{/ usr share pallet debian})
+  ].find {|f| File.directory? f }
+
+  # A list of all build dependencies required by pallet.
+  PALLET_DEPENDS  = ["pallet (>= #{Pallet::VERSION})"] << %w{rake}
+  PALLET_SUGGESTS = ['fakeroot']
+
   #
-  #   Pallet::Deb.new(pallet) do |deb|
-  #--
-  # TODO: EXAMPLE!!
-  #++
-  #   end
+  # Creates a new specification for building a deb. Yields itself to the
+  # block passed for further initialization. Must be passed an instance
+  # of the pallet with information such as version, author, package
+  # name, etc. already configured.
   #
-  # === GPG Integration
+  # Can be passed a hash whose key is the pallet, and whose value is
+  # either an array of Rake tasks this task depends on, or a single
+  # dependent Rake task.
   #
-  # Pallet::Deb will sign its built Debian packages with the GPG key
-  # id in the environment variable $GPG_KEY_ID, if it is set.
-  # Otherwise, it will sign with the key associated with the
-  # maintainer's email address, if it is avaialble.
+  #   # creates a new Pallet::Deb packager
+  #   p.packages << Pallet::Deb.new(p)
   #
-  # == Caveats
+  #   # creates a new Pallet::Deb packager, that depends on other tasks
+  #   p.packages << Pallet::Deb.new(p => [:build, :doc])
   #
-  # * Uses dpkg-buildpackage, which is not very flexible. Should be
-  #   rewritten later to do everything on its own.
-  # * Can only be used to build a single package, rather than multiple
-  #   packages from one source.
-  # * Packages are installed into .., rather than pkg/
-  # * No doc-base integration
+  #   # changes the task name to 'package:debian'
+  #   p.packages << Pallet::Deb.new(p, 'debian')
   #
-  class Deb
-
-    # The name the generated rake task will use. Defaults to 'deb'.
-    attr_accessor :task_name
-
-    # An array of Debian build dependencies needed in order to build
-    # the package for this project. Defaults to any core build
-    # requirements introduced by pallet (currently only debhelper (>=
-    # 5) and dpkg-dev).
-    attr_accessor :build_depends
-
-    # All Debian packages this project depends on.
-    attr_accessor :depends
-
-    # Any additional requirements not satisfiable through the Debian
-    # packaging system. For instance, Ruby gems. Any requirements
-    # provided this way will be presented to the user through a
-    # Debconf dialog upon installation.
-    attr_accessor :requirements
-
-    # An array of any tasks which should run and complete successfully
-    # before the Debian package is built.
-    attr_accessor :prerequisites
-
-    # A struct containing a few statically-named commands that can
-    # replace parts of the Pallet::Deb build process. Currently
-    # allows assignment to the _build_, _install_, _package_,
-    # _document_, and _clean_ instance variables.
-    #
-    # _commands.build_ defaults to 'make', 'ant', or nil depending on
-    # whether or not a Makefile, build.xml, or no build file is
-    # detected, respectively.
-    #
-    # _commands.clean_ deafults to 'rake clean'. It can be overridden
-    # if you have another method of cleaning your build directory.
-    #
-    # _commands.install_ defaults to nil. If your project already
-    # provides a command that installs all files needed for the
-    # project into a prefixed directory, you can specify this rather
-    # than providing InstallSpecs to _Pallet::Deb#files_. However,
-    # this command +must+ be able to support a "DESTDIR=$DIR"-style
-    # parameter which determines the install prefix.
-    #
-    # _commands.package_ defaults to nil. If this is specified, the
-    # +entire+ build process will consist of calling this command.
-    # This might be desirable if your project already provides a
-    # _debian_ directory and a _make deb_ command to build the Debian
-    # package. Otherwise, leave this at its default.
-    #
-    # _commands.document_ defaults to nil. If specified, this command
-    # is run to build any automatically-generated documentation.
-    #
-    attr_accessor :commands
-
-
-    # An array of InstallSpec objects pointing to files and their
-    # destination in the finished package. May be omitted if
-    # _commands.install_ is provided.
-    attr_accessor :files
-
-    # A FileList, array, or other enumerable object containing a list
-    # of all project documentation to include in the Debian pacakge.
-    attr_accessor :docs
-
-    # The location on the filesystem of the project Changelog.
-    # Defaults to 'CHANGELOG', if one exists.
-    attr_accessor :changelog
-
-    # A hash pointing to the location of scripts the Debian package
-    # should include. The key in the hash is the debhelper-reconigzed
-    # type of script (cron.d, postinst, postrm, init.d, etc.). The
-    # value is its location in your project hierarchy.
-    attr_accessor :scripts
-
-    # The machine architecture the package can be built to support.
-    # Defaults to 'any', but 'all' should be used for languages that
-    # aren't compiled to a specific platform.
-    attr_accessor :architecture
-
-    # The version of the Debian policy we support
-    DEBIAN_POLICY_VERSION = '3.7.2'
-
-    # Mapping of build spec files to the command that invokes them. We
-    # don't include rake here, since most Ruby programs don't need
-    # "building", and there is no idiomatic rake task used for
-    # building extensions.
-    BUILD_COMMANDS = { 'Makefile'  => 'make --silent',
-                       'build.xml' => 'ant', }
-
-    # Build dependencies required by pallet, which will always be
-    # added to the debian/control file.
-    BUILD_DEPENDS = ['debhelper (> 5.0)', 'dpkg-dev']
-
-    # Default places to look for documentation.
-    DEFAULT_DOCS = FileList[%w{README* TODO* doc*}]
-    
-    # Default changelog search locations.
-    DEFAULT_CHANGELOG = FileList[%w{CHANGELOG*}]
-
-    # 
-    # Creates a new specification for building a deb. Yields itself to
-    # the blocked passed for further initialization.
-    # 
-    def initialize(pallet)
-
-      @pallet = pallet
-
-      # configure defaults
-      self.task_name     = :deb
-      self.depends       = []
-      self.build_depends = []
-      self.requirements  = []
-      self.prerequisites = []
-      self.files         = []
-      self.docs          = DEFAULT_DOCS
-      self.changelog     = DEFAULT_CHANGELOG.first
-      self.scripts       = {}
-      self.commands      = Struct.new(:build, :clean, :install, :package, :document).new
-      self.architecture  = 'any'
-
-      # try and determine a default build command
-      BUILD_COMMANDS.find do |file, command|
-        self.commands.build = command if File.exist? file
-      end
-
-      # default packaging command; adds GPG key if it's in the environment
-      self.commands.package = "dpkg-buildpackage -rfakeroot -b"
-      self.commands.package << " -k#{ENV['GPG_KEY_ID']}" if ENV['GPG_KEY_ID']
+  def initialize(pallet, task_name = 'deb')
 
-      # default clean command
-      self.commands.clean = 'rake --silent clean'
+    @pallet, self.prerequisites = deconstruct_hash(pallet)
 
-      # send me off to be configured
-      yield self if block_given?
+    self.task_name     = task_name
 
-      # append our core build-dependencies to any others specified, so
-      # the user doesn't have to
-      self.build_depends |= BUILD_DEPENDS
+    # file locations
+    self.files         = []
+    self.docs          = []
+    self.configs       = []
+    self.scripts       = {}
+    
+    # package flags
+    self.architecture  = 'all'
+    self.distribution  = 'unstable'
+    self.priority      = 'extra'
+    self.section       = 'misc'
+    self.urgency       = 'low'
+
+    # dependencies
+    self.build_depends = []
+    self.depends       = []
+    self.recommends    = []
+    self.suggests      = []
+    self.conflicts     = []
+    self.provides      = []
+    self.enhances      = []
+
+    # send me off to be configured
+    yield self if block_given?
+
+    # get rid of changelog, copyright if user specified them in docs
+    # self.docs.delete(self.changelog)
+    # self.docs.delete(self.copyright)
 
-    end
+  end
 
-    def define
+  def define
 
-      desc 'Build this project into a Debian package'
-      task self.task_name => self.prerequisites do
-        debianize unless File.directory? 'debian'
-        packagize
+    desc 'Build this project into a Debian package'
+    task self.task_name => [ "#{self.task_name}:clean",
+                             "#{self.task_name}:build",
+                             "#{self.task_name}:package", ]
+    
+    namespace self.task_name do
+    
+      # perform the actual package build
+      task :build => self.prerequisites
+
+      # package the project
+      task :package => %w{dh:testdir    dh:testroot
+                          dh:install    dh:installdocs
+                          dh:installchangelogs
+                          dh:compress   dh:installdeb
+                          dh:gencontrol} do
+        mkdir Pallet::PACKAGE_DIR unless File.directory?(Pallet::PACKAGE_DIR)
+        system *%W{dpkg-deb --build #{path_for(:bpkg)} #{path_for(:pkg)}}
       end
 
-      task 'clean'     => ['clean:deb']
-      task 'clean:deb' do
-        # don't call debian/rules clean if we've already been called
-        # through Make; this might not be entirely reliable...
-        ENV['MAKELEVEL'] or system 'fakeroot debian/rules clean' if File.exist? 'debian/rules'
-      end
+      desc 'Clean the Debian build tree'
+      task :clean => %w{dh:clean}
 
-      task 'clobber'     => ['clobber:deb']
-      task 'clobber:deb' do
-        rm_r 'debian' rescue nil
-        files = Dir["../#{@pallet.name}_#{@pallet.version}*.changes"] +
-                Dir["../#{@pallet.name}_#{@pallet.version}*.deb"]
-        files.each {|f| rm f if File.exist? f }
+      desc 'Remove all Debian files generated by pallet'
+      task :clobber do
+        rm_r path_for(:spkg) if File.exist? path_for(:pstamp)
       end
+ 
+      namespace :dh do
 
-    end
+        # perform a clean of the entire debian tree
+        task :clean => %w{testdir testroot} do
+          rm_r path_for(:bpkg), :force => true
+          rm path_for(:spkg, 'files'), :force => true
+        end
 
-    private
+        # become fakeroot if not root already; god this is evil
+        task :testroot do
+          unless Process.uid == 0
+            begin
+              exec("fakeroot #{$0} #{ARGV.join(' ')}")
+            rescue Errno::ENOENT => ex
+              fail(<<-MESSAGE.margin.gsub(%r{\n}, ' '))
+                |fakeroot must be installed if packaging is not
+                |performed as root
+              MESSAGE
+            end
+          end
+        end
 
-    # 
-    # Build the _debian/_ directory under the project root
-    #
-    def debianize
+        # ensure that we're in the proper directory
+        task :testdir => path_for(:spkg)
+
+        # install binary package directory
+        task :install => path_for(:bpkg)
+
+        # install changelogs
+        task :installchangelogs => path_for(:docs, 'changelog.Debian')
+
+        # install documentation directory
+        task :installdocs => path_for(:docs)
+
+        # compress non-html, non-css, non-compressed files 
+        task :compress => [ path_for(:docs), path_for(:man), path_for(:info) ] do
+          [:docs, :man, :info].each do |doc|
+            Dir[path_for(doc, '*')].each do |filename|
+              next unless File.file?(filename)
+              next if File.size(filename) < 4096
+              next if filename =~ %r{\.(html|css)$}
+              next if filename =~ %r{\.(bz2|gz|zip)$}
+              next if filename =~ %r{changelog}
+              File.open(filename) do |f|
+                Zlib::GzipWriter.open("#{filename}.gz") do |gz|
+                  gz.write f.read
+                end
+              end
+              File.unlink filename
+            end
+          end
+        end
 
-      locations = [File.dirname(__FILE__) + '/../../share/debian',
-                   '/usr/share/pallet/debian']
-      templates = locations.find {|f| puts f; File.directory? f }
+        task :fixperms do
+          [:docs, :man].each do |doc|
+            Dir[path_for(doc, '**', '*')].each do |f|
+              dirs, files = f.partition {|f| File.directory?(f) }
+              chown 'root', 'root', dirs
+              chown 'root', 'root', files
+            end
+          end
+          Dir[path_for(:bpkg, '**', '*')].each do |f|
+            mode = File.stat(f)
+            case
+              when File.dirname(f) =~ %r{/bin/}       then chmod(f, mode & 0755)
+              when File.dirname(f) =~ %r{/usr/games}  then chmod(f, mode & 0755)
+              when File.dirname(f) =~ %r{/etc/init.d} then chmod(f, mode & 0755)
+              when File.directory?(f)                 then chmod(f, mode & 0755)
+              else                                         chmod(f, mode & 0644)
+            end
+          end
+        end
 
-      # make the target directory
-      mkdir 'debian'
+        task :installdeb => path_for(:ctrl)
 
-      # copy/gsub template files into place
-      Dir[templates + '/**/*'].each do |file|
+        task :gencontrol => path_for(:ctrl, 'control')
         
-        dest = 'debian/' + File.basename(file)
-
-        # gsub our replacements in the file in memory, then write back
-        # out to the destination
-        begin
-          s = File.open(file, File::RDONLY)
-          d = File.open(dest, File::WRONLY | File::CREAT)
-          d.write replacements.inject(s.readlines.join) {|contents, rep| contents.gsub %r|##{rep[0]}#|, rep[1] }
-        ensure
-          s.close
-          d.close
-        end
+      end
 
+      # debian/
+      file path_for(:spkg) do
+        mkdir path_for(:spkg)
+        touch path_for(:pstamp)
+        install self.changelog, path_for(:spkg, 'changelog') if self.changelog
+        install self.copyright, path_for(:spkg, 'copyright') \
+          rescue raise ArgumentError, 'copyright file must be present'
+        inflate_templates(path_for(:spkg), *Dir[path_for(:stmpl, '*')])
       end
 
-      # mark debian/rules as executable
-      chmod 0755, 'debian/rules'
+      # debian/foo
+      file path_for(:bpkg) => path_for(:spkg) do
+        mkdir_p path_for(:bpkg)
+        files.each {|i| i.install(path_for(:bpkg)) }
+      end
 
-      # relocate any additional scripts into the debian directory
-      scripts.each_pair do |type, location|
-        ln_sf "../#{location}", "debian/#{type}"
+      # debian/foo/usr/share/doc/foo
+      file path_for(:docs) => path_for(:bpkg) do
+        mkdir_p path_for(:docs)
+        install path_for(:spkg, 'copyright'), path_for(:docs, 'copyright')
+        docs.each {|i| i.install(path_for(:docs)) }
+      end
+      
+      # debian/foo/usr/share/doc/foo/changelog.Debian
+      file path_for(:docs, 'changelog.Debian') => path_for(:docs) do
+        install path_for(:spkg, 'changelog'), path_for(:docs, 'changelog.Debian')
       end
 
-    end
+      # man/info
+      file path_for(:man)
+      file path_for(:info)
 
-    def packagize
-      system self.commands.package
-    end
+      # debian/foo/DEBIAN
+      file path_for(:ctrl) => path_for(:bpkg) do
+        mkdir_p path_for(:ctrl)
+        [:postinst, :preinst, :postrm, :prerm].each do |script|
+          cp scripts[script], path_for(:ctrl) if scripts[script]
+        end
+        File.open(path_for(:ctrl, 'conffiles'), 'w') do |f|
+          # cd into the directory, so filelists from this location will
+          # be accurate
+          chdir(path_for(:bpkg)) do
+            files = (Dir['etc/**/*'] + configs.to_a).find_all {|f| File.file? f }
+            f.write files.join("\n")
+          end
+        end
+      end
 
-    def replacements
-      @replacements_cache ||= {
-        'ARCHITECTURE' => lambda { self.architecture },
-        'BUILD_DEPS'   => lambda { self.build_depends.join ', ' },
-        'CHANGELOG'    => lambda { self.changelog },
-        'CLEAN'        => lambda { self.commands.clean },
-        'CONFFILES'    => lambda { conffiles },
-        'DATE'         => lambda { %x{822-date}.chomp },
-        'DEPENDS'      => lambda { self.depends.join ', ' },
-        'DESCRIPTION'  => lambda { @pallet.description.gsub(/\n/, "\n ") },
-        'DIRECTORIES'  => lambda { directories },
-        'DOCS'         => lambda { system self.commands.document if self.commands.document; self.docs.join "\n" },
-        'EMAIL'        => lambda { @pallet.email },
-        'FILES'        => lambda { system self.commands.build if self.commands.build; install },
-        'INSTALL'      => lambda { self.commands.install ? "#{self.commands.install} DESTDIR=debian/#{@pallet.name}" : nil },
-        'MAKE'         => lambda { self.commands.build },
-        'MODE'         => lambda { self.architecture == 'all' ? 'indep' : 'arch' },
-        'PACKAGE'      => lambda { @pallet.name },
-        'POLICY'       => lambda { DEBIAN_POLICY_VERSION },
-        'REQUIREMENTS' => lambda { self.requirements.map {|r| ' * ' + r }.join "\n" },
-        'SUMMARY'      => lambda { @pallet.summary },
-        'UNUSED-MODE'  => lambda { self.architecture == 'all' ? 'arch' : 'indep' },
-        'USERNAME'     => lambda { @pallet.author },
-        'VERSION'      => lambda { @pallet.version },
-      }.instance_eval { each {|k,v| self[k] = v.call.to_s } }
-    end
+      # debian/foo/DEBIAN/control
+      file path_for(:ctrl, 'control') => path_for(:ctrl) do
+        system *%W{dpkg-gencontrol -Pdebian/#{@pallet.name} -p#{@pallet.name}}
+      end
 
-    # 
-    # Generate the complete list of directories needed.
-    #
-    def directories
-      self.files.inject([]) {|m, s| m + s.directories.values }.uniq.join "\n"
     end
 
-    # 
-    # Generate a list of "install" commands to move files into the
-    # correct directory.
-    #
-    def install
-      self.files.inject([]) do |m,s|
-        m + s.files.map {|src, dst| "#{src} #{File.dirname(dst)}" }
-      end.join "\n"
+    # have clean/clobber depend on our custom clean/clobber
+    task :clean   => "#{self.task_name}:clean"
+    task :clobber => "#{self.task_name}:clobber"
+
+  end
+
+  private
+
+  # 
+  # Will deconstruct a hash parameter into an array consisting of its
+  # one key and an array containing its value. Useful for deconstructing
+  # Rake-style "task_name => [dependency]" style args.
+  #
+  def deconstruct_hash(hash)
+    case hash
+    when Hash
+      fail "Too many task names: #{hash.keys.join(' ')}" if hash.size > 1
+      fail "No task name given" if hash.size < 1
+      pallet = hash.keys[0]
+      deps   = hash[pallet]
+      deps   = [deps] if [String, Symbol, Regexp, Proc].find {|f| f === deps }
+      [pallet, deps]
+    else
+      [hash, []]
     end
+  end
+
+  # 
+  # Moves templates to the destination directory, inflating any
+  # parameters inside the template to their value in +replacements+.
+  #
+  def inflate_templates(destination, *files)
+
+    files.each do |file|
+      
+      dest = File.join(destination, File.basename(file))
+      next if File.exist?(dest)
+
+      # gsub our replacements in the file in memory, then write back out
+      # to the destination
+      begin
+        s = File.open(file, File::RDONLY)
+        d = File.open(dest, File::WRONLY | File::CREAT, 
+                            File.stat(file).mode & 0777)
+        d.write(replacements.inject(s.readlines.join) do |contents, rep|
+          contents.gsub %r|##{rep[0]}#|, rep[1]
+        end)
+      ensure
+        s.close if s
+        d.close if d
+      end
 
-    #
-    # Returns a list of configuration files in _files_, from the
-    # perspective of the destination on the filesystem when the
-    # package is installed
-    #
-    def conffiles
-     self.files.inject([]) do |m,s|
-        m + (s.attributes[:conf] ? s.files.map {|src, dst| dst } : [])
-      end.join "\n"
     end
 
   end
+
+  def replacements
+    @replacements_cache ||= {
+      'ARCHITECTURE'  => self.architecture,
+      'BUILD_DEPS'    => self.build_depends.join(', '),
+      'CONFLICTS'     => self.conflicts,
+      'DATE'          => Time.now.rfc822,
+      'DEPENDS'       => self.depends.join(', '),
+      'DESCRIPTION'   => @pallet.description.gsub(%r{\n}, "\n "),
+      'DISTRIBUTION'  => self.distribution,
+      'EMAIL'         => @pallet.email,
+      'ENHANCES'      => self.enhances,
+      'PACKAGE'       => @pallet.name,
+      'PALLET_DEPS'   => PALLET_DEPENDS.join(', '),
+      'POLICY'        => POLICY_VERSION,
+      'PRIORITY'      => self.priority,
+      'PROVIDES'      => self.provides,
+      'RECOMMENDS'    => self.recommends,
+      'SECTION'       => self.section,
+      'SUMMARY'       => @pallet.summary,
+      'SUGGESTS'      => self.suggests,
+      'TARGET-UNUSED' => target[1],
+      'TARGET-USED'   => target[0],
+      'TASKNAME'      => self.task_name,
+      'VERSION'       => @pallet.version,
+      'URGENCY'       => self.urgency,
+      'USERNAME'      => @pallet.author,
+    }.instance_eval { each {|k,v| self[k] = v.to_s } }
+  end
+
+  # 
+  # Returns the build target for the project: indep or arch
+  #
+  def target
+    targets = %w{indep arch}
+    architecture == 'all' ? targets : targets.reverse
+  end
+
+  def path_for(type, *filename)
+    @dir_cache ||= {
+      :spkg   => [BUILD_DIR],
+      :pstamp => [BUILD_DIR, '.pallet-stamp'],
+      :bpkg   => [BUILD_DIR, @pallet.name],
+      :ctrl   => [BUILD_DIR, @pallet.name, 'DEBIAN'],
+      :docs   => [BUILD_DIR, @pallet.name, 'usr', 'share', 'doc', @pallet.name],
+      :man    => [BUILD_DIR, 'usr', 'share', 'man'],
+      :info   => [BUILD_DIR, 'usr', 'share', 'info'],
+      :tmpl   => [TEMPLATE_LOCATION],
+      :stmpl  => [TEMPLATE_LOCATION, %w{source}],
+      :btmpl  => [TEMPLATE_LOCATION, %w{binary}],
+      :pkg    => [Pallet::PACKAGE_DIR, "#{@pallet.name}_#{@pallet.version}_#{self.architecture}.deb"],
+    }
+    File.join(@dir_cache[type], *filename)
+  end
+
 end