fpm 1.2.0 → 1.3.0

data/lib/fpm/package/deb.rb

@@ -186,7 +186,7 @@ class FPM::Package::Deb < FPM::Package
   # characters.
   def name
     if @name =~ /[A-Z]/
-      @logger.warn("Debian tools (dpkg/apt) don't do well with packages " \
+      logger.warn("Debian tools (dpkg/apt) don't do well with packages " \
         "that use capital letters in the name. In some cases it will " \
         "automatically downcase them, in others it will not. It is confusing." \
         " Best to not use any capital letters at all. I have downcased the " \
@@ -196,11 +196,17 @@ class FPM::Package::Deb < FPM::Package
     end
 
     if @name.include?("_")
-      @logger.info("Debian package names cannot include underscores; " \
+      logger.info("Debian package names cannot include underscores; " \
                    "automatically converting to dashes", :name => @name)
       @name = @name.gsub(/[_]/, "-")
     end
 
+    if @name.include?(" ")
+      logger.info("Debian package names cannot include spaces; " \
+                   "automatically converting to dashes", :name => @name)
+      @name = @name.gsub(/[ ]/, "-")
+    end
+
     return @name
   end # def name
   
@@ -226,7 +232,7 @@ class FPM::Package::Deb < FPM::Package
         if value.nil?
           return nil
         else
-          @logger.info("deb field", field => value.split(": ", 2).last)
+          logger.info("deb field", field => value.split(": ", 2).last)
           return value.split(": ",2).last
         end
       end
@@ -330,21 +336,36 @@ class FPM::Package::Deb < FPM::Package
 
     # If we are given --deb-shlibs but no --after-install script, we
     # should implicitly create a before/after scripts that run ldconfig
-    if attributes[:deb_shlibs] 
+    if attributes[:deb_shlibs]
       if !script?(:after_install)
-        @logger.info("You gave --deb-shlibs but no --after-install, so " \
+        logger.info("You gave --deb-shlibs but no --after-install, so " \
                      "I am adding an after-install script that runs " \
                      "ldconfig to update the system library cache")
         scripts[:after_install] = template("deb/ldconfig.sh.erb").result(binding)
       end
       if !script?(:after_remove)
-        @logger.info("You gave --deb-shlibs but no --after-remove, so " \
+        logger.info("You gave --deb-shlibs but no --after-remove, so " \
                      "I am adding an after-remove script that runs " \
                      "ldconfig to update the system library cache")
         scripts[:after_remove] = template("deb/ldconfig.sh.erb").result(binding)
       end
     end
 
+    if script?(:before_upgrade) or script?(:after_upgrade)
+      if script?(:before_install) or script?(:before_upgrade)
+        scripts[:before_install] = template("deb/preinst_upgrade.sh.erb").result(binding)
+      end
+      if script?(:before_remove)
+        scripts[:before_remove] = template("deb/prerm_upgrade.sh.erb").result(binding)
+      end
+      if script?(:after_install) or script?(:after_upgrade)
+        scripts[:after_install] = template("deb/postinst_upgrade.sh.erb").result(binding)
+      end
+      if script?(:after_remove)
+        scripts[:after_remove] = template("deb/postrm_upgrade.sh.erb").result(binding)
+      end
+    end
+
     write_control_tarball
 
     # Tar up the staging_path into data.tar.{compression type}
@@ -363,13 +384,24 @@ class FPM::Package::Deb < FPM::Package
           "Unknown compression type '#{self.attributes[:deb_compression]}'"
     end
 
-    if attributes[:deb_changelog]
-      dest_changelog = File.join(staging_path, "usr/share/doc/#{name}/changelog.Debian")
-      FileUtils.mkdir_p(File.dirname(dest_changelog))
-      FileUtils.cp attributes[:deb_changelog], dest_changelog
-      File.chmod(0644, dest_changelog)
-      safesystem("gzip", dest_changelog)
-    end
+    # Write the changelog file
+    dest_changelog = File.join(staging_path, "usr/share/doc/#{name}/changelog.Debian.gz")
+    FileUtils.mkdir_p(File.dirname(dest_changelog))
+    File.new(dest_changelog, "wb", 0644).tap do |changelog|
+      Zlib::GzipWriter.new(changelog, Zlib::BEST_COMPRESSION).tap do |changelog_gz|
+        if attributes[:deb_changelog]
+          logger.info("Writing user-specified changelog", :source => attributes[:deb_changelog])
+          File.new(attributes[:deb_changelog]).tap do |fd|
+            chunk = nil
+            # Ruby 1.8.7 doesn't have IO#copy_stream
+            changelog_gz.write(chunk) while chunk = fd.read(16384)
+          end.close
+        else
+          logger.info("Creating boilerplate changelog file")
+          changelog_gz.write(template("deb/changelog.erb").result(binding))
+        end
+      end.close
+    end # No need to close, GzipWriter#close will close it.
 
     attributes.fetch(:deb_init_list, []).each do |init|
       name = File.basename(init, ".init")
@@ -445,13 +477,13 @@ class FPM::Package::Deb < FPM::Package
     name_re = /^[^ \(]+/
     name = dep[name_re]
     if name =~ /[A-Z]/
-      @logger.warn("Downcasing dependency '#{name}' because deb packages " \
+      logger.warn("Downcasing dependency '#{name}' because deb packages " \
                    " don't work so good with uppercase names")
       dep = dep.gsub(name_re) { |n| n.downcase }
     end
 
     if dep.include?("_")
-      @logger.warn("Replacing dependency underscores with dashes in '#{dep}' because " \
+      logger.warn("Replacing dependency underscores with dashes in '#{dep}' because " \
                    "debs don't like underscores")
       dep = dep.gsub("_", "-")
     end
@@ -493,13 +525,13 @@ class FPM::Package::Deb < FPM::Package
     name_re = /^[^ \(]+/
     name = provides[name_re]
     if name =~ /[A-Z]/
-      @logger.warn("Downcasing provides '#{name}' because deb packages " \
+      logger.warn("Downcasing provides '#{name}' because deb packages " \
                    " don't work so good with uppercase names")
       provides = provides.gsub(name_re) { |n| n.downcase }
     end
 
     if provides.include?("_")
-      @logger.warn("Replacing 'provides' underscores with dashes in '#{provides}' because " \
+      logger.warn("Replacing 'provides' underscores with dashes in '#{provides}' because " \
                    "debs don't like underscores")
       provides = provides.gsub("_", "-")
     end
@@ -530,25 +562,25 @@ 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)
+      logger.info("Creating", :path => controltar, :from => control_path)
 
       args = [ tar_cmd, "-C", control_path, "-zcf", controltar, 
         "--owner=0", "--group=0", "--numeric-owner", "." ]
       safesystem(*args)
     end
 
-    @logger.debug("Removing no longer needed control dir", :path => control_path)
+    logger.debug("Removing no longer needed control dir", :path => control_path)
   ensure
     FileUtils.rm_r(control_path)
   end # def write_control_tarball
 
   def write_control
     # warn user if epoch is set
-    @logger.warn("epoch in Version is set", :epoch => self.epoch) if self.epoch
+    logger.warn("epoch in Version is set", :epoch => self.epoch) if self.epoch
 
     # calculate installed-size if necessary:
     if attributes[:deb_installed_size].nil?
-      @logger.info("No deb_installed_size set, calculating now.")
+      logger.info("No deb_installed_size set, calculating now.")
       total = 0
       Find.find(staging_path) do |path|
         stat = File.lstat(path)
@@ -564,14 +596,14 @@ class FPM::Package::Deb < FPM::Package
     # Write the control file
     with(control_path("control")) do |control|
       if attributes[:deb_custom_control]
-        @logger.debug("Using '#{attributes[:deb_custom_control]}' template for the control file")
+        logger.debug("Using '#{attributes[:deb_custom_control]}' template for the control file")
         control_data = File.read(attributes[:deb_custom_control])
       else
-        @logger.debug("Using 'deb.erb' template for the control file")
+        logger.debug("Using 'deb.erb' template for the control file")
         control_data = template("deb.erb").result(binding)
       end
 
-      @logger.debug("Writing control file", :path => control)
+      logger.debug("Writing control file", :path => control)
       File.write(control, control_data)
       File.chmod(0644, control)
       edit_file(control) if attributes[:edit?]
@@ -587,7 +619,7 @@ class FPM::Package::Deb < FPM::Package
       next unless script?(scriptname)
 
       with(control_path(filename)) do |controlscript|
-        @logger.debug("Writing control script", :source => filename, :target => controlscript)
+        logger.debug("Writing control script", :source => filename, :target => controlscript)
         File.write(controlscript, script(scriptname))
         # deb maintainer scripts are required to be executable
         File.chmod(0755, controlscript)
@@ -630,7 +662,7 @@ class FPM::Package::Deb < FPM::Package
 
   def write_shlibs
     return unless attributes[:deb_shlibs]
-    @logger.info("Adding shlibs", :content => attributes[:deb_shlibs])
+    logger.info("Adding shlibs", :content => attributes[:deb_shlibs])
     File.open(control_path("shlibs"), "w") do |out|
       out.write(attributes[:deb_shlibs])
     end

data/lib/fpm/package/dir.rb

@@ -64,7 +64,7 @@ class FPM::Package::Dir < FPM::Package
 
     destination = File.join(staging_path, destination)
 
-    @logger["method"] = "input"
+    logger["method"] = "input"
     begin
       ::Dir.chdir(chdir) do
         begin
@@ -87,7 +87,7 @@ class FPM::Package::Dir < FPM::Package
     self.vendor = [ENV["USER"], Socket.gethostname].join("@")
   ensure
     # Clean up any logger context we added.
-    @logger.remove("method")
+    logger.remove("method")
   end # def input
 
   # Output this package to the given directory.
@@ -96,11 +96,11 @@ class FPM::Package::Dir < FPM::Package
 
     output_path = File.expand_path(output_path)
     ::Dir.chdir(staging_path) do
-      @logger["method"] = "output"
+      logger["method"] = "output"
       clone(".", output_path)
     end
   ensure
-    @logger.remove("method")
+    logger.remove("method")
   end # def output
 
   private
@@ -116,7 +116,7 @@ class FPM::Package::Dir < FPM::Package
   # 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)
+    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
@@ -132,12 +132,15 @@ class FPM::Package::Dir < FPM::Package
     end
 
     # For single file copies, permit file destinations
-    if File.file?(source) && !File.directory?(destination) 
+    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, destination)
     else
       # Copy all files from 'path' into staging_path
       Find.find(source) do |path|
@@ -152,7 +155,7 @@ class FPM::Package::Dir < FPM::Package
   # 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)
+    logger.debug("Copying path", :source => source, :destination => destination)
     directory = File.dirname(destination)
     if !File.directory?(directory)
       FileUtils.mkdir_p(directory)
@@ -161,7 +164,7 @@ class FPM::Package::Dir < FPM::Package
     if File.directory?(source)
       if !File.symlink?(source)
         # Create a directory if this path is a directory
-        @logger.debug("Creating", :directory => destination)
+        logger.debug("Creating", :directory => destination)
         if !File.directory?(destination)
           FileUtils.mkdir(destination)
         end
@@ -169,22 +172,22 @@ class FPM::Package::Dir < FPM::Package
         # 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,
+        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)
+        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)
+        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)
+        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
 

data/lib/fpm/package/gem.rb

@@ -62,13 +62,13 @@ class FPM::Package::Gem < FPM::Package
       path = download(gem, gem_version)
     end
 
-    @logger.info("Using gem file", :path => path)
+    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)
+    logger.info("Trying to download", :gem => gem_name, :version => gem_version)
 
     gem_fetch = [ "#{attributes[:gem_gem]}", "fetch", gem_name]
 
@@ -79,7 +79,7 @@ class FPM::Package::Gem < FPM::Package
     FileUtils.mkdir(download_dir) unless File.directory?(download_dir)
 
     ::Dir.chdir(download_dir) do |dir|
-      @logger.debug("Downloading in directory #{dir}")
+      logger.debug("Downloading in directory #{dir}")
       safesystem(*gem_fetch)
     end
 
@@ -203,7 +203,7 @@ class FPM::Package::Gem < FPM::Package
     #       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)
+      logger.info("Deleting empty bin_path", :path => tmp)
       ::Dir.rmdir(tmp)
       tmp = File.dirname(tmp)
     end

data/lib/fpm/package/npm.rb

@@ -24,25 +24,17 @@ class FPM::Package::NPM < FPM::Package
       "global" => "true"
     }
 
-    if attributes.include?(:npm_registry) && !attributes[:npm_registry].nil?
-      settings["registry"] = attributes[:npm_registry]
-    end
-
-    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
+    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)
+      logger.debug("Configuring npm", key => value)
       npm_flags += [ "--#{key}", value ]
     end
 
@@ -105,5 +97,21 @@ class FPM::Package::NPM < FPM::Package
     # 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

data/lib/fpm/package/osxpkg.rb

@@ -82,7 +82,7 @@ class FPM::Package::OSXpkg < FPM::Package
       next unless script?(scriptname)
 
       with(scripts_path(filename)) do |pkgscript|
-        @logger.info("Writing pkg script", :source => filename, :target => 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)
@@ -110,7 +110,7 @@ class FPM::Package::OSXpkg < FPM::Package
       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}")
+      logger.info("inferring name #{self.name} from pkg-id #{identifier}")
     end
   end # def extract_info
 

data/lib/fpm/package/pear.rb

@@ -41,73 +41,73 @@ class FPM::Package::PEAR < FPM::Package
     end
 
     # Create a temporary config file
-    @logger.debug("Creating pear 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)
 
     if attributes[:pear_php_dir]
-      @logger.info("Setting php_dir", :php_dir => attributes[:pear_php_dir])
+      logger.info("Setting php_dir", :php_dir => attributes[:pear_php_dir])
       safesystem("pear", "-c", config, "config-set", "php_dir", "#{staging_path(installroot)}/#{attributes[:pear_php_dir]}")
     end
 
     if attributes[:pear_data_dir]
-      @logger.info("Setting data_dir", :data_dir => attributes[:pear_data_dir])
+      logger.info("Setting data_dir", :data_dir => attributes[:pear_data_dir])
       safesystem("pear", "-c", config, "config-set", "data_dir", "#{staging_path(installroot)}/#{attributes[:pear_data_dir]}")
     end
 
     bin_dir = attributes[:pear_bin_dir] || "usr/bin"
-    @logger.info("Setting bin_dir", :bin_dir => bin_dir)
+    logger.info("Setting bin_dir", :bin_dir => bin_dir)
     safesystem("pear", "-c", config, "config-set", "bin_dir", bin_dir)
 
     php_bin = attributes[:pear_php_bin] || "/usr/bin/php"
-    @logger.info("Setting php_bin", :php_bin => php_bin)
+    logger.info("Setting php_bin", :php_bin => php_bin)
     safesystem("pear", "-c", config, "config-set", "php_bin", php_bin)
 
     # do channel-discover if required
     if !attributes[:pear_channel].nil?
-      @logger.info("Custom channel specified", :channel => attributes[:pear_channel])
+      logger.info("Custom channel specified", :channel => attributes[:pear_channel])
       channel_list = safesystemout("pear", "-c", config, "list-channels")
       if channel_list !~ /#{Regexp.quote(attributes[:pear_channel])}/
-        @logger.info("Discovering new channel", :channel => attributes[:pear_channel])
+        logger.info("Discovering new channel", :channel => attributes[:pear_channel])
         safesystem("pear", "-c", config, "channel-discover", attributes[:pear_channel])
       end
       input_package = "#{attributes[:pear_channel]}/#{input_package}"
-      @logger.info("Prefixing package name with channel", :package => input_package)
+      logger.info("Prefixing package name with channel", :package => input_package)
     end
 
     # do channel-update if requested
     if attributes[:pear_channel_update?]
       channel = attributes[:pear_channel] || "pear"
-      @logger.info("Updating the channel", :channel => channel)
+      logger.info("Updating the channel", :channel => channel)
       safesystem("pear", "-c", config, "channel-update", channel)
     end
 
-    @logger.info("Installing pear package", :package => input_package,
+    logger.info("Installing pear package", :package => input_package,
                   :directory => staging_path)
     ::Dir.chdir(staging_path) do
       safesystem("pear", "-c", config, "install", "-n", "-f", input_package)
     end
 
     pear_cmd = "pear -c #{config} remote-info #{input_package}"
-    @logger.info("Fetching package information", :package => input_package, :command => pear_cmd)
+    logger.info("Fetching package information", :package => input_package, :command => pear_cmd)
     name = %x{#{pear_cmd} | sed -ne '/^Package\s*/s/^Package\s*//p'}.chomp
     self.name = "#{attributes[:pear_package_name_prefix]}-#{name}"
     self.version = %x{#{pear_cmd} | sed -ne '/^Installed\s*/s/^Installed\s*//p'}.chomp
     self.description  = %x{#{pear_cmd} | sed -ne '/^Summary\s*/s/^Summary\s*//p'}.chomp
-    @logger.debug("Package info", :name => self.name, :version => self.version,
+    logger.debug("Package info", :name => self.name, :version => self.version,
                   :description => self.description)
 
     # Remove the stuff we don't want
     delete_these = [".depdb", ".depdblock", ".filemap", ".lock", ".channel", "cache", "temp", "download", ".channels", ".registry"]
     Find.find(staging_path) do |path|
       if File.file?(path)
-        @logger.info("replacing staging_path in file", :replace_in => path, :staging_path => staging_path)
+        logger.info("replacing staging_path in file", :replace_in => path, :staging_path => staging_path)
         begin
           content = File.read(path).gsub(/#{Regexp.escape(staging_path)}/, "")
           File.write(path, content)
         rescue ArgumentError => e
-          @logger.warn("error replacing staging_path in file", :replace_in => path, :error => e)
+          logger.warn("error replacing staging_path in file", :replace_in => path, :error => e)
         end
       end
       FileUtils.rm_r(path) if delete_these.include?(File.basename(path))