imap-backup 4.0.4 → 4.1.1

data/lib/imap/backup/{configuration/setup.rb → setup.rb}

@@ -1,16 +1,16 @@
 require "highline"
 
-module Imap::Backup
-  module Configuration; end
+require "imap/backup/account"
+require "imap/backup/setup/helpers"
 
-  class Configuration::Setup
+module Imap::Backup
+  class Setup
     class << self
       attr_accessor :highline
     end
     self.highline = HighLine.new
 
     def run
-      Imap::Backup.setup_logging config
       catch :done do
         loop do
           Kernel.system("clear")
@@ -23,35 +23,41 @@ module Imap::Backup
 
     def show_menu
       self.class.highline.choose do |menu|
-        menu.header = "Choose an action"
+        menu.header = <<~MENU.chomp
+          #{helpers.title_prefix} Main Menu
+
+          Choose an action
+        MENU
         account_items menu
         add_account_item menu
         toggle_logging_item menu
-        menu.choice("save and exit") do
-          config.save
-          throw :done
-        end
-        menu.choice("exit without saving changes") do
-          throw :done
+        if config.modified?
+          menu.choice("save and exit") do
+            config.save
+            throw :done
+          end
+          menu.choice("exit without saving changes")  { throw :done }
+        else
+          menu.choice("quit") { throw :done }
         end
       end
     end
 
     def account_items(menu)
       config.accounts.each do |account|
-        next if account[:delete]
+        next if account.marked_for_deletion?
 
-        item = account[:username].clone
-        item << " *" if account[:modified]
+        item = account.username.clone
+        item << " *" if account.modified?
         menu.choice(item) do
-          edit_account account[:username]
+          edit_account account.username
         end
       end
     end
 
     def add_account_item(menu)
       menu.choice("add account") do
-        username = Configuration::Asker.email
+        username = Asker.email
         edit_account username
       end
     end
@@ -61,35 +67,37 @@ module Imap::Backup
       new_setting = !config.debug?
       menu.choice(menu_item) do
         config.debug = new_setting
-        Imap::Backup.setup_logging config
+        Imap::Backup::Logger.setup_logging(config)
       end
     end
 
     def config
-      @config ||= Configuration::Store.new
+      @config ||= Configuration.new
     end
 
     def default_account_config(username)
-      {
+      ::Imap::Backup::Account.new(
         username: username,
         password: "",
         local_path: File.join(config.path, username.tr("@", "_")),
         folders: []
-      }.tap do |c|
+      ).tap do |a|
         server = Email::Provider.for_address(username)
-        c[:server] = server.host if server.host
+        a.server = server.host if server.host
       end
     end
 
     def edit_account(username)
-      account = config.accounts.find { |a| a[:username] == username }
+      account = config.accounts.find { |a| a.username == username }
       if account.nil?
         account = default_account_config(username)
         config.accounts << account
       end
-      Configuration::Account.new(
-        config, account, Configuration::Setup.highline
-      ).run
+      Account.new(config, account, Setup.highline).run
+    end
+
+    def helpers
+      Helpers.new
     end
   end
 end

data/lib/imap/backup/uploader.rb

@@ -12,12 +12,12 @@ module Imap::Backup
       count = missing_uids.count
       return if count.zero?
 
-      Imap::Backup.logger.debug "[#{folder.name}] #{count} to restore"
+      Imap::Backup::Logger.logger.debug "[#{folder.name}] #{count} to restore"
       serializer.each_message(missing_uids).with_index do |(uid, message), i|
         next if message.nil?
 
         log_prefix = "[#{folder.name}] uid: #{uid} (#{i + 1}/#{count}) -"
-        Imap::Backup.logger.debug(
+        Imap::Backup::Logger.logger.debug(
           "#{log_prefix} #{message.supplied_body.size} bytes"
         )
 

data/lib/imap/backup/version.rb

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

data/lib/imap/backup.rb

@@ -3,46 +3,20 @@ module Imap; end
 require "imap/backup/utils"
 require "imap/backup/account/connection"
 require "imap/backup/account/folder"
-require "imap/backup/configuration/account"
-require "imap/backup/configuration/asker"
-require "imap/backup/configuration/connection_tester"
-require "imap/backup/configuration/folder_chooser"
-require "imap/backup/configuration/list"
-require "imap/backup/configuration/setup"
-require "imap/backup/configuration/store"
+require "imap/backup/configuration"
 require "imap/backup/downloader"
+require "imap/backup/logger"
 require "imap/backup/uploader"
 require "imap/backup/serializer"
 require "imap/backup/serializer/mbox"
+require "imap/backup/setup"
+require "imap/backup/setup/account"
+require "imap/backup/setup/asker"
+require "imap/backup/setup/connection_tester"
+require "imap/backup/setup/folder_chooser"
 require "imap/backup/version"
 require "email/provider"
 
-require "logger"
-
 module Imap::Backup
   class ConfigurationNotFound < StandardError; end
-
-  class Logger
-    include Singleton
-
-    attr_reader :logger
-
-    def initialize
-      @logger = ::Logger.new($stdout)
-      $stdout.sync = true
-    end
-  end
-
-  def self.logger
-    Logger.instance.logger
-  end
-
-  def self.setup_logging(config)
-    logger.level =
-      if config.debug?
-        ::Logger::Severity::DEBUG
-      else
-        ::Logger::Severity::ERROR
-      end
-  end
 end

data/lib/retry_on_error.rb

@@ -5,7 +5,7 @@ module RetryOnError
   rescue *errors => e
     if tries < limit
       message = "#{e}, attempt #{tries} of #{limit}"
-      Imap::Backup.logger.debug message
+      Imap::Backup::Logger.logger.debug message
       tries += 1
       retry
     end

data/spec/features/backup_spec.rb

@@ -58,6 +58,7 @@ RSpec.describe "backup", type: :feature, docker: true do
         email3
         original_folder_uid_validity
         connection.run_backup
+        connection.disconnect
         server_rename_folder folder, new_name
       end
       let(:renamed_folder) { "#{folder}.#{original_folder_uid_validity}" }

data/spec/features/support/email_server.rb

@@ -63,11 +63,14 @@ module EmailServerHelpers
   end
 
   def server_folders
-    root_info = imap.list("", "")[0]
-    root = root_info.name
     imap.list(root, "*")
   end
 
+  def root
+    root_info = imap.list("", "")[0]
+    root_info.name
+  end
+
   def server_create_folder(folder)
     imap.create(folder)
     imap.disconnect

data/spec/features/support/shared/connection_context.rb

@@ -2,11 +2,13 @@ shared_context "imap-backup connection" do
   let(:local_backup_path) { Dir.mktmpdir(nil, "tmp") }
   let(:default_connection) { fixture("connection") }
   let(:backup_folders) { nil }
-  let(:connection_options) do
-    default_connection.merge(
-      local_path: local_backup_path,
-      folders: backup_folders
+  let(:account) do
+    Imap::Backup::Account.new(
+      default_connection.merge(
+        local_path: local_backup_path,
+        folders: backup_folders
+      )
     )
   end
-  let(:connection) { Imap::Backup::Account::Connection.new(connection_options) }
+  let(:connection) { Imap::Backup::Account::Connection.new(account) }
 end

data/spec/support/higline_test_helpers.rb

@@ -2,7 +2,7 @@ module HighLineTestHelpers
   def prepare_highline
     @input = instance_double(IO, eof?: false, gets: "q\n")
     @output = StringIO.new
-    Imap::Backup::Configuration::Setup.highline = HighLine.new(@input, @output)
+    Imap::Backup::Setup.highline = HighLine.new(@input, @output)
     [@input, @output]
   end
 end

data/spec/support/silence_logging.rb

@@ -1,7 +1,7 @@
 def silence_logging
   RSpec.configure do |config|
     config.before(:suite) do
-      Imap::Backup.logger.level = Logger::UNKNOWN
+      Imap::Backup::Logger.logger.level = Logger::UNKNOWN
     end
   end
 end

data/spec/unit/email/provider/{default_spec.rb → base_spec.rb}

@@ -1,10 +1,4 @@
-describe Email::Provider::Default do
-  describe "#host" do
-    it "is unset" do
-      expect(subject.host).to be_nil
-    end
-  end
-
+describe Email::Provider::Base do
   describe "#options" do
     it "returns options" do
       expect(subject.options).to be_a(Hash)

data/spec/unit/email/provider_spec.rb

@@ -17,10 +17,10 @@ describe Email::Provider do
     end
 
     context "with unknown providers" do
-      it "returns a default provider" do
+      it "returns the Unknown provider" do
         result = described_class.for_address("foo@unknown.com")
 
-        expect(result).to be_a(Email::Provider::Default)
+        expect(result).to be_a(Email::Provider::Unknown)
       end
     end
   end

data/spec/unit/imap/backup/account/connection_spec.rb

@@ -5,6 +5,7 @@ describe Imap::Backup::Account::Connection do
   FOLDER_CONFIG = {name: BACKUP_FOLDER}.freeze
   FOLDER_NAME = "my_folder".freeze
   GMAIL_IMAP_SERVER = "imap.gmail.com".freeze
+  IMAP_FOLDER = "imap_folder".freeze
   LOCAL_PATH = "local_path".freeze
   LOCAL_UID = "local_uid".freeze
   PASSWORD = "secret".freeze
@@ -12,7 +13,7 @@ describe Imap::Backup::Account::Connection do
   SERVER = "imap.example.com".freeze
   USERNAME = "username@example.com".freeze
 
-  subject { described_class.new(options) }
+  subject { described_class.new(account) }
 
   let(:client) do
     instance_double(
@@ -20,14 +21,16 @@ describe Imap::Backup::Account::Connection do
     )
   end
   let(:imap_folders) { [] }
-  let(:options) do
-    {
+  let(:account) do
+    instance_double(
+      Imap::Backup::Account,
       username: USERNAME,
       password: PASSWORD,
       local_path: LOCAL_PATH,
       folders: config_folders,
-      server: server
-    }
+      server: server,
+      connection_options: nil
+    )
   end
   let(:config_folders) { [FOLDER_CONFIG] }
   let(:root_info) do
@@ -59,21 +62,10 @@ describe Imap::Backup::Account::Connection do
   end
 
   describe "#initialize" do
-    [
-      [:username, USERNAME],
-      [:password, PASSWORD],
-      [:local_path, LOCAL_PATH],
-      [:server, SERVER]
-    ].each do |attr, expected|
-      it "expects #{attr}" do
-        expect(subject.public_send(attr)).to eq(expected)
-      end
-    end
-
     it "creates the path" do
       expect(Imap::Backup::Utils).to receive(:make_folder)
 
-      subject.username
+      subject
     end
   end
 
@@ -110,19 +102,23 @@ describe Imap::Backup::Account::Connection do
     end
   end
 
-  describe "#folders" do
+  describe "#folder_names" do
     let(:imap_folders) do
-      [BACKUP_FOLDER]
+      [IMAP_FOLDER]
     end
 
     it "returns the list of folders" do
-      expect(subject.folders).to eq([BACKUP_FOLDER])
+      expect(subject.folder_names).to eq([IMAP_FOLDER])
     end
   end
 
   describe "#status" do
     let(:folder) do
-      instance_double(Imap::Backup::Account::Folder, uids: [remote_uid])
+      instance_double(
+        Imap::Backup::Account::Folder,
+        uids: [remote_uid],
+        name: IMAP_FOLDER
+      )
     end
     let(:remote_uid) { "remote_uid" }
 
@@ -132,7 +128,7 @@ describe Imap::Backup::Account::Connection do
     end
 
     it "returns the names of folders" do
-      expect(subject.status[0][:name]).to eq(BACKUP_FOLDER)
+      expect(subject.status[0][:name]).to eq(IMAP_FOLDER)
     end
 
     it "returns local message uids" do
@@ -148,7 +144,7 @@ describe Imap::Backup::Account::Connection do
     let(:folder) do
       instance_double(
         Imap::Backup::Account::Folder,
-        name: "folder",
+        name: IMAP_FOLDER,
         exist?: exists,
         uid_validity: uid_validity
       )
@@ -159,11 +155,11 @@ describe Imap::Backup::Account::Connection do
 
     before do
       allow(Imap::Backup::Downloader).
-        to receive(:new).with(folder, serializer) { downloader }
+        to receive(:new).with(folder, serializer, anything) { downloader }
       allow(Imap::Backup::Account::Folder).to receive(:new).
         with(subject, BACKUP_FOLDER) { folder }
       allow(Imap::Backup::Serializer::Mbox).to receive(:new).
-        with(LOCAL_PATH, BACKUP_FOLDER) { serializer }
+        with(LOCAL_PATH, IMAP_FOLDER) { serializer }
     end
 
     context "with supplied config_folders" do
@@ -257,7 +253,7 @@ describe Imap::Backup::Account::Connection do
         Imap::Backup::Account::Folder,
         create: nil,
         uids: uids,
-        name: FOLDER_NAME,
+        name: IMAP_FOLDER,
         uid_validity: uid_validity
       )
     end

data/spec/unit/imap/backup/cli/accounts_spec.rb

@@ -0,0 +1,47 @@
+require "imap/backup/cli/accounts"
+
+describe Imap::Backup::CLI::Accounts do
+  subject { described_class.new }
+
+  let(:accounts) { [account1, account2] }
+  let(:account1) do
+    instance_double(
+      Imap::Backup::Account,
+      username: "a1@example.com"
+    )
+  end
+  let(:account2) do
+    instance_double(
+      Imap::Backup::Account,
+      username: "a2@example.com"
+    )
+  end
+  let(:store) do
+    instance_double(Imap::Backup::Configuration, accounts: accounts)
+  end
+  let(:exists) { true }
+
+  before do
+    allow(Imap::Backup::Configuration).to receive(:new) { store }
+    allow(Imap::Backup::Configuration).
+      to receive(:exist?) { exists }
+  end
+
+  describe "#each" do
+    specify "calls the block with each account" do
+      result = subject.map { |a| a }
+
+      expect(result).to eq(accounts)
+    end
+
+    context "when the configuration file is missing" do
+      let(:exists) { false }
+
+      it "fails" do
+        expect do
+          subject.each {}
+        end.to raise_error(Imap::Backup::ConfigurationNotFound, /not found/)
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/cli/local_spec.rb

@@ -1,8 +1,18 @@
 describe Imap::Backup::CLI::Local do
-  let(:list) do
-    instance_double(Imap::Backup::Configuration::List, accounts: accounts)
+  let(:accounts) do
+    instance_double(
+      Imap::Backup::CLI::Accounts,
+      find: ->(&block) { [account].find { |a| block.call(a) } }
+    )
+  end
+  let(:account) do
+    instance_double(
+      Imap::Backup::Account,
+      username: email,
+      marked_for_deletion?: false,
+      modified?: false
+    )
   end
-  let(:accounts) { [{username: email}] }
   let(:connection) do
     instance_double(
       Imap::Backup::Account::Connection,
@@ -31,9 +41,10 @@ describe Imap::Backup::CLI::Local do
 
   before do
     allow(Kernel).to receive(:puts)
-    allow(Imap::Backup::Configuration::List).to receive(:new) { list }
+    allow(Imap::Backup::CLI::Accounts).to receive(:new) { accounts }
     allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
     allow(Mail).to receive(:new) { mail }
+    allow(accounts).to receive(:each).and_yield(account)
   end
 
   describe "accounts" do

data/spec/unit/imap/backup/cli/utils_spec.rb

@@ -1,50 +1,62 @@
-describe Imap::Backup::CLI::Utils do
-  let(:list) do
-    instance_double(Imap::Backup::Configuration::List, accounts: accounts)
-  end
-  let(:accounts) { [{username: email}] }
-  let(:connection) do
-    instance_double(
-      Imap::Backup::Account::Connection,
-      local_folders: local_folders
-    )
-  end
-  let(:local_folders) { [[serializer, folder]] }
-  let(:folder) do
-    instance_double(
-      Imap::Backup::Account::Folder,
-      exist?: true,
-      name: "name",
-      uid_validity: "uid_validity",
-      uids: %w(123 456)
-    )
-  end
-  let(:serializer) do
-    instance_double(
-      Imap::Backup::Serializer::Mbox,
-      uids: %w(123 789),
-      apply_uid_validity: nil,
-      save: nil
-    )
-  end
-  let(:email) { "foo@example.com" }
+module Imap::Backup
+  describe CLI::Utils do
+    let(:accounts) do
+      instance_double(
+        CLI::Accounts,
+        find: ->(&block) { [account].find { |a| block.call(a) } }
+      )
+    end
+    let(:account) { instance_double(Account, username: email) }
+    let(:connection) do
+      instance_double(
+        Account::Connection,
+        account: account,
+        backup_folders: [folder]
+      )
+    end
+    let(:account) do
+      instance_double(
+        Account,
+        local_path: "path"
+      )
+    end
+    let(:folder) do
+      instance_double(
+        Account::Folder,
+        exist?: true,
+        name: "name",
+        uid_validity: "uid_validity",
+        uids: %w(123 456)
+      )
+    end
+    let(:serializer) do
+      instance_double(
+        Serializer::Mbox,
+        uids: %w(123 789),
+        apply_uid_validity: nil,
+        save: nil
+      )
+    end
+    let(:email) { "foo@example.com" }
 
-  before do
-    allow(Imap::Backup::Configuration::List).to receive(:new) { list }
-    allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
-  end
+    before do
+      allow(CLI::Accounts).to receive(:new) { accounts }
+      allow(Account::Connection).to receive(:new) { connection }
+      allow(Serializer::Mbox).to receive(:new) { serializer }
+    end
 
-  describe "ignore_history" do
-    it "ensures the local UID validity matches the server" do
-      subject.ignore_history(email)
+    describe "ignore_history" do
+      it "ensures the local UID validity matches the server" do
+        subject.ignore_history(email)
 
-      expect(serializer).to have_received(:apply_uid_validity).with("uid_validity")
-    end
+        expect(serializer).to have_received(:apply_uid_validity).with("uid_validity")
+      end
 
-    it "fills the local folder with fake emails" do
-      subject.ignore_history(email)
+      it "fills the local folder with fake emails" do
+        subject.ignore_history(email)
 
-      expect(serializer).to have_received(:save).with("456", /From: fake@email.com/)
+        expect(serializer).to have_received(:save).with("456", /From: fake@email.com/)
+      end
     end
   end
 end