dpkg-s3 0.3.1 → 0.4.0

data/lib/dpkg/s3/lock.rb

@@ -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

@@ -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

@@ -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