fpm 0.3.11 → 0.4.0pre1

data/lib/fpm/package/gem.rb

@@ -0,0 +1,162 @@
+require "fpm/namespace"
+require "fpm/package"
+require "rubygems/package"
+require "rubygems"
+require "fileutils"
+require "fpm/util"
+
+# A rubygems package.
+#
+# This does not currently support 'output'
+#
+# The following attributes are supported:
+#
+# * :gem_bin_path
+# * :package_name_prefix
+# * :gem_gem
+class FPM::Package::Gem < FPM::Package
+  option "--bin-path", "DIRECTORY", "The directory to install gem executables",
+    :default => ::Gem::bindir
+  option "--package-prefix", "NAMEPREFIX",
+    "(DEPRECATED, use --package-name-prefix) Name to prefix the package " \
+    "name with." do |value|
+    @logger.warn("Using deprecated flag: --package-prefix. Please use " \
+                 "--package-name-prefix")
+    value
+  end
+  option "--package-name-prefix", "PREFIX", "Name to prefix the package " \
+    "name with.", :default => "rubygem"
+  option "--gem", "PATH_TO_GEM",
+          "The path to the 'gem' tool (defaults to 'gem' and searches " \
+          "your $PATH)", :default => "gem"
+
+  def input(gem)
+    # 'arg'  is the name of the rubygem we should unpack.
+    path_to_gem = download_if_necessary(gem, version)
+
+    # Got a good gem now (downloaded or otherwise)
+    #
+    # 1. unpack it into staging_path
+    # 2. take the metadata from it and update our wonderful package with it.
+    load_package_info(path_to_gem)
+    install_to_staging(path_to_gem)
+  end # def input
+
+  def download_if_necessary(gem, gem_version)
+    path = gem
+    if !File.exists?(path)
+      looks_like_name_re = /^[A-Za-z0-9_-]+$/
+      if path =~ looks_like_name_re
+        path = download(gem, gem_version)
+      else
+        raise FPM::Package::InvalidArgument.new("Gem '#{gem}' doesn't appear to be a valid rubygem file or name?")
+      end
+    end
+
+    @logger.info("Using gem file", :path => path)
+    return path
+  end # def download_if_necessary
+
+  def download(gem_name, gem_version=nil)
+    # This code mostly mutated from rubygem's fetch_command.rb
+    # Code use permissible by rubygems's "GPL or these conditions below"
+    # http://rubygems.rubyforge.org/rubygems-update/LICENSE_txt.html
+
+    @logger.info("Trying to download", :gem => gem_name, :version => gem_version)
+    dep = ::Gem::Dependency.new(gem_name, gem_version)
+
+    # TODO(sissel): Make a flag to allow prerelease gems?
+    #dep.prerelease = options[:prerelease]
+
+    if ::Gem::SpecFetcher.fetcher.respond_to?(:fetch_with_errors)
+      specs_and_sources, errors =
+        ::Gem::SpecFetcher.fetcher.fetch_with_errors(dep, true, true, false)
+    else
+      specs_and_sources =
+        ::Gem::SpecFetcher.fetcher.fetch(dep, true)
+      errors = "???"
+    end
+    spec, source_uri = specs_and_sources.sort_by { |s,| s.version }.last
+
+    if spec.nil? then
+      @logger.error("Invalid gem?", :name => gem_name, :version => gem_version, :errors => errors)
+      raise InvalidArgument.new("Invalid gem: #{gem_name}")
+    end
+
+    path = ::Gem::RemoteFetcher.fetcher.download(spec, source_uri)
+    return path
+  end # def download
+
+  def load_package_info(gem_path)
+    file = File.new(gem_path, 'r')
+
+    ::Gem::Package.open(file, 'r') do |gem|
+      spec = gem.metadata
+
+      if !attributes[:gem_package_prefix].nil?
+        attributes[:gem_package_name_prefix] = attributes[:gem_package_prefix]
+      end
+
+      self.name = [attributes[:gem_package_name_prefix], spec.name].join("-")
+      self.license = (spec.license or "no license listed in #{File.basename(file)}")
+      self.version = spec.version.to_s
+      self.vendor = spec.author
+      self.url = spec.homepage
+      self.category = "Languages/Development/Ruby"
+
+      # if the gemspec has C extensions defined, then this should be a 'native' arch.
+      if !spec.extensions.empty?
+        self.architecture = "native"
+      else
+        self.architecture = "all"
+      end
+
+      # make sure we have a description
+      description_options = [ spec.description, spec.summary, "#{spec.name} - no description given" ]
+      self.description = description_options.find { |d| !(d.nil? or d.strip.empty?) }
+
+      # Upstream rpms seem to do this, might as well share.
+      self.provides << "rubygem(#{self.name})"
+
+      # By default, we'll usually automatically provide this, but in the case that we are
+      # composing multiple packages, it's best to explicitly include it in the provides list.
+      self.provides << "rubygem-#{self.name}"
+
+      spec.runtime_dependencies.map do |dep|
+        # rubygems 1.3.5 doesn't have 'Gem::Dependency#requirement'
+        if dep.respond_to?(:requirement)
+          reqs = dep.requirement.to_s
+        else
+          reqs = dep.version_requirements
+        end
+
+        # Some reqs can be ">= a, < b" versions, let's handle that.
+        reqs.to_s.split(/, */).each do |req|
+          self.dependencies << "#{attributes[:gem_package_name_prefix]}-#{dep.name} #{req}"
+        end
+      end # runtime_dependencies
+    end # ::Gem::Package
+  end # def load_package_info
+
+  def install_to_staging(gem_path)
+    if attributes.include?(:path_prefix)
+      installdir = "#{staging_path}/#{attributes[:path_prefix]}"
+    else
+      installdir = File.join(staging_path, ::Gem::dir)
+    end
+
+    ::FileUtils.mkdir_p(installdir)
+    # TODO(sissel): Allow setting gem tool path
+    args = [attributes[:gem_gem], "install", "--quiet", "--no-ri", "--no-rdoc",
+       "--install-dir", installdir, "--ignore-dependencies", "-E"]
+    if attributes[:gem_bin_path]
+      bin_path = File.join(staging_path, attributes[:gem_bin_path])
+      args += ["--bindir", bin_path]
+    end
+
+    args << gem_path
+    safesystem(*args)
+  end # def install_to_staging
+
+  public(:input, :output)
+end # class FPM::Package::Gem

data/lib/fpm/{source → package}/npm.rb

@@ -1,9 +1,9 @@
 require "fpm/namespace"
-require "fpm/source"
+require "fpm/package"
 require "fpm/util"
 require "fileutils"
 
-class FPM::Source::Npm < FPM::Source
+class FPM::Package::NPM < FPM::Package
   def get_source(params)
     @npm = @paths.first
   end # def get_source
@@ -33,4 +33,4 @@ class FPM::Source::Npm < FPM::Source
     safesystem(*["gzip", "-f", tar_path])
   end
 
-end # class FPM::Source::Gem
+end # class FPM::Package::NPM

data/lib/fpm/package/pear.rb

@@ -0,0 +1,41 @@
+require "fpm/namespace"
+require "fpm/package"
+require "fileutils"
+require "fpm/util"
+
+class FPM::Package::PEAR < FPM::Package
+  option "--package-prefix", "PREFIX",
+    "Name prefix for python package", :default => "php-pear"
+
+  def input(input_package)
+    if !program_in_path?("pear")
+      raise ExecutableNotFound.new("pear")
+    end
+
+    # Create a temporary config file
+    @logger.debug("Creating pear config file")
+    config = File.expand_path(build_path("pear.config"))
+    installroot = attributes[:prefix] || "/usr/share"
+    safesystem("pear", "config-create", staging_path(installroot), config)
+
+    @logger.info("Fetching package information", :package => input_package)
+    pear_cmd = "pear -c #{config} remote-info #{input_package}"
+    name = %x{#{pear_cmd} | sed -ne '/^Package\s*/s/^Package\s*//p'}.chomp
+    self.name = "#{attributes[:pear_package_prefix]}-#{name}"
+    self.version = %x{#{pear_cmd} | sed -ne '/^Latest\s*/s/^Latest\s*//p'}.chomp
+    self.description  = %x{#{pear_cmd} | sed -ne '/^Summary\s*/s/^Summary\s*//p'}.chomp
+
+    @logger.info("Installing pear package", :package => input_package,
+                  :directory => staging_path)
+    ::Dir.chdir(staging_path) do
+      safesystem("pear", "-c", config, "install", "-n", "-f", "-P", ".",
+                 input_package)
+    end
+ 
+    # Remove the stuff we don't want
+    delete_these = [".depdb", ".depdblock", ".filemap", ".lock", ".channel"]
+    Find.find(staging_path) do |path|
+      FileUtils.rm_r(path) if delete_these.include?(File.basename(path))
+    end
+  end # def input
+end # class FPM::Package::PEAR

data/lib/fpm/{target → package}/puppet.rb

@@ -5,9 +5,7 @@ require "fpm/errors"
 require "etc"
 require "fileutils"
 
-# TODO(sissel): Add dependency checking support.
-# IIRC this has to be done as a 'checkinstall' step.
-class FPM::Target::Puppet < FPM::Package
+class FPM::Package::Puppet < FPM::Package
   def architecture
     case @architecture
     when nil, "native"

data/lib/fpm/{source → package}/pyfpm/get_metadata.py

@@ -61,7 +61,7 @@ class get_metadata(Command):
       dependencies = [dependencies]
 
     final_deps = []
-    dep_re = re.compile("([^<>= ]+)(?:\s*([<>=]{1,2})\s*(.*))?$")
+    dep_re = re.compile("([^<>= ]+)(?:\s*([<>=]{1,2})\s*([^,]*))?(?:,\s*([<>=]{1,2})\s*(.*))?$")
     for dep in dependencies:
       # python deps are strings that look like:
       # "packagename"
@@ -74,10 +74,17 @@ class get_metadata(Command):
       elif m.groups()[1] is None:
         name, cond, version = m.groups()[0], ">=", 0
       else:
-        name, cond, version = m.groups()
+        groups = m.groups()
+        name, cond, version = groups[0:3]
+        if groups[3] is not None:
+          final_deps.append("%s %s %s" % (groups[0],
+                                          self._replace_deprecated(groups[3]),
+                                          groups[4]))
       # end if
 
-      final_deps.append("%s %s %s" % (name, cond, version))
+      final_deps.append("%s %s %s" % (name,
+                                      self._replace_deprecated(cond),
+                                      version))
     # end for i in dependencies
 
     data["dependencies"] = final_deps
@@ -90,4 +97,9 @@ class get_metadata(Command):
       print json.write(data)
 
   # def run
+
+  def _replace_deprecated(self, sign):
+    """Replace deprecated operators"""
+    return {'<': '<<', '>': '>>'}.get(sign, sign)
+
 # class list_dependencies

data/lib/fpm/package/python.rb

@@ -0,0 +1,125 @@
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/util"
+require "rubygems/package"
+require "rubygems"
+require "fileutils"
+require "tmpdir"
+require "json"
+
+class FPM::Package::Python < FPM::Package
+  option "--bin", "PYTHON_EXECUTABLE",
+    "The path to the python executable you wish to run.", :default => "python"
+  option "--easyinstall", "EASYINSTALL_EXECUTABLE",
+    "The path to the easy_install executable tool", :default => "easy_install"
+  option "--pypi", "PYPI_URL",
+    "PyPi Server uri for retrieving packages.",
+    :default => "http://pypi.python.org/simple"
+  option "--package-prefix", "PREFIX",
+    "Name prefix for python package", :default => "python"
+
+  def input(package)
+    path_to_package = download_if_necessary(package, version)
+
+    if File.directory?(path_to_package)
+      setup_py = File.join(path_to_package, "setup.py")
+    else
+      setup_py = path_to_package
+    end
+
+    if !File.exists?(setup_py)
+      @logger.error("Could not find 'setup.py'", :path => setup_py)
+      raise "Unable to find python package; tried #{setup_py}"
+    end
+
+    load_package_info(setup_py)
+    install_to_staging(setup_py)
+  end # def input
+
+  def download_if_necessary(package, version=nil)
+    path = package
+    # If it's a path, assume local build.
+    if File.directory?(path) or (File.exists?(path) and File.basename(path) == "setup.py")
+      return path
+    end
+
+    @logger.info("Trying to download", :package => package)
+
+    if version.nil?
+      want_pkg = "#{package}"
+    else
+      want_pkg = "#{package}==#{version}"
+    end
+
+    # TODO(sissel): support a settable path to 'easy_install'
+    # TODO(sissel): support a tunable for uthe url to pypi
+    safesystem("easy_install", "-i", "http://pypi.python.org/simple",
+               "--editable", "-U", "--build-directory", build_path, want_pkg)
+
+    # easy_install will put stuff in @tmpdir/packagename/, so find that:
+    #  @tmpdir/somepackage/setup.py
+    dirs = ::Dir.glob(File.join(build_path, "*"))
+    if dirs.length != 1
+      raise "Unexpected directory layout after easy_install. Maybe file a bug? The directory is #{build_path}"
+    end
+    return dirs.first
+  end # def download
+
+  def load_package_info(setup_py)
+    if !attributes.include?(:package_name_prefix)
+      attributes[:package_name_prefix] = "python"
+    end
+
+    # Add ./pyfpm/ to the python library path
+    pylib = File.expand_path(File.dirname(__FILE__))
+    setup_cmd = "env PYTHONPATH=#{pylib} #{self.attributes[:python_bin]} #{setup_py} --command-packages=pyfpm get_metadata"
+    output = ::Dir.chdir(File.dirname(setup_py)) { `#{setup_cmd}` }
+    puts output
+    metadata = JSON.parse(output[/\{.*\}/msx])
+
+    self.architecture = metadata["architecture"]
+    self.description = metadata["description"]
+    self.license = metadata["license"]
+    self.version = metadata["version"]
+    self.url = metadata["url"]
+
+    self.name = fix_name(metadata["name"])
+
+    self.dependencies += metadata["dependencies"].collect do |dep|
+      name, cmp, version = dep.split
+      name = fix_name(name)
+      "#{name} #{cmp} #{version}"
+    end
+  end # def load_package_info
+
+  # Sanitize package name.
+  # Some PyPI packages can be named 'python-foo', so we don't want to end up
+  # with a package named 'python-python-foo'.
+  # But we want packages named like 'pythonweb' to be suffixed
+  # 'python-pythonweb'.
+  def fix_name(name)
+    if name.start_with?("python")
+      # If the python package is called "python-foo" strip the "python-" part while
+      # prepending the package name prefix.
+      return [attributes[:package_name_prefix], name.gsub(/^python-/, "")].join("-")
+    else
+      return [attributes[:package_name_prefix], name].join("-")
+    end
+  end # def fix_name
+
+  def install_to_staging(setup_py)
+    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
+      if attributes[:prefix]
+        safesystem(attributes[:python_bin], "setup.py", "install", "--prefix",
+                   File.join(staging_path, attributes[:prefix]))
+      else
+        safesystem(attributes[:python_bin], "setup.py", "install", "--root",
+                   staging_path)
+      end
+    end
+  end # def install_to_staging
+end # class FPM::Package::Python

data/lib/fpm/package/rpm.rb

@@ -0,0 +1,132 @@
+require "fpm/package"
+require "backports"
+require "fileutils"
+require "find"
+require "arr-pm/file" # gem 'arr-pm'
+
+# RPM Package type.
+#
+# Build RPMs without having to waste hours reading Maximum-RPM.
+# Well, in case you want to read it, here: http://www.rpm.org/max-rpm/
+#
+# The following attributes are supported:
+#
+# * :rpm_rpmbuild_define - an array of definitions to give to rpmbuild.
+#   These are used, verbatim, each as: --define ITEM
+class FPM::Package::RPM < FPM::Package
+  option "--rpmbuild-define", "DEFINITION",
+    "Pass a --define argument to rpmbuild." do |define|
+    attributes[:rpm_rpmbuild_define] ||= []
+    attributes[:rpm_rpmbuild_define] << define
+  end
+
+  private
+
+  def architecture
+    case @architecture
+      when nil
+        return %x{uname -m}.chomp   # default to current arch
+      when "amd64" # debian and redhat disagree on architecture names
+        return "x86_64"
+      when "native"
+        return %x{uname -m}.chomp   # 'native' is current arch
+      when "all"
+        # Translate fpm "all" arch to what it means in RPM.
+        return "noarch"
+      else
+        return @architecture
+    end
+  end # def architecture
+
+  # See FPM::Package#converted_from
+  def converted_from(origin)
+    if origin == FPM::Package::Gem
+      # Gem dependency operator "~>" is not compatible with rpm. Translate any found.
+      fixed_deps = []
+      self.dependencies.collect do |dep|
+        name, op, version = dep.split(/\s+/)
+        if op == "~>"
+          # ~> x.y means: > x.y and < (x+1).0
+          fixed_deps << "#{name} > #{version}"
+          fixed_deps << "#{name} < #{version.to_i + 1}.0.0"
+        else
+          fixed_deps << dep
+        end
+      end
+      self.dependencies = fixed_deps
+    end
+  end # def converted
+
+  def input(path)
+    rpm = ::RPM::File.new(path)
+
+    tags = {}
+    rpm.header.tags.each do |tag|
+      tags[tag.tag] = tag.value
+    end
+
+    self.architecture = tags[:arch]
+    self.category = tags[:group]
+    self.config_files = config_files
+    self.description = tags[:description]
+    self.epoch = (tags[:epoch] || [nil]).first # for some reason epoch is an array
+    self.iteration = tags[:release]
+    self.license = tags[:license]
+    self.maintainer = maintainer
+    self.name = tags[:name]
+    self.url = tags[:url]
+    self.vendor = tags[:vendor]
+    self.version = tags[:version]
+
+    # TODO(sissel): Collect {pre,post}{install,uninstall} scripts
+    # TODO(sissel): put 'trigger scripts' stuff into attributes
+    # TODO(sissel): support provides
+    # TODO(sissel): support conflicts
+    # TODO(sissel): support replaces
+
+    self.dependencies += rpm.requires.collect do |name, operator, version|
+      [name, operator, version].join(" ")
+    end
+    #input.replaces += replaces
+
+    # Extract to the staging directory
+    rpm.extract(staging_path)
+  end # def input
+
+  def output(output_path)
+    %w(BUILD RPMS SRPMS SOURCES SPECS).each { |d| FileUtils.mkdir_p(build_path(d)) }
+    args = ["rpmbuild", "-bb",
+      "--define", "buildroot #{build_path}/BUILD",
+      "--define", "_topdir #{build_path}",
+      "--define", "_sourcedir #{build_path}",
+      "--define", "_rpmdir #{build_path}/RPMS"]
+
+    (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)
+    File.write("/tmp/rpm.spec", rpmspec)
+
+    args << specfile
+    #if defines.empty?
+      #args = prefixargs + spec
+    #else
+      #args = prefixargs + defines.collect{ |define| ["--define", define] }.flatten + spec
+    #end
+
+    @logger.info("Running rpmbuild", :args => args)
+    safesystem(*args)
+
+    ::Dir["#{build_path}/RPMS/**/*.rpm"].each do |rpmpath|
+      # This should only output one rpm, should we verify this?
+      FileUtils.cp(rpmpath, output_path)
+    end
+
+    @logger.log("Created rpm", :path => output_path)
+  end # def output
+
+  public(:input, :output, :converted_from)
+end # class FPM::Package::RPM