#!/usr/bin/env ruby
#

require "rubygems"
require "optparse"
require "ostruct"
require "erb"
require "fpm"

def main(args)
  settings = OpenStruct.new

  opts = OptionParser.new do |opts|
    opts.banner = "Usage: #{$0} [options]"
    
    # TODO(sissel): Maybe this should be '-o OUTPUT' ?
    opts.on("-p PACKAGEFILE", "--package PACKAGEFILE",
            "The package file to manage") do |path|
      if path =~ /^\//
        settings.package_path = path
      else
        settings.package_path = "#{Dir.pwd}/#{path}"
      end

    opts.on("-C DIRECTORY", "Change directory before searching for files") do |dir|
      settings.chdir = dir
    end
  end # OptionParser

  opts.parse!(args)








  if !settings.package_path
    $stderr.puts "No package file given to manage. Give with -p PACKAGEFILE"
    return 1
  end



  package = FPM::Deb.new

  package.name = settings.package_name
  package.version = settings.version


  package.maintainer = settings.maintainer if settings.maintainer



  package.architecture = settings.architecture or %x{uname -m}.chomp



  package.assemble({








    "output" => settings.package_path,














    "root" => settings.chdir,

    "paths" => args, # Remainder of args are paths.





















  })




end # def main






















ret = main(ARGV) 
exit(ret != nil ? ret : 0)

Gem::Specification.new do |spec|
  files = []
  dirs = %w{lib bin templates}
  dirs.each do |dir|
    files += Dir["#{dir}/**/*"]
  end

  rev = Time.now.strftime("%Y%m%d%H%M%S")
  spec.name = "fpm"
  spec.version = "0.1.0"

require "fpm/namespace"
require "fpm/package"
require "fpm/deb"

#!/usr/bin/env ruby
#

require "erb"
require "fpm/namespace"
require "fpm/package"

class FPM::Deb < FPM::Package

  # Assemble the package.
  # params:
  #  "root" => "/some/path"   # the 'root' of your package directory
  #  "paths" => [ "/some/path" ...]  # paths to icnlude in this package
  #  "output" => "foo.deb"  # what to output to.
  #
  # The 'output' file path will have 'VERSION' and 'ARCH' replaced with
  # the appropriate values if if you want the filename generated.
  def assemble(params)
    raise "No package name given. Can't assemble package" if !@name

    root = params["root"]
    paths = params["paths"]
    output = params["output"]
    type = "deb" 

    p self.inspect

    # Debian calls x86_64 "amd64"
    @architecture = "amd64" if @architecture == "x86_64"

    output.gsub!(/VERSION/, "#{@version}-#{@iteration}")
    output.gsub!(/ARCH/, @architecture)

    builddir = "#{Dir.pwd}/build-#{type}-#{File.basename(output)}"
    @garbage << builddir

    Dir.mkdir(builddir) if !File.directory?(builddir)

    Dir.chdir(root || ".") do 
      self.tar("#{builddir}/data.tar", paths)
      # TODO(sissel): Make a helper method.
      system(*["gzip", "-f", "#{builddir}/data.tar"])

      # Generate md5sums
      md5sums = self.checksum(paths)
      File.open("#{builddir}/md5sums", "w") { |f| f.puts md5sums.join("\n") }

      # Generate 'control' file
      template = File.new("#{File.dirname(__FILE__)}/../../templates/deb.erb").read()
      control = ERB.new(template).result(binding)
      File.open("#{builddir}/control", "w") { |f| f.puts control }
    end

    # create control.tar.gz
    Dir.chdir(builddir) do
      # Make the control
      system("tar -zcf control.tar.gz control md5sums")
     
      # create debian-binary
      File.open("debian-binary", "w") { |f| f.puts "2.0" }

      # pack up the .deb
      system("ar -qc #{output} debian-binary control.tar.gz data.tar.gz")
    end
  end  # def assemble

  def checksum(paths)
    md5sums = []
    paths.each do |path|
      md5sums += %x{find #{path} -type f -print0 | xargs -0 md5sum}.split("\n")
    end
  end # def checksum
end # class FPM::Deb

module FPM; end

require "fpm/namespace"
require "socket" # for Socket.gethostname

class FPM::Package 
  # The name of this package
  attr_accessor :name

  # The version of this package (the upstream version)
  attr_accessor :version

  # The iteration of this 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.
  attr_accessor :iteration

  # Who maintains this package? This could be the upstream author
  # or the package maintainer. You pick.
  attr_accessor :maintainer

  # URL for this package.
  # Could be the homepage. Could be the download url. You pick.
  attr_accessor :url

  # The category of this package.
  # RedHat calls this 'Group'
  # Debian calls this 'Section'
  # FreeBSD would put this in /usr/ports/<category>/...
  attr_accessor :category

  # A identifier representing the license. Any string is fine.
  attr_accessor :license

  # What architecture is this package for?
  attr_accessor :architecture

  # TODO(sissel): Dependencies?
  
  def initialize
    @iteration = 1
    @url = ""
    @category = "default"
    @license = "unknown"
    @maintainer = "<#{ENV["USER"]}@#{Socket.gethostname}>"
    @architecture = nil

    # Garbage is stuff you may want to clean up.
    @garbage = []
  end

  def tar(output, paths)
    dirs = []
    paths.each do |path|
      while path != "/" and path != "."
        dirs << path if !dirs.include?(path) 
        path = File.dirname(path)
      end
    end # paths.each
    dirs = dirs.sort { |a,b| a.length <=> b.length}
    system(*["tar", "--owner=root", "--group=root", "-cf", output, "--no-recursion", *dirs])
    system(*["tar", "--owner=root", "--group=root", "-rf", output, *paths])
  end

end

Package: <%= @package %>
Version: <%= @version %>-<%= @package_iteration %>
Architecture: <%= @architecture %>
Maintainer: <%= @maintainer %>
Installed-Size: 12345
Depends: <%= @dependencies.join(", ") rescue "" %>
Section: <%= @category %> 
Priority: extra
Homepage: <%= @url %>
Description: <%= @summary %>
  <%= @summary %>

    maintainer = package["author"]
  else
    m = package["maintainers"][0] \
      rescue { "name" => "missing upstream author", "email" => ENV["USER"] }
    maintainer = "#{m["name"]} <#{m["email"]}>"
  end

  pkgcmd = [ "fpm", 
    "-n", "nodejs-#{package["name"]}",
    "-v", package["version"],
    "-m", maintainer,
    "-a", "all",
  ]

  depends.each do |dep|