imap-backup 6.0.0.rc2 → 6.1.0

data/lib/imap/backup/serializer/mbox.rb

@@ -6,14 +6,20 @@ module Imap::Backup
       @folder_path = folder_path
     end
 
+    def valid?
+      exist?
+    end
+
     def append(message)
       File.open(pathname, "ab") do |file|
         file.write message
       end
     end
 
-    def exist?
-      File.exist?(pathname)
+    def delete
+      return if !exist?
+
+      File.unlink(pathname)
     end
 
     def length
@@ -41,5 +47,15 @@ module Imap::Backup
         f.truncate(length)
       end
     end
+
+    def touch
+      File.open(pathname, "a") {}
+    end
+
+    private
+
+    def exist?
+      File.exist?(pathname)
+    end
   end
 end

data/lib/imap/backup/serializer/message_enumerator.rb

@@ -0,0 +1,29 @@
+require "email/mboxrd/message"
+require "imap/backup/serializer/mbox_enumerator"
+
+module Imap::Backup
+  class Serializer::MessageEnumerator
+    attr_reader :imap
+    attr_reader :mbox
+
+    def initialize(imap:, mbox:)
+      @imap = imap
+      @mbox = mbox
+    end
+
+    def run(uids:)
+      indexes = uids.each.with_object({}) do |uid_maybe_string, acc|
+        uid = uid_maybe_string.to_i
+        index = imap.index(uid)
+        acc[index] = uid if index
+      end
+      enumerator = Serializer::MboxEnumerator.new(mbox.pathname)
+      enumerator.each.with_index do |raw, i|
+        uid = indexes[i]
+        next if !uid
+
+        yield uid, Email::Mboxrd::Message.from_serialized(raw)
+      end
+    end
+  end
+end

data/lib/imap/backup/serializer/unused_name_finder.rb

@@ -0,0 +1,25 @@
+module Imap::Backup
+  class Serializer::UnusedNameFinder
+    attr_reader :serializer
+
+    def initialize(serializer:)
+      @serializer = serializer
+    end
+
+    def run
+      digit = 0
+      folder = nil
+
+      loop do
+        extra = digit.zero? ? "" : "-#{digit}"
+        folder = "#{serializer.folder}-#{serializer.uid_validity}#{extra}"
+        test = Serializer.new(serializer.path, folder)
+        break if !test.validate!
+
+        digit += 1
+      end
+
+      folder
+    end
+  end
+end

data/lib/imap/backup/serializer.rb

@@ -1,12 +1,20 @@
 require "forwardable"
 
 require "email/mboxrd/message"
+require "imap/backup/serializer/appender"
 require "imap/backup/serializer/imap"
 require "imap/backup/serializer/mbox"
 require "imap/backup/serializer/mbox_enumerator"
+require "imap/backup/serializer/message_enumerator"
+require "imap/backup/serializer/unused_name_finder"
 
 module Imap::Backup
   class Serializer
+    def self.folder_path_for(path:, folder:)
+      relative = File.join(path, folder)
+      File.expand_path(relative)
+    end
+
     extend Forwardable
 
     def_delegator :mbox, :pathname, :mbox_pathname
@@ -20,10 +28,25 @@ module Imap::Backup
       @folder = folder
     end
 
+    # Returns true if there are existing, valid files
+    # false otherwise (in which case any existing files are deleted)
+    def validate!
+      return true if imap.valid? && mbox.valid?
+
+      imap.delete
+      @imap = nil
+      mbox.delete
+      @mbox = nil
+
+      false
+    end
+
     def apply_uid_validity(value)
+      validate!
+
       case
       when uid_validity.nil?
-        imap.uid_validity = value
+        internal_force_uid_validity(value)
         nil
       when uid_validity == value
         # NOOP
@@ -34,94 +57,71 @@ module Imap::Backup
     end
 
     def force_uid_validity(value)
-      imap.uid_validity = value
+      validate!
+
+      internal_force_uid_validity(value)
     end
 
     def append(uid, message)
-      raise "Can't add messages without uid_validity" if !imap.uid_validity
-
-      uid = uid.to_i
-      if imap.include?(uid)
-        Logger.logger.debug(
-          "[#{folder}] message #{uid} already downloaded - skipping"
-        )
-        return
-      end
+      validate!
 
-      do_append uid, message
+      appender = Serializer::Appender.new(folder: folder, imap: imap, mbox: mbox)
+      appender.run(uid: uid, message: message)
     end
 
     def load(uid_maybe_string)
+      validate!
+
       uid = uid_maybe_string.to_i
       message_index = imap.index(uid)
       return nil if message_index.nil?
 
-      load_nth(message_index)
+      internal_load_nth(message_index)
     end
 
     def load_nth(index)
-      enumerator = Serializer::MboxEnumerator.new(mbox.pathname)
-      enumerator.each.with_index do |raw, i|
-        next if i != index
+      validate!
 
-        return Email::Mboxrd::Message.from_serialized(raw)
-      end
-      nil
+      internal_load_nth(index)
     end
 
-    def each_message(required_uids)
-      return enum_for(:each_message, required_uids) if !block_given?
+    def each_message(required_uids, &block)
+      validate!
 
-      indexes = required_uids.each.with_object({}) do |uid_maybe_string, acc|
-        uid = uid_maybe_string.to_i
-        index = imap.index(uid)
-        acc[index] = uid if index
-      end
-      enumerator = Serializer::MboxEnumerator.new(mbox.pathname)
-      enumerator.each.with_index do |raw, i|
-        uid = indexes[i]
-        next if !uid
+      return enum_for(:each_message, required_uids) if !block
 
-        yield uid, Email::Mboxrd::Message.from_serialized(raw)
-      end
+      enumerator = Serializer::MessageEnumerator.new(imap: imap, mbox: mbox)
+      enumerator.run(uids: required_uids, &block)
     end
 
+    private
+
     def rename(new_name)
-      # Initialize so we get memoized instances with the correct folder_path
-      mbox
-      imap
-      @folder = new_name
-      ensure_containing_directory
-      mbox.rename folder_path
-      imap.rename folder_path
+      destination = self.class.folder_path_for(path: path, folder: new_name)
+      ensure_containing_directory(new_name)
+      mbox.rename destination
+      imap.rename destination
     end
 
-    private
+    def internal_force_uid_validity(value)
+      imap.uid_validity = value
+      mbox.touch
+    end
+
+    def internal_load_nth(index)
+      enumerator = Serializer::MboxEnumerator.new(mbox.pathname)
+      enumerator.each.with_index do |raw, i|
+        next if i != index
 
-    def do_append(uid, message)
-      mboxrd_message = Email::Mboxrd::Message.new(message)
-      initial = mbox.length || 0
-      mbox_appended = false
-      begin
-        mbox.append mboxrd_message.to_serialized
-        mbox_appended = true
-        imap.append uid
-      rescue StandardError => e
-        mbox.rewind(initial) if mbox_appended
-
-        message = <<-ERROR.gsub(/^\s*/m, "")
-          [#{folder}] failed to append message #{uid}:
-          #{message}. #{e}:
-          #{e.backtrace.join("\n")}"
-        ERROR
-        Logger.logger.warn message
+        return Email::Mboxrd::Message.from_serialized(raw)
       end
+      nil
     end
 
     def mbox
       @mbox ||=
         begin
-          ensure_containing_directory
+          ensure_containing_directory(folder)
           Serializer::Mbox.new(folder_path)
         end
     end
@@ -129,21 +129,16 @@ module Imap::Backup
     def imap
       @imap ||=
         begin
-          ensure_containing_directory
+          ensure_containing_directory(folder)
           Serializer::Imap.new(folder_path)
         end
     end
 
     def folder_path
-      folder_path_for(path, folder)
+      self.class.folder_path_for(path: path, folder: folder)
     end
 
-    def folder_path_for(path, folder)
-      relative = File.join(path, folder)
-      File.expand_path(relative)
-    end
-
-    def ensure_containing_directory
+    def ensure_containing_directory(folder)
       relative = File.dirname(folder)
       directory = Serializer::Directory.new(path, relative)
       directory.ensure_exists
@@ -154,29 +149,14 @@ module Imap::Backup
       # Clear memoization so we get empty data
       @mbox = nil
       @imap = nil
-      imap.uid_validity = value
+      internal_force_uid_validity(value)
 
       new_name
     end
 
     def rename_existing_folder
-      digit = 0
-      new_name = nil
-      loop do
-        extra = digit.zero? ? "" : "-#{digit}"
-        new_name = "#{folder}-#{imap.uid_validity}#{extra}"
-        new_folder_path = folder_path_for(path, new_name)
-        test_mbox = Serializer::Mbox.new(new_folder_path)
-        test_imap = Serializer::Imap.new(new_folder_path)
-        break if !test_mbox.exist? && !test_imap.exist?
-
-        digit += 1
-      end
-
-      previous = folder
-      rename(new_name)
-      @folder = previous
-
+      new_name = Serializer::UnusedNameFinder.new(serializer: self).run
+      rename new_name
       new_name
     end
   end

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

@@ -0,0 +1,81 @@
+require "imap/backup/setup/helpers"
+
+module Imap::Backup
+  class Setup; end
+  class Setup::Account; end
+
+  class Setup::Account::Header
+    attr_reader :account
+    attr_reader :menu
+
+    def initialize(menu:, account:)
+      @menu = menu
+      @account = account
+    end
+
+    def run
+      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(', ')}#{multi_fetch_size}
+        server  #{space}#{account.server}#{connection_options}#{reset_seen_flags_after_fetch}
+
+        Choose an action
+      HEADER
+    end
+
+    private
+
+    def folders
+      account.folders || []
+    end
+
+    def helpers
+      Setup::Helpers.new
+    end
+
+    def modified_flag
+      account.modified? ? "*" : ""
+    end
+
+    def multi_fetch_size
+      "\nmulti-fetch #{account.multi_fetch_size}" if account.multi_fetch_size > 1
+    end
+
+    def connection_options
+      return nil if !account.connection_options
+
+      escaped = JSON.generate(account.connection_options)
+      escaped.gsub!('"', '\"')
+      "\nconnection 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"
+    end
+
+    def space
+      account.connection_options ? " " * 12 : " " * 4
+    end
+
+    def masked_password
+      if (account.password == "") || account.password.nil?
+        "(unset)"
+      else
+        account.password.gsub(/./, "x")
+      end
+    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("\\", "\\\\\\\\")
+    end
+  end
+end

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

@@ -1,11 +1,19 @@
-require "imap/backup/setup/helpers"
+require "imap/backup/setup/account/header"
+require "imap/backup/setup/backup_path"
+require "imap/backup/setup/email"
 
 module Imap::Backup
   class Setup; end
 
-  Setup::Account = Struct.new(:config, :account, :highline) do
+  class Setup::Account
+    attr_reader :account
+    attr_reader :config
+    attr_reader :highline
+
     def initialize(config, account, highline)
-      super
+      @account = account
+      @config = config
+      @highline = highline
     end
 
     def run
@@ -29,6 +37,7 @@ module Imap::Backup
         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 }
@@ -37,54 +46,12 @@ module Imap::Backup
     end
 
     def header(menu)
-      modified = account.modified? ? "*" : ""
-
-      if account.multi_fetch_size > 1
-        multi_fetch_size = "\nmulti-fetch #{account.multi_fetch_size}"
-      end
-
-      if account.connection_options
-        escaped =
-          JSON.generate(account.connection_options)
-        connection_options =
-          "\nconnection options  '#{escaped}'"
-        space = " " * 12
-      else
-        connection_options = nil
-        space = " " * 4
-      end
-
-      menu.header = <<~HEADER.chomp
-        #{helpers.title_prefix} Account#{modified}
-
-        email   #{space}#{account.username}
-        password#{space}#{masked_password}
-        path    #{space}#{account.local_path}
-        folders #{space}#{folders.map { |f| f[:name] }.join(', ')}#{multi_fetch_size}
-        server  #{space}#{account.server}#{connection_options}
-
-        Choose an action
-      HEADER
+      Setup::Account::Header.new(menu: menu, account: account).run
     end
 
     def modify_email(menu)
       menu.choice("modify email") do
-        username = Setup::Asker.email(username)
-        Kernel.puts "username: #{username}"
-        other_accounts = config.accounts.reject { |a| a == account }
-        others = other_accounts.map { |a| a.username }
-        Kernel.puts "others: #{others.inspect}"
-        if others.include?(username)
-          Kernel.puts(
-            "There is already an account set up with that email address"
-          )
-        else
-          account.username = username
-          default = default_server(username)
-          if default && (account.server.nil? || (account.server == ""))
-            account.server = default
-          end
-        end
+        Setup::Email.new(account: account, config: config).run
       end
     end
 
@@ -96,25 +63,9 @@ module Imap::Backup
       end
     end
 
-    def path_modification_validator(path)
-      same = config.accounts.find do |a|
-        a.username != account.username && a.local_path == path
-      end
-      if same
-        Kernel.puts "The path '#{path}' is used to backup " \
-          "the account '#{same.username}'"
-        false
-      else
-        true
-      end
-    end
-
     def modify_backup_path(menu)
       menu.choice("modify backup path") do
-        existing = account.local_path.clone
-        account.local_path = Setup::Asker.backup_path(
-          account.local_path, ->(path) { path_modification_validator(path) }
-        )
+        Setup::BackupPath.new(account: account, config: config).run
       end
     end
 
@@ -153,6 +104,19 @@ module Imap::Backup
       end
     end
 
+    def toggle_reset_seen_flags_after_fetch(menu)
+      menu_item =
+        if account.reset_seen_flags_after_fetch
+          "don't fix changes to unread flags during download"
+        else
+          "fix changes to unread flags during download"
+        end
+      new_value = account.reset_seen_flags_after_fetch ? nil : true
+      menu.choice(menu_item) do
+        account.reset_seen_flags_after_fetch = new_value
+      end
+    end
+
     def test_connection(menu)
       menu.choice("test connection") do
         result = Setup::ConnectionTester.new(account).test
@@ -169,32 +133,5 @@ module Imap::Backup
         end
       end
     end
-
-    def folders
-      account.folders || []
-    end
-
-    def masked_password
-      if (account.password == "") || account.password.nil?
-        "(unset)"
-      else
-        account.password.gsub(/./, "x")
-      end
-    end
-
-    def default_server(username)
-      provider = Email::Provider.for_address(username)
-
-      if provider.is_a?(Email::Provider::Unknown)
-        Kernel.puts "Can't decide provider for email address '#{username}'"
-        return nil
-      end
-
-      provider.host
-    end
-
-    def helpers
-      Setup::Helpers.new
-    end
   end
 end

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

@@ -1,11 +1,13 @@
 module Imap::Backup
   class Setup; end
 
-  Setup::Asker = Struct.new(:highline) do
+  class Setup::Asker
     EMAIL_MATCHER = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]+$/i.freeze
 
+    attr_reader :highline
+
     def initialize(highline)
-      super
+      @highline = highline
     end
 
     def email(default = "")
@@ -30,15 +32,6 @@ module Imap::Backup
       password
     end
 
-    def backup_path(default, validator)
-      highline.ask("backup directory: ") do |q|
-        q.default  = default
-        q.readline = true
-        q.validate = validator
-        q.responses[:not_valid] = "Choose a different directory "
-      end
-    end
-
     def self.email(default = "")
       new(Setup.highline).email(default)
     end
@@ -46,9 +39,5 @@ module Imap::Backup
     def self.password
       new(Setup.highline).password
     end
-
-    def self.backup_path(default, validator)
-      new(Setup.highline).backup_path(default, validator)
-    end
   end
 end

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

@@ -0,0 +1,45 @@
+module Imap::Backup
+  class Setup; end
+
+  class Setup::BackupPath
+    attr_reader :account
+    attr_reader :config
+
+    def initialize(account:, config:)
+      @account = account
+      @config = config
+    end
+
+    def run
+      account.local_path = highline.ask("backup directory: ") do |q|
+        q.default  = account.local_path || default
+        q.readline = true
+        q.validate = ->(path) { path_modification_validator(path) }
+        q.responses[:not_valid] = "Choose a different directory "
+      end
+    end
+
+    def default
+      File.join(config.path, account.username.tr("@", "_"))
+    end
+
+    private
+
+    def highline
+      Setup.highline
+    end
+
+    def path_modification_validator(path)
+      same = config.accounts.find do |a|
+        a.username != account.username && a.local_path == path
+      end
+      if same
+        Kernel.puts "The path '#{path}' is used to backup " \
+                    "the account '#{same.username}'"
+        false
+      else
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require "email/provider"
+
+module Imap::Backup
+  class Setup; end
+
+  class Setup::Email
+    attr_reader :account
+    attr_reader :config
+
+    def initialize(account:, config:)
+      @account = account
+      @config = config
+    end
+
+    def run
+      username = Setup::Asker.email(account.username)
+      other_accounts = config.accounts.reject { |a| a == account }
+      others = other_accounts.map(&:username)
+      if others.include?(username)
+        Kernel.puts(
+          "There is already an account set up with that email address"
+        )
+      else
+        account.username = username
+        if account.server.nil? || (account.server == "")
+          default = default_server(username)
+          account.server = default if default
+        end
+      end
+    end
+
+    private
+
+    def default_server(username)
+      provider = Email::Provider.for_address(username)
+
+      if provider.is_a?(Email::Provider::Unknown)
+        Kernel.puts "Can't decide provider for email address '#{username}'"
+        return nil
+      end
+
+      provider.host
+    end
+  end
+end