fpm 0.4.32 → 0.4.35

data/CHANGELIST

@@ -1,3 +1,19 @@
+0.4.35 (May 8, 2013)
+  - Fix dependencies listed in the gem.
+
+0.4.34 (May 7, 2013)
+  - Now supports CPAN - Perl mongers rejoice! For example:
+    'fpm -s cpan -t deb DBI'
+  - deb: fixed some additional complaints by lintian (#420, patch by Pranay
+    Kanwar)
+  - rpm: add flags --rpm-autoreqprov, --rpm-autoreq, and --rpm-autoprov
+    to tell rpm to enable that feature in the rpm spec. (#416, patch by Adam
+    Stephens)
+
+0.4.33 (April 9, 2013)
+  - Now supports npm, the node package manager. For example: 
+    'fpm -s npm -t deb express'
+
 0.4.32 (April 9, 2013)
   - COMPATIBILITY WARNING: rpm: The default epoch is now nothing because this
     aligns more closely with typical rpm packages in the real world. This

data/CONTRIBUTORS

@@ -18,6 +18,7 @@ Thomas Meson (github: zllak)
 Oliver Hookins (github: ohookins)
 llasram
 sbuss
+Brett Gailey (github: dnbert)
 
 If you have contributed (bug reports, feature requests, help in IRC, blog
 posts, code, etc) and aren't listed here, please let me know if you wish to be

data/lib/fpm/command.rb

@@ -77,52 +77,34 @@ class FPM::Command < Clamp::Command
   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
+    :multivalued => true, :attribute_name => :dependencies
 
   option "--no-depends", :flag, "Do not list any dependencies in this package",
     :default => false
 
-  option "--no-auto-depends", :flag, "Do not list any dependencies in this package automatically",
-    :default => false
+  option "--no-auto-depends", :flag, "Do not list any dependencies in this" \
+    "package automatically", :default => false
 
   option "--provides", "PROVIDES",
     "What this package provides (usually a name). This flag can be "\
-    "specified multiple times." do |val|
-    @provides ||= []
-    @provides << val
-  end # --provides
+    "specified multiple times.", :multivalued => true,
+    :attribute_name => :provides
   option "--conflicts", "CONFLICTS",
     "Other packages/versions this package conflicts with. This flag can " \
-    "specified multiple times." do |val|
-    @conflicts ||= []
-    @conflicts << val
-  end # --conflicts
+    "specified multiple times.", :multivalued => true,
+    :attribute_name => :conflicts
   option "--replaces", "REPLACES",
     "Other packages/versions this package replaces. This flag can be "\
-    "specified multiple times." do |val|
-    @replaces ||= []
-    @replaces << val
-  end # --replaces
+    "specified multiple times.", :multivalued => true,
+    :attribute_name => :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. If you have multiple files to mark as " \
-    "configuration files, specify this flag multiple times." do |val|
-    #You can specify a directory to have it scanned marking all files found as
-    #config files. If you have multiple "
-    @config_files ||= []
-    @config_files << val
-  end # --config-files
-  option "--directories", "DIRECTORIES",
-    "Mark a directory as being owned by the package" \
-    do |val|
-    @directories ||= []
-    @directories << val
-  end # directories
+    "configuration files, specify this flag multiple times.",
+    :multivalued => true, :attribute_name => :config_files
+  option "--directories", "DIRECTORIES", "Mark a directory as being owned " \
+    "by the package", :multivalued => true, :attribute_name => :directories
   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 " \
@@ -134,12 +116,14 @@ class FPM::Command < Clamp::Command
     "a name suffix to append to package and dependencies."
   option ["-e", "--edit"], :flag,
     "Edit the package spec before building.", :default => false
+
+  excludes = []
   option ["-x", "--exclude"], "EXCLUDE_PATTERN",
     "Exclude paths matching pattern (shell wildcard globs valid here). " \
     "If you have multiple file patterns to exclude, specify this flag " \
     "multiple times.", :attribute_name => :excludes do |val|
-    @excludes ||= []
-    @excludes << val
+    excludes << val
+    next excludes
   end # -x / --exclude
   option "--description", "DESCRIPTION", "Add a description for this package." \
     " You can include '\n' sequences to indicate newline breaks.",
@@ -199,10 +183,10 @@ class FPM::Command < Clamp::Command
 
   option "--template-value", "KEY=VALUE",
     "Make 'key' available in script templates, so <%= key %> given will be " \
-    "the provided value. Implies --template-scripts" do |kv|
+    "the provided value. Implies --template-scripts",
+    :multivalued => true do |kv| 
     @template_scripts = true
-    @template_values ||= []
-    @template_values << kv.split("=", 2)
+    next kv.split("=", 2)
   end
 
   option "--workdir", "WORKDIR",
@@ -220,16 +204,6 @@ class FPM::Command < Clamp::Command
     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)
@@ -239,7 +213,6 @@ class FPM::Command < Clamp::Command
     @dependencies = []
     @config_files = []
     @directories = []
-    @excludes = []
   end # def initialize
 
   # Execute this command. See Clamp::Command#execute and Clamp's documentation
@@ -406,8 +379,8 @@ class FPM::Command < Clamp::Command
     output = input.convert(output_class)
 
     # Provide any template values as methods on the package.
-    if !@template_values.nil?
-      @template_values.each do |key, value|
+    if template_scripts?
+      template_value_list.each do |key, value|
         (class << output; self; end).send(:define_method, key) { value }
       end
     end

data/lib/fpm/package.rb

@@ -93,9 +93,6 @@ class FPM::Package
   # (Not all packages support this)
   attr_accessor :replaces
 
-  # Array of glob patterns to exclude from this package
-  attr_accessor :excludes
-
   # a summary or description of the package
   attr_accessor :description
 
@@ -315,8 +312,11 @@ class FPM::Package
       .collect { |path| path[staging_path.length + 1.. -1] }
   end # def files
  
+  def template_dir
+    File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "templates"))
+  end
+
   def template(path)
-    template_dir = File.expand_path(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)

data/lib/fpm/package/cpan.rb

@@ -0,0 +1,190 @@
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/util"
+require "fileutils"
+require "find"
+
+class FPM::Package::CPAN < FPM::Package
+  # Flags '--foo' will be accessable  as attributes[:npm_foo]
+  option "--perl-bin", "PERL_EXECUTABLE",
+    "The path to the perl executable you wish to run.", :default => "perl"
+  option "--cpanm-bin", "CPANM_EXECUTABLE",
+    "The path to the cpanm executable you wish to run.", :default => "cpanm"
+  option "--package-name-prefix", "NAME_PREFIX", "Name to prefix the package " \
+    "name with.", :default => "perl"
+  option "--test", :flag, "Run the tests before packaging?", :default => true
+
+  private
+  def input(package)
+    require "ftw" # for http access
+    require "json"
+
+    agent = FTW::Agent.new
+    result = search(package, agent)
+    tarball = download(result, agent)
+    moduledir = unpack(tarball)
+
+    # Read package metadata (name, version, etc)
+    if File.exists?(File.join(moduledir, "META.json"))
+      metadata = JSON.parse(File.read(File.join(moduledir, ("META.json"))))
+    elsif File.exists?(File.join(moduledir, ("META.yml")))
+      require "yaml"
+      metadata = YAML.load_file(File.join(moduledir, ("META.yml")))
+    else
+      raise FPM::InvalidPackageConfiguration, 
+        "Could not find package metadata. Checked for META.json and META.yml"
+    end
+    self.version = metadata["version"]
+    self.description = metadata["abstract"]
+
+    self.license = case metadata["license"]
+      when Array; metadata["license"].first
+      else; metadata["license"]
+    end
+
+    if metadata.include?("distribution")
+      @logger.info("Setting package name from 'distribution'",
+                   :distribution => metadata["distribution"])
+      self.name = fix_name(metadata["distribution"])
+    else
+      @logger.info("Setting package name from 'name'",
+                   :name => metadata["name"])
+      self.name = fix_name(metadata["name"])
+    end
+
+    # Not all things have 'author' listed.
+    self.vendor = metadata["author"].join(", ") if metadata.include?("author")
+    self.url = metadata["resources"]["homepage"] rescue "unknown"
+
+    # TODO(sissel): figure out if this perl module compiles anything
+    # and set the architecture appropriately.
+    self.architecture = "all"
+
+    # Install any build/configure dependencies with cpanm.
+    # We'll install to a temporary directory.
+    @logger.info("Installing any build or configure dependencies")
+    safesystem(attributes[:cpan_cpanm_bin], "-L", build_path("cpan"), moduledir)
+
+    if !attributes[:no_auto_depends?] 
+      if metadata.include?("requires")
+        metadata["requires"].each do |dep_name, version|
+          # Special case for representing perl core as a version.
+          if dep_name == "perl"
+            self.dependencies << "#{dep_name} >= #{version}"
+            next
+          end
+          dep = search(dep_name, agent)
+          
+          if dep.include?("distribution")
+            name = fix_name(dep["distribution"])
+          else
+            name = fix_name(dep_name)
+          end
+
+          if version.to_s == "0"
+            # Assume 'Foo = 0' means any version?
+            self.dependencies << "#{name}"
+          else
+            self.dependencies << "#{name} = #{version}"
+          end
+        end
+      end
+    end #no_auto_depends
+
+    ::Dir.chdir(moduledir) do
+      # TODO(sissel): install build and config dependencies to resolve
+      # build/configure requirements.
+      # META.yml calls it 'configure_requires' and 'build_requires'
+      # META.json calls it prereqs/build and prereqs/configure
+ 
+      prefix = attributes[:prefix] || "/usr/local"
+      # TODO(sissel): Set default INSTALL path?
+      # perl -e 'use Config; print "$Config{sitelib}"'
+      safesystem(attributes[:cpan_perl_bin],
+                 "-Mlocal::lib=#{build_path("cpan")}",
+                 "Makefile.PL",
+                 "PREFIX=#{prefix}",
+                 # Have to specify INSTALL_BASE as empty otherwise
+                 # Makefile.PL lies and claims we've set both PREFIX and
+                 # INSTALL_BASE.
+                 "INSTALL_BASE="
+                )
+
+      make = [ "make" ]
+
+      safesystem(*make)
+      safesystem(*(make + ["test"])) if attributes[:cpan_test?]
+      safesystem(*(make + ["DESTDIR=#{staging_path}", "install"]))
+    end
+
+    # TODO(sissel): figure out if this perl module compiles anything
+    # and set the architecture appropriately.
+    self.architecture = "all"
+
+    # Find any shared objects in the staging directory to set architecture as
+    # native if found; otherwise keep the 'all' default.
+    Find.find(staging_path) do |path|
+      if path =~ /\.so$/  
+        @logger.info("Found shared library, setting architecture=native",
+                     :path => path)
+        self.architecture = "native" 
+      end
+    end
+  end
+
+  def unpack(tarball)
+    directory = build_path("module")
+    ::Dir.mkdir(directory)
+    args = [ "-C", directory, "-zxf", tarball,
+      "--strip-components", "1" ]
+    safesystem("tar", *args)
+    return directory
+  end
+
+  def download(metadata, agent)
+    distribution = metadata["distribution"]
+    author = metadata["author"]
+    @logger.info("Downloading perl module",
+                 :distribution => distribution,
+                 :version => version)
+
+    # default to latest versionunless we specify one
+    version = metadata["version"] if version.nil?
+
+    tarball = "#{distribution}-#{version}.tar.gz"
+    url = "http://search.cpan.org/CPAN/authors/id/#{author[0,1]}/#{author[0,2]}/#{author}/#{tarball}"
+    response = agent.get!(url)
+    if response.error?
+      @logger.error("Download failed", :error => response.status_line,
+                    :url => url)
+      raise FPM::InvalidPackageConfiguration, "metacpan query failed"
+    end
+
+    File.open(build_path(tarball), "w") do |fd|
+      response.read_body { |c| fd.write(c) }
+    end
+    return build_path(tarball)
+  end # def download
+
+  def search(package, agent)
+    @logger.info("Asking metacpan about a module", :module => package)
+    metacpan_url = "http://api.metacpan.org/v0/module/" + package
+    response = agent.get!(metacpan_url)
+    if response.error?
+      @logger.error("metacpan query failed.", :error => response.status_line,
+                    :module => package, :url => metacpan_url)
+      raise FPM::InvalidPackageConfiguration, "metacpan query failed"
+    end
+
+    data = ""
+    response.read_body { |c| data << c }
+    metadata = JSON.parse(data)
+    return metadata
+  end # def metadata
+
+  def fix_name(name)
+    return [attributes[:cpan_package_name_prefix], name].join("-").gsub("::", "-")
+  end # def fix_name
+
+  public(:input)
+end # class FPM::Package::NPM

data/lib/fpm/package/deb.rb

@@ -126,9 +126,14 @@ class FPM::Package::Deb < FPM::Package
         @architecture = %x{uname -m}.chomp
       end
     end
-    if @architecture == "x86_64"
+
+    case @architecture
+    when "x86_64"
       # Debian calls x86_64 "amd64"
       @architecture = "amd64"
+    when "noarch"
+      # Debian calls noarch "all"
+      @architecture = "all"
     end
     return @architecture
   end # def architecture
@@ -432,7 +437,7 @@ class FPM::Package::Deb < FPM::Package
     # Make the control.tar.gz
     with(build_path("control.tar.gz")) do |controltar|
       @logger.info("Creating", :path => controltar, :from => control_path)
-      safesystem(tar_cmd, "--numeric-owner", "--owner=0", "--group=0", "-zcf",
+      safesystem(tar_cmd, "--owner=root", "--group=root", "-zcf",
                  controltar, "-C", control_path, ".")
     end
 

data/lib/fpm/package/npm.rb

@@ -4,33 +4,95 @@ require "fpm/util"
 require "fileutils"
 
 class FPM::Package::NPM < FPM::Package
-  def get_source(params)
-    @npm = @paths.first
-  end # def get_source
-
-  def download(npm_name, version=nil)
-  end # def download
-
-  def get_metadata
-    # set self[:...] values
-    # :name
-    # :maintainer
-    # :url
-    # :category
-    # :dependencies
-  end # def get_metadata
-
-  def make_tarball!(tar_path, builddir)
-    tmpdir = "#{tar_path}.dir"
-    installdir = "#{tmpdir}/#{::Gem::dir}"
-    ::FileUtils.mkdir_p(installdir)
-    args = ["gem", "install", "--quiet", "--no-ri", "--no-rdoc",
-       "--install-dir", installdir, "--ignore-dependencies", @paths.first]
-    safesystem(*args)
-    tar(tar_path, ".", tmpdir)
-
-    # TODO(sissel): Make a helper method.
-    safesystem(*["gzip", "-f", tar_path])
+  # Flags '--foo' will be accessable  as attributes[:npm_foo]
+  option "--bin", "NPM_EXECUTABLE",
+    "The path to the npm executable you wish to run.", :default => "npm"
+
+  option "--package-name-prefix", "PREFIX", "Name to prefix the package " \
+    "name with.", :default => "node"
+
+  private
+  def input(package)
+    # Notes:
+    # * npm respects PREFIX
+    settings = {
+      "cache" => build_path("npm_cache"),
+      "loglevel" => "warn",
+      "global" => "true"
+    }
+
+    if attributes.include?(:prefix) && !attributes[:prefix].nil?
+      settings["prefix"] = staging_path(attributes[:prefix])
+    else
+      @logger.info("Setting default npm install prefix",
+                   :prefix => "/usr/local")
+      settings["prefix"] = staging_path("/usr/local")
+    end
+
+    FileUtils.mkdir_p(settings["prefix"])
+
+    npm_flags = []
+    settings.each do |key, value|
+      # npm lets you specify settings in a .npmrc but the same key=value settings
+      # are valid as '--key value' command arguments to npm. Woo!
+      @logger.debug("Configuring npm", key => value)
+      npm_flags += [ "--#{key}", value ]
+    end
+
+    install_args = [
+      attributes[:npm_bin],
+      "install",
+      # use 'package' or 'package@version'
+     (version ? "#{package}@#{version}" : package)
+    ]
+
+    # The only way to get npm to respect the 'prefix' setting appears to
+    # be to set the --global flag.
+    #install_args << "--global"
+    install_args += npm_flags
+
+    safesystem(*install_args)
+
+    # Query details about our now-installed package.
+    # We do this by using 'npm ls' with json + long enabled to query details
+    # about the installed package.
+    npm_ls_cmd = [attributes[:npm_bin], "ls", "--json", "--long", package] + npm_flags
+    npm_ls_fd = IO.popen(npm_ls_cmd)
+    npm_ls_out = npm_ls_fd.read()
+    pid, status = Process.waitpid2(npm_ls_fd.pid)
+    if !status.success?
+      raise FPM::Util::ProcessFailed.new("#{npm_ls_cmd.first} failed (exit " \
+                                         "code #{status.exitstatus}). " \
+                                         "Full command was: #{npm_ls_cmd.inspect}")
+    end
+    npm_ls = JSON.parse(npm_ls_out)
+    name, info = npm_ls["dependencies"].first
+
+    self.name = [attributes[:npm_package_name_prefix], name].join("-")
+    self.version = info["version"]
+
+    if info.include?("repository")
+      self.url = info["repository"]["url"]
+    else
+      self.url = "https://npmjs.org/package/#{self.name}"
+    end
+
+    self.description = info["description"]
+    self.vendor = sprintf("%s <%s>", info["author"]["name"],
+                          info["author"]["email"])
+
+    # npm installs dependencies in the module itself, so if you do
+    # 'npm install express' it installs dependencies (like 'connect')
+    # to: node_modules/express/node_modules/connect/...
+    #
+    # To that end, I don't think we necessarily need to include 
+    # any automatic dependency information since every 'npm install'
+    # is fully self-contained. That's why you don't see any bother, yet,
+    # to include the package's dependencies in here.
+    #
+    # It's possible someone will want to decouple that in the future,
+    # but I will wait for that feature request.
   end
 
+  public(:input)
 end # class FPM::Package::NPM