fpm-itchio 1.4.0

data/lib/fpm/package/osxpkg.rb

@@ -0,0 +1,164 @@
+require "fpm/package"
+require "fpm/util"
+require "fileutils"
+require "fpm/package/dir"
+require 'tempfile'  # stdlib
+require 'pathname'  # stdlib
+require 'rexml/document'  # stdlib
+
+# Use an OS X pkg built with pkgbuild.
+#
+# Supports input and output. Requires pkgbuild and (for input) pkgutil, part of a
+# standard OS X install in 10.7 and higher.
+class FPM::Package::OSXpkg < FPM::Package
+
+  # Map of what scripts are named.
+  SCRIPT_MAP = {
+    :before_install     => "preinstall",
+    :after_install      => "postinstall",
+  } unless defined?(SCRIPT_MAP)
+
+  POSTINSTALL_ACTIONS = [ "logout", "restart", "shutdown" ]
+  OWNERSHIP_OPTIONS = ["recommended", "preserve", "preserve-other"]
+
+  option "--identifier-prefix", "IDENTIFIER_PREFIX",
+    "Reverse domain prefix prepended to package identifier, " \
+    "ie. 'org.great.my'. If this is omitted, the identifer " \
+    "will be the package name."
+  option "--payload-free", :flag, "Define no payload, assumes use of script options.",
+    :default => false
+  option "--ownership", "OWNERSHIP",
+    "--ownership option passed to pkgbuild. Defaults to 'recommended'. " \
+    "See pkgbuild(1).", :default => 'recommended' do |value|
+    if !OWNERSHIP_OPTIONS.include?(value)
+      raise ArgumentError, "osxpkg-ownership value of '#{value}' is invalid. " \
+        "Must be one of #{OWNERSHIP_OPTIONS.join(", ")}"
+    end
+    value
+  end
+
+  option "--postinstall-action", "POSTINSTALL_ACTION",
+    "Post-install action provided in package metadata. " \
+    "Optionally one of '#{POSTINSTALL_ACTIONS.join("', '")}'." do |value|
+    if !POSTINSTALL_ACTIONS.include?(value)
+      raise ArgumentError, "osxpkg-postinstall-action value of '#{value}' is invalid. " \
+        "Must be one of #{POSTINSTALL_ACTIONS.join(", ")}"
+    end
+    value
+  end
+
+  dont_obsolete_paths = []
+  option "--dont-obsolete", "DONT_OBSOLETE_PATH",
+    "A file path for which to 'dont-obsolete' in the built PackageInfo. " \
+    "Can be specified multiple times." do |path|
+      dont_obsolete_paths << path
+    end
+
+  private
+  # return the identifier by prepending the reverse-domain prefix
+  # to the package name, else return just the name
+  def identifier
+    identifier = name.dup
+    if self.attributes[:osxpkg_identifier_prefix]
+      identifier.insert(0, "#{self.attributes[:osxpkg_identifier_prefix]}.")
+    end
+    identifier
+  end # def identifier
+
+  # scripts_path and write_scripts cribbed from deb.rb
+  def scripts_path(path=nil)
+    @scripts_path ||= build_path("Scripts")
+    FileUtils.mkdir(@scripts_path) if !File.directory?(@scripts_path)
+
+    if path.nil?
+      return @scripts_path
+    else
+      return File.join(@scripts_path, path)
+    end
+  end # def scripts_path
+
+  def write_scripts
+    SCRIPT_MAP.each do |scriptname, filename|
+      next unless script?(scriptname)
+
+      scripts_path(filename).tap do |pkgscript|
+        logger.info("Writing pkg script", :source => filename, :target => pkgscript)
+        File.write(pkgscript, script(scriptname))
+        # scripts are required to be executable
+        File.chmod(0755, pkgscript)
+      end
+    end
+  end # def write_scripts
+
+  # Returns path of a processed template PackageInfo given to 'pkgbuild --info'
+  # note: '--info' is undocumented:
+  # http://managingosx.wordpress.com/2012/07/05/stupid-tricks-with-pkgbuild
+  def pkginfo_template_path
+    pkginfo_template = Tempfile.open("fpm-PackageInfo")
+    pkginfo_data = template("osxpkg.erb").result(binding)
+    pkginfo_template.write(pkginfo_data)
+    pkginfo_template.close
+    pkginfo_template.path
+  end # def write_pkginfo_template
+
+  # Extract name and version from PackageInfo XML
+  def extract_info(package)
+    build_path("expand").tap do |path|
+      doc = REXML::Document.new File.open(File.join(path, "PackageInfo"))
+      pkginfo_elem = doc.elements["pkg-info"]
+      identifier = pkginfo_elem.attribute("identifier").value
+      self.version = pkginfo_elem.attribute("version").value
+      # set name to the last dot element of the identifier
+      self.name = identifier.split(".").last
+      logger.info("inferring name #{self.name} from pkg-id #{identifier}")
+    end
+  end # def extract_info
+
+  # Take a flat package as input
+  def input(input_path)
+    # TODO: Fail if it's a Distribution pkg or old-fashioned
+    expand_dir = File.join(build_path, "expand")
+    # expand_dir must not already exist for pkgutil --expand
+    safesystem("pkgutil --expand #{input_path} #{expand_dir}")
+
+    extract_info(input_path)
+
+    # extract Payload
+    safesystem("tar -xz -f #{expand_dir}/Payload -C #{staging_path}")
+  end # def input
+
+  # Output a pkgbuild pkg.
+  def output(output_path)
+    output_check(output_path)
+
+    temp_info = pkginfo_template_path
+
+    args = ["--identifier", identifier,
+            "--info", temp_info,
+            "--version", version.to_s,
+            "--ownership", attributes[:osxpkg_ownership]]
+
+    if self.attributes[:osxpkg_payload_free?]
+      args << "--nopayload"
+    else
+      args += ["--root", staging_path]
+    end
+
+    if attributes[:before_install_given?] or attributes[:after_install_given?]
+      write_scripts
+      args += ["--scripts", scripts_path]
+    end
+    args << output_path
+
+    safesystem("pkgbuild", *args)
+    FileUtils.remove_file(temp_info)
+  end # def output
+
+  def to_s(format=nil)
+    return super("NAME-VERSION.pkg") if format.nil?
+    return super(format)
+  end # def to_s
+
+  public(:input, :output, :identifier, :to_s)
+
+end # class FPM::Package::OSXpkg

data/lib/fpm/package/p5p.rb

@@ -0,0 +1,124 @@
+require "erb"
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/errors"
+require "fpm/util"
+
+class FPM::Package::P5P < FPM::Package
+
+  option "--user", "USER",
+    "Set the user to USER in the prototype files.",
+    :default => 'root'
+
+  option "--group", "GROUP",
+    "Set the group to GROUP in the prototype file.",
+    :default => 'root'
+
+  option "--zonetype", "ZONETYPE",
+    "Set the allowed zone types (global, nonglobal, both)",
+    :default => 'value=global value=nonglobal' do |value|
+      case @value
+      when "both"
+        value = "value=global value=nonglobal"
+      else
+        value = "value=#{value}"
+      end
+    end # value
+
+  option "--publisher", "PUBLISHER", 
+    "Set the publisher name for the repository",
+    :default => 'FPM'
+
+  option "--lint" , :flag, "Check manifest with pkglint",
+    :default => true
+
+  option "--validate", :flag, "Validate with pkg install",
+    :default => true
+
+  def architecture
+    case @architecture
+    when nil, "native"
+      @architecture = %x{uname -p}.chomp
+    when "all"
+      @architecture = 'i386 value=sparc'
+    end
+
+    return @architecture
+  end # def architecture
+
+  def output(output_path)
+    
+    # Fixup the category to an acceptable solaris category
+    case @category
+    when nil, "default"
+      @category = 'Applications/System Utilities'
+    end
+
+    # Manifest Filename
+    manifest_fn = build_path("#{name}.p5m")
+
+    # Generate a package manifest.
+    pkg_generate = safesystemout("pkgsend", "generate", "#{staging_path}")
+    File.write(build_path("#{name}.p5m.1"), pkg_generate)
+
+    # Add necessary metadata to the generated manifest.
+    metadata_template = template("p5p_metadata.erb").result(binding)
+    File.write(build_path("#{name}.mog"), metadata_template)
+
+    # Combine template and filelist; allow user to edit before proceeding
+    File.open(manifest_fn, "w") do |manifest|
+      manifest.write metadata_template
+      manifest.write pkg_generate
+    end
+    edit_file(manifest_fn) if attributes[:edit?]
+
+    # Execute the transmogrification on the manifest
+    pkg_mogrify = safesystemout("pkgmogrify", manifest_fn)
+    File.write(build_path("#{name}.p5m.2"), pkg_mogrify)
+    safesystem("cp", build_path("#{name}.p5m.2"), manifest_fn)
+
+    # Evaluate dependencies.
+    if !attributes[:no_auto_depends?]
+	    pkgdepend_gen = safesystemout("pkgdepend", "generate",  "-md", "#{staging_path}",  manifest_fn)
+      File.write(build_path("#{name}.p5m.3"), pkgdepend_gen)
+
+      # Allow user to review added dependencies
+      edit_file(build_path("#{name}.p5m.3")) if attributes[:edit?]
+
+	    safesystem("pkgdepend", "resolve",  "-m", build_path("#{name}.p5m.3"))
+      safesystem("cp", build_path("#{name}.p5m.3.res"), manifest_fn)
+    end
+
+    # Final format of manifest
+    safesystem("pkgfmt", manifest_fn)
+
+    # Final edit for lint check and packaging
+    edit_file(manifest_fn) if attributes[:edit?]
+
+    # Add any facets or actuators that are needed.
+    # TODO(jcraig): add manpage actuator to enable install wo/ man pages
+
+    # Verify the package.
+    if attributes[:p5p_lint] then
+      safesystem("pkglint", manifest_fn)
+    end
+
+    # Publish the package.
+    repo_path = build_path("#{name}_repo")
+    safesystem("pkgrepo", "create", repo_path)
+    safesystem("pkgrepo", "set", "-s", repo_path, "publisher/prefix=#{attributes[:p5p_publisher]}")
+    safesystem("pkgsend", "-s", repo_path,
+      "publish", "-d", "#{staging_path}", "#{build_path}/#{name}.p5m")
+    safesystem("pkgrecv", "-s", repo_path, "-a",
+      "-d", build_path("#{name}.p5p"), name)
+
+    # Test the package
+    if attributes[:p5p_validate] then
+      safesystem("pkg", "install",  "-nvg", build_path("#{name}.p5p"), name)
+    end
+
+    # Cleanup
+    safesystem("mv", build_path("#{name}.p5p"), output_path)
+
+  end # def output
+end # class FPM::Package::IPS

data/lib/fpm/package/pacman.rb

@@ -0,0 +1,397 @@
+# -*- coding: utf-8 -*-
+require "fpm/package"
+require "backports"
+require "fileutils"
+require "find"
+
+class FPM::Package::Pacman < FPM::Package
+
+  option "--optional-depends", "PACKAGE",
+    "Add an optional dependency to the pacman package.", :multivalued => true
+
+  option "--use-file-permissions", :flag,
+    "Use existing file permissions when defining ownership and modes"
+
+  option "--user", "USER", "The owner of files in this package", :default => 'root'
+
+  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" ]
+
+  option "--compression", "COMPRESSION", "The compression type to use, must " \
+    "be one of #{COMPRESSION_TYPES.join(", ")}.", :default => "xz" do |value|
+    if !COMPRESSION_TYPES.include?(value)
+      raise ArgumentError, "Pacman compression value of '#{value}' is invalid. " \
+        "Must be one of #{COMPRESSION_TYPES.join(", ")}"
+    end
+    value
+  end
+
+  def initialize(*args)
+    super(*args)
+    attributes[:pacman_optional_depends] = []
+  end # def initialize
+
+  def architecture
+    case @architecture
+      when nil
+        return %x{uname -m}.chomp   # default to current arch
+      when "amd64" # debian and pacman disagree on architecture names
+        return "x86_64"
+      when "native"
+        return %x{uname -m}.chomp   # 'native' is current arch
+      when "all", "any", "noarch"
+        return "any"
+      else
+        return @architecture
+    end
+  end # def architecture
+
+  def iteration
+    return @iteration || 1
+  end # def iteration
+
+  def config_files
+    return @config_files || []
+  end # def config_files
+
+  def dependencies
+    bogus_regex = /[^\sA-Za-z0-9><=-]/
+    # Actually modifies depencies if they are not right
+    bogus_dependencies = @dependencies.grep bogus_regex
+    if bogus_dependencies.any?
+      @dependencies.reject! { |a| a =~ bogus_regex }
+      logger.warn("Some of the dependencies looked like they weren't package " \
+                  "names. Such dependency entries only serve to confuse arch. " \
+                  "I am removing them.",
+                  :removed_dependencies => bogus_dependencies,
+                  :fixed_dependencies => @dependencies)
+    end
+    return @dependencies
+  end
+
+
+  # This method is invoked on a package when it has been converted to a new
+  # package format. The purpose of this method is to do any extra conversion
+  # steps, like translating dependency conditions, etc.
+  #def converted_from(origin)
+    # nothing to do by default. Subclasses may implement this.
+    # See the RPM package class for an example.
+  #end # def converted_from
+
+  # Add a new source to this package.
+  # The exact behavior depends on the kind of package being managed.
+  #
+  # For instance:
+  #
+  # * for FPM::Package::Dir, << expects a path to a directory or files.
+  # * for FPM::Package::RPM, << expects a path to an rpm.
+  #
+  # The idea is that you can keep pumping in new things to a package
+  # for later conversion or output.
+  #
+  # Implementations are expected to put files relevant to the 'input' in the
+  # staging_path
+  def input(pacman_pkg_path)
+    control = {}
+    # Unpack the control tarball
+    safesystem("tar", "-C", staging_path, "-xf", pacman_pkg_path)
+    pkginfo = staging_path(".PKGINFO")
+    mtree = staging_path(".MTREE")
+    install = staging_path(".INSTALL")
+
+    control_contents = File.read(pkginfo)
+    FileUtils.rm(pkginfo)
+    FileUtils.rm(mtree)
+
+
+    control_lines = control_contents.split("\n")
+    control_lines.each do |line|
+      key, val = line.split(/ += +/, 2)
+      if control.has_key? key
+        control[key].push(val)
+      else
+        control[key] = [val]
+      end
+    end
+
+    self.name = control["pkgname"][0]
+
+    # Parse 'epoch:version-iteration' in the version string
+    version_re = /^(?:([0-9]+):)?(.+?)(?:-(.*))?$/
+    m = version_re.match(control["pkgver"][0])
+    if !m
+      raise "Unsupported version string '#{control["pkgver"][0]}'"
+    end
+    self.epoch, self.version, self.iteration = m.captures
+
+    self.maintainer = control["packager"][0]
+
+    # Arch has no notion of vendor, so...
+    #self.vendor =
+
+    self.url = control["url"][0]
+    # Groups could include more than one.
+    # Speaking of just taking the first entry of the field:
+    # A crude thing to do, but I suppose it's better than nothing.
+    # -- Daniel Haskin, 3/24/2015
+    self.category = control["group"][0] || self.category
+
+    # Licenses could include more than one.
+    # Speaking of just taking the first entry of the field:
+    # A crude thing to do, but I suppose it's better than nothing.
+    # -- Daniel Haskin, 3/24/2015
+    self.license = control["license"][0] || self.license
+
+    self.architecture = control["arch"][0]
+
+    self.dependencies = control["depend"] || self.dependencies
+
+    self.provides = control["provides"] || self.provides
+
+    self.conflicts = control["conflict"] || self.conflicts
+
+    self.replaces = control["replaces"] || self.replaces
+
+    self.description = control["pkgdesc"][0]
+
+    if control.include? "backup"
+      self.config_files = control["backup"].map{|file| "/" + file}
+    else
+      self.config_files = []
+    end
+
+    self.dependencies = control["depend"] || self.dependencies
+
+    self.attributes[:pacman_optional_depends] = control["optdepend"] || []
+    # There are other available attributes, but I didn't include them because:
+    # - makedepend: deps needed to make the arch package. But it's already
+    #   made. It just needs to be converted at this point
+    # - checkdepend: See above
+    # - makepkgopt: See above
+    # - size: can be dynamically generated
+    # - builddate: Should be changed to time of package conversion in the new
+    #   package, so this value should be thrown away.
+
+    if File.exist?(install)
+      functions = parse_install_script(install)
+      if functions.include?("pre_install")
+        self.scripts[:before_install] = functions["pre_install"].join("\n")
+      end
+      if functions.include?("post_install")
+        self.scripts[:after_install] = functions["post_install"].join("\n")
+      end
+      if functions.include?("pre_upgrade")
+        self.scripts[:before_upgrade] = functions["pre_upgrade"].join("\n")
+      end
+      if functions.include?("post_upgrade")
+        self.scripts[:after_upgrade] = functions["post_upgrade"].join("\n")
+      end
+      if functions.include?("pre_remove")
+        self.scripts[:before_remove] = functions["pre_remove"].join("\n")
+      end
+      if functions.include?("post_remove")
+        self.scripts[:after_remove] = functions["post_remove"].join("\n")
+      end
+      FileUtils.rm(install)
+    end
+
+    # Note: didn't use `self.directories`.
+    # Pacman doesn't really record that information, to my knowledge.
+
+  end # def input
+
+  def compression_option
+    case self.attributes[:pacman_compression]
+      when nil, "xz"
+        return "--xz"
+      when "none"
+        return ""
+      when "gz"
+        return "-z"
+      when "bzip2"
+        return "-j"
+      else
+        return "--xz"
+      end
+  end
+
+  def compression_ending
+    case self.attributes[:pacman_compression]
+      when nil, "xz"
+        return ".xz"
+      when "none"
+        return ""
+      when "gz"
+        return ".gz"
+      when "bzip2"
+        return ".bz2"
+      else
+        return ".xz"
+      end
+  end
+
+  # Output this package to the given path.
+  def output(output_path)
+    output_check(output_path)
+
+    # Copy all files from staging to BUILD dir
+    Find.find(staging_path) do |path|
+      src = path.gsub(/^#{staging_path}/, '')
+      dst = build_path(src)
+      copy_entry(path, dst, preserve=true, remove_destination=true)
+      copy_metadata(path, dst)
+    end
+
+    # This value is used later in the template for PKGINFO
+    size = safesystemout("du", "-sk", build_path).split(/\s+/)[0].to_i * 1024
+    builddate = Time.new.to_i
+
+    pkginfo = template("pacman.erb").result(binding)
+    pkginfo_file = build_path(".PKGINFO")
+    File.write(pkginfo_file, pkginfo)
+
+    if script?(:before_install) or script?(:after_install) or \
+        script?(:before_upgrade) or script?(:after_upgrade) or \
+        script?(:before_remove) or script?(:after_remove)
+      install_script = template("pacman/INSTALL.erb").result(binding)
+      install_script_file = build_path(".INSTALL")
+      File.write(install_script_file, install_script)
+    end
+
+    generate_mtree
+
+    File.expand_path(output_path).tap do |path|
+      ::Dir.chdir(build_path) do
+        safesystem(*(["tar",
+                      compression_option,
+                      "-cf",
+                      path] + data_tar_flags + \
+                      ::Dir.entries(".").reject{|entry| entry =~ /^\.{1,2}$/ }))
+      end
+    end
+  end # def output
+
+  def data_tar_flags
+    data_tar_flags = []
+    if attributes[:pacman_use_file_permissions?].nil?
+      if !attributes[:pacman_user].nil?
+        if attributes[:pacman_user] == 'root'
+          data_tar_flags += [ "--numeric-owner", "--owner", "0" ]
+        else
+          data_tar_flags += [ "--owner", attributes[:deb_user] ]
+        end
+      end
+
+      if !attributes[:pacman_group].nil?
+        if attributes[:pacman_group] == 'root'
+          data_tar_flags += [ "--numeric-owner", "--group", "0" ]
+        else
+          data_tar_flags += [ "--group", attributes[:deb_group] ]
+        end
+      end
+    end
+    return data_tar_flags
+  end # def data_tar_flags
+
+  def default_output
+    v = version
+    v = "#{epoch}:#{v}" if epoch
+    if iteration
+      "#{name}_#{v}-#{iteration}_#{architecture}.#{type}"
+    else
+      "#{name}_#{v}_#{architecture}.#{type}"
+    end
+  end # def default_output
+
+  def to_s(format=nil)
+    # Default format if nil
+    # git_1.7.9.3-1_amd64.deb
+    return super("NAME-FULLVERSION-ARCH.pkg.tar#{compression_ending}") if format.nil?
+    return super(format)
+  end # def to_s
+
+  private
+
+  def generate_mtree
+    ::Dir.chdir(build_path) do
+      cmd = "LANG=C bsdtar "
+      cmd += "-czf .MTREE "
+      cmd += "--format=mtree "
+      cmd += "--options='!all,use-set,type,uid,gid,mode,time,size,md5,sha256,link' "
+      cmd += ::Dir.entries(".").reject{|entry| entry =~ /^\.{1,2}$/ }.join(" ")
+      safesystem(cmd)
+    end
+  end # def generate_mtree
+
+  # KNOWN ISSUE:
+  # If an un-matched bracket is used in valid bash, as in
+  # `echo "{"`, this function will choke.
+  # However, to cover this case basically
+  # requires writing almost half a bash parser,
+  # and it is a very small corner case.
+  # Otherwise, this approach is very robust.
+  def gobble_function(cons,prod)
+    level = 1
+    while level > 0
+      line = cons.next
+      # Not the best, but pretty good
+      # short of writing an *actual* sh
+      # parser
+      level += line.count "{"
+      level -= line.count "}"
+      if level > 0
+        prod.push(line.rstrip())
+      else
+        fine = line.sub(/\s*[}]\s*$/, "")
+        if !(fine =~ /^\s*$/)
+          prod.push(fine.rstrip())
+        end
+      end
+    end
+  end # def gobble_function
+
+  FIND_SCRIPT_FUNCTION_LINE =
+    /^\s*(\w+)\s*\(\s*\)\s*\{\s*([^}]+?)?\s*(\})?\s*$/
+
+  def parse_install_script(path)
+    global_lines = []
+    look_for = Set.new(["pre_install", "post_install",
+                        "pre_upgrade", "post_upgrade",
+                        "pre_remove", "post_remove"])
+    functions = {}
+    look_for.each do |fname|
+      functions[fname] = []
+    end
+
+    open(path, "r") do |iscript|
+      lines = iscript.each
+      begin
+        while true
+          line = lines.next
+          # This regex picks up beginning names of posix shell
+          # functions
+          # Examples:
+          #   fname() {
+          #   fname() { echo hi }
+          m = FIND_SCRIPT_FUNCTION_LINE.match(line)
+          if not m.nil? and look_for.include? m[1]
+            if not m[2].nil?
+              functions[m[1]].push(m[2].rstrip())
+            end
+            gobble_function(lines, functions[m[1]])
+          else
+            global_lines.push(line.rstrip())
+          end
+        end
+      rescue StopIteration
+      end
+    end
+    look_for.each do |name|
+      # Add global lines to each function to preserve global variables, etc.
+      functions[name] = global_lines + functions[name]
+    end
+    return functions
+  end # def parse_install_script
+end # class FPM::Package::Pacman