imap-backup 4.0.3 → 4.0.7

data/lib/imap/backup/configuration/store.rb

@@ -1,11 +1,14 @@
 require "json"
 require "os"
 
+require "imap/backup/account"
+
 module Imap::Backup
   module Configuration; end
 
   class Configuration::Store
     CONFIGURATION_DIRECTORY = File.expand_path("~/.imap-backup")
+    VERSION = "2.0"
 
     attr_reader :pathname
 
@@ -19,6 +22,7 @@ module Imap::Backup
 
     def initialize(pathname = self.class.default_pathname)
       @pathname = pathname
+      @debug = nil
     end
 
     def path
@@ -26,53 +30,71 @@ module Imap::Backup
     end
 
     def save
+      ensure_loaded!
       FileUtils.mkdir(path) if !File.directory?(path)
       make_private(path) if !windows?
       remove_modified_flags
       remove_deleted_accounts
-      File.open(pathname, "w") { |f| f.write(JSON.pretty_generate(data)) }
+      save_data = {
+        version: VERSION,
+        accounts: accounts.map(&:to_h),
+        debug: debug?
+      }
+      File.open(pathname, "w") { |f| f.write(JSON.pretty_generate(save_data)) }
       FileUtils.chmod(0o600, pathname) if !windows?
     end
 
     def accounts
-      data[:accounts]
+      @accounts ||= begin
+        ensure_loaded!
+        data[:accounts].map { |data| Account.new(data) }
+      end
     end
 
     def modified?
-      accounts.any? { |a| a[:modified] || a[:delete] }
+      ensure_loaded!
+      accounts.any? { |a| a.modified? || a.marked_for_deletion? }
     end
 
     def debug?
-      data[:debug]
+      ensure_loaded!
+      @debug
     end
 
     def debug=(value)
-      data[:debug] = [true, false].include?(value) ? value : false
+      ensure_loaded!
+      @debug = [true, false].include?(value) ? value : false
     end
 
     private
 
+    def ensure_loaded!
+      return true if @data
+
+      data
+      @debug = data.key?(:debug) ? data[:debug] == true : false
+      true
+    end
+
     def data
       @data ||=
         begin
           if File.exist?(pathname)
             Utils.check_permissions(pathname, 0o600) if !windows?
             contents = File.read(pathname)
-            data = JSON.parse(contents, symbolize_names: true)
+            JSON.parse(contents, symbolize_names: true)
           else
-            data = {accounts: []}
+            {accounts: []}
           end
-          data[:debug] = data.key?(:debug) ? data[:debug] == true : false
-          data
         end
     end
 
     def remove_modified_flags
-      accounts.each { |a| a.delete(:modified) }
+      accounts.each { |a| a.clear_changes! }
     end
 
     def remove_deleted_accounts
-      accounts.reject! { |a| a[:delete] }
+      accounts.reject! { |a| a.marked_for_deletion? }
     end
 
     def make_private(path)

data/lib/imap/backup/version.rb

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

data/lib/imap/backup.rb

@@ -29,6 +29,7 @@ module Imap::Backup
 
     def initialize
       @logger = ::Logger.new($stdout)
+      $stdout.sync = true
     end
   end
 

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

@@ -12,7 +12,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 +20,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 +61,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
 

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

@@ -1,8 +1,15 @@
 describe Imap::Backup::CLI::Local do
   let(:list) do
-    instance_double(Imap::Backup::Configuration::List, accounts: accounts)
+    instance_double(Imap::Backup::Configuration::List, accounts: [account])
+  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,

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

@@ -1,50 +1,52 @@
-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(:list) do
+      instance_double(Configuration::List, accounts: [account])
+    end
+    let(:account) { instance_double(Account, username: email) }
+    let(:connection) do
+      instance_double(
+        Account::Connection,
+        local_folders: local_folders
+      )
+    end
+    let(:local_folders) { [[serializer, folder]] }
+    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(Configuration::List).to receive(:new) { list }
+      allow(Account::Connection).to receive(:new) { connection }
+    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

data/spec/unit/imap/backup/configuration/account_spec.rb

@@ -6,7 +6,32 @@ describe Imap::Backup::Configuration::Account do
 
   subject { described_class.new(store, account, highline) }
 
-  let(:account) { ACCOUNT }
+  let(:account) do
+    instance_double(
+      Imap::Backup::Account,
+      username: existing_email,
+      password: existing_password,
+      server: current_server,
+      connection_options: nil,
+      local_path: "/backup/path",
+      folders: [{name: "my_folder"}]
+    )
+  end
+  let(:account1) do
+    instance_double(
+      Imap::Backup::Account,
+      username: other_email,
+      local_path: other_existing_path
+    )
+  end
+  let(:accounts) { [account, account1] }
+  let(:existing_email) { "user@example.com" }
+  let(:new_email) { "foo@example.com" }
+  let(:current_server) { "imap.example.com" }
+  let(:existing_password) { "password" }
+  let(:other_email) { "other@example.com" }
+  let(:other_existing_path) { "/other/existing/path" }
+
   let(:highline) { HIGHLINE }
   let(:store) { STORE }
 
@@ -43,28 +68,6 @@ describe Imap::Backup::Configuration::Account do
     let(:store) do
       instance_double(Imap::Backup::Configuration::Store, accounts: accounts)
     end
-    let(:accounts) { [account, account1] }
-    let(:account) do
-      {
-        username: existing_email,
-        server: current_server,
-        local_path: "/backup/path",
-        folders: [{name: "my_folder"}],
-        password: existing_password
-      }
-    end
-    let(:account1) do
-      {
-        username: other_email,
-        local_path: other_existing_path
-      }
-    end
-    let(:existing_email) { "user@example.com" }
-    let(:new_email) { "foo@example.com" }
-    let(:current_server) { "imap.example.com" }
-    let(:existing_password) { "password" }
-    let(:other_email) { "other@example.com" }
-    let(:other_existing_path) { "/other/existing/path" }
 
     before do
       allow(Kernel).to receive(:system)
@@ -139,6 +142,8 @@ describe Imap::Backup::Configuration::Account do
 
     describe "choosing 'modify email'" do
       before do
+        allow(account).to receive(:"username=")
+        allow(account).to receive(:"server=")
         allow(Imap::Backup::Configuration::Asker).
           to receive(:email) { new_email }
         subject.run
@@ -158,7 +163,7 @@ describe Imap::Backup::Configuration::Account do
               let(:current_server) { nil }
 
               it "sets a default server" do
-                expect(account[:server]).to eq(expected)
+                expect(account).to have_received(:"server=").with(expected)
               end
             end
 
@@ -166,7 +171,7 @@ describe Imap::Backup::Configuration::Account do
               let(:current_server) { "" }
 
               it "sets a default server" do
-                expect(account[:server]).to eq(expected)
+                expect(account).to have_received(:"server=").with(expected)
               end
             end
           end
@@ -183,17 +188,15 @@ describe Imap::Backup::Configuration::Account do
           end
 
           it "does not set a default server" do
-            expect(account[:server]).to be_nil
+            expect(account).to_not have_received(:"server=")
           end
         end
       end
 
       context "when the email is new" do
         it "modifies the email address" do
-          expect(account[:username]).to eq(new_email)
+          expect(account).to have_received(:"username=").with(new_email)
         end
-
-        include_examples "it flags the account as modified"
       end
 
       context "when the email already exists" do
@@ -205,10 +208,8 @@ describe Imap::Backup::Configuration::Account do
         end
 
         it "doesn't set the email" do
-          expect(account[:username]).to eq(existing_email)
+          expect(account.username).to eq(existing_email)
         end
-
-        include_examples "it doesn't flag the account as modified"
       end
     end
 
@@ -216,6 +217,7 @@ describe Imap::Backup::Configuration::Account do
       let(:new_password) { "new_password" }
 
       before do
+        allow(account).to receive(:"password=")
         allow(Imap::Backup::Configuration::Asker).
           to receive(:password) { new_password }
         subject.run
@@ -224,20 +226,16 @@ describe Imap::Backup::Configuration::Account do
 
       context "when the user enters a password" do
         it "updates the password" do
-          expect(account[:password]).to eq(new_password)
+          expect(account).to have_received(:"password=").with(new_password)
         end
-
-        include_examples "it flags the account as modified"
       end
 
       context "when the user cancels" do
         let(:new_password) { nil }
 
         it "does nothing" do
-          expect(account[:password]).to eq(existing_password)
+          expect(account.password).to eq(existing_password)
         end
-
-        include_examples "it doesn't flag the account as modified"
       end
     end
 
@@ -245,6 +243,7 @@ describe Imap::Backup::Configuration::Account do
       let(:server) { "server" }
 
       before do
+        allow(account).to receive(:"server=")
         allow(highline).to receive(:ask).with("server: ") { server }
 
         subject.run
@@ -253,16 +252,15 @@ describe Imap::Backup::Configuration::Account do
       end
 
       it "updates the server" do
-        expect(account[:server]).to eq(server)
+        expect(account).to have_received(:"server=").with(server)
       end
-
-      include_examples "it flags the account as modified"
     end
 
     describe "choosing 'modify backup path'" do
       let(:new_backup_path) { "/new/path" }
 
       before do
+        allow(account).to receive(:"local_path=")
         @validator = nil
         allow(
           Imap::Backup::Configuration::Asker
@@ -275,7 +273,7 @@ describe Imap::Backup::Configuration::Account do
       end
 
       it "updates the path" do
-        expect(account[:local_path]).to eq(new_backup_path)
+        expect(account).to have_received(:"local_path=").with(new_backup_path)
       end
 
       context "when the path is not used by other backups" do
@@ -293,8 +291,6 @@ describe Imap::Backup::Configuration::Account do
           # rubocop:enable RSpec/InstanceVariable
         end
       end
-
-      include_examples "it flags the account as modified"
     end
 
     describe "choosing 'choose backup folders'" do
@@ -333,6 +329,7 @@ describe Imap::Backup::Configuration::Account do
       let(:confirmed) { true }
 
       before do
+        allow(account).to receive(:mark_for_deletion!)
         allow(highline).to receive(:agree) { confirmed }
         subject.run
         catch :done do
@@ -345,13 +342,17 @@ describe Imap::Backup::Configuration::Account do
       end
 
       context "when the user confirms deletion" do
-        include_examples "it flags the account to be deleted"
+        it "flags the account to be deleted" do
+          expect(account).to have_received(:mark_for_deletion!)
+        end
       end
 
       context "without confirmation" do
         let(:confirmed) { false }
 
-        include_examples "it doesn't flag the account to be deleted"
+        it "doesn't flag the account to be deleted" do
+          expect(account).to_not have_received(:mark_for_deletion!)
+        end
       end
     end
   end

data/spec/unit/imap/backup/configuration/folder_chooser_spec.rb

@@ -9,7 +9,14 @@ describe Imap::Backup::Configuration::FolderChooser do
         Imap::Backup::Account::Connection, folders: connection_folders
       )
     end
-    let(:account) { {folders: []} }
+    let(:account) do
+      instance_double(
+        Imap::Backup::Account,
+        folders: account_folders,
+        "folders=": nil
+      )
+    end
+    let(:account_folders) { [] }
     let(:connection_folders) { [] }
     let!(:highline_streams) { prepare_highline }
     let(:input) { highline_streams[0] }
@@ -36,7 +43,7 @@ describe Imap::Backup::Configuration::FolderChooser do
     end
 
     describe "folder listing" do
-      let(:account) { {folders: [{name: "my_folder"}]} }
+      let(:account_folders) { [{name: "my_folder"}]}
       let(:connection_folders) do
         # N.B. my_folder is already backed up
         %w(my_folder another_folder)
@@ -62,10 +69,9 @@ describe Imap::Backup::Configuration::FolderChooser do
         end
 
         specify "are added to the account" do
-          expect(account[:folders]).to include(name: "another_folder")
+          expect(account).to have_received(:"folders=").
+            with([{name: "my_folder"}, {name: "another_folder"}])
         end
-
-        include_examples "it flags the account as modified"
       end
 
       context "when removing folders" do
@@ -76,22 +82,16 @@ describe Imap::Backup::Configuration::FolderChooser do
         end
 
         specify "are removed from the account" do
-          expect(account[:folders]).to_not include(name: "my_folder")
+          expect(account).to have_received(:"folders=").with([])
         end
-
-        include_examples "it flags the account as modified"
       end
     end
 
     context "with missing remote folders" do
-      let(:account) do
-        {folders: [{name: "on_server"}, {name: "not_on_server"}]}
-      end
-      let(:connection_folders) do
-        [
-          instance_double(Imap::Backup::Account::Folder, name: "on_server")
-        ]
+      let(:account_folders) do
+        [{name: "on_server"}, {name: "not_on_server"}]
       end
+      let(:connection_folders) { ["on_server"] }
 
       before do
         allow(Kernel).to receive(:puts)
@@ -99,10 +99,9 @@ describe Imap::Backup::Configuration::FolderChooser do
       end
 
       specify "are removed from the account" do
-        expect(account[:folders]).to_not include(name: "not_on_server")
+        expect(account).to have_received(:"folders=").
+          with([{name: "on_server"}])
       end
-
-      include_examples "it flags the account as modified"
     end
 
     context "when folders are not available" do

data/spec/unit/imap/backup/configuration/list_spec.rb

@@ -1,11 +1,18 @@
 describe Imap::Backup::Configuration::List do
   subject { described_class.new }
 
-  let(:accounts) do
-    [
-      {username: "a1@example.com"},
-      {username: "a2@example.com"}
-    ]
+  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::Store, accounts: accounts)