imap-backup 8.0.0.rc1 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f852c0552212ba77c4e4dda834b8727860a788ea73ecf395255c248b9f728e4
-  data.tar.gz: 1a33b9e2efd04d4e9dcd4e48b401d7001330de8950477947aa4547d15c9554e8
+  metadata.gz: ccb9808337c50af0fe59f2cdc85dedcbab50b5b0980a60e2ccf10fc3734b9f37
+  data.tar.gz: e0b67bd5bfb040220f54c9a662c90ad545fce9c84a5fadaf6d93a485ac865ffc
 SHA512:
-  metadata.gz: 10ec5bf1f6426652d8b1875e1dbc4150ac7191aea988fbe2235d9966cb3394df1a6353d541f1de0c65a13c15a3b01d3502d4c36634427831244f2996a80d5bf6
-  data.tar.gz: eba30293362b4bc0c79e3a389cf56d3d218addec339fbc802aa245df8ef8f6f0f7b0588f6ee7ec1b5def04dbdddff39bea91370718d0dab0026cf2189474e82d
+  metadata.gz: 4070e85e86a627a0791924cba209d044dd71fd54a7d0d79a7c34b9aade4d4827ae020ed3a78d5e4169d0d8aa188ce34741f5a6a44d4f0ae1b035e6bbead30df8
+  data.tar.gz: b20ac83f5bffea68ab4dd3ae12fcef6df78cb20aab136864ba97e23ddaa414fe344e122d430bf1de242e393e50ccef916ee4e1fba77353836aee9e148c5a3da8

data/README.md

@@ -70,7 +70,6 @@ Alternatively, add it to your crontab.
 # Commands
 
 * [backup](docs/commands/backup.md)
-* [folders](docs/commands/folders.md)
 * [local accounts](docs/commands/local-accounts.md)
 * [local folders](docs/commands/local-folders.md)
 * [local list](docs/commands/local-list.md)
@@ -104,4 +103,8 @@ If you have problems:
 
 # Development
 
-See the [Development documentation](./docs/development.md)
+See the [Development documentation](./docs/development.md) for notes
+on development and testing.
+
+See [the CHANGELOG](./CHANGELOG.md) to a list of changes that have been
+made in each release.

data/lib/imap/backup/account/connection/backup_folders.rb

@@ -12,16 +12,26 @@ module Imap::Backup
     end
 
     def run
+      all_names = Account::Connection::FolderNames.new(client: client, account: account).run
+
       names =
         if account.folders&.any?
           account.folders.map { |af| af[:name] }
         else
-          Account::Connection::FolderNames.new(client: client, account: account).run
+          all_names
         end
 
-      names.map do |name|
+      all_names.map do |name|
+        backup =
+          if account.folder_blacklist
+            !names.include?(name)
+          else
+            names.include?(name)
+          end
+        next if !backup
+
         Account::Folder.new(account.connection, name)
-      end
+      end.compact
     end
   end
 end

data/lib/imap/backup/account/connection.rb

@@ -27,6 +27,10 @@ module Imap::Backup
         Account::Connection::BackupFolders.new(client: client, account: account).run
     end
 
+    def namespaces
+      client.namespace
+    end
+
     def run_backup(refresh: false)
       Logger.logger.info "Running backup of account: #{account.username}"
       # start the connection so we get logging messages in the right order

data/lib/imap/backup/account/folder.rb

@@ -100,24 +100,24 @@ module Imap::Backup
     end
 
     def delete_multi(uids)
-      set_flags(uids, [:Deleted])
+      add_flags(uids, [:Deleted])
       client.expunge
     end
 
-    def apply_flags(uids, flags)
+    def set_flags(uids, flags)
       client.select(utf7_encoded_name)
       flags.reject! { |f| f == :Recent }
       client.uid_store(uids, "FLAGS", flags)
     end
 
-    def set_flags(uids, flags)
+    def add_flags(uids, flags)
       # Use read-write access, via `select`
       client.select(utf7_encoded_name)
       flags.reject! { |f| f == :Recent }
       client.uid_store(uids, "+FLAGS", flags)
     end
 
-    def unset_flags(uids, flags)
+    def remove_flags(uids, flags)
       client.select(utf7_encoded_name)
       client.uid_store(uids, "-FLAGS", flags)
     end
@@ -126,7 +126,7 @@ module Imap::Backup
       existing = uids
       return if existing.empty?
 
-      set_flags(existing, [:Deleted])
+      add_flags(existing, [:Deleted])
       client.expunge
     end
 

data/lib/imap/backup/account.rb

@@ -8,6 +8,7 @@ module Imap::Backup
     attr_reader :password
     attr_reader :local_path
     attr_reader :folders
+    attr_reader :folder_blacklist
     attr_reader :mirror_mode
     attr_reader :server
     attr_reader :connection_options
@@ -19,6 +20,7 @@ module Imap::Backup
       @password = options[:password]
       @local_path = options[:local_path]
       @folders = options[:folders]
+      @folder_blacklist = options[:folder_blacklist]
       @mirror_mode = options[:mirror_mode]
       @server = options[:server]
       @connection_options = options[:connection_options]
@@ -57,6 +59,7 @@ module Imap::Backup
       h = {username: @username, password: @password}
       h[:local_path] = @local_path if @local_path
       h[:folders] = @folders if @folders
+      h[:folder_blacklist] = true if @folder_blacklist
       h[:mirror_mode] = true if @mirror_mode
       h[:server] = @server if @server
       h[:connection_options] = @connection_options if @connection_options
@@ -85,6 +88,10 @@ module Imap::Backup
       update(:folders, value)
     end
 
+    def folder_blacklist=(value)
+      update(:folder_blacklist, value)
+    end
+
     def mirror_mode=(value)
       update(:mirror_mode, value)
     end
@@ -94,7 +101,12 @@ module Imap::Backup
     end
 
     def connection_options=(value)
-      parsed = JSON.parse(value, symbolize_names: true)
+      parsed =
+        if value == ""
+          nil
+        else
+          JSON.parse(value, symbolize_names: true)
+        end
       update(:connection_options, parsed)
     end
 

data/lib/imap/backup/cli/helpers.rb

@@ -13,12 +13,12 @@ module Imap::Backup
           )
         end
 
-        def self.verbose_option
+        def self.format_option
           method_option(
-            "verbose",
-            type: :boolean,
-            desc: "increase the amount of logging",
-            aliases: ["-v"]
+            "format",
+            type: :string,
+            desc: "the output type, 'text' for plain text or 'json'",
+            aliases: ["-f"]
           )
         end
 
@@ -30,13 +30,37 @@ module Imap::Backup
             aliases: ["-q"]
           )
         end
+
+        def self.verbose_option
+          method_option(
+            "verbose",
+            type: :boolean,
+            desc: "increase the amount of logging",
+            aliases: ["-v"]
+          )
+        end
       end
     end
 
+    def options
+      @symbolized_options ||= # rubocop:disable Naming/MemoizedInstanceVariableName
+        begin
+          options = super()
+          options.each.with_object({}) do |(k, v), acc|
+            key =
+              if k.is_a?(String)
+                k.gsub("-", "_").intern
+              else
+                k
+              end
+            acc[key] = v
+          end
+        end
+    end
+
     def load_config(**options)
-      opts = symbolized(options)
-      path = opts[:config]
-      require_exists = opts.key?(:require_exists) ? opts[:require_exists] : true
+      path = options[:config]
+      require_exists = options.key?(:require_exists) ? options[:require_exists] : true
       if require_exists
         exists = Configuration.exist?(path: path)
         if !exists
@@ -47,18 +71,6 @@ module Imap::Backup
       Configuration.new(path: path)
     end
 
-    def symbolized(options)
-      options.each.with_object({}) do |(k, v), acc|
-        key =
-          if k.is_a?(String)
-            k.gsub("-", "_").intern
-          else
-            k
-          end
-        acc[key] = v
-      end
-    end
-
     def account(config, email)
       account = config.accounts.find { |a| a.username == email }
       raise "#{email} is not a configured account" if !account

data/lib/imap/backup/cli/local.rb

@@ -7,43 +7,55 @@ module Imap::Backup
 
     desc "accounts", "List locally backed-up accounts"
     config_option
+    format_option
     def accounts
-      config = load_config(**symbolized(options))
-      config.accounts.each { |a| Kernel.puts a.username }
+      config = load_config(**options)
+      names = config.accounts.map(&:username)
+      case options[:format]
+      when "json"
+        list = names.map { |n| {username: n} }
+        Kernel.puts list.to_json
+      else
+        names.each { |n| Kernel.puts n }
+      end
     end
 
     desc "folders EMAIL", "List backed up folders"
     config_option
+    format_option
     def folders(email)
-      config = load_config(**symbolized(options))
+      config = load_config(**options)
       connection = connection(config, email)
 
-      connection.local_folders.each do |_s, f|
-        Kernel.puts %("#{f.name}")
+      folders = connection.local_folders
+      case options[:format]
+      when "json"
+        list = folders.map { |_s, f| {name: f.name} }
+        Kernel.puts list.to_json
+      else
+        folders.each do |_s, f|
+          Kernel.puts %("#{f.name}")
+        end
       end
     end
 
     desc "list EMAIL FOLDER", "List emails in a folder"
     config_option
+    format_option
     def list(email, folder_name)
-      config = load_config(**symbolized(options))
+      config = load_config(**options)
       connection = connection(config, email)
 
-      folder_serializer, _folder = connection.local_folders.find do |(_s, f)|
+      serializer, _folder = connection.local_folders.find do |(_s, f)|
         f.name == folder_name
       end
-      raise "Folder '#{folder_name}' not found" if !folder_serializer
-
-      Kernel.puts format(
-        "%-10<uid>s  %-#{MAX_SUBJECT}<subject>s - %<date>s",
-        {uid: "UID", subject: "Subject", date: "Date"}
-      )
-      Kernel.puts "-" * (12 + MAX_SUBJECT + 28)
+      raise "Folder '#{folder_name}' not found" if !serializer
 
-      uids = folder_serializer.uids
-
-      folder_serializer.each_message(uids).map do |message|
-        list_message message
+      case options[:format]
+      when "json"
+        list_emails_as_json serializer
+      else
+        list_emails_as_text serializer
       end
     end
 
@@ -54,30 +66,51 @@ module Imap::Backup
       the UID.
     DESC
     config_option
+    format_option
     def show(email, folder_name, uids)
-      config = load_config(**symbolized(options))
+      config = load_config(**options)
       connection = connection(config, email)
 
-      folder_serializer, _folder = connection.local_folders.find do |(_s, f)|
+      serializer, _folder = connection.local_folders.find do |(_s, f)|
         f.name == folder_name
       end
-      raise "Folder '#{folder_name}' not found" if !folder_serializer
+      raise "Folder '#{folder_name}' not found" if !serializer
 
       uid_list = uids.split(",")
-      folder_serializer.each_message(uid_list).each do |message|
-        if uid_list.count > 1
-          Kernel.puts <<~HEADER
-            #{'-' * 80}
-            #{format('| UID: %-71s |', message.uid)}
-            #{'-' * 80}
-          HEADER
-        end
-        Kernel.puts message.body
+
+      case options[:format]
+      when "json"
+        show_emails_as_json serializer, uid_list
+      else
+        show_emails_as_text serializer, uid_list
       end
     end
 
     no_commands do
-      def list_message(message)
+      def list_emails_as_json(serializer)
+        emails = serializer.each_message.map do |message|
+          {
+            uid: message.uid,
+            date: message.date.to_s,
+            subject: message.subject || ""
+          }
+        end
+        Kernel.puts emails.to_json
+      end
+
+      def list_emails_as_text(serializer)
+        Kernel.puts format(
+          "%-10<uid>s  %-#{MAX_SUBJECT}<subject>s - %<date>s",
+          {uid: "UID", subject: "Subject", date: "Date"}
+        )
+        Kernel.puts "-" * (12 + MAX_SUBJECT + 28)
+
+        serializer.each_message.map do |message|
+          list_message_as_text message
+        end
+      end
+
+      def list_message_as_text(message)
         m = {
           uid: message.uid,
           date: message.date.to_s,
@@ -89,6 +122,26 @@ module Imap::Backup
           Kernel.puts format("% 10<uid>u: %-#{MAX_SUBJECT}<subject>s - %<date>s", m)
         end
       end
+
+      def show_emails_as_json(serializer, uids)
+        emails = serializer.each_message(uids).map do |m|
+          m.to_h.tap { |h| h[:body] = m.body }
+        end
+        Kernel.puts emails.to_json
+      end
+
+      def show_emails_as_text(serializer, uids)
+        serializer.each_message(uids).each do |message|
+          if uids.count > 1
+            Kernel.puts <<~HEADER
+              #{'-' * 80}
+              #{format('| UID: %-71s |', message.uid)}
+              #{'-' * 80}
+            HEADER
+          end
+          Kernel.puts message.body
+        end
+      end
     end
   end
 end

data/lib/imap/backup/cli/remote.rb

@@ -1,3 +1,5 @@
+require "imap/backup/logger"
+
 module Imap::Backup
   class CLI::Remote < Thor
     include Thor::Actions
@@ -5,14 +7,100 @@ module Imap::Backup
 
     desc "folders EMAIL", "List account folders"
     config_option
-    verbose_option
+    format_option
     quiet_option
+    verbose_option
     def folders(email)
-      config = load_config(**symbolized(options))
+      Imap::Backup::Logger.setup_logging options
+      names = names(email)
+      case options[:format]
+      when "json"
+        json_format_names names
+      else
+        list_names names
+      end
+    end
+
+    desc "namespaces EMAIL", "List account namespaces"
+    long_desc <<~DESC
+      Lists namespaces defined for an email account.
+
+      This command is useful in deciding the parameters for
+      the `imap-backup migrate` and `imap-backup mirror` commands.
+    DESC
+    config_option
+    format_option
+    quiet_option
+    verbose_option
+    def namespaces(email)
+      Imap::Backup::Logger.setup_logging options
+      config = load_config(**options)
       connection = connection(config, email)
+      namespaces = connection.namespaces
+      case options[:format]
+      when "json"
+        json_format_namespaces namespaces
+      else
+        list_namespaces namespaces
+      end
+    end
+
+    no_commands do
+      def names(email)
+        config = load_config(**options)
+        connection = connection(config, email)
+
+        connection.folder_names
+      end
+
+      def json_format_names(names)
+        list = names.map do |name|
+          {name: name}
+        end
+        Kernel.puts list.to_json
+      end
+
+      def list_names(names)
+        names.each do |name|
+          Kernel.puts %("#{name}")
+        end
+      end
+
+      def json_format_namespaces(namespaces)
+        list = {
+          personal: namespace_info(namespaces.personal.first),
+          other: namespace_info(namespaces.other.first),
+          shared: namespace_info(namespaces.shared.first)
+        }
+        Kernel.puts list.to_json
+      end
+
+      def list_namespaces(namespaces)
+        Kernel.puts format(
+          "%-10<name>s %-10<prefix>s %<delim>s",
+          {name: "Name", prefix: "Prefix", delim: "Delimiter"}
+        )
+        list_namespace namespaces, :personal
+        list_namespace namespaces, :other
+        list_namespace namespaces, :shared
+      end
+
+      def list_namespace(namespaces, name)
+        info = namespace_info(namespaces.send(name).first, quote: true)
+        if info
+          Kernel.puts format("%-10<name>s %-10<prefix>s %<delim>s", name: name, **info)
+        else
+          Kernel.puts format("%-10<name>s (Not defined)", name: name)
+        end
+      end
+
+      def namespace_info(namespace, quote: false)
+        return nil if !namespace
 
-      connection.folder_names.each do |name|
-        Kernel.puts %("#{name}")
+        {
+          prefix: quote ? namespace.prefix.to_json : namespace.prefix,
+          delim: quote ? namespace.delim.to_json : namespace.delim
+        }
       end
     end
   end

data/lib/imap/backup/cli/utils.rb

@@ -8,12 +8,12 @@ module Imap::Backup
     FAKE_EMAIL = "fake@email.com".freeze
 
     desc "ignore-history EMAIL", "Skip downloading emails up to today for all configured folders"
-    verbose_option
+    config_option
     quiet_option
+    verbose_option
     def ignore_history(email)
-      opts = symbolized(options)
-      Imap::Backup::Logger.setup_logging opts
-      config = load_config(**opts)
+      Imap::Backup::Logger.setup_logging options
+      config = load_config(**options)
       connection = connection(config, email)
 
       connection.backup_folders.each do |folder|
@@ -27,12 +27,13 @@ module Imap::Backup
     desc(
       "export-to-thunderbird EMAIL [OPTIONS]",
       <<~DOC
-        [Experimental] Copy backed up emails to Thunderbird.
+        Copy backed up emails to Thunderbird.
         A folder called 'imap-backup/EMAIL' is created under 'Local Folders'.
       DOC
     )
-    verbose_option
+    config_option
     quiet_option
+    verbose_option
     method_option(
       "force",
       type: :boolean,
@@ -46,12 +47,11 @@ module Imap::Backup
       aliases: ["-p"]
     )
     def export_to_thunderbird(email)
-      opts = symbolized(options)
-      Imap::Backup::Logger.setup_logging opts
-      force = opts.key?(:force) ? opts[:force] : false
-      profile_name = opts[:profile]
+      Imap::Backup::Logger.setup_logging options
+      force = options.key?(:force) ? options[:force] : false
+      profile_name = options[:profile]
 
-      config = load_config(**opts)
+      config = load_config(**options)
       connection = connection(config, email)
       profile = thunderbird_profile(profile_name)
 

data/lib/imap/backup/cli.rb

@@ -45,8 +45,8 @@ module Imap::Backup
     DESC
     accounts_option
     config_option
-    verbose_option
     quiet_option
+    verbose_option
     method_option(
       "refresh",
       type: :boolean,
@@ -54,21 +54,8 @@ module Imap::Backup
       aliases: ["-r"]
     )
     def backup
-      Imap::Backup::Logger.setup_logging symbolized(options)
-      Backup.new(symbolized(options)).run
-    end
-
-    desc "folders [OPTIONS]", "This command is deprecated, use `imap-backup remote folders ACCOUNT`"
-    long_desc <<~DESC
-      Lists all folders of all configured accounts.
-      This command is deprecated.
-      Instead, use a combination of `imap-backup local accounts` to get the list of accounts,
-      and `imap-backup remote folders ACCOUNT` to get the folder list.
-    DESC
-    accounts_option
-    config_option
-    def folders
-      Folders.new(symbolized(options)).run
+      Imap::Backup::Logger.setup_logging options
+      Backup.new(options).run
     end
 
     desc "local SUBCOMMAND [OPTIONS]", "View local info"
@@ -76,7 +63,6 @@ module Imap::Backup
 
     desc(
       "migrate SOURCE_EMAIL DESTINATION_EMAIL [OPTIONS]",
-      "[Experimental] " \
       "Uploads backed-up emails from account SOURCE_EMAIL to account DESTINATION_EMAIL"
     )
     long_desc <<~DESC
@@ -98,8 +84,8 @@ module Imap::Backup
       deleted before uploading the migrated emails.
     DESC
     config_option
-    verbose_option
     quiet_option
+    verbose_option
     method_option(
       "destination-prefix",
       type: :string,
@@ -119,8 +105,8 @@ module Imap::Backup
       aliases: ["-s"]
     )
     def migrate(source_email, destination_email)
-      Imap::Backup::Logger.setup_logging symbolized(options)
-      Migrate.new(source_email, destination_email, **symbolized(options)).run
+      Imap::Backup::Logger.setup_logging options
+      Migrate.new(source_email, destination_email, **options).run
     end
 
     desc(
@@ -144,8 +130,8 @@ module Imap::Backup
       the known UIDs on the source account to those on the destination account.
     DESC
     config_option
-    verbose_option
     quiet_option
+    verbose_option
     method_option(
       "destination-prefix",
       type: :string,
@@ -159,8 +145,8 @@ module Imap::Backup
       aliases: ["-s"]
     )
     def mirror(source_email, destination_email)
-      Imap::Backup::Logger.setup_logging symbolized(options)
-      Mirror.new(source_email, destination_email, **symbolized(options)).run
+      Imap::Backup::Logger.setup_logging options
+      Mirror.new(source_email, destination_email, **options).run
     end
 
     desc "remote SUBCOMMAND [OPTIONS]", "View info about online accounts"
@@ -173,11 +159,11 @@ module Imap::Backup
     DESC
     accounts_option
     config_option
-    verbose_option
     quiet_option
+    verbose_option
     def restore(email = nil)
-      Imap::Backup::Logger.setup_logging symbolized(options)
-      Restore.new(email, symbolized(options)).run
+      Imap::Backup::Logger.setup_logging options
+      Restore.new(email, options).run
     end
 
     desc "setup", "Configure imap-backup"
@@ -186,11 +172,11 @@ module Imap::Backup
       Configure email accounts to back up.
     DESC
     config_option
-    verbose_option
     quiet_option
+    verbose_option
     def setup
-      Imap::Backup::Logger.setup_logging symbolized(options)
-      Setup.new(symbolized(options)).run
+      Imap::Backup::Logger.setup_logging options
+      Setup.new(options).run
     end
 
     desc "stats EMAIL [OPTIONS]", "Print stats for each account folder"
@@ -200,17 +186,12 @@ module Imap::Backup
       are only present in the backup (as they have been deleted on the server) "local".
     DESC
     config_option
-    verbose_option
+    format_option
     quiet_option
-    method_option(
-      "format",
-      type: :string,
-      desc: "the output type, text (plain text) or json",
-      aliases: ["-f"]
-    )
+    verbose_option
     def stats(email)
-      Imap::Backup::Logger.setup_logging symbolized(options)
-      Stats.new(email, symbolized(options)).run
+      Imap::Backup::Logger.setup_logging options
+      Stats.new(email, options).run
     end
 
     desc "utils SUBCOMMAND [OPTIONS]", "Various utilities"

data/lib/imap/backup/client/default.rb

@@ -7,7 +7,7 @@ module Imap::Backup
   class Client::Default
     extend Forwardable
     def_delegators :imap, *%i(
-      append authenticate create expunge login
+      append authenticate create expunge login namespace
       responses uid_fetch uid_search uid_store
     )
 

data/lib/imap/backup/downloader.rb

@@ -51,7 +51,7 @@ module Imap::Backup
           if changed.any?
             ids = changed.join(", ")
             debug "Removing '\Seen' flag for the following messages: #{ids}"
-            folder.unset_flags(changed, [:Seen])
+            folder.remove_flags(changed, [:Seen])
           end
           uids_and_bodies
         else

data/lib/imap/backup/mirror.rb

@@ -56,7 +56,7 @@ module Imap::Backup
         next if !source_uid
 
         message = serializer.get(source_uid)
-        folder.apply_flags([destination_uid], message.flags) if flags.sort != message.flags.sort
+        folder.set_flags([destination_uid], message.flags) if flags.sort != message.flags.sort
       end
     end
 

data/lib/imap/backup/setup/account/header.rb

@@ -14,14 +14,22 @@ module Imap::Backup
     end
 
     def run
+      rows = [
+        email,
+        password,
+        server,
+        connection_options,
+        mode,
+        path,
+        folders,
+        multi_fetch,
+        reset_seen_flags_after_fetch
+      ].compact
+
       menu.header = <<~HEADER.chomp
         #{helpers.title_prefix} Account#{modified_flag}
 
-        email   #{space}#{account.username}
-        password#{space}#{masked_password}
-        path    #{space}#{local_path}
-        folders #{space}#{folders.map { |f| f[:name] }.join(', ')}#{mirror_mode}#{multi_fetch_size}
-        server  #{space}#{account.server}#{connection_options}#{reset_seen_flags_after_fetch}
+        #{format_rows(rows)}
 
         Choose an action
       HEADER
@@ -29,28 +37,70 @@ module Imap::Backup
 
     private
 
-    def folders
-      account.folders || []
+    def modified_flag
+      account.modified? ? "*" : ""
     end
 
-    def mirror_mode
-      if account.mirror_mode
-        "\nmode    #{space}mirror emails"
-      else
-        "\nmode    #{space}keep all emails"
-      end
+    def email
+      ["email", account.username]
     end
 
-    def helpers
-      Setup::Helpers.new
+    def password
+      masked_password =
+        if (account.password == "") || account.password.nil?
+          "(unset)"
+        else
+          account.password.gsub(/./, "x")
+        end
+      ["password", masked_password]
     end
 
-    def modified_flag
-      account.modified? ? "*" : ""
+    def path
+      # In order to handle backslashes, as Highline effectively
+      # does an eval (!) on its templates, we need to doubly
+      # escape them
+      local_path = account.local_path.gsub("\\", "\\\\\\\\")
+      ["path", local_path]
     end
 
-    def multi_fetch_size
-      "\nmulti-fetch #{account.multi_fetch_size}" if account.multi_fetch_size > 1
+    def folders
+      label =
+        if account.folder_blacklist
+          "exclude"
+        else
+          "include"
+        end
+      items = account.folders || []
+      list =
+        case
+        when items.any?
+          items.map { |f| f[:name] }.join(", ")
+        when !account.folder_blacklist
+          "(all folders)"
+        else
+          "(all folders) <- you have opted to not backup any folders!"
+        end
+      [label, list]
+    end
+
+    def mode
+      value =
+        if account.mirror_mode
+          "mirror emails"
+        else
+          "keep all emails"
+        end
+      ["mode", value]
+    end
+
+    def multi_fetch
+      return nil if account.multi_fetch_size == 1
+
+      ["multi-fetch", account.multi_fetch_size]
+    end
+
+    def server
+      ["server", account.server]
     end
 
     def connection_options
@@ -58,32 +108,33 @@ module Imap::Backup
 
       escaped = JSON.generate(account.connection_options)
       escaped.gsub!('"', '\"')
-      "\nconnection options  '#{escaped}'"
+      ["connection options", "'#{escaped}'"]
     end
 
     def reset_seen_flags_after_fetch
       return nil if !account.reset_seen_flags_after_fetch
 
-      "\nchanges to unread flags will be reset during download"
+      ["changes to unread flags will be reset during download"]
     end
 
-    def space
-      account.connection_options ? " " * 12 : " " * 4
-    end
-
-    def masked_password
-      if (account.password == "") || account.password.nil?
-        "(unset)"
-      else
-        account.password.gsub(/./, "x")
+    def format_rows(rows)
+      largest_label, _value = rows.max_by do |(label, value)|
+        if value
+          label.length
+        else
+          0
+        end
       end
+      rows.map do |(label, value)|
+        format(
+          "%-#{largest_label.length}<label>s %<value>s",
+          {label: label, value: value}
+        )
+      end.join("\n")
     end
 
-    def local_path
-      # In order to handle backslashes, as Highline effectively
-      # does an eval (!) on its templates, we need to doubly
-      # escape them
-      account.local_path.gsub("\\", "\\\\\\\\")
+    def helpers
+      Setup::Helpers.new
     end
   end
 end

data/lib/imap/backup/setup/account.rb

@@ -36,14 +36,15 @@ module Imap::Backup
         header menu
         modify_email menu
         modify_password menu
+        modify_server menu
+        modify_connection_options menu
+        test_connection menu
+        toggle_mirror_mode menu
         modify_backup_path menu
+        toggle_folder_blacklist menu
         choose_folders menu
-        toggle_mirror_mode menu
         modify_multi_fetch_size menu
-        modify_server menu
-        modify_connection_options menu
         toggle_reset_seen_flags_after_fetch menu
-        test_connection menu
         delete_account menu
         menu.choice("(q) return to main menu") { throw :done }
         menu.hidden("quit") { throw :done }
@@ -74,8 +75,17 @@ module Imap::Backup
       end
     end
 
+    def toggle_folder_blacklist(menu)
+      menu_item = "toggle folder inclusion mode (whitelist/blacklist)"
+      new_value = account.folder_blacklist ? nil : true
+      menu.choice(menu_item) do
+        account.folder_blacklist = new_value
+      end
+    end
+
     def choose_folders(menu)
-      menu.choice("choose backup folders") do
+      action = account.folder_blacklist ? "exclude from backups" : "include in backups"
+      menu.choice("choose folders to #{action}") do
         Setup::FolderChooser.new(account).run
       end
     end
@@ -105,15 +115,7 @@ module Imap::Backup
 
     def modify_connection_options(menu)
       menu.choice("modify connection options") do
-        default =
-          if account.connection_options
-            account.connection_options.to_json
-          else
-            ""
-          end
-        connection_options = highline.ask("connections options (as JSON): ") do |q|
-          q.default = default
-        end
+        connection_options = highline.ask("connections options (as JSON): ")
         if !connection_options.nil?
           begin
             account.connection_options = connection_options

data/lib/imap/backup/version.rb

@@ -4,6 +4,6 @@ module Imap::Backup
   MAJOR    = 8
   MINOR    = 0
   REVISION = 0
-  PRE      = "rc1".freeze
+  PRE      = nil
   VERSION  = [MAJOR, MINOR, REVISION, PRE].compact.map(&:to_s).join(".")
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imap-backup
 version: !ruby/object:Gem::Version
-  version: 8.0.0.rc1
+  version: 8.0.0
 platform: ruby
 authors:
 - Joe Yates
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-19 00:00:00.000000000 Z
+date: 2022-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
@@ -240,7 +240,6 @@ files:
 - lib/imap/backup/account/folder.rb
 - lib/imap/backup/cli.rb
 - lib/imap/backup/cli/backup.rb
-- lib/imap/backup/cli/folders.rb
 - lib/imap/backup/cli/helpers.rb
 - lib/imap/backup/cli/local.rb
 - lib/imap/backup/cli/migrate.rb
@@ -300,9 +299,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.3.7
 signing_key:

data/lib/imap/backup/cli/folders.rb

@@ -1,35 +0,0 @@
-module Imap::Backup
-  class CLI::Folders < Thor
-    include Thor::Actions
-    include CLI::Helpers
-
-    attr_reader :emails
-    attr_reader :options
-
-    def initialize(options)
-      super([])
-      @options = options
-    end
-
-    no_commands do
-      def run
-        config = load_config(**options)
-        each_connection(config, emails) do |connection|
-          Kernel.puts connection.account.username
-          # TODO: Make folder_names private once this command
-          # has been removed.
-          folders = connection.folder_names
-          if folders.nil?
-            Kernel.warn "Unable to list account folders"
-            return false
-          end
-          folders.each { |f| Kernel.puts "\t#{f}" }
-        end
-      end
-
-      def emails
-        (options[:accounts] || "").split(",")
-      end
-    end
-  end
-end