imap-backup 5.2.0 → 6.0.1

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

@@ -0,0 +1,37 @@
+require "os"
+
+module Imap::Backup
+  class Serializer; end
+
+  class Serializer::Directory
+    DIRECTORY_PERMISSIONS = 0o700
+
+    attr_reader :relative
+    attr_reader :path
+
+    def initialize(path, relative)
+      @path = path
+      @relative = relative
+    end
+
+    def ensure_exists
+      if !File.directory?(full_path)
+        Utils.make_folder(
+          path, relative, DIRECTORY_PERMISSIONS
+        )
+      end
+
+      return if OS.windows?
+      return if Utils.mode(full_path) == DIRECTORY_PERMISSIONS
+
+      FileUtils.chmod DIRECTORY_PERMISSIONS, full_path
+    end
+
+    private
+
+    def full_path
+      containing_directory = File.join(path, relative)
+      File.expand_path(containing_directory)
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+require "json"
+
+module Imap::Backup
+  class Serializer::Imap
+    CURRENT_VERSION = 2
+
+    attr_reader :folder_path
+    attr_reader :loaded
+
+    def initialize(folder_path)
+      @folder_path = folder_path
+      @loaded = false
+      @uid_validity = nil
+      @uids = nil
+      @version = nil
+    end
+
+    def valid?
+      return false if !exist?
+      return false if version != CURRENT_VERSION
+      return false if !uid_validity
+
+      true
+    end
+
+    def append(uid)
+      uids << uid
+      save
+    end
+
+    def delete
+      return if !exist?
+
+      File.unlink(pathname)
+    end
+
+    def include?(uid)
+      uids.include?(uid)
+    end
+
+    def index(uid)
+      uids.find_index(uid)
+    end
+
+    def rename(new_path)
+      if exist?
+        old_pathname = pathname
+        @folder_path = new_path
+        File.rename(old_pathname, pathname)
+      else
+        @folder_path = new_path
+      end
+    end
+
+    def uid_validity
+      ensure_loaded
+      @uid_validity
+    end
+
+    def uid_validity=(value)
+      ensure_loaded
+      @uid_validity = value
+      @uids ||= []
+      save
+    end
+
+    def uids
+      ensure_loaded
+      @uids || []
+    end
+
+    def update_uid(old, new)
+      index = uids.find_index(old.to_i)
+      return if index.nil?
+
+      uids[index] = new.to_i
+      save
+    end
+
+    def version
+      ensure_loaded
+      @version
+    end
+
+    private
+
+    def pathname
+      "#{folder_path}.imap"
+    end
+
+    def exist?
+      File.exist?(pathname)
+    end
+
+    def ensure_loaded
+      return if loaded
+
+      data = load
+      if data
+        @uids = data[:uids].map(&:to_i)
+        @uid_validity = data[:uid_validity]
+        @version = data[:version]
+      else
+        @uids = []
+        @uid_validity = nil
+        @version = CURRENT_VERSION
+      end
+      @loaded = true
+    end
+
+    def load
+      return nil if !exist?
+
+      data = nil
+      begin
+        content = File.read(pathname)
+        data = JSON.parse(content, symbolize_names: true)
+      rescue JSON::ParserError
+        return nil
+      end
+
+      return nil if !data.key?(:version)
+      return nil if !data.key?(:uid_validity)
+      return nil if !data.key?(:uids)
+      return nil if !data[:uids].is_a?(Array)
+
+      data
+    end
+
+    def save
+      ensure_loaded
+
+      raise "Cannot save metadata without a uid_validity" if !uid_validity
+
+      data = {
+        version: @version,
+        uid_validity: @uid_validity,
+        uids: @uids
+      }
+      content = data.to_json
+      File.open(pathname, "w") { |f| f.write content }
+    end
+  end
+end

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

@@ -1,116 +1,61 @@
-require "forwardable"
-
-require "imap/backup/serializer/mbox_store"
-
 module Imap::Backup
   class Serializer::Mbox
-    extend Forwardable
-    def_delegators :store, :mbox_pathname
-
-    attr_reader :path
-    attr_reader :folder
-
-    def initialize(path, folder)
-      @path = path
-      @folder = folder
-    end
-
-    def apply_uid_validity(value)
-      case
-      when store.uid_validity.nil?
-        store.uid_validity = value
-        nil
-      when store.uid_validity == value
-        # NOOP
-        nil
-      else
-        apply_new_uid_validity value
-      end
-    end
+    attr_reader :folder_path
 
-    def force_uid_validity(value)
-      store.uid_validity = value
+    def initialize(folder_path)
+      @folder_path = folder_path
     end
 
-    def uids
-      store.uids
+    def valid?
+      exist?
     end
 
-    def load(uid)
-      store.load(uid)
+    def append(message)
+      File.open(pathname, "ab") do |file|
+        file.write message
+      end
     end
 
-    def each_message(uids)
-      store.each_message(uids)
-    end
+    def delete
+      return if !exist?
 
-    def save(uid, message)
-      store.add(uid, message)
+      File.unlink(pathname)
     end
 
-    def rename(new_name)
-      @folder = new_name
-      store.rename new_name
-    end
+    def length
+      return nil if !exist?
 
-    def update_uid(old, new)
-      store.update_uid old, new
+      File.stat(pathname).size
     end
 
-    private
-
-    def store
-      @store ||=
-        begin
-          create_containing_directory
-          Serializer::MboxStore.new(path, folder)
-        end
+    def pathname
+      "#{folder_path}.mbox"
     end
 
-    def apply_new_uid_validity(value)
-      digit = 0
-      new_name = nil
-      loop do
-        extra = digit.zero? ? "" : "-#{digit}"
-        new_name = "#{folder}-#{store.uid_validity}#{extra}"
-        test_store = Serializer::MboxStore.new(path, new_name)
-        break if !test_store.exist?
-
-        digit += 1
+    def rename(new_path)
+      if exist?
+        old_pathname = pathname
+        @folder_path = new_path
+        File.rename(old_pathname, pathname)
+      else
+        @folder_path = new_path
       end
-      rename_store new_name, value
-    end
-
-    def rename_store(new_name, value)
-      store.rename new_name
-      @store = nil
-      store.uid_validity = value
-      new_name
     end
 
-    def relative_path
-      File.dirname(folder)
-    end
-
-    def containing_directory
-      File.join(path, relative_path)
+    def rewind(length)
+      File.open(pathname, File::RDWR | File::CREAT, 0o644) do |f|
+        f.truncate(length)
+      end
     end
 
-    def full_path
-      File.expand_path(containing_directory)
+    def touch
+      File.open(pathname, "a") {}
     end
 
-    def create_containing_directory
-      if !File.directory?(full_path)
-        Utils.make_folder(
-          path, relative_path, Serializer::DIRECTORY_PERMISSIONS
-        )
-      end
+    private
 
-      if Utils.mode(full_path) !=
-         Serializer::DIRECTORY_PERMISSIONS
-        FileUtils.chmod Serializer::DIRECTORY_PERMISSIONS, full_path
-      end
+    def exist?
+      File.exist?(pathname)
     end
   end
 end

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

@@ -1,4 +1,6 @@
 module Imap::Backup
+  class Serializer; end
+
   class Serializer::MboxEnumerator
     attr_reader :mbox_pathname
 

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,6 +1,163 @@
+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
-  module Serializer
-    DIRECTORY_PERMISSIONS = 0o700
-    FILE_PERMISSIONS      = 0o600
+  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
+    def_delegators :imap, :uid_validity, :uids, :update_uid
+
+    attr_reader :folder
+    attr_reader :path
+
+    def initialize(path, folder)
+      @path = path
+      @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?
+        internal_force_uid_validity(value)
+        nil
+      when uid_validity == value
+        # NOOP
+        nil
+      else
+        apply_new_uid_validity value
+      end
+    end
+
+    def force_uid_validity(value)
+      validate!
+
+      internal_force_uid_validity(value)
+    end
+
+    def append(uid, message)
+      validate!
+
+      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?
+
+      internal_load_nth(message_index)
+    end
+
+    def load_nth(index)
+      validate!
+
+      internal_load_nth(index)
+    end
+
+    def each_message(required_uids, &block)
+      validate!
+
+      return enum_for(:each_message, required_uids) if !block
+
+      enumerator = Serializer::MessageEnumerator.new(imap: imap, mbox: mbox)
+      enumerator.run(uids: required_uids, &block)
+    end
+
+    private
+
+    def rename(new_name)
+      destination = self.class.folder_path_for(path: path, folder: new_name)
+      ensure_containing_directory(new_name)
+      mbox.rename destination
+      imap.rename destination
+    end
+
+    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
+
+        return Email::Mboxrd::Message.from_serialized(raw)
+      end
+      nil
+    end
+
+    def mbox
+      @mbox ||=
+        begin
+          ensure_containing_directory(folder)
+          Serializer::Mbox.new(folder_path)
+        end
+    end
+
+    def imap
+      @imap ||=
+        begin
+          ensure_containing_directory(folder)
+          Serializer::Imap.new(folder_path)
+        end
+    end
+
+    def folder_path
+      self.class.folder_path_for(path: path, folder: folder)
+    end
+
+    def ensure_containing_directory(folder)
+      relative = File.dirname(folder)
+      directory = Serializer::Directory.new(path, relative)
+      directory.ensure_exists
+    end
+
+    def apply_new_uid_validity(value)
+      new_name = rename_existing_folder
+      # Clear memoization so we get empty data
+      @mbox = nil
+      @imap = nil
+      internal_force_uid_validity(value)
+
+      new_name
+    end
+
+    def rename_existing_folder
+      new_name = Serializer::UnusedNameFinder.new(serializer: self).run
+      rename new_name
+      new_name
+    end
   end
 end

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

@@ -0,0 +1,75 @@
+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}
+
+        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 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