dpkg-s3 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b810c961735475ddaa1c7c796f14c92f2625995082bd2800a6bd25ae36e9b112
-  data.tar.gz: a20b8c3ca88bce3c73e46c5923da96a0baf75252b872cb350dc0c3573d624a7f
+  metadata.gz: 9387fafa37c357aa1ceafee3b3e1cccee3f12ff7d6d503bf5e07ac5d141b7f11
+  data.tar.gz: c80b9551e201f18fda1c0b466f233cb6912bd4ebadc4e829fd706a167cf26f23
 SHA512:
-  metadata.gz: 846afd19f584a6476ce9f6a8fa6ec35019cfad11d761ebc0eed2e229cc1cdf70bd9b47ec3fae0961965e0fb43f22eef3d2cbcd3899a239d25af18c9887c07122
-  data.tar.gz: 57e25b91f94625e813d6b473d7173130ed34834344bcb7f661215e245ed4392078a7a220debdd0d406ec4f1ebaf7750bc855cb3a9a249f9beec20525bccf0a1b
+  metadata.gz: df6087bebb91c0ae7237264df676cb86486e6a1d57d7c041659a5bdde57d78ae7bb2018bab9b2a8ec71f1f00ca4bc28aa96c52ae472563967b3b77593ff83539
+  data.tar.gz: 1165f3a4b48fb249a2d4e766eea5b5445e8ad00344c45fef98d322ccb705f1d40fb13782399e0e128615dbffe99aef353cd472e0a2f58e56143e141505e85221

data/README.md

@@ -1,7 +1,7 @@
 # dpkg-s3
 
 <p align="left">
-  <a href="https://github.com/gamunu/dpkg-s3/actions"><img alt="test status" src="https://github.com/gamunu/dpkg-s3/workflows/Ruby/badge.svg"></a>
+  <a href="https://github.com/gamunu/dpkg-s3/actions"><img alt="test status" src="https://github.com/gamunu/dpkg-s3/workflows/ruby/badge.svg"></a>
 </p>
 
 `dpkg-s3` is a simple utility to make creating and managing APT repositories on

data/bin/dpkg-s3

@@ -1,13 +1,28 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'pathname'
-$:.unshift File.join(Pathname.new(__FILE__).realpath,'../../lib')
+$LOAD_PATH.unshift File.join(Pathname.new(__FILE__).realpath, '../../lib')
 
 require 'rubygems'
 require 'dpkg/s3/cli'
 
+# String monkey patch class to add red and gray colors
+class String
+  def red
+    "\e[31m#{self}\e[0m"
+  end
+
+  def gray
+    "\e[37m#{self}\e[0m"
+  end
+end
+
 begin
   Dpkg::S3::CLI.start
-rescue
-  $stderr.puts "\n\tError during processing: #{$!.message}\n\n"
-end
+rescue StandardError => e
+  warn "\n\tError during processing: #{e.message}\n\n".red
+  warn "\n\tDebug: #{e.backtrace}\n\n".gray
+rescue Interrupt
+  warn "\nOperation canceled. Please verify repository for broken packages".red
+end

data/lib/dpkg/s3.rb

@@ -1,6 +1,7 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
 module Dpkg
   module S3
-    VERSION = "0.3.1"
+    VERSION = '0.4.0'
   end
 end

data/lib/dpkg/s3/cli.rb

@@ -1,641 +1,639 @@
-# -*- encoding : utf-8 -*-
-require "aws-sdk-s3"
-require "thor"
-require "dpkg/s3"
-require "dpkg/s3/utils"
-require "dpkg/s3/manifest"
-require "dpkg/s3/package"
-require "dpkg/s3/release"
-require "dpkg/s3/lock"
-
-class Dpkg::S3::CLI < Thor
-  class_option :bucket,
-  :type     => :string,
-  :aliases  => "-b",
-  :desc     => "The name of the S3 bucket to upload to."
-
-  class_option :prefix,
-  :type     => :string,
-  :desc     => "The path prefix to use when storing on S3."
-
-  class_option :origin,
-  :type     => :string,
-  :aliases  => "-o",
-  :desc     => "The origin to use in the repository Release file."
-
-  class_option :suite,
-  :type     => :string,
-  :desc     => "The suite to use in the repository Release file."
-
-  class_option :codename,
-  :default  => "stable",
-  :type     => :string,
-  :aliases  => "-c",
-  :desc     => "The codename of the APT repository."
-
-  class_option :component,
-  :default  => "main",
-  :type     => :string,
-  :aliases  => "-m",
-  :desc     => "The component of the APT repository."
-
-  class_option :section,
-  :type     => :string,
-  :aliases  => "-s",
-  :hide     => true
-
-  class_option :access_key_id,
-  :type     => :string,
-  :desc     => "The access key for connecting to S3."
-
-  class_option :secret_access_key,
-  :type     => :string,
-  :desc     => "The secret key for connecting to S3."
-
-  class_option :session_token,
-  :type     => :string,
-  :desc     => "The (optional) session token for connecting to S3."
-
-  class_option :endpoint,
-  :type     => :string,
-  :desc     => "The URL endpoint to the S3 API."
-
-  class_option :s3_region,
-  :type     => :string,
-  :desc     => "The region for connecting to S3.",
-  :default  => ENV["AWS_DEFAULT_REGION"] || "us-east-1"
-
-  class_option :force_path_style,
-  :default  => false,
-  :type     => :boolean,
-  :desc     => "Use S3 path style instead of subdomains."
-
-  class_option :proxy_uri,
-  :type     => :string,
-  :desc     => "The URI of the proxy to send service requests through."
-
-  class_option :visibility,
-  :default  => "public",
-  :type     => :string,
-  :aliases  => "-v",
-  :desc     => "The access policy for the uploaded files. " +
-    "Can be public, private, or authenticated."
-
-  class_option :sign,
-  :type     => :string,
-  :desc     => "GPG Sign the Release file when uploading a package, " +
-    "or when verifying it after removing a package. " +
-    "Use --sign with your GPG key ID to use a specific key (--sign=6643C242C18FE05B)."
-
-  class_option :gpg_options,
-  :default => "",
-  :type    => :string,
-  :desc    => "Additional command line options to pass to GPG when signing."
-
-  class_option :encryption,
-  :default  => false,
-  :type     => :boolean,
-  :aliases  => "-e",
-  :desc     => "Use S3 server side encryption."
-
-  class_option :quiet,
-  :type => :boolean,
-  :aliases => "-q",
-  :desc => "Doesn't output information, just returns status appropriately."
-
-  class_option :cache_control,
-  :type     => :string,
-  :aliases  => "-C",
-  :desc     => "Add cache-control headers to S3 objects."
-
-  desc "upload FILES",
-  "Uploads the given files to a S3 bucket as an APT repository."
-
-  option :arch,
-  :type     => :string,
-  :aliases  => "-a",
-  :desc     => "The architecture of the package in the APT repository."
-
-  option :preserve_versions,
-  :default  => false,
-  :type     => :boolean,
-  :aliases  => "-p",
-  :desc     => "Whether to preserve other versions of a package " +
-    "in the repository when uploading one."
-
-  option :lock,
-  :default  => false,
-  :type     => :boolean,
-  :aliases  => "-l",
-  :desc     => "Whether to check for an existing lock on the repository " +
-    "to prevent simultaneous updates "
-
-  option :fail_if_exists,
-  :default  => false,
-  :type     => :boolean,
-  :desc     => "Whether to overwrite any existing package that has the same " +
-    "filename in the pool or the same name and version in the manifest but " +
-	"different contents."
-
-  option :skip_package_upload,
-  :default  => false,
-  :type     => :boolean,
-  :desc     => "Whether to skip all package uploads." +
-    "This is useful when hosting .deb files outside of the bucket."
-
-  def self.exit_on_failure?
-    true
-  end
-
-  def upload(*files)
-    if files.nil? || files.empty?
-      error("You must specify at least one file to upload")
-    end
+# frozen_string_literal: true
+
+require 'aws-sdk-s3'
+require 'thor'
+require 'dpkg/s3'
+require 'dpkg/s3/utils'
+require 'dpkg/s3/manifest'
+require 'dpkg/s3/package'
+require 'dpkg/s3/release'
+require 'dpkg/s3/lock'
+
+module Dpkg
+  module S3
+    # CLI interface for dpkg-s3
+    class CLI < Thor
+      class_option :bucket,
+                   type: :string,
+                   aliases: '-b',
+                   desc: 'The name of the S3 bucket to upload to.'
+
+      class_option :prefix,
+                   type: :string,
+                   desc: 'The path prefix to use when storing on S3.'
+
+      class_option :origin,
+                   type: :string,
+                   aliases: '-o',
+                   desc: 'The origin to use in the repository Release file.'
+
+      class_option :suite,
+                   type: :string,
+                   desc: 'The suite to use in the repository Release file.'
+
+      class_option :codename,
+                   default: 'stable',
+                   type: :string,
+                   aliases: '-c',
+                   desc: 'The codename of the APT repository.'
+
+      class_option :component,
+                   default: 'main',
+                   type: :string,
+                   aliases: '-m',
+                   desc: 'The component of the APT repository.'
+
+      class_option :section,
+                   type: :string,
+                   aliases: '-s',
+                   hide: true
+
+      class_option :access_key_id,
+                   type: :string,
+                   desc: 'The access key for connecting to S3.'
+
+      class_option :secret_access_key,
+                   type: :string,
+                   desc: 'The secret key for connecting to S3.'
+
+      class_option :session_token,
+                   type: :string,
+                   desc: 'The (optional) session token for connecting to S3.'
+
+      class_option :endpoint,
+                   type: :string,
+                   desc: 'The URL endpoint to the S3 API.'
+
+      class_option :s3_region,
+                   type: :string,
+                   desc: 'The region for connecting to S3.',
+                   default: ENV['AWS_DEFAULT_REGION'] || 'us-east-1'
+
+      class_option :force_path_style,
+                   default: false,
+                   type: :boolean,
+                   desc: 'Use S3 path style instead of subdomains.'
+
+      class_option :proxy_uri,
+                   type: :string,
+                   desc: 'The URI of the proxy to send service requests through.'
+
+      class_option :visibility,
+                   default: 'public',
+                   type: :string,
+                   aliases: '-v',
+                   desc: 'The access policy for the uploaded files. ' \
+                                'Can be public, private, or authenticated.'
+
+      class_option :sign,
+                   type: :string,
+                   desc: 'GPG Sign the Release file when uploading a package, ' \
+                                'or when verifying it after removing a package. ' \
+                                'Use --sign with your GPG key ID to use a specific key (--sign=6643C242C18FE05B).'
+
+      class_option :gpg_options,
+                   default: '',
+                   type: :string,
+                   desc: 'Additional command line options to pass to GPG when signing.'
+
+      class_option :encryption,
+                   default: false,
+                   type: :boolean,
+                   aliases: '-e',
+                   desc: 'Use S3 server side encryption.'
+
+      class_option :quiet,
+                   type: :boolean,
+                   aliases: '-q',
+                   desc: "Doesn't output information, just returns status appropriately."
+
+      class_option :cache_control,
+                   type: :string,
+                   aliases: '-C',
+                   desc: 'Add cache-control headers to S3 objects.'
+
+      desc 'upload FILES',
+           'Uploads the given files to a S3 bucket as an APT repository.'
+
+      option :arch,
+             type: :string,
+             aliases: '-a',
+             desc: 'The architecture of the package in the APT repository.'
+
+      option :preserve_versions,
+             default: false,
+             type: :boolean,
+             aliases: '-p',
+             desc: 'Whether to preserve other versions of a package ' \
+                          'in the repository when uploading one.'
+
+      option :lock,
+             default: false,
+             type: :boolean,
+             aliases: '-l',
+             desc: 'Whether to check for an existing lock on the repository ' \
+                          'to prevent simultaneous updates '
+
+      option :fail_if_exists,
+             default: false,
+             type: :boolean,
+             desc: 'Whether to overwrite any existing package that has the same ' \
+                          'filename in the pool or the same name and version in the manifest but ' \
+                           'different contents.'
+
+      option :skip_package_upload,
+             default: false,
+             type: :boolean,
+             desc: 'Whether to skip all package uploads.' \
+                          'This is useful when hosting .deb files outside of the bucket.'
+
+      def self.exit_on_failure?
+        true
+      end
 
-    # make sure all the files exists
-    if missing_file = files.find { |pattern| Dir.glob(pattern).empty? }
-      error("File '#{missing_file}' doesn't exist")
-    end
+      def upload(*files)
+        error('You must specify at least one file to upload') if files.nil? || files.empty?
 
-    # configure AWS::S3
-    configure_s3_client
-
-    begin
-      if options[:lock]
-        log("Checking for existing lock file")
-        if Dpkg::S3::Lock.locked?(options[:codename], component, options[:arch], options[:cache_control])
-          lock = Dpkg::S3::Lock.current(options[:codename], component, options[:arch], options[:cache_control])
-          log("Repository is locked by another user: #{lock.user} at host #{lock.host}")
-          log("Attempting to obtain a lock")
-          Dpkg::S3::Lock.wait_for_lock(options[:codename], component, options[:arch], options[:cache_control])
+        # make sure all the files exists
+        if (missing_file = files.find { |pattern| Dir.glob(pattern).empty? })
+          error("File '#{missing_file}' doesn't exist")
         end
-        log("Locking repository for updates")
-        Dpkg::S3::Lock.lock(options[:codename], component, options[:arch], options[:cache_control])
-        @lock_acquired = true
-      end
 
-      # retrieve the existing manifests
-      log("Retrieving existing manifests")
-      release  = Dpkg::S3::Release.retrieve(options[:codename], options[:origin], options[:suite], options[:cache_control])
-      manifests = {}
-      release.architectures.each do |arch|
-        manifests[arch] = Dpkg::S3::Manifest.retrieve(options[:codename], component, arch, options[:cache_control], options[:fail_if_exists], options[:skip_package_upload])
-      end
+        # configure AWS::S3
+        configure_s3_client
 
-      packages_arch_all = []
+        begin
+          if options[:lock]
+            log('Checking for existing lock file')
+            if Dpkg::S3::Lock.locked?(options[:codename], component, options[:arch], options[:cache_control])
+              lock = Dpkg::S3::Lock.current(options[:codename], component, options[:arch], options[:cache_control])
+              log("Repository is locked by another user: #{lock.user} at host #{lock.host}")
+              log('Attempting to obtain a lock')
+              Dpkg::S3::Lock.wait_for_lock(options[:codename], component, options[:arch], options[:cache_control])
+            end
+            log('Locking repository for updates')
+            Dpkg::S3::Lock.lock(options[:codename], component, options[:arch], options[:cache_control])
+            @lock_acquired = true
+          end
 
-      # examine all the files
-      files.collect { |f| Dir.glob(f) }.flatten.each do |file|
-        log("Examining package file #{File.basename(file)}")
-        pkg = Dpkg::S3::Package.parse_file(file)
+          # retrieve the existing manifests
+          log('Retrieving existing manifests')
+          release = Dpkg::S3::Release.retrieve(options[:codename], options[:origin], options[:suite],
+                                               options[:cache_control])
+          manifests = {}
+          release.architectures.each do |arch|
+            manifests[arch] =
+              Dpkg::S3::Manifest.retrieve(options[:codename], component, arch, options[:cache_control],
+                                          options[:fail_if_exists], skip_upload: options[:skip_package_upload])
+          end
 
-        # copy over some options if they weren't given
-        arch = options[:arch] || pkg.architecture
+          packages_arch_all = []
 
-        # If they've specified an arch type that doesn't match the package let them know
-        if options.key?("arch") && options[:arch] != pkg.architecture
-          warn("You specified architecture #{options[:arch]} but package #{pkg.name} has architecture type of #{pkg.architecture}")
-        end
+          # examine all the files
+          files.collect { |f| Dir.glob(f) }.flatten.each do |file|
+            log("Examining package file #{File.basename(file)}")
+            pkg = Dpkg::S3::Package.parse_file(file)
 
-        # validate we have them
-        error("No architcture given and unable to determine one for #{file}. " +
-              "Please specify one with --arch [i386|amd64|armhf].") unless arch
-
-        # If the arch is all and the list of existing manifests is none, then
-        # throw an error. This is mainly the case when initializing a brand new
-        # repository. With "all", we won't know which architectures they're using.
-        if arch == "all" && manifests.count == 0
-          manifests['amd64'] = Dpkg::S3::Manifest.retrieve(options[:codename], component,'amd64', options[:cache_control], options[:fail_if_exists], options[:skip_package_upload])
-          manifests['i386'] = Dpkg::S3::Manifest.retrieve(options[:codename], component,'i386', options[:cache_control], options[:fail_if_exists], options[:skip_package_upload])
-          manifests['armhf'] = Dpkg::S3::Manifest.retrieve(options[:codename], component,'armhf', options[:cache_control], options[:fail_if_exists], options[:skip_package_upload])
-
-         # error("Package #{File.basename(file)} had architecture \"all\", " +
-         #       "however noexisting package lists exist. This can often happen " +
-         #       "if the first package you are add to a new repository is an " +
-         #       "\"all\" architecture file. Please use --arch [i386|amd64|armhf] or " +
-         #       "another platform type to upload the file.")
-        end
+            # copy over some options if they weren't given
+            arch = options[:arch] || pkg.architecture
 
-        # retrieve the manifest for the arch if we don't have it already
-        manifests[arch] ||= Dpkg::S3::Manifest.retrieve(options[:codename], component, arch, options[:cache_control], options[:fail_if_exists], options[:skip_package_upload])
+            # If they've specified an arch type that doesn't match the package let them know
+            if options.key?('arch') && options[:arch] != pkg.architecture
+              warn("You specified architecture #{options[:arch]} but package #{pkg.name} has architecture
+               type of #{pkg.architecture}")
+            end
 
-        # add package in manifests
-        begin
-          manifests[arch].add(pkg, options[:preserve_versions])
-        rescue Dpkg::S3::Utils::AlreadyExistsError => e
-          error("Preparing manifest failed because: #{e}")
-        end
+            # validate we have them
+            unless arch
+              error("No architcture given and unable to determine one for #{file}. " \
+                    'Please specify one with --arch [i386|amd64|armhf].')
+            end
 
-        # If arch is all, we must add this package in all arch available
-        if arch == 'all'
-          packages_arch_all << pkg
-        end
-      end
+            # If the arch is all and the list of existing manifests is none, then
+            # throw an error. This is mainly the case when initializing a brand new
+            # repository. With "all", we won't know which architectures they're using.
+            if arch == 'all' && manifests.count.zero?
+              manifests['amd64'] =
+                Dpkg::S3::Manifest.retrieve(options[:codename], component, 'amd64', options[:cache_control],
+                                            options[:fail_if_exists], skip_upload: options[:skip_package_upload])
+              manifests['i386'] =
+                Dpkg::S3::Manifest.retrieve(options[:codename], component, 'i386', options[:cache_control],
+                                            options[:fail_if_exists], skip_upload: options[:skip_package_upload])
+              manifests['armhf'] =
+                Dpkg::S3::Manifest.retrieve(options[:codename], component, 'armhf', options[:cache_control],
+                                            options[:fail_if_exists], skip_upload: options[:skip_package_upload])
+
+              # error("Package #{File.basename(file)} had architecture \"all\", " +
+              #       "however noexisting package lists exist. This can often happen " +
+              #       "if the first package you are add to a new repository is an " +
+              #       "\"all\" architecture file. Please use --arch [i386|amd64|armhf] or " +
+              #       "another platform type to upload the file.")
+            end
 
-      manifests.each do |arch, manifest|
-        next if arch == 'all'
-        packages_arch_all.each do |pkg|
-          begin
-            manifest.add(pkg, options[:preserve_versions], false)
-          rescue Dpkg::S3::Utils::AlreadyExistsError => e
-            error("Preparing manifest failed because: #{e}")
+            # retrieve the manifest for the arch if we don't have it already
+            manifests[arch] ||= Dpkg::S3::Manifest.retrieve(options[:codename], component, arch,
+                                                            options[:cache_control], options[:fail_if_exists],
+                                                            skip_upload: options[:skip_package_upload])
+
+            # add package in manifests
+            begin
+              manifests[arch].add(pkg, options[:preserve_versions])
+            rescue Dpkg::S3::Utils::AlreadyExistsError => e
+              error("Preparing manifest failed because: #{e}")
+            end
+
+            # If arch is all, we must add this package in all arch available
+            packages_arch_all << pkg if arch == 'all'
           end
-        end
-      end
 
-      # upload the manifest
-      log("Uploading packages and new manifests to S3")
-      manifests.each_value do |manifest|
-        begin
-          manifest.write_to_s3 { |f| sublog("Transferring #{f}") }
-        rescue Dpkg::S3::Utils::AlreadyExistsError => e
-          error("Uploading manifest failed because: #{e}")
+          manifests.each do |arch, manifest|
+            next if arch == 'all'
+
+            packages_arch_all.each do |pkg|
+              begin
+                manifest.add(pkg, options[:preserve_versions], needs_uploading: false)
+              rescue Dpkg::S3::Utils::AlreadyExistsError => e
+                error("Preparing manifest failed because: #{e}")
+              end
+            end
+          end
+
+          # upload the manifest
+          log('Uploading packages and new manifests to S3')
+          manifests.each_value do |manifest|
+            begin
+              manifest.write_to_s3 { |f| sublog("Transferring #{f}") }
+            rescue Dpkg::S3::Utils::AlreadyExistsError => e
+              error("Uploading manifest failed because: #{e}")
+            end
+            release.update_manifest(manifest)
+          end
+          release.write_to_s3 { |f| sublog("Transferring #{f}") }
+
+          log('Update complete.')
+        ensure
+          if options[:lock] && @lock_acquired
+            Dpkg::S3::Lock.unlock(options[:codename], component, options[:arch], options[:cache_control])
+            log('Lock released.')
+          end
         end
-        release.update_manifest(manifest)
       end
-      release.write_to_s3 { |f| sublog("Transferring #{f}") }
 
-      log("Update complete.")
-    ensure
-      if options[:lock] && @lock_acquired
-        Dpkg::S3::Lock.unlock(options[:codename], component, options[:arch], options[:cache_control])
-        log("Lock released.")
-      end
-    end
-  end
+      desc 'list', 'Lists packages in given codename, component, and optionally architecture'
+
+      option :long,
+             type: :boolean,
+             aliases: '-l',
+             desc: 'Shows all package information in original format.',
+             default: false
+
+      option :arch,
+             type: :string,
+             aliases: '-a',
+             desc: 'The architecture of the package in the APT repository.'
+
+      def list
+        configure_s3_client
+
+        release = Dpkg::S3::Release.retrieve(options[:codename])
+        archs = release.architectures
+        archs &= [options[:arch]] if options[:arch] && options[:arch] != 'all'
+        widths = [0, 0]
+        rows = archs.map do |arch|
+          manifest = Dpkg::S3::Manifest.retrieve(options[:codename], component,
+                                                 arch, options[:cache_control],
+                                                 false, skip_upload: false)
+          manifest.packages.map do |package|
+            if options[:long]
+              package.generate(options[:codename])
+            else
+              [package.name, package.full_version, package.architecture].tap do |row|
+                row.each_with_index do |col, i|
+                  widths[i] = [widths[i], col.size].max if widths[i]
+                end
+              end
+            end
+          end
+        end.flatten(1)
 
-  desc "list", "Lists packages in given codename, component, and optionally architecture"
-
-  option :long,
-  :type     => :boolean,
-  :aliases  => '-l',
-  :desc     => "Shows all package information in original format.",
-  :default  => false
-
-  option :arch,
-  :type     => :string,
-  :aliases  => "-a",
-  :desc     => "The architecture of the package in the APT repository."
-
-  def list
-    configure_s3_client
-
-    release = Dpkg::S3::Release.retrieve(options[:codename])
-    archs = release.architectures
-    archs &= [options[:arch]] if options[:arch] && options[:arch] != "all"
-    widths = [0, 0]
-    rows = archs.map { |arch|
-      manifest = Dpkg::S3::Manifest.retrieve(options[:codename], component,
-                                            arch, options[:cache_control],
-                                            false, false)
-      manifest.packages.map do |package|
         if options[:long]
-          package.generate(options[:codename])
+          $stdout.puts rows.join("\n")
         else
-          [package.name, package.full_version, package.architecture].tap do |row|
-            row.each_with_index do |col, i|
-              widths[i] = [widths[i], col.size].max if widths[i]
-            end
+          rows.each do |row|
+            $stdout.puts format("% -#{widths[0]}<package>s  % -#{widths[1]}<version>s  %<arch>s",
+                                package: row[0], version: row[1], arch: row[2])
           end
         end
       end
-    }.flatten(1)
 
-    if options[:long]
-      $stdout.puts rows.join("\n")
-    else
-      rows.each do |row|
-        $stdout.puts "% -#{widths[0]}s  % -#{widths[1]}s  %s" % row
-      end
-    end
-  end
-
-  desc "show PACKAGE VERSION ARCH", "Shows information about a package."
-
-  def show(package_name, version, arch)
-    if version.nil?
-      error "You must specify the name of the package to show."
-    end
-    if version.nil?
-      error "You must specify the version of the package to show."
-    end
-    if arch.nil?
-      error "You must specify the architecture of the package to show."
-    end
+      desc 'show PACKAGE VERSION ARCH', 'Shows information about a package.'
 
-    configure_s3_client
-
-    # retrieve the existing manifests
-    manifest = Dpkg::S3::Manifest.retrieve(options[:codename], component, arch,
-                                          options[:cache_control], false, false)
-    package = manifest.packages.detect { |p|
-      p.name == package_name && p.full_version == version
-    }
-    if package.nil?
-      error "No such package found."
-    end
+      def show(package_name, version, arch)
+        error 'You must specify the name of the package to show.' if version.nil?
+        error 'You must specify the version of the package to show.' if version.nil?
+        error 'You must specify the architecture of the package to show.' if arch.nil?
 
-    puts package.generate(options[:codename])
-  end
-
-  desc "copy PACKAGE TO_CODENAME TO_COMPONENT ",
-    "Copy the package named PACKAGE to given codename and component. If --versions is not specified, copy all versions of PACKAGE. Otherwise, only the specified versions will be copied. Source codename and component is given by --codename and --component options."
-
-  option :cache_control,
-  :type     => :string,
-  :aliases  => "-C",
-  :desc     => "Add cache-control headers to S3 objects."
-
-  option :arch,
-    :type     => :string,
-    :aliases  => "-a",
-    :desc     => "The architecture of the package in the APT repository."
-
-  option :versions,
-    :default  => nil,
-    :type     => :array,
-    :desc     => "The space-delimited versions of PACKAGE to delete. If not " +
-    "specified, ALL VERSIONS will be deleted. Fair warning. " +
-    "E.g. --versions \"0.1 0.2 0.3\""
-
-  option :preserve_versions,
-    :default  => false,
-    :type     => :boolean,
-    :aliases  => "-p",
-    :desc     => "Whether to preserve other versions of a package " +
-    "in the repository when uploading one."
-
-  option :fail_if_exists,
-  :default  => true,
-  :type     => :boolean,
-  :desc     => "Whether to overwrite any existing package that has the same " +
-    "filename in the pool or the same name and version in the manifest."
-
-  def copy(package_name, to_codename, to_component)
-    if package_name.nil?
-      error "You must specify a package name."
-    end
-    if to_codename.nil?
-      error "You must specify a codename to copy to."
-    end
-    if to_component.nil?
-      error "You must specify a component to copy to."
-    end
-
-    arch = options[:arch]
-    if arch.nil?
-      error "You must specify the architecture of the package to copy."
-    end
+        configure_s3_client
 
-    versions = options[:versions]
-    if versions.nil?
-      warn "===> WARNING: Copying all versions of #{package_name}"
-    else
-      log "Versions to copy: #{versions.join(', ')}"
-    end
-
-    configure_s3_client
-
-    # retrieve the existing manifests
-    log "Retrieving existing manifests"
-    from_manifest = Dpkg::S3::Manifest.retrieve(options[:codename],
-                                               component, arch,
-                                               options[:cache_control],
-                                               false, options[:skip_package_upload])
-    to_release = Dpkg::S3::Release.retrieve(to_codename)
-    to_manifest = Dpkg::S3::Manifest.retrieve(to_codename, to_component, arch,
-                                             options[:cache_control],
-                                             options[:fail_if_exists],
-                                             options[:skip_package_upload])
-    packages = from_manifest.packages.select { |p|
-      p.name == package_name &&
-        (versions.nil? || versions.include?(p.full_version))
-    }
-    if packages.size == 0
-      error "No packages found in repository."
-    end
+        # retrieve the existing manifests
+        manifest = Dpkg::S3::Manifest.retrieve(options[:codename], component, arch,
+                                               options[:cache_control], false, false)
+        package = manifest.packages.detect do |p|
+          p.name == package_name && p.full_version == version
+        end
+        error 'No such package found.' if package.nil?
 
-    packages.each do |package|
-      begin
-        to_manifest.add package, options[:preserve_versions], false
-      rescue Dpkg::S3::Utils::AlreadyExistsError => e
-        error("Preparing manifest failed because: #{e}")
+        puts package.generate(options[:codename])
       end
-    end
 
-    begin
-      to_manifest.write_to_s3 { |f| sublog("Transferring #{f}") }
-    rescue Dpkg::S3::Utils::AlreadyExistsError => e
-      error("Copying manifest failed because: #{e}")
-    end
-    to_release.update_manifest(to_manifest)
-    to_release.write_to_s3 { |f| sublog("Transferring #{f}") }
+      desc 'copy PACKAGE TO_CODENAME TO_COMPONENT ',
+           'Copy the package named PACKAGE to given codename and component. If --versions is not specified, '\
+           'copy all versions of PACKAGE. Otherwise, only the specified versions will be copied. '\
+           'Source codename and component is given by --codename and --component options.'
+
+      option :cache_control,
+             type: :string,
+             aliases: '-C',
+             desc: 'Add cache-control headers to S3 objects.'
+
+      option :arch,
+             type: :string,
+             aliases: '-a',
+             desc: 'The architecture of the package in the APT repository.'
+
+      option :versions,
+             default: nil,
+             type: :array,
+             desc: 'The space-delimited versions of PACKAGE to delete. If not ' \
+                          'specified, ALL VERSIONS will be deleted. Fair warning. ' \
+                          'E.g. --versions "0.1 0.2 0.3"'
+
+      option :preserve_versions,
+             default: false,
+             type: :boolean,
+             aliases: '-p',
+             desc: 'Whether to preserve other versions of a package ' \
+                          'in the repository when uploading one.'
+
+      option :fail_if_exists,
+             default: true,
+             type: :boolean,
+             desc: 'Whether to overwrite any existing package that has the same ' \
+                          'filename in the pool or the same name and version in the manifest.'
+
+      def copy(package_name, to_codename, to_component)
+        error 'You must specify a package name.' if package_name.nil?
+        error 'You must specify a codename to copy to.' if to_codename.nil?
+        error 'You must specify a component to copy to.' if to_component.nil?
+
+        arch = options[:arch]
+        error 'You must specify the architecture of the package to copy.' if arch.nil?
+
+        versions = options[:versions]
+        if versions.nil?
+          warn "===> WARNING: Copying all versions of #{package_name}"
+        else
+          log "Versions to copy: #{versions.join(', ')}"
+        end
 
-    log "Copy complete."
-  end
+        configure_s3_client
+
+        # retrieve the existing manifests
+        log 'Retrieving existing manifests'
+        from_manifest = Dpkg::S3::Manifest.retrieve(options[:codename],
+                                                    component, arch,
+                                                    options[:cache_control],
+                                                    false, skip_upload: options[:skip_package_upload])
+        to_release = Dpkg::S3::Release.retrieve(to_codename)
+        to_manifest = Dpkg::S3::Manifest.retrieve(to_codename, to_component, arch,
+                                                  options[:cache_control],
+                                                  options[:fail_if_exists],
+                                                  skip_upload: options[:skip_package_upload])
+        packages = from_manifest.packages.select do |p|
+          p.name == package_name &&
+            (versions.nil? || versions.include?(p.full_version))
+        end
+        error 'No packages found in repository.' if packages.size.zero?
 
-  desc "delete PACKAGE",
-    "Remove the package named PACKAGE. If --versions is not specified, delete" +
-    "all versions of PACKAGE. Otherwise, only the specified versions will be " +
-    "deleted."
-
-  option :arch,
-    :type     => :string,
-    :aliases  => "-a",
-    :desc     => "The architecture of the package in the APT repository."
-
-  option :versions,
-    :default  => nil,
-    :type     => :array,
-    :desc     => "The space-delimited versions of PACKAGE to delete. If not " +
-    "specified, ALL VERSIONS will be deleted. Fair warning. " +
-    "E.g. --versions \"0.1 0.2 0.3\""
-
-  def delete(package)
-    if package.nil?
-      error("You must specify a package name.")
-    end
+        packages.each do |package|
+          begin
+            to_manifest.add package, options[:preserve_versions], false
+          rescue Dpkg::S3::Utils::AlreadyExistsError => e
+            error("Preparing manifest failed because: #{e}")
+          end
+        end
 
-    versions = options[:versions]
-    if versions.nil?
-      warn("===> WARNING: Deleting all versions of #{package}")
-    else
-      log("Versions to delete: #{versions.join(', ')}")
-    end
+        begin
+          to_manifest.write_to_s3 { |f| sublog("Transferring #{f}") }
+        rescue Dpkg::S3::Utils::AlreadyExistsError => e
+          error("Copying manifest failed because: #{e}")
+        end
+        to_release.update_manifest(to_manifest)
+        to_release.write_to_s3 { |f| sublog("Transferring #{f}") }
 
-    arch = options[:arch]
-    if arch.nil?
-      error("You must specify the architecture of the package to remove.")
-    end
+        log 'Copy complete.'
+      end
 
-    configure_s3_client
+      desc 'delete PACKAGE',
+           'Remove the package named PACKAGE. If --versions is not specified, delete' \
+           'all versions of PACKAGE. Otherwise, only the specified versions will be ' \
+           'deleted.'
+
+      option :arch,
+             type: :string,
+             aliases: '-a',
+             desc: 'The architecture of the package in the APT repository.'
+
+      option :versions,
+             default: nil,
+             type: :array,
+             desc: 'The space-delimited versions of PACKAGE to delete. If not ' \
+                          'specified, ALL VERSIONS will be deleted. Fair warning. ' \
+                          'E.g. --versions "0.1 0.2 0.3"'
+
+      def delete(package)
+        error('You must specify a package name.') if package.nil?
+
+        versions = options[:versions]
+        if versions.nil?
+          warn("===> WARNING: Deleting all versions of #{package}")
+        else
+          log("Versions to delete: #{versions.join(', ')}")
+        end
 
-    # retrieve the existing manifests
-    log("Retrieving existing manifests")
-    release  = Dpkg::S3::Release.retrieve(options[:codename], options[:origin], options[:suite])
-    if arch == 'all'
-      selected_arch = release.architectures
-    else
-      selected_arch = [arch]
-    end
-    all_found = 0
-    selected_arch.each { |ar|
-      manifest = Dpkg::S3::Manifest.retrieve(options[:codename], component, ar, options[:cache_control], false, options[:skip_package_upload])
-
-      deleted = manifest.delete_package(package, versions)
-      all_found += deleted.length
-      if deleted.length == 0
-          if versions.nil?
+        arch = options[:arch]
+        error('You must specify the architecture of the package to remove.') if arch.nil?
+
+        configure_s3_client
+
+        # retrieve the existing manifests
+        log('Retrieving existing manifests')
+        release = Dpkg::S3::Release.retrieve(options[:codename], options[:origin], options[:suite])
+        selected_arch = if arch == 'all'
+                          release.architectures
+                        else
+                          [arch]
+                        end
+        all_found = 0
+        selected_arch.each do |ar|
+          manifest = Dpkg::S3::Manifest.retrieve(options[:codename], component, ar, options[:cache_control], false,
+                                                 skip_upload: options[:skip_package_upload])
+
+          deleted = manifest.delete_package(package, versions)
+          all_found += deleted.length
+          if deleted.length.zero?
+            if versions.nil?
               sublog("No packages were deleted. #{package} not found in arch #{ar}.")
-              next
+            else
+              sublog("No packages were deleted. #{package} versions #{versions.join(', ')}
+               could not be found in arch #{ar}.")
+            end
+            next
           else
-              sublog("No packages were deleted. #{package} versions #{versions.join(', ')} could not be found in arch #{ar}.")
-              next
-          end
-      else
-          deleted.each { |p|
+            deleted.each do |p|
               sublog("Deleting #{p.name} version #{p.full_version} from arch #{ar}")
-          }
-      end
+            end
+          end
+
+          log('Uploading new manifests to S3')
+          manifest.write_to_s3 { |f| sublog("Transferring #{f}") }
+          release.update_manifest(manifest)
+          release.write_to_s3 { |f| sublog("Transferring #{f}") }
+
+          log('Update complete.')
+        end
+        return unless all_found.zero?
 
-      log("Uploading new manifests to S3")
-      manifest.write_to_s3 {|f| sublog("Transferring #{f}") }
-      release.update_manifest(manifest)
-      release.write_to_s3 {|f| sublog("Transferring #{f}") }
-
-      log("Update complete.")
-    }
-    if all_found == 0
-      if versions.nil?
-        error("No packages were deleted. #{package} not found.")
-      else
-        error("No packages were deleted. #{package} versions #{versions.join(', ')} could not be found.")
+        if versions.nil?
+          error("No packages were deleted. #{package} not found.")
+        else
+          error("No packages were deleted. #{package} versions #{versions.join(', ')} could not be found.")
+        end
       end
-    end
 
-  end
+      desc 'verify', 'Verifies that the files in the package manifests exist'
+
+      option :fix_manifests,
+             default: false,
+             type: :boolean,
+             aliases: '-f',
+             desc: 'Whether to fix problems in manifests when verifying.'
 
+      def verify
+        configure_s3_client
 
-  desc "verify", "Verifies that the files in the package manifests exist"
+        log('Retrieving existing manifests')
+        release = Dpkg::S3::Release.retrieve(options[:codename], options[:origin], options[:suite])
 
-  option :fix_manifests,
-  :default  => false,
-  :type     => :boolean,
-  :aliases  => "-f",
-  :desc     => "Whether to fix problems in manifests when verifying."
+        release.architectures.each do |arch|
+          log("Checking for missing packages in: #{options[:codename]}/#{options[:component]} #{arch}")
+          manifest = Dpkg::S3::Manifest.retrieve(options[:codename], component,
+                                                 arch, options[:cache_control], false,
+                                                 skip_upload: options[:skip_package_upload])
+          missing_packages = []
 
-  def verify
-    configure_s3_client
+          manifest.packages.each do |p|
+            next if Dpkg::S3::Utils.s3_exists? p.url_filename_encoded(options[:codename])
 
-    log("Retrieving existing manifests")
-    release = Dpkg::S3::Release.retrieve(options[:codename], options[:origin], options[:suite])
+            sublog("The following packages are missing:\n\n") if missing_packages.empty?
+            puts(p.generate(options[:codename]))
+            puts('')
 
-    release.architectures.each do |arch|
-      log("Checking for missing packages in: #{options[:codename]}/#{options[:component]} #{arch}")
-      manifest = Dpkg::S3::Manifest.retrieve(options[:codename], component,
-                                            arch, options[:cache_control], false,
-                                            options[:skip_package_upload])
-      missing_packages = []
+            missing_packages << p
+          end
+
+          next unless options[:sign] || (options[:fix_manifests] && !missing_packages.empty?)
 
-      manifest.packages.each do |p|
-        unless Dpkg::S3::Utils.s3_exists? p.url_filename_encoded(options[:codename])
-          sublog("The following packages are missing:\n\n") if missing_packages.empty?
-          puts(p.generate(options[:codename]))
-          puts("")
+          log("Removing #{missing_packages.length} package(s) from the manifest...")
+          missing_packages.each { |p| manifest.packages.delete(p) }
+          manifest.write_to_s3 { |f| sublog("Transferring #{f}") }
+          release.update_manifest(manifest)
+          release.write_to_s3 { |f| sublog("Transferring #{f}") }
 
-          missing_packages << p
+          log('Update complete.')
         end
       end
 
-      if options[:sign] || (options[:fix_manifests] && !missing_packages.empty?)
-        log("Removing #{missing_packages.length} package(s) from the manifest...")
-        missing_packages.each { |p| manifest.packages.delete(p) }
-        manifest.write_to_s3 { |f| sublog("Transferring #{f}") }
-        release.update_manifest(manifest)
-        release.write_to_s3 { |f| sublog("Transferring #{f}") }
+      private
 
-        log("Update complete.")
-      end
-    end
-  end
+      def component
+        return @component if @component
 
-  private
-
-  def component
-    return @component if @component
-    @component = if (section = options[:section])
-                   warn("===> WARNING: The --section/-s argument is " \
-                        "deprecated, please use --component/-m.")
-                   section
-                 else
-                   options[:component]
-                 end
-  end
+        @component = if (section = options[:section])
+                       warn('===> WARNING: The --section/-s argument is ' \
+                            'deprecated, please use --component/-m.')
+                       section
+                     else
+                       options[:component]
+                     end
+      end
 
-  def puts(*args)
-    $stdout.puts(*args) unless options[:quiet]
-  end
+      def puts(*args)
+        $stdout.puts(*args) unless options[:quiet]
+      end
 
-  def log(message)
-    puts ">> #{message}" unless options[:quiet]
-  end
+      def log(message)
+        puts ">> #{message}" unless options[:quiet]
+      end
 
-  def sublog(message)
-    puts "   -- #{message}" unless options[:quiet]
-  end
+      def sublog(message)
+        puts "   -- #{message}" unless options[:quiet]
+      end
 
-  def error(message)
-    $stderr.puts "!! #{message}" unless options[:quiet]
-    exit 1
-  end
+      def error(message)
+        warn "!! #{message}" unless options[:quiet]
+        exit 1
+      end
 
-  def provider
-    access_key_id     = options[:access_key_id]
-    secret_access_key = options[:secret_access_key]
-    session_token     = options[:session_token]
+      def provider
+        access_key_id     = options[:access_key_id]
+        secret_access_key = options[:secret_access_key]
+        session_token     = options[:session_token]
 
-    if access_key_id.nil? ^ secret_access_key.nil?
-      error("If you specify one of --access-key-id or --secret-access-key, you must specify the other.")
-    end
-    static_credentials = {}
-    static_credentials[:access_key_id]     = access_key_id     if access_key_id
-    static_credentials[:secret_access_key] = secret_access_key if secret_access_key
-    static_credentials[:session_token]     = session_token     if session_token
+        if access_key_id.nil? ^ secret_access_key.nil?
+          error('If you specify one of --access-key-id or --secret-access-key, you must specify the other.')
+        end
+        static_credentials = {}
+        static_credentials[:access_key_id]     = access_key_id     if access_key_id
+        static_credentials[:secret_access_key] = secret_access_key if secret_access_key
+        static_credentials[:session_token]     = session_token     if session_token
 
-    static_credentials
-  end
+        static_credentials
+      end
 
-  def configure_s3_client
-    error("No value provided for required options '--bucket'") unless options[:bucket]
-
-    settings = {
-      :region => options[:s3_region],
-      :http_proxy   => options[:proxy_uri],
-      :force_path_style => options[:force_path_style]
-    }
-    settings[:endpoint] = options[:endpoint] if options[:endpoint]
-    settings.merge!(provider)
-
-    Dpkg::S3::Utils.s3          = Aws::S3::Client.new(settings)
-    Dpkg::S3::Utils.bucket      = options[:bucket]
-    Dpkg::S3::Utils.signing_key = options[:sign]
-    Dpkg::S3::Utils.gpg_options = options[:gpg_options]
-    Dpkg::S3::Utils.prefix      = options[:prefix]
-    Dpkg::S3::Utils.encryption  = options[:encryption]
-
-    # make sure we have a valid visibility setting
-    Dpkg::S3::Utils.access_policy =
-      case options[:visibility]
-      when "public"
-        "public-read"
-      when "private"
-        "private"
-      when "authenticated"
-        "authenticated-read"
-      when "bucket_owner"
-        "bucket-owner-full-control"
-      else
-        error("Invalid visibility setting given. Can be public, private, authenticated, or bucket_owner.")
+      def configure_s3_client
+        error("No value provided for required options '--bucket'") unless options[:bucket]
+
+        settings = {
+          region: options[:s3_region],
+          http_proxy: options[:proxy_uri],
+          force_path_style: options[:force_path_style]
+        }
+        settings[:endpoint] = options[:endpoint] if options[:endpoint]
+        settings.merge!(provider)
+
+        Dpkg::S3::Utils.s3          = Aws::S3::Client.new(settings)
+        Dpkg::S3::Utils.bucket      = options[:bucket]
+        Dpkg::S3::Utils.signing_key = options[:sign]
+        Dpkg::S3::Utils.gpg_options = options[:gpg_options]
+        Dpkg::S3::Utils.prefix      = options[:prefix]
+        Dpkg::S3::Utils.encryption  = options[:encryption]
+
+        # make sure we have a valid visibility setting
+        Dpkg::S3::Utils.access_policy =
+          case options[:visibility]
+          when 'public'
+            'public-read'
+          when 'private'
+            'private'
+          when 'authenticated'
+            'authenticated-read'
+          when 'bucket_owner'
+            'bucket-owner-full-control'
+          else
+            error('Invalid visibility setting given. Can be public, private, authenticated, or bucket_owner.')
+          end
       end
+    end
   end
 end