require "fpm/namespace"
require "fpm/builder"

require "fpm/package"
require "fpm/target/deb"
require "fpm/target/rpm"

require "fpm/source"
require "fpm/source/dir"
require "fpm/source/gem"
require "fpm/source/python"
require "fpm/source/rpm"

    ::Dir.chdir(builddir) do
      @package.build!({
        :tarball => tar_path,
        :output => output
      })
    end

    garbage << @source.garbage if @source.respond_to?(:garbage)

    cleanup!
  end # def assemble!

  private
  def builddir
    @builddir ||= File.expand_path(
      "#{Dir.pwd}/build-#{@package.type}-#{File.basename(output)}"
    )

__all__ = [ "list_dependencies" ]

from distutils.core import Command
import json
import re

# Note, the last time I coded python daily was at Google, so it's entirely
# possible some of my techniques below are outdated or bad.
# If you have fixes, let me know.

class get_metadata(Command):
  description = "get package metadata"
  user_options = []

  def initialize_options(self):
    pass
  # def initialize_options

  def finalize_options(self):
    pass
  # def finalize_options

  def run(self):
    #print type(self.distribution)
    #for i in sorted(dir(self.distribution)):
      #if i.startswith("_"):
        #continue
      ###print "%s: %r" % (i, self.__getattr__(i))
      #print "%s" % i

    data = {
      "name": self.distribution.get_name(),
      "version": self.distribution.get_version(),
      "author": "%s <%s>" % (self.distribution.get_author(),
        self.distribution.get_author_email()),
      "description": self.distribution.get_description(),
      "license": self.distribution.get_license(),
      "url": self.distribution.get_url(),
    }

    # If there are python C/extension modules, we'll want to build a native
    # arch package.
    if self.distribution.has_ext_modules():
      data["architecture"] = "native"
    else:
      data["architecture"] = "all"
    # end if

    dependencies = []
    try:
      dependencies = self.distribution.install_requires
    except:
      pass

    final_deps = []
    dep_re = re.compile("([^<>= ]+)\s*([<>=]{1,2})\s*(.*)$")
    for dep in dependencies:
      # python deps are strings that look like:
      # "packagename"
      # "packagename >= version"
      # Replace 'packagename' with 'python#{suffix}-packagename'
      m = dep_re.match(dep)
      if len(m.groups()) == 1:
        name, cond, version = m.groups()[0], ">=", 0
      else:
        name, cond, version = m.groups()
      # end if

      final_deps.append("%s %s %s" % (name, cond, version))
    # end for i in dependencies

    data["dependencies"] = final_deps

    #print json.dumps(data, indent=2)
    print json.dumps(data, indent=2)
  # def run
# class list_dependencies

require "fpm/namespace"
require "fpm/source"
require "rubygems/package"
require "rubygems"
require "fileutils"
require "tmpdir"
require "json"

class FPM::Source::Python < FPM::Source
  def get_source(params)
    package = @paths.first
    if ["setup.py", "."].include?(package)
      # Assume we're building from an existing python package.
      # Source already acquired, nothing to do!
      return
    end

    if !File.exists?(package) 
      download(package)
    end
  end # def get_source

  def download(package)
    puts "Trying to download #{package} (using easy_install)"
    @tmpdir = ::Dir.mktmpdir("python-build", ::Dir.pwd)

    system("easy_install", "--editable", "--build-directory", @tmpdir, package)

    # easy_install will put stuff in @tmpdir/packagename/, flatten that.
    #  That is, we want @tmpdir/setup.py, and start with
    #  @tmpdir/somepackage/setup.py
    dirs = ::Dir.glob(File.join(@tmpdir, "*"))
    if dirs.length != 1
      raise "Unexpected directory layout after easy_install. Maybe file a bug? The directory is #{@tmpdir}"
    end
    @paths = dirs
  end # def download

  def get_metadata
    setup_py = @paths.first
    if File.directory?(setup_py)
      setup_py = File.join(setup_py, "setup.py")
      @paths = [setup_py]
    end

    if !File.exists?(setup_py)
      raise "Unable to find python package; tried #{setup_py}"
    end

    pylib = File.expand_path(File.dirname(__FILE__))
    setup_cmd = "env PYTHONPATH=#{pylib} python #{setup_py} --command-packages=pyfpm get_metadata"
    output = ::Dir.chdir(File.dirname(setup_py)) { `#{setup_cmd}` }
    puts output
    metadata = JSON.parse(output[/\{.*\}/msx])
    #p metadata

    self[:architecture] = metadata["architecture"]
    self[:description] = metadata["description"]
    self[:license] = metadata["license"]
    self[:version] = metadata["version"]
    self[:name] = "python#{self[:suffix]}-#{metadata["name"]}"
    self[:url] = metadata["url"]
    self[:dependencies] = metadata["dependencies"]
  end # def get_metadata

  def make_tarball!(tar_path, builddir)
    setup_py = @paths.first
    dir = File.dirname(setup_py)

    # Some setup.py's assume $PWD == current directory of setup.py, so let's
    # chdir first.
    ::Dir.chdir(dir) do
      system("python", "setup.py", "bdist")
    end

    dist_tar = ::Dir.glob(File.join(dir, "dist", "*.tar.gz")).first
    puts "Found dist tar: #{dist_tar}"
    puts "Copying to #{tar_path}"

    @paths = [ "." ]

    system("cp", dist_tar, "#{tar_path}.gz")
  end # def make_tarball!

  def garbage
    trash = []
    trash << @tmpdir if @tmpdir
    return trash
  end # def garbage

end # class FPM::Source::Gem