fpm 1.9.3 → 1.12.0

data/lib/fpm/package/dir.rb

@@ -1,6 +1,6 @@
 require "fpm/package"
 require "fpm/util"
-require "backports"
+require "backports/latest"
 require "fileutils"
 require "find"
 require "socket"
@@ -83,8 +83,8 @@ class FPM::Package::Dir < FPM::Package
     # can include license data from themselves (rpms, gems, etc),
     # but to make sure a simple dir -> rpm works without having
     # to specify a license.
-    self.license = "unknown"
-    self.vendor = [ENV["USER"], Socket.gethostname].join("@")
+    self.license ||= "unknown"
+    self.vendor ||= [ENV["USER"], Socket.gethostname].join("@")
   ensure
     # Clean up any logger context we added.
     logger.remove("method")

data/lib/fpm/package/empty.rb

@@ -1,5 +1,5 @@
 require "fpm/package"
-require "backports"
+require "backports/latest"
 
 # Empty Package type. For strict/meta/virtual package creation
 

data/lib/fpm/package/freebsd.rb

@@ -1,4 +1,4 @@
-require "backports" # gem backports
+require "backports/latest" # gem backports/latest
 require "fpm/package"
 require "fpm/util"
 require "digest"

data/lib/fpm/package/gem.rb

@@ -4,6 +4,7 @@ require "rubygems"
 require "fileutils"
 require "fpm/util"
 require "yaml"
+require "git"
 
 # A rubygems package.
 #
@@ -53,6 +54,15 @@ class FPM::Package::Gem < FPM::Package
     "The directory where fpm installs the gem temporarily before conversion. " \
     "Normally a random subdirectory of workdir."
 
+  option "--git-repo", "GIT_REPO",
+    "Use this git repo address as the source of the gem instead of " \
+    "rubygems.org.", :default => nil
+
+  option "--git-branch", "GIT_BRANCH",
+    "When using a git repo as the source of the gem instead of " \
+    "rubygems.org, use this git branch.",
+    :default => nil
+
   # Override parent method
   def staging_path(path=nil)
     @gem_staging_path ||= attributes[:gem_stagingdir] || Stud::Temporary.directory("package-#{type}-staging")
@@ -91,21 +101,33 @@ class FPM::Package::Gem < FPM::Package
 
     logger.info("Trying to download", :gem => gem_name, :version => gem_version)
 
-    gem_fetch = [ "#{attributes[:gem_gem]}", "fetch", gem_name]
-
-    gem_fetch += ["--prerelease"] if attributes[:gem_prerelease?]
-    gem_fetch += ["--version", gem_version] if gem_version
-
     download_dir = build_path(gem_name)
     FileUtils.mkdir(download_dir) unless File.directory?(download_dir)
 
-    ::Dir.chdir(download_dir) do |dir|
-      logger.debug("Downloading in directory #{dir}")
-      safesystem(*gem_fetch)
+    if attributes[:gem_git_repo]
+      logger.debug("Git cloning in directory #{download_dir}")
+      g = Git.clone(attributes[:gem_git_repo],gem_name,:path => download_dir)
+      if attributes[:gem_git_branch]
+        g.branch(attributes[:gem_git_branch]).checkout
+        g.pull('origin',attributes[:gem_git_branch])
+      end
+      gem_build = [ "#{attributes[:gem_gem]}", "build", "#{g.dir.to_s}/#{gem_name}.gemspec"]
+      ::Dir.chdir(g.dir.to_s) do |dir|
+        logger.debug("Building in directory #{dir}")
+        safesystem(*gem_build)
+      end
+      gem_files = ::Dir.glob(File.join(g.dir.to_s, "*.gem"))
+    else
+      gem_fetch = [ "#{attributes[:gem_gem]}", "fetch", gem_name]
+      gem_fetch += ["--prerelease"] if attributes[:gem_prerelease?]
+      gem_fetch += ["--version", gem_version] if gem_version
+      ::Dir.chdir(download_dir) do |dir|
+        logger.debug("Downloading in directory #{dir}")
+        safesystem(*gem_fetch)
+      end
+      gem_files = ::Dir.glob(File.join(download_dir, "*.gem"))
     end
 
-    gem_files = ::Dir.glob(File.join(download_dir, "*.gem"))
-
     if gem_files.length != 1
       raise "Unexpected number of gem files in #{download_dir},  #{gem_files.length} should be 1"
     end
@@ -198,8 +220,13 @@ class FPM::Package::Gem < FPM::Package
 
     ::FileUtils.mkdir_p(installdir)
     # TODO(sissel): Allow setting gem tool path
-    args = [attributes[:gem_gem], "install", "--quiet", "--no-ri", "--no-rdoc",
-       "--no-user-install", "--install-dir", installdir]
+    args = [attributes[:gem_gem], "install", "--quiet", "--no-user-install", "--install-dir", installdir]
+    if ::Gem::VERSION =~ /^[012]\./ 
+      args += [ "--no-ri", "--no-rdoc" ]
+    else
+      # Rubygems 3.0.0 changed --no-ri to --no-document
+      args += [ "--no-document" ]
+    end
 
     if !attributes[:gem_embed_dependencies?]
       args += ["--ignore-dependencies"]

data/lib/fpm/package/pacman.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 require "fpm/package"
 require "fpm/util"
-require "backports"
+require "backports/latest"
 require "fileutils"
 require "find"
 
@@ -18,10 +18,10 @@ class FPM::Package::Pacman < FPM::Package
   option "--group", "GROUP", "The group owner of files in this package", :default => 'root'
 
   # The list of supported compression types. Default is xz (LZMA2)
-  COMPRESSION_TYPES = [ "gz", "bzip2", "xz", "none" ]
+  COMPRESSION_TYPES = [ "gz", "bzip2", "xz", "zstd", "none" ]
 
   option "--compression", "COMPRESSION", "The compression type to use, must " \
-    "be one of #{COMPRESSION_TYPES.join(", ")}.", :default => "xz" do |value|
+    "be one of #{COMPRESSION_TYPES.join(", ")}.", :default => "zstd" do |value|
     if !COMPRESSION_TYPES.include?(value)
       raise ArgumentError, "Pacman compression value of '#{value}' is invalid. " \
         "Must be one of #{COMPRESSION_TYPES.join(", ")}"
@@ -209,31 +209,39 @@ class FPM::Package::Pacman < FPM::Package
 
   def compression_option
     case self.attributes[:pacman_compression]
-      when nil, "xz"
-        return "--xz"
+      when nil, "zstd"
+        return "--zstd"
       when "none"
         return ""
       when "gz"
         return "-z"
+      when "xz"
+        return "--xz"
       when "bzip2"
         return "-j"
+      when "zstd"
+        return "--zstd"
       else
-        return "--xz"
+        return "--zstd"
       end
   end
 
   def compression_ending
     case self.attributes[:pacman_compression]
-      when nil, "xz"
-        return ".xz"
+      when nil, "zstd"
+        return ".zst"
       when "none"
         return ""
       when "gz"
         return ".gz"
+      when "zx"
+        return ".xz"
       when "bzip2"
         return ".bz2"
+      when "zstd"
+        return ".zst"
       else
-        return ".xz"
+        return ".zst"
       end
   end
 
@@ -245,7 +253,11 @@ class FPM::Package::Pacman < FPM::Package
     Find.find(staging_path) do |path|
       src = path.gsub(/^#{staging_path}/, '')
       dst = build_path(src)
-      copy_entry(path, dst, preserve=true, remove_destination=true)
+      begin
+        copy_entry(path, dst, preserve=true, remove_destination=true)
+      rescue
+        copy_entry(path, dst, preserve=false, remove_destination=true)
+      end
       copy_metadata(path, dst)
     end
 

data/lib/fpm/package/pyfpm/get_metadata.py

@@ -47,6 +47,11 @@ class get_metadata(Command):
 
     def process_dep(self, dep):
         deps = []
+        if hasattr(dep, 'marker') and dep.marker:
+            # PEP0508 marker present
+            if not dep.marker.evaluate():
+                return deps
+
         if dep.specs:
             for operator, version in dep.specs:
                 deps.append("%s %s %s" % (dep.project_name,

data/lib/fpm/package/python.rb

@@ -29,6 +29,9 @@ class FPM::Package::Python < FPM::Package
   option "--pypi", "PYPI_URL",
     "PyPi Server uri for retrieving packages.",
     :default => "https://pypi.python.org/simple"
+  option "--trusted-host", "PYPI_TRUSTED",
+    "Mark this host or host:port pair as trusted for pip",
+    :default => nil
   option "--package-prefix", "NAMEPREFIX",
     "(DEPRECATED, use --package-name-prefix) Name to prefix the package " \
     "name with." do |value|
@@ -136,7 +139,31 @@ class FPM::Package::Python < FPM::Package
     else
       logger.debug("using pip", :pip => attributes[:python_pip])
       # TODO: Support older versions of pip
-      safesystem(attributes[:python_pip], "download", "--no-clean", "--no-deps", "--no-binary", ":all:", "-i", attributes[:python_pypi], "--build", target,  want_pkg)
+
+      setup_cmd = [
+        attributes[:python_pip],
+        "download",
+        "--no-clean",
+        "--no-deps",
+        "--no-binary",
+        ":all:",
+        "-i", attributes[:python_pypi],
+      ]
+
+      if attributes[:python_trusted_host]
+        setup_cmd += [
+          "--trusted-host",
+          attributes[:python_trusted_host],
+        ]
+      end
+
+      setup_cmd += [
+        "--build",
+        target,
+        want_pkg,
+      ]
+      
+      safesystem(*setup_cmd)
     end
 
     # easy_install will put stuff in @tmpdir/packagename/, so find that:
@@ -183,7 +210,7 @@ class FPM::Package::Python < FPM::Package
 
     output = ::Dir.chdir(setup_dir) do
       tmp = build_path("metadata.json")
-      setup_cmd = "env PYTHONPATH=#{pylib} #{attributes[:python_bin]} " \
+      setup_cmd = "env PYTHONPATH=#{pylib}:$PYTHONPATH #{attributes[:python_bin]} " \
         "setup.py --command-packages=pyfpm get_metadata --output=#{tmp}"
 
       if attributes[:python_obey_requirements_txt?]
@@ -229,7 +256,7 @@ class FPM::Package::Python < FPM::Package
 
     if !attributes[:no_auto_depends?] and attributes[:python_dependencies?]
       metadata["dependencies"].each do |dep|
-        dep_re = /^([^<>!= ]+)\s*(?:([<>!=]{1,2})\s*(.*))?$/
+        dep_re = /^([^<>!= ]+)\s*(?:([~<>!=]{1,2})\s*(.*))?$/
         match = dep_re.match(dep)
         if match.nil?
           logger.error("Unable to parse dependency", :dependency => dep)
@@ -240,7 +267,7 @@ class FPM::Package::Python < FPM::Package
         next if attributes[:python_disable_dependency].include?(name)
 
         # convert == to =
-        if cmp == "=="
+        if cmp == "==" or cmp == "~="
           logger.info("Converting == dependency requirement to =", :dependency => dep )
           cmp = "="
         end

data/lib/fpm/package/rpm.rb

@@ -1,5 +1,5 @@
 require "fpm/package"
-require "backports"
+require "backports/latest"
 require "fileutils"
 require "find"
 require "arr-pm/file" # gem 'arr-pm'
@@ -24,9 +24,10 @@ class FPM::Package::RPM < FPM::Package
 
   COMPRESSION_MAP = {
     "none" => "w0.gzdio",
-    "xz" => "w9.xzdio",
-    "gzip" => "w9.gzdio",
-    "bzip2" => "w9.bzdio"
+    "xz" => ".xzdio",
+    "xzmt" => "T.xzdio",
+    "gzip" => ".gzdio",
+    "bzip2" => ".bzdio"
   } unless defined?(COMPRESSION_MAP)
 
   option "--use-file-permissions", :flag,
@@ -67,6 +68,15 @@ class FPM::Package::RPM < FPM::Package
     value.downcase
   end
 
+  option "--compression-level", "[0-9]", "Select a compression level. 0 is store-only. 9 is max compression.",
+    :default => "9" do |value|
+    valint = value.to_i
+    unless value =~ /^\d$/ && valint >= 0 && valint <= 9
+      raise "Invalid compression level '#{value}'. Valid values are integers between 0 and 9 inclusive."
+    end
+    valint
+  end
+
   option "--compression", COMPRESSION_MAP.keys.join("|"),
     "Select a compression method. gzip works on the most platforms.",
     :default => "gzip" do |value|
@@ -141,6 +151,10 @@ class FPM::Package::RPM < FPM::Package
            "names in rpm requires instead of the redhat style " \
            "rubygem(foo).", :default => false
 
+  option "--macro-expansion", :flag,
+           "install-time macro expansion in %pre %post %preun %postun scripts " \
+           "(see: https://rpm.org/user_doc/scriptlet_expansion.html)", :default => false
+
   option "--verifyscript", "FILE",
     "a script to be run on verification" do |val|
     File.expand_path(val) # Get the full path to the script
@@ -515,10 +529,11 @@ class FPM::Package::RPM < FPM::Package
     end
 
     # copy all files from staging to BUILD dir
+    # [#1538] Be sure to preserve the original timestamps.
     Find.find(staging_path) do |path|
       src = path.gsub(/^#{staging_path}/, '')
       dst = File.join(build_path, build_sub_dir, src)
-      copy_entry(path, dst)
+      copy_entry(path, dst, preserve=true)
     end
 
     rpmspec = template("rpm.erb").result(binding)
@@ -596,7 +611,12 @@ class FPM::Package::RPM < FPM::Package
   end # def to_s
 
   def payload_compression
-    return COMPRESSION_MAP[attributes[:rpm_compression]]
+    if attributes[:rpm_compression] == 'none'
+      # when 'none' ignore any compression level and return w0.gzdio
+      return COMPRESSION_MAP[attributes[:rpm_compression]]
+    else
+      return "w#{attributes[:rpm_compression_level]}" + COMPRESSION_MAP[attributes[:rpm_compression]]
+    end
   end # def payload_compression
 
   def digest_algorithm

data/lib/fpm/package/sh.rb

@@ -3,7 +3,7 @@ require "fpm/namespace"
 require "fpm/package"
 require "fpm/errors"
 require "fpm/util"
-require "backports"
+require "backports/latest"
 require "fileutils"
 require "digest"
 

data/lib/fpm/package/snap.rb

@@ -0,0 +1,130 @@
+require "yaml"
+
+require "fpm/package"
+require "fpm/util"
+require "fileutils"
+require "fpm/package/dir"
+
+# Support for snaps (.snap files).
+#
+# This supports the input and output of snaps.
+class FPM::Package::Snap < FPM::Package
+
+  option "--yaml", "FILEPATH",
+    "Custom version of the snap.yaml file." do | snap_yaml |
+    File.expand_path(snap_yaml)
+  end
+
+  option "--confinement", "CONFINEMENT",
+    "Type of confinement to use for this snap.",
+    default: "devmode" do | confinement |
+    if ['strict', 'devmode', 'classic'].include? confinement
+      confinement
+    else
+      raise "Unsupported confinement type '#{confinement}'"
+    end
+  end
+
+  option "--grade", "GRADE", "Grade of this snap.",
+    default: "devel" do | grade |
+    if ['stable', 'devel'].include? grade
+      grade
+    else
+      raise "Unsupported grade type '#{grade}'"
+    end
+  end
+
+   # Input a snap
+  def input(input_snap)
+    extract_snap_to_staging input_snap
+    extract_snap_metadata_from_staging
+  end # def input
+
+  # Output a snap.
+  def output(output_snap)
+    output_check(output_snap)
+
+    write_snap_yaml
+
+    # Create the snap from the staging path
+    safesystem("mksquashfs", staging_path, output_snap, "-noappend", "-comp",
+               "xz", "-no-xattrs", "-no-fragments", "-all-root")
+  end # def output
+
+  def to_s(format=nil)
+    # Default format if nil
+    # name_version_arch.snap
+    return super(format.nil? ? "NAME_FULLVERSION_ARCH.EXTENSION" : format)
+  end # def to_s
+
+  private
+
+  def extract_snap_to_staging(snap_path)
+    safesystem("unsquashfs", "-f", "-d", staging_path, snap_path)
+  end
+
+  def extract_snap_metadata_from_staging
+    metadata = YAML.safe_load(File.read(
+      staging_path(File.join("meta", "snap.yaml"))))
+
+    self.name = metadata["name"]
+    self.version = metadata["version"]
+    self.description = metadata["summary"] + "\n" + metadata["description"]
+    self.architecture = metadata["architectures"][0]
+    self.attributes[:snap_confinement] = metadata["confinement"]
+    self.attributes[:snap_grade] = metadata["grade"]
+
+    if metadata["apps"].nil?
+      attributes[:snap_apps] = []
+    else
+      attributes[:snap_apps] = metadata["apps"]
+    end
+
+    if metadata["hooks"].nil?
+      attributes[:snap_hooks] = []
+    else
+      attributes[:snap_hooks] = metadata["hooks"]
+    end
+  end
+
+  def write_snap_yaml
+    # Write the snap.yaml
+    if attributes[:snap_yaml]
+      logger.debug("Using '#{attributes[:snap_yaml]}' as the snap.yaml")
+      yaml_data = File.read(attributes[:snap_yaml])
+    else
+      summary, *remainder = (self.description or "no summary given").split("\n")
+      description = "no description given"
+      if remainder.any?
+        description = remainder.join("\n")
+      end
+
+      yaml_data = {
+        "name" => self.name,
+        "version" => self.version,
+        "summary" => summary,
+        "description" => description,
+        "architectures" => [self.architecture],
+        "confinement" => self.attributes[:snap_confinement],
+        "grade" => self.attributes[:snap_grade],
+      }
+
+      unless attributes[:snap_apps].nil? or attributes[:snap_apps].empty?
+        yaml_data["apps"] = attributes[:snap_apps]
+      end
+
+      unless attributes[:snap_hooks].nil? or attributes[:snap_hooks].empty?
+        yaml_data["hooks"] = attributes[:snap_hooks]
+      end
+
+      yaml_data = yaml_data.to_yaml
+    end
+
+    FileUtils.mkdir_p(staging_path("meta"))
+    snap_yaml_path = staging_path(File.join("meta", "snap.yaml"))
+    logger.debug("Writing snap.yaml", :path => snap_yaml_path)
+    File.write(snap_yaml_path, yaml_data)
+    File.chmod(0644, snap_yaml_path)
+    edit_file(snap_yaml_path) if attributes[:edit?]
+  end # def write_snap_yaml
+end # class FPM::Package::Snap