fpm-itchio 1.4.0

data/lib/fpm/package/dir.rb

@@ -0,0 +1,207 @@
+require "fpm/package"
+require "fpm/util"
+require "backports"
+require "fileutils"
+require "find"
+require "socket"
+
+# A directory package.
+#
+# This class supports both input and output. As a note, 'output' will
+# only emit the files, not any metadata. This is an effective way
+# to extract another package type.
+class FPM::Package::Dir < FPM::Package
+  private
+
+  # Add a new path to this package.
+  #
+  # A special handling of the path occurs if it includes a '=' symbol.
+  # You can say "source=destination" and it will copy files from that source
+  # to the given destination in the package.
+  #
+  # This lets you take a local directory and map it to the desired location at
+  # packaging time. Such as: "./src/redis-server=/usr/local/bin" will make
+  # the local file ./src/redis-server appear as /usr/local/bin/redis-server in
+  # your package.
+  #
+  # If the path is a directory, it is copied recursively. The behavior
+  # of the copying is modified by the :chdir and :prefix attributes.
+  #
+  # If :prefix is set, the destination path is prefixed with that value.
+  # If :chdir is set, the current directory is changed to that value
+  # during the copy.
+  #
+  # Example: Copy /etc/X11 into this package as /opt/xorg/X11:
+  #
+  #     package.attributes[:prefix] = "/opt/xorg"
+  #     package.attributes[:chdir] = "/etc"
+  #     package.input("X11")
+  def input(path)
+    chdir = attributes[:chdir] || "."
+
+    # Support mapping source=dest
+    # This mapping should work the same way 'rsync -a' does
+    #   Meaning 'rsync -a source dest'
+    #   and 'source=dest' in fpm work the same as the above rsync
+    if path =~ /.=./ && !File.exists?(chdir == '.' ? path : File.join(chdir, path))
+      origin, destination = path.split("=", 2)
+
+      if File.directory?(origin) && origin[-1,1] == "/"
+        chdir = chdir == '.' ? origin : File.join(chdir, origin)
+        source = "."
+      else
+        origin_dir = File.dirname(origin)
+        chdir = chdir == '.' ? origin_dir : File.join(chdir, origin_dir)
+        source = File.basename(origin)
+      end
+    else
+      source, destination = path, "/"
+    end
+
+    if attributes[:prefix]
+      destination = File.join(attributes[:prefix], destination)
+    end
+
+    destination = File.join(staging_path, destination)
+
+    logger["method"] = "input"
+    begin
+      ::Dir.chdir(chdir) do
+        begin
+          clone(source, destination)
+        rescue Errno::ENOENT => e
+          raise FPM::InvalidPackageConfiguration,
+            "Cannot package the path '#{File.join(chdir, source)}', does it exist?"
+        end
+      end
+    rescue Errno::ENOENT => e
+      raise FPM::InvalidPackageConfiguration,
+        "Cannot chdir to '#{chdir}'. Does it exist?"
+    end
+
+    # Set some defaults. This is useful because other package types
+    # 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("@")
+  ensure
+    # Clean up any logger context we added.
+    logger.remove("method")
+  end # def input
+
+  # Output this package to the given directory.
+  def output(output_path)
+    output_check(output_path)
+
+    output_path = File.expand_path(output_path)
+    ::Dir.chdir(staging_path) do
+      logger["method"] = "output"
+      clone(".", output_path)
+    end
+  ensure
+    logger.remove("method")
+  end # def output
+
+  private
+  # Copy a file or directory to a destination
+  #
+  # This is special because it respects the full path of the source.
+  # Aditionally, hardlinks will be used instead of copies.
+  #
+  # Example:
+  #
+  #     clone("/tmp/hello/world", "/tmp/example")
+  #
+  # The above will copy, recursively, /tmp/hello/world into
+  # /tmp/example/hello/world
+  def clone(source, destination)
+    logger.debug("Cloning path", :source => source, :destination => destination)
+    # Edge case check; abort if the temporary directory is the source.
+    # If the temporary dir is the same path as the source, it causes
+    # fpm to recursively (and forever) copy the staging directory by
+    # accident (#542).
+    if File.expand_path(source) == File.expand_path(::Dir.tmpdir)
+      raise FPM::InvalidPackageConfiguration,
+        "A source directory cannot be the root of your temporary " \
+        "directory (#{::Dir.tmpdir}). fpm uses the temporary directory " \
+        "to stage files during packaging, so this setting would have " \
+        "caused fpm to loop creating staging directories and copying " \
+        "them into your package! Oops! If you are confused, maybe you could " \
+        "check your TMPDIR, TMP, or TEMP environment variables?"
+    end
+
+    # For single file copies, permit file destinations
+    fileinfo = File.lstat(source)
+    if fileinfo.file? && !File.directory?(destination)
+      if destination[-1,1] == "/"
+        copy(source, File.join(destination, source))
+      else
+        copy(source, destination)
+      end
+    elsif fileinfo.symlink?
+      copy(source, File.join(destination, source))
+    else
+      # Copy all files from 'path' into staging_path
+      Find.find(source) do |path|
+        target = File.join(destination, path)
+        copy(path, target)
+      end
+    end
+  end # def clone
+
+  # Copy a path.
+  #
+  # Files will be hardlinked if possible, but copied otherwise.
+  # Symlinks should be copied as symlinks.
+  def copy(source, destination)
+    logger.debug("Copying path", :source => source, :destination => destination)
+    directory = File.dirname(destination)
+    # lstat to follow symlinks
+    dstat = File.stat(directory) rescue nil
+    if dstat.nil?
+      FileUtils.mkdir_p(directory)
+    elsif dstat.directory?
+      # do nothing, it's already a directory!
+    else
+      # It exists and is not a directory. This is probably a user error or a bug.
+      readable_path = directory.gsub(staging_path, "")
+      logger.error("You wanted to copy a file into a directory, but that's not a directory, it's a file!", :path => readable_path, :stat => dstat)
+      raise FPM::InvalidPackageConfiguration, "Tried to treat #{readable_path} like a directory, but it's a file!"
+    end
+
+    if File.directory?(source)
+      if !File.symlink?(source)
+        # Create a directory if this path is a directory
+        logger.debug("Creating", :directory => destination)
+        if !File.directory?(destination)
+          FileUtils.mkdir(destination)
+        end
+      else
+        # Linking symlinked directories causes a hardlink to be created, which
+        # results in the source directory being wiped out during cleanup,
+        # so copy the symlink.
+        logger.debug("Copying symlinked directory", :source => source,
+                      :destination => destination)
+        FileUtils.copy_entry(source, destination)
+      end
+    else
+      # Otherwise try copying the file.
+      begin
+        logger.debug("Linking", :source => source, :destination => destination)
+        File.link(source, destination)
+      rescue Errno::ENOENT, Errno::EXDEV, Errno::EPERM
+        # Hardlink attempt failed, copy it instead
+        logger.debug("Copying", :source => source, :destination => destination)
+        copy_entry(source, destination)
+      rescue Errno::EEXIST
+        sane_path = destination.gsub(staging_path, "")
+        logger.error("Cannot copy file, the destination path is probably a directory and I attempted to write a file.", :path => sane_path, :staging => staging_path)
+      end
+    end
+
+    copy_metadata(source, destination)
+  end # def copy
+
+  public(:input, :output)
+end # class FPM::Package::Dir

data/lib/fpm/package/empty.rb

@@ -0,0 +1,13 @@
+require "fpm/package"
+require "backports"
+
+# Empty Package type. For strict/meta/virtual package creation
+
+class FPM::Package::Empty < FPM::Package
+  def output(output_path)
+    logger.warn("Your package has gone into the void.")
+  end
+  def to_s(fmt)
+    return ""
+  end
+end

data/lib/fpm/package/gem.rb

@@ -0,0 +1,224 @@
+require "fpm/namespace"
+require "fpm/package"
+require "rubygems"
+require "fileutils"
+require "fpm/util"
+require "yaml"
+
+# A rubygems package.
+#
+# This does not currently support 'output'
+#
+# The following attributes are supported:
+#
+# * :gem_bin_path
+# * :gem_package_name_prefix
+# * :gem_gem
+class FPM::Package::Gem < FPM::Package
+  # Flags '--foo' will be accessable  as attributes[:gem_foo]
+  option "--bin-path", "DIRECTORY", "The directory to install gem executables"
+  option "--package-prefix", "NAMEPREFIX",
+    "(DEPRECATED, use --package-name-prefix) Name to prefix the package " \
+    "name with." do |value|
+    logger = Cabin::Channel.get
+    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"
+  option "--fix-name", :flag, "Should the target package name be prefixed?",
+    :default => true
+  option "--fix-dependencies", :flag, "Should the package dependencies be " \
+    "prefixed?", :default => true
+  option "--env-shebang", :flag, "Should the target package have the " \
+    "shebang rewritten to use env?", :default => true
+
+  option "--prerelease", :flag, "Allow prerelease versions of a gem", :default => false
+  option "--disable-dependency", "gem_name",
+    "The gem name to remove from dependency list",
+    :multivalued => true, :attribute_name => :gem_disable_dependencies
+
+  option "--version-bins", :flag, "Append the version to the bins", :default => false
+
+  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.exist?(path)
+      path = download(gem, gem_version)
+    end
+
+    logger.info("Using gem file", :path => path)
+    return path
+  end # def download_if_necessary
+
+  def download(gem_name, gem_version=nil)
+
+    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)
+    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
+
+    return gem_files.first
+  end # def download
+
+  def load_package_info(gem_path)
+
+    spec = YAML.load(%x{#{attributes[:gem_gem]} specification #{gem_path} --yaml})
+
+    if !attributes[:gem_package_prefix].nil?
+      attributes[:gem_package_name_prefix] = attributes[:gem_package_prefix]
+    end
+
+    # name prefixing is optional, if enabled, a name 'foo' will become
+    # 'rubygem-foo' (depending on what the gem_package_name_prefix is)
+    self.name = spec.name
+    if attributes[:gem_fix_name?]
+      self.name = fix_name(spec.name)
+    end
+
+    #self.name = [attributes[:gem_package_name_prefix], spec.name].join("-")
+    self.license = (spec.license or "no license listed in #{File.basename(gem_path)}")
+
+    # expand spec's version to match RationalVersioningPolicy to prevent cases
+    # where missing 'build' number prevents correct dependency resolution by target
+    # package manager. Ie. for dpkg 1.1 != 1.1.0
+    m = spec.version.to_s.scan(/(\d+)\.?/)
+    self.version = m.flatten.fill('0', m.length..2).join('.')
+
+    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.
+    # TODO(sissel): Figure out how to hint this only to rpm?
+    # maybe something like attributes[:rpm_provides] for rpm specific stuff?
+    # Or just ignore it all together.
+    #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 << "#{self.name} = #{self.version}"
+
+    if !attributes[:no_auto_depends?]
+      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|
+          if attributes[:gem_disable_dependencies]
+            next if attributes[:gem_disable_dependencies].include?(dep.name)
+          end
+
+          if attributes[:gem_fix_dependencies?]
+            name = fix_name(dep.name)
+          else
+            name = dep.name
+          end
+          self.dependencies << "#{name} #{req}"
+        end
+      end # runtime_dependencies
+    end #no_auto_depends
+  end # def load_package_info
+
+  def install_to_staging(gem_path)
+    if attributes.include?(:prefix) && ! attributes[:prefix].nil?
+      installdir = "#{staging_path}/#{attributes[:prefix]}"
+    else
+      gemdir = safesystemout(*[attributes[:gem_gem], 'env', 'gemdir']).chomp
+      installdir = File.join(staging_path, gemdir)
+    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"]
+    if attributes[:gem_env_shebang?]
+      args += ["-E"]
+    end
+
+    if attributes.include?(:gem_bin_path) && ! attributes[:gem_bin_path].nil?
+      bin_path = File.join(staging_path, attributes[:gem_bin_path])
+    else
+      gem_env  = safesystemout(*[attributes[:gem_gem], 'env']).split("\n")
+      gem_bin  = gem_env.select{ |line| line =~ /EXECUTABLE DIRECTORY/ }.first.split(': ').last
+      bin_path = File.join(staging_path, gem_bin)
+    end
+
+    args += ["--bindir", bin_path]
+    ::FileUtils.mkdir_p(bin_path)
+    args << gem_path
+    safesystem(*args)
+
+    # Delete bin_path if it's empty, and any empty parents (#612)
+    # Above, we mkdir_p bin_path because rubygems aborts if the parent
+    # directory doesn't exist, for example:
+    #   ERROR:  While executing gem ... (Errno::ENOENT)
+    #       No such file or directory - /tmp/something/weird/bin
+    tmp = bin_path
+    while ::Dir.entries(tmp).size == 2 || tmp == "/"  # just [ "..", "." ] is an empty directory
+      logger.info("Deleting empty bin_path", :path => tmp)
+      ::Dir.rmdir(tmp)
+      tmp = File.dirname(tmp)
+    end
+    if attributes[:gem_version_bins?] and File.directory?(bin_path)
+      (::Dir.entries(bin_path) - ['.','..']).each do |bin|
+        FileUtils.mv("#{bin_path}/#{bin}", "#{bin_path}/#{bin}-#{self.version}")
+      end
+    end
+  end # def install_to_staging
+
+  # Sanitize package name.
+  # This prefixes the package name with 'rubygem' (but depends on the attribute
+  # :gem_package_name_prefix
+  def fix_name(name)
+    return [attributes[:gem_package_name_prefix], name].join("-")
+  end # def fix_name
+  public(:input, :output)
+end # class FPM::Package::Gem

data/lib/fpm/package/npm.rb

@@ -0,0 +1,120 @@
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/util"
+require "fileutils"
+
+class FPM::Package::NPM < FPM::Package
+  class << self
+    include FPM::Util
+  end
+  # 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"
+
+  option "--registry", "NPM_REGISTRY",
+    "The npm registry to use instead of the default."
+
+  private
+  def input(package)
+    # Notes:
+    # * npm respects PREFIX
+    settings = {
+      "cache" => build_path("npm_cache"),
+      "loglevel" => "warn",
+      "global" => "true"
+    }
+
+    settings["registry"] = attributes[:npm_registry] if attributes[:npm_registry_given?]
+    set_default_prefix unless attributes[:prefix_given?]
+
+    settings["prefix"] = staging_path(attributes[:prefix])
+    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_out = safesystemout(attributes[:npm_bin], "ls", "--json", "--long", *npm_flags)
+    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.fetch("version", "0.0.0")
+
+    if info.include?("repository")
+      self.url = info["repository"]["url"]
+    else
+      self.url = "https://npmjs.org/package/#{self.name}"
+    end
+
+    self.description = info["description"]
+    # Supposedly you can upload a package for npm with no author/author email
+    # so I'm being safer with this. Author can also be a hash or a string
+    self.vendor = "Unknown <unknown@unknown.unknown>"
+    if info.include?("author")
+      author_info = info["author"]
+      # If a hash, assemble into a string
+      if author_info.respond_to? :fetch
+        self.vendor = sprintf("%s <%s>", author_info.fetch("name", "unknown"),
+                              author_info.fetch("email", "unknown@unknown.unknown"))
+      else
+        # Probably will need a better check for validity here
+        self.vendor = author_info unless author_info == ""
+      end
+    end
+
+    # 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
+
+  def set_default_prefix
+    attributes[:prefix] = self.class.default_prefix
+    attributes[:prefix_given?] = true
+  end
+
+  def self.default_prefix
+    npm_prefix = safesystemout("npm", "prefix", "-g").chomp
+    if npm_prefix.count("\n") > 0
+      raise FPM::InvalidPackageConfiguration, "`npm prefix -g` returned unexpected output."
+    elsif !File.directory?(npm_prefix)
+      raise FPM::InvalidPackageConfiguration, "`npm prefix -g` returned a non-existent directory"
+    end
+    logger.info("Setting default npm install prefix", :prefix => npm_prefix)
+    npm_prefix
+  end
+
+  public(:input)
+end # class FPM::Package::NPM