RubyGems - dpkg-s3 - Versions diffs - 0.3.1 → 0.4.0 - Mend

dpkg-s3 0.3.1 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

checksums.yaml +4 -4
data/README.md +1 -1
data/bin/dpkg-s3 +19 -4
data/lib/dpkg/s3.rb +3 -2
data/lib/dpkg/s3/cli.rb +572 -574
data/lib/dpkg/s3/lock.rb +65 -53
data/lib/dpkg/s3/manifest.rb +128 -126
data/lib/dpkg/s3/package.rb +267 -282
data/lib/dpkg/s3/release.rb +139 -141
data/lib/dpkg/s3/templates/package.erb +1 -1
data/lib/dpkg/s3/utils.rb +112 -114
metadata +37 -9

data/lib/dpkg/s3/lock.rb CHANGED Viewed

@@ -1,67 +1,79 @@
-# -*- encoding : utf-8 -*-
-require "tempfile"
-require "socket"
-require "etc"
-require "securerandom"
+# frozen_string_literal: true
-class Dpkg::S3::Lock
-  attr_accessor :user
-  attr_accessor :host
+require 'tempfile'
+require 'socket'
+require 'etc'
+require 'securerandom'
-  def initialize
-    @user = nil
-    @host = nil
-  end
-  class << self
-    def locked?(codename, component = nil, architecture = nil, cache_control = nil)
-      Dpkg::S3::Utils.s3_exists?(lock_path(codename, component, architecture, cache_control))
-    end
+# Dpkg is the root module for all storage modules including S3
+module Dpkg
+  # S3 storage module resposible of handling packages on S3 including upload, delete
+  module S3
+    # Lock is resposible of creating lock file on S3 to ensure when multiple instances of uploads will
+    # not conflict with each other
+    class Lock
+      attr_accessor :user, :host
-    def wait_for_lock(codename, component = nil, architecture = nil, cache_control = nil, max_attempts=60, wait=10)
-      attempts = 0
-      while self.locked?(codename, component, architecture, cache_control) do
-        attempts += 1
-        throw "Unable to obtain a lock after #{max_attempts}, giving up." if attempts > max_attempts
-        sleep(wait)
+      def initialize
+        @user = nil
+        @host = nil
       end
-    end
-    def lock(codename, component = nil, architecture = nil, cache_control = nil)
-      lockfile = Tempfile.new("lockfile")
-      lock_content = generate_lock_content
-      lockfile.write lock_content
-      lockfile.close
+      class << self
+        def locked?(codename, component = nil, architecture = nil, cache_control = nil)
+          Dpkg::S3::Utils.s3_exists?(lock_path(codename, component, architecture, cache_control))
+        end
-      Dpkg::S3::Utils.s3_store(lockfile.path,
-                              lock_path(codename, component, architecture, cache_control),
-                              "text/plain",
-                              cache_control)
+        def wait_for_lock(codename, component = nil, architecture = nil, cache_control = nil)
+          max_attempts = 60
+          wait = 10
+          attempts = 0
+          while locked?(codename, component, architecture, cache_control)
+            attempts += 1
+            throw "Unable to obtain a lock after #{max_attempts}, giving up." if attempts > max_attempts
+            sleep(wait)
+          end
+        end
-      return if lock_content == Dpkg::S3::Utils.s3_read(lock_path(codename, component, architecture, cache_control))
-      throw "Failed to acquire lock, was overwritten by another deb-s3 process"
-    end
+        def lock(codename, component = nil, architecture = nil, cache_control = nil)
+          lockfile = Tempfile.new('lockfile')
+          lock_content = generate_lock_content
+          lockfile.write lock_content
+          lockfile.close
-    def unlock(codename, component = nil, architecture = nil, cache_control = nil)
-      Dpkg::S3::Utils.s3_remove(lock_path(codename, component, architecture, cache_control))
-    end
+          Dpkg::S3::Utils.s3_store(lockfile.path,
+                                   lock_path(codename, component, architecture, cache_control),
+                                   'text/plain',
+                                   cache_control)
-    def current(codename, component = nil, architecture = nil, cache_control = nil)
-      lock_content = Dpkg::S3::Utils.s3_read(lock_path(codename, component, architecture, cache_control))
-      lock_content = lock_content.split.first.split('@')
-      lock = Dpkg::S3::Lock.new
-      lock.user = lock_content[0]
-      lock.host = lock_content[1] if lock_content.size > 1
-      lock
-    end
+          return if lock_content == Dpkg::S3::Utils.s3_read(lock_path(codename, component, architecture, cache_control))
-    private
-    def lock_path(codename, component = nil, architecture = nil, cache_control = nil)
-      "dists/#{codename}/#{component}/binary-#{architecture}/lockfile"
-    end
+          throw 'Failed to acquire lock, was overwritten by another deb-s3 process'
+        end
+        def unlock(codename, component = nil, architecture = nil, cache_control = nil)
+          Dpkg::S3::Utils.s3_remove(lock_path(codename, component, architecture, cache_control))
+        end
+        def current(codename, component = nil, architecture = nil, cache_control = nil)
+          lock_content = Dpkg::S3::Utils.s3_read(lock_path(codename, component, architecture, cache_control))
+          lock_content = lock_content.split.first.split('@')
+          lock = Dpkg::S3::Lock.new
+          lock.user = lock_content[0]
+          lock.host = lock_content[1] if lock_content.size > 1
+          lock
+        end
-    def generate_lock_content
-      "#{Etc.getlogin}@#{Socket.gethostname}\n#{SecureRandom.hex}"
+        private
+        def lock_path(codename, component = nil, architecture = nil, _cache_control = nil)
+          "dists/#{codename}/#{component}/binary-#{architecture}/lockfile"
+        end
+        def generate_lock_content
+          "#{Etc.getlogin}@#{Socket.gethostname}\n#{SecureRandom.hex}"
+        end
+      end
     end
   end
 end

data/lib/dpkg/s3/manifest.rb CHANGED Viewed

@@ -1,144 +1,146 @@
-# -*- encoding : utf-8 -*-
-require "tempfile"
-require "zlib"
+# frozen_string_literal: true
+require 'tempfile'
+require 'zlib'
 require 'dpkg/s3/utils'
 require 'dpkg/s3/package'
-class Dpkg::S3::Manifest
-  include Dpkg::S3::Utils
-  attr_accessor :codename
-  attr_accessor :component
-  attr_accessor :cache_control
-  attr_accessor :architecture
-  attr_accessor :fail_if_exists
-  attr_accessor :skip_package_upload
-  attr_accessor :files
-  attr_reader :packages
-  attr_reader :packages_to_be_upload
-  def initialize
-    @packages = []
-    @packages_to_be_upload = []
-    @component = nil
-    @architecture = nil
-    @files = {}
-    @cache_control = ""
-    @fail_if_exists = false
-    @skip_package_upload = false
-  end
-  class << self
-    def retrieve(codename, component, architecture, cache_control, fail_if_exists, skip_package_upload=false)
-      m = if s = Dpkg::S3::Utils.s3_read("dists/#{codename}/#{component}/binary-#{architecture}/Packages")
-        self.parse_packages(s)
-      else
-        self.new
+# Dpkg is the root module for all storage modules including S3
+module Dpkg
+  # S3 storage module resposible of handling packages on S3 including upload, delete
+  module S3
+    # Manifest is resposible of creating/retrieving and rebuilding the debian Package manifest with
+    # standard information required when publishing the packages to a S3 debian repository
+    class Manifest
+      include Dpkg::S3::Utils
+      attr_accessor :codename, :component, :cache_control, :architecture, :fail_if_exists, :skip_package_upload, :files
+      attr_reader :packages, :packages_to_be_upload
+      def initialize
+        @packages = []
+        @packages_to_be_upload = []
+        @component = nil
+        @architecture = nil
+        @files = {}
+        @cache_control = ''
+        @fail_if_exists = false
+        @skip_package_upload = false
       end
-      m.codename = codename
-      m.component = component
-      m.architecture = architecture
-      m.cache_control = cache_control
-      m.fail_if_exists = fail_if_exists
-      m.skip_package_upload = skip_package_upload
-      m
-    end
+      class << self
+        def retrieve(codename, component, architecture, cache_control, fail_if_exists, skip_upload: false)
+          m = if (s = Dpkg::S3::Utils.s3_read("dists/#{codename}/#{component}/binary-#{architecture}/Packages"))
+                parse_packages(s)
+              else
+                new
+              end
+          m.codename = codename
+          m.component = component
+          m.architecture = architecture
+          m.cache_control = cache_control
+          m.fail_if_exists = fail_if_exists
+          m.skip_package_upload = skip_upload
+          m
+        end
+        def parse_packages(str)
+          m = new
+          str.split("\n\n").each do |s|
+            next if s.chomp.empty?
-    def parse_packages(str)
-      m = self.new
-      str.split("\n\n").each do |s|
-        next if s.chomp.empty?
-        m.packages << Dpkg::S3::Package.parse_string(s)
+            m.packages << Dpkg::S3::Package.parse_string(s)
+          end
+          m
+        end
       end
-      m
-    end
-  end
-  def add(pkg, preserve_versions, needs_uploading=true)
-    if self.fail_if_exists
-      packages.each { |p|
-        next unless p.name == pkg.name && \
-                    p.full_version == pkg.full_version && \
-                    File.basename(p.url_filename(@codename)) != \
-                    File.basename(pkg.url_filename(@codename))
-        raise AlreadyExistsError,
-              "package #{pkg.name}_#{pkg.full_version} already exists " \
-              "with different filename (#{p.url_filename(@codename)})"
-      }
-    end
-    if preserve_versions
-      packages.delete_if { |p| p.name == pkg.name && p.full_version == pkg.full_version }
-    else
-      packages.delete_if { |p| p.name == pkg.name }
-    end
-    packages << pkg
-    packages_to_be_upload << pkg if needs_uploading
-    pkg
-  end
+      def add(pkg, preserve_versions, needs_uploading: true)
+        if fail_if_exists
+          packages.each do |p|
+            next unless p.name == pkg.name && \
+                        p.full_version == pkg.full_version && \
+                        File.basename(p.url_filename(@codename)) == \
+                        File.basename(pkg.url_filename(@codename))
+            raise AlreadyExistsError,
+                  "package #{pkg.name}_#{pkg.full_version} already exists " \
+                  "with filename (#{p.url_filename(@codename)})"
+          end
+        end
+        if preserve_versions
+          packages.delete_if { |p| p.name == pkg.name && p.full_version == pkg.full_version }
+        else
+          packages.delete_if { |p| p.name == pkg.name }
+        end
+        packages << pkg
+        packages_to_be_upload << pkg if needs_uploading
+        pkg
+      end
-  def delete_package(pkg, versions=nil)
-    deleted = []
-    new_packages = @packages.select { |p|
-        # Include packages we didn't name
-        if p.name != pkg
-           p
-        # Also include the packages not matching a specified version
-        elsif (!versions.nil? and p.name == pkg and !versions.include?(p.version) and !versions.include?("#{p.version}-#{p.iteration}") and !versions.include?(p.full_version))
+      def delete_package(pkg, versions = nil)
+        new_packages = @packages.select do |p|
+          # Include packages we didn't name
+          # Also include the packages not matching a specified version
+          if p.name != pkg || (!versions.nil? && (p.name == pkg) && !versions.include?(p.version) &&
+                !versions.include?("#{p.version}-#{p.iteration}") && !versions.include?(p.full_version))
             p
+          end
         end
-    }
-    deleted = @packages - new_packages
-    @packages = new_packages
-    deleted
-  end
+        deleted = @packages - new_packages
+        @packages = new_packages
+        deleted
+      end
-  def generate
-    @packages.collect { |pkg| pkg.generate(@codename) }.join("\n")
-  end
+      def generate
+        @packages.collect { |pkg| pkg.generate(@codename) }.join("\n")
+      end
-  def write_to_s3
-    manifest = self.generate
+      def write_to_s3
+        manifest = generate
-    unless self.skip_package_upload
-      # store any packages that need to be stored
-      @packages_to_be_upload.each do |pkg|
-        yield pkg.url_filename(@codename) if block_given?
-        s3_store(pkg.filename, pkg.url_filename(@codename), 'application/x-debian-package', self.cache_control, self.fail_if_exists)
-      end
-    end
+        unless skip_package_upload
+          # store any packages that need to be stored
+          @packages_to_be_upload.each do |pkg|
+            yield pkg.url_filename(@codename) if block_given?
+            s3_store(pkg.filename, pkg.url_filename(@codename), 'application/x-debian-package', cache_control,
+                     fail_if_exists: fail_if_exists)
+          end
+        end
-    # generate the Packages file
-    pkgs_temp = Tempfile.new("Packages")
-    pkgs_temp.write manifest
-    pkgs_temp.close
-    f = "dists/#{@codename}/#{@component}/binary-#{@architecture}/Packages"
-    yield f if block_given?
-    s3_store(pkgs_temp.path, f, 'text/plain; charset=utf-8', self.cache_control)
-    @files["#{@component}/binary-#{@architecture}/Packages"] = hashfile(pkgs_temp.path)
-    pkgs_temp.unlink
-    # generate the Packages.gz file
-    gztemp = Tempfile.new("Packages.gz")
-    gztemp.close
-    Zlib::GzipWriter.open(gztemp.path) { |gz| gz.write manifest }
-    f = "dists/#{@codename}/#{@component}/binary-#{@architecture}/Packages.gz"
-    yield f if block_given?
-    s3_store(gztemp.path, f, 'application/x-gzip', self.cache_control)
-    @files["#{@component}/binary-#{@architecture}/Packages.gz"] = hashfile(gztemp.path)
-    gztemp.unlink
-    nil
-  end
+        # generate the Packages file
+        pkgs_temp = Tempfile.new('Packages')
+        pkgs_temp.write manifest
+        pkgs_temp.close
+        f = "dists/#{@codename}/#{@component}/binary-#{@architecture}/Packages"
+        yield f if block_given?
+        s3_store(pkgs_temp.path, f, 'text/plain; charset=utf-8', cache_control)
+        @files["#{@component}/binary-#{@architecture}/Packages"] = hashfile(pkgs_temp.path)
+        pkgs_temp.unlink
+        # generate the Packages.gz file
+        gztemp = Tempfile.new('Packages.gz')
+        gztemp.close
+        Zlib::GzipWriter.open(gztemp.path) { |gz| gz.write manifest }
+        f = "dists/#{@codename}/#{@component}/binary-#{@architecture}/Packages.gz"
+        yield f if block_given?
+        s3_store(gztemp.path, f, 'application/x-gzip', cache_control)
+        @files["#{@component}/binary-#{@architecture}/Packages.gz"] = hashfile(gztemp.path)
+        gztemp.unlink
+        nil
+      end
-  def hashfile(path)
-    {
-      :size   => File.size(path),
-      :sha1   => Digest::SHA1.file(path).hexdigest,
-      :sha256 => Digest::SHA2.file(path).hexdigest,
-      :md5    => Digest::MD5.file(path).hexdigest
-    }
+      def hashfile(path)
+        {
+          size: File.size(path),
+          sha1: Digest::SHA1.file(path).hexdigest,
+          sha256: Digest::SHA2.file(path).hexdigest,
+          md5: Digest::MD5.file(path).hexdigest
+        }
+      end
+    end
   end
 end

data/lib/dpkg/s3/package.rb CHANGED Viewed

@@ -1,312 +1,297 @@
-# -*- encoding : utf-8 -*-
-require "digest/sha1"
-require "digest/sha2"
-require "digest/md5"
-require "socket"
-require "tmpdir"
-require "cgi"
+# frozen_string_literal: true
-require 'dpkg/s3/utils'
-class Dpkg::S3::Package
-  include Dpkg::S3::Utils
-  attr_accessor :name
-  attr_accessor :version
-  attr_accessor :epoch
-  attr_accessor :iteration
-  attr_accessor :maintainer
-  attr_accessor :vendor
-  attr_accessor :url
-  attr_accessor :category
-  attr_accessor :license
-  attr_accessor :architecture
-  attr_accessor :description
-  attr_accessor :dependencies
-  # Any other attributes specific to this package.
-  # This is where you'd put rpm, deb, or other specific attributes.
-  attr_accessor :attributes
-  # hashes
-  attr_accessor :url_filename
-  attr_accessor :sha1
-  attr_accessor :sha256
-  attr_accessor :md5
-  attr_accessor :size
-  attr_accessor :filename
-  class << self
-    include Dpkg::S3::Utils
-    def parse_file(package)
-      p = self.new
-      p.extract_info(extract_control(package))
-      p.apply_file_info(package)
-      p.filename = package
-      p
-    end
+require 'digest/sha1'
+require 'digest/sha2'
+require 'digest/md5'
+require 'English'
+require 'socket'
+require 'tmpdir'
+require 'cgi'
-    def parse_string(s)
-      p = self.new
-      p.extract_info(s)
-      p
-    end
+require 'dpkg/s3/utils'
-    def extract_control(package)
-      if system("which dpkg > /dev/null 2>&1")
-        `dpkg -f #{package}`
-      else
-	# use ar to determine control file name (control.ext)
-        package_files = `ar t #{package}`
-        control_file = package_files.split("\n").select do |file|
-          file.start_with?("control.")
-        end.first
-        if control_file === "control.tar.gz"
-	  compression = "z"
-	else
-	  compression = "J"
+# Dpkg is the root module for all storage modules including S3
+module Dpkg
+  # S3 storage module resposible of handling packages on S3 including upload, delete
+  module S3
+    # Package class inlcudes methods for extracting the control file of a debian archive and extracting
+    # information required for publishing package
+    class Package
+      include Dpkg::S3::Utils
+      attr_accessor :name, :version, :epoch, :iteration, :maintainer, :vendor, :url, :category, :license, :architecture,
+                    :description, :dependencies, :sha1, :sha256, :md5, :size, :filename, :url_filename
+      # Any other attributes specific to this package.
+      # This is where you'd put rpm, deb, or other specific attributes.
+      attr_accessor :attributes
+      class << self
+        include Dpkg::S3::Utils
+        def parse_file(package)
+          p = new
+          p.extract_info(extract_control(package))
+          p.apply_file_info(package)
+          p.filename = package
+          p
         end
-        # ar fails to find the control.tar.gz tarball within the .deb
-        # on Mac OS. Try using ar to list the control file, if found,
-        # use ar to extract, otherwise attempt with tar which works on OS X.
-        extract_control_tarball_cmd = "ar p #{package} #{control_file}"
-        begin
-          safesystem("ar t #{package} #{control_file} &> /dev/null")
-        rescue SafeSystemError
-          warn "Failed to find control data in .deb with ar, trying tar."
-          extract_control_tarball_cmd = "tar #{compression}xf #{package} --to-stdout #{control_file}"
+        def parse_string(str)
+          p = new
+          p.extract_info(str)
+          p
         end
-        Dir.mktmpdir do |path|
-          safesystem("#{extract_control_tarball_cmd} | tar -#{compression}xf - -C #{path}")
-          File.read(File.join(path, "control"), :encoding => "UTF-8")
+        def extract_control(package)
+          if system('which dpkg > /dev/null 2>&1')
+            `dpkg -f #{package}`
+          else
+            # use ar to determine control file name (control.ext)
+            package_files = `ar t #{package}`
+            control_file = package_files.split("\n").select do |file|
+              file.start_with?('control.')
+            end.first
+            compression = if control_file == 'control.tar.gz'
+                            'z'
+                          else
+                            'J'
+                          end
+            # ar fails to find the control.tar.gz tarball within the .deb
+            # on Mac OS. Try using ar to list the control file, if found,
+            # use ar to extract, otherwise attempt with tar which works on OS X.
+            extract_control_tarball_cmd = "ar p #{package} #{control_file}"
+            begin
+              safesystem("ar t #{package} #{control_file} &> /dev/null")
+            rescue SafeSystemError
+              warn 'Failed to find control data in .deb with ar, trying tar.'
+              extract_control_tarball_cmd = "tar #{compression}xf #{package} --to-stdout #{control_file}"
+            end
+            Dir.mktmpdir do |path|
+              safesystem("#{extract_control_tarball_cmd} | tar -#{compression}xf - -C #{path}")
+              File.read(File.join(path, 'control'), encoding: 'UTF-8')
+            end
+          end
         end
       end
-    end
-  end
-  def initialize
-    @attributes = {}
-    # Reference
-    # http://www.debian.org/doc/manuals/maint-guide/first.en.html
-    # http://wiki.debian.org/DeveloperConfiguration
-    # https://github.com/jordansissel/fpm/issues/37
-    if ENV.include?("DEBEMAIL") and ENV.include?("DEBFULLNAME")
-      # Use DEBEMAIL and DEBFULLNAME as the default maintainer if available.
-      @maintainer = "#{ENV["DEBFULLNAME"]} <#{ENV["DEBEMAIL"]}>"
-    else
-      # TODO(sissel): Maybe support using 'git config' for a default as well?
-      # git config --get user.name, etc can be useful.
-      #
-      # Otherwise default to user@currenthost
-      @maintainer = "<#{ENV["USER"]}@#{Socket.gethostname}>"
-    end
-    @name = nil
-    @architecture = "native"
-    @description = "no description given"
-    @version = nil
-    @epoch = nil
-    @iteration = nil
-    @url = nil
-    @category = "default"
-    @license = "unknown"
-    @vendor = "none"
-    @sha1 = nil
-    @sha256 = nil
-    @md5 = nil
-    @size = nil
-    @filename = nil
-    @url_filename = nil
-    @dependencies = []
-  end
+      def initialize
+        @attributes = {}
+        # Reference
+        # http://www.debian.org/doc/manuals/maint-guide/first.en.html
+        # http://wiki.debian.org/DeveloperConfiguration
+        # https://github.com/jordansissel/fpm/issues/37
+        @maintainer = if ENV.include?('DEBEMAIL') && ENV.include?('DEBFULLNAME')
+                        # Use DEBEMAIL and DEBFULLNAME as the default maintainer if available.
+                        "#{ENV['DEBFULLNAME']} <#{ENV['DEBEMAIL']}>"
+                      else
+                        # TODO(sissel): Maybe support using 'git config' for a default as well?
+                        # git config --get user.name, etc can be useful.
+                        #
+                        # Otherwise default to user@currenthost
+                        "<#{ENV['USER']}@#{Socket.gethostname}>"
+                      end
+        @name = nil
+        @architecture = 'native'
+        @description = 'no description given'
+        @version = nil
+        @epoch = nil
+        @iteration = nil
+        @url = nil
+        @category = 'default'
+        @license = 'unknown'
+        @vendor = 'none'
+        @sha1 = nil
+        @sha256 = nil
+        @md5 = nil
+        @size = nil
+        @filename = nil
+        @url_filename = nil
+        @dependencies = []
+      end
-  def full_version
-    return nil if [epoch, version, iteration].all?(&:nil?)
-    [[epoch, version].compact.join(":"), iteration].compact.join("-")
-  end
+      def full_version
+        return nil if [epoch, version, iteration].all?(&:nil?)
-  def filename=(f)
-    @filename = f
-    @filename
-  end
+        [[epoch, version].compact.join(':'), iteration].compact.join('-')
+      end
-  def url_filename(codename)
-    @url_filename || "pool/#{codename}/#{self.name[0]}/#{self.name[0..1]}/#{File.basename(self.filename)}"
-  end
+      def url_filename(codename) # rubocop:disable Lint/DuplicateMethods
+        @url_filename || "pool/#{codename}/#{name[0]}/#{name[0..1]}/#{File.basename(filename)}"
+      end
-  def url_filename_encoded(codename)
-    @url_filename || "pool/#{codename}/#{self.name[0]}/#{self.name[0..1]}/#{s3_escape(File.basename(self.filename))}"
-  end
+      def url_filename_encoded(codename)
+        @url_filename || "pool/#{codename}/#{name[0]}/#{name[0..1]}/#{s3_escape(File.basename(filename))}"
+      end
-  def generate(codename = nil)
-    template("package.erb").result(binding)
-  end
+      def generate(codename = nil)
+        template('package.erb').result(binding)
+      end
-  # from fpm
-  def parse_depends(data)
-    return [] if data.nil? or data.empty?
-    # parse dependencies. Debian dependencies come in one of two forms:
-    # * name
-    # * name (op version)
-    # They are all on one line, separated by ", "
-    dep_re = /^([^ ]+)(?: \(([>=<]+) ([^)]+)\))?$/
-    return data.split(/, */).collect do |dep|
-      m = dep_re.match(dep)
-      if m
-        name, op, version = m.captures
-        # this is the proper form of dependency
-        if op && version && op != "" && version != ""
-          "#{name} (#{op} #{version})".strip
-        else
-          name.strip
+      # from fpm
+      def parse_depends(data)
+        return [] if data.nil? || data.empty?
+        # parse dependencies. Debian dependencies come in one of two forms:
+        # * name
+        # * name (op version)
+        # They are all on one line, separated by ", "
+        dep_re = /^([^ ]+)(?: \(([>=<]+) ([^)]+)\))?$/
+        data.split(/, */).collect do |dep|
+          m = dep_re.match(dep)
+          if m
+            name, op, version = m.captures
+            # this is the proper form of dependency
+            if op && version && op != '' && version != ''
+              "#{name} (#{op} #{version})".strip
+            else
+              name.strip
+            end
+          else
+            # Assume normal form dependency, "name op version".
+            dep
+          end
         end
-      else
-        # Assume normal form dependency, "name op version".
-        dep
-      end
-    end
-  end # def parse_depends
-  # from fpm
-  def fix_dependency(dep)
-    # Deb dependencies are: NAME (OP VERSION), like "zsh (> 3.0)"
-    # Convert anything that looks like 'NAME OP VERSION' to this format.
-    if dep =~ /[\(,\|]/
-      # Don't "fix" ones that could appear well formed already.
-    else
-      # Convert ones that appear to be 'name op version'
-      name, op, version = dep.split(/ +/)
-      if !version.nil?
-        # Convert strings 'foo >= bar' to 'foo (>= bar)'
-        dep = "#{name} (#{debianize_op(op)} #{version})"
       end
-    end
-    name_re = /^[^ \(]+/
-    name = dep[name_re]
-    if name =~ /[A-Z]/
-      dep = dep.gsub(name_re) { |n| n.downcase }
-    end
-    if dep.include?("_")
-      dep = dep.gsub("_", "-")
-    end
+      # from fpm
+      def fix_dependency(dep)
+        # Deb dependencies are: NAME (OP VERSION), like "zsh (> 3.0)"
+        # Convert anything that looks like 'NAME OP VERSION' to this format.
+        if dep =~ /[(,|]/
+          # Don't "fix" ones that could appear well formed already.
+        else
+          # Convert ones that appear to be 'name op version'
+          name, op, version = dep.split(/ +/)
+          unless version.nil?
+            # Convert strings 'foo >= bar' to 'foo (>= bar)'
+            dep = "#{name} (#{debianize_op(op)} #{version})"
+          end
+        end
-    # Convert gem ~> X.Y.Z to '>= X.Y.Z' and << X.Y+1.0
-    if dep =~ /\(~>/
-      name, version = dep.gsub(/[()~>]/, "").split(/ +/)[0..1]
-      nextversion = version.split(".").collect { |v| v.to_i }
-      l = nextversion.length
-      nextversion[l-2] += 1
-      nextversion[l-1] = 0
-      nextversion = nextversion.join(".")
-      return ["#{name} (>= #{version})", "#{name} (<< #{nextversion})"]
-    elsif (m = dep.match(/(\S+)\s+\(!= (.+)\)/))
-      # Append this to conflicts
-      self.conflicts += [dep.gsub(/!=/,"=")]
-      return []
-    elsif (m = dep.match(/(\S+)\s+\(= (.+)\)/)) and
-        self.attributes[:deb_ignore_iteration_in_dependencies?]
-      # Convert 'foo (= x)' to 'foo (>= x)' and 'foo (<< x+1)'
-      # but only when flag --ignore-iteration-in-dependencies is passed.
-      name, version = m[1..2]
-      nextversion = version.split('.').collect { |v| v.to_i }
-      nextversion[-1] += 1
-      nextversion = nextversion.join(".")
-      return ["#{name} (>= #{version})", "#{name} (<< #{nextversion})"]
-    else
-      # otherwise the dep is probably fine
-      return dep.rstrip
-    end
-  end # def fix_dependency
+        name_re = /^[^ (]+/
+        name = dep[name_re]
+        dep = dep.gsub(name_re, &:downcase) if name =~ /[A-Z]/
+        dep = dep.gsub('_', '-') if dep.include?('_')
+        # Convert gem ~> X.Y.Z to '>= X.Y.Z' and << X.Y+1.0
+        if dep =~ /\(~>/
+          name, version = dep.gsub(/[()~>]/, '').split(/ +/)[0..1]
+          nextversion = version.split('.').collect(&:to_i)
+          l = nextversion.length
+          nextversion[l - 2] += 1
+          nextversion[l - 1] = 0
+          nextversion = nextversion.join('.')
+          ["#{name} (>= #{version})", "#{name} (<< #{nextversion})"]
+        elsif (m = dep.match(/(\S+)\s+\(!= (.+)\)/))
+          # Append this to conflicts
+          self.conflicts += [dep.gsub(/!=/, '=')]
+          []
+        elsif (m = dep.match(/(\S+)\s+\(= (.+)\)/)) &&
+              attributes[:deb_ignore_iteration_in_dependencies?]
+          # Convert 'foo (= x)' to 'foo (>= x)' and 'foo (<< x+1)'
+          # but only when flag --ignore-iteration-in-dependencies is passed.
+          name, version = m[1..2]
+          nextversion = version.split('.').collect(&:to_i)
+          nextversion[-1] += 1
+          nextversion = nextversion.join('.')
+          ["#{name} (>= #{version})", "#{name} (<< #{nextversion})"]
+        else
+          # otherwise the dep is probably fine
+          dep.rstrip
+        end
+      end
-  # from fpm
-  def extract_info(control)
-    fields = parse_control(control)
+      # from fpm
+      def extract_info(control)
+        fields = parse_control(control)
+        # Parse 'epoch:version-iteration' in the version string
+        full_version = fields.delete('Version')
+        raise "Unsupported version string '#{full_version}'" if full_version !~ /^(?:([0-9]+):)?(.+?)(?:-(.*))?$/
+        self.epoch, self.version, self.iteration = $LAST_MATCH_INFO.captures
+        self.architecture = fields.delete('Architecture')
+        self.category = fields.delete('Section')
+        self.license = fields.delete('License') || license
+        self.maintainer = fields.delete('Maintainer')
+        self.name = fields.delete('Package')
+        self.url = fields.delete('Homepage')
+        self.vendor = fields.delete('Vendor') || vendor
+        attributes[:deb_priority] = fields.delete('Priority')
+        attributes[:deb_origin] = fields.delete('Origin')
+        attributes[:deb_installed_size] = fields.delete('Installed-Size')
+        # Packages manifest fields
+        filename = fields.delete('Filename')
+        self.url_filename = filename
+        self.sha1 = fields.delete('SHA1')
+        self.sha256 = fields.delete('SHA256')
+        self.md5 = fields.delete('MD5sum')
+        self.size = fields.delete('Size')
+        self.description = fields.delete('Description')
+        # self.config_files = config_files
+        self.dependencies += Array(parse_depends(fields.delete('Depends')))
+        attributes[:deb_recommends] = fields.delete('Recommends')
+        attributes[:deb_suggests]   = fields.delete('Suggests')
+        attributes[:deb_enhances]   = fields.delete('Enhances')
+        attributes[:deb_pre_depends] = fields.delete('Pre-Depends')
+        attributes[:deb_breaks]    = fields.delete('Breaks')
+        attributes[:deb_conflicts] = fields.delete('Conflicts')
+        attributes[:deb_provides]  = fields.delete('Provides')
+        attributes[:deb_replaces]  = fields.delete('Replaces')
+        attributes[:deb_field] = fields.map do |k, v|
+          [k.sub(/\AX[BCS]{0,3}-/, ''), v]
+        end.to_h
+      end
-    # Parse 'epoch:version-iteration' in the version string
-    full_version = fields.delete('Version')
-    if full_version !~ /^(?:([0-9]+):)?(.+?)(?:-(.*))?$/
-      raise "Unsupported version string '#{full_version}'"
-    end
-    self.epoch, self.version, self.iteration = $~.captures
-    self.architecture = fields.delete('Architecture')
-    self.category = fields.delete('Section')
-    self.license = fields.delete('License') || self.license
-    self.maintainer = fields.delete('Maintainer')
-    self.name = fields.delete('Package')
-    self.url = fields.delete('Homepage')
-    self.vendor = fields.delete('Vendor') || self.vendor
-    self.attributes[:deb_priority] = fields.delete('Priority')
-    self.attributes[:deb_origin] = fields.delete('Origin')
-    self.attributes[:deb_installed_size] = fields.delete('Installed-Size')
-    # Packages manifest fields
-    filename = fields.delete('Filename')
-    self.url_filename = filename && CGI.unescape(filename)
-    self.sha1 = fields.delete('SHA1')
-    self.sha256 = fields.delete('SHA256')
-    self.md5 = fields.delete('MD5sum')
-    self.size = fields.delete('Size')
-    self.description = fields.delete('Description')
-    #self.config_files = config_files
-    self.dependencies += Array(parse_depends(fields.delete('Depends')))
-    self.attributes[:deb_recommends] = fields.delete('Recommends')
-    self.attributes[:deb_suggests]   = fields.delete('Suggests')
-    self.attributes[:deb_enhances]   = fields.delete('Enhances')
-    self.attributes[:deb_pre_depends] = fields.delete('Pre-Depends')
-    self.attributes[:deb_breaks]    = fields.delete('Breaks')
-    self.attributes[:deb_conflicts] = fields.delete('Conflicts')
-    self.attributes[:deb_provides]  = fields.delete('Provides')
-    self.attributes[:deb_replaces]  = fields.delete('Replaces')
-    self.attributes[:deb_field] = Hash[fields.map { |k, v|
-      [k.sub(/\AX[BCS]{0,3}-/, ''), v]
-    }]
-  end # def extract_info
-  def apply_file_info(file)
-    self.size = File.size(file)
-    self.sha1 = Digest::SHA1.file(file).hexdigest
-    self.sha256 = Digest::SHA2.file(file).hexdigest
-    self.md5 = Digest::MD5.file(file).hexdigest
-  end
+      def apply_file_info(file)
+        self.size = File.size(file)
+        self.sha1 = Digest::SHA1.file(file).hexdigest
+        self.sha256 = Digest::SHA2.file(file).hexdigest
+        self.md5 = Digest::MD5.file(file).hexdigest
+      end
-  def parse_control(control)
-    field = nil
-    value = ""
-    {}.tap do |fields|
-      control.each_line do |line|
-        if line =~ /^(\s+)(\S.*)$/
-          indent, rest = $1, $2
-          # Continuation
-          if indent.size == 1 && rest == "."
-            value << "\n"
-            rest = ""
-          elsif value.size > 0
-            value << "\n"
+      def parse_control(control)
+        field = nil
+        value = ''
+        {}.tap do |fields|
+          control.each_line do |line|
+            case line
+            when /^(\s+)(\S.*)$/
+              indent = Regexp.last_match(1)
+              rest = Regexp.last_match(2)
+              # Continuation
+              if indent.size == 1 && rest == '.'
+                value << "\n"
+                rest = ''
+              elsif value.size.positive?
+                value << "\n"
+              end
+              value << rest
+            when /^([-\w]+):(.*)$/
+              fields[field] = value if field
+              field = Regexp.last_match(1)
+              value = Regexp.last_match(2).strip
+            end
           end
-          value << rest
-        elsif line =~ /^([-\w]+):(.*)$/
           fields[field] = value if field
-          field, value = $1, $2.strip
         end
       end
-      fields[field] = value if field
     end
   end
 end