imap-backup 4.0.0 → 4.0.4

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

@@ -0,0 +1,98 @@
+require "imap/backup/thunderbird/mailbox_exporter"
+
+module Imap::Backup
+  class CLI::Utils < Thor
+    include Thor::Actions
+    include CLI::Helpers
+
+    FAKE_EMAIL = "fake@email.com".freeze
+
+    desc "ignore-history EMAIL", "Skip downloading emails up to today for all configured folders"
+    def ignore_history(email)
+      connection = connection(email)
+
+      connection.local_folders.each do |serializer, folder|
+        next if !folder.exist?
+
+        do_ignore_folder_history(folder, serializer)
+      end
+    end
+
+    desc(
+      "export-to-thunderbird EMAIL [OPTIONS]",
+      <<~DOC
+        [Experimental] Copy backed up emails to Thunderbird.
+        A folder called 'imap-backup/EMAIL' is created under 'Local Folders'.
+      DOC
+    )
+    method_option(
+      "force",
+      type: :boolean,
+      banner: "overwrite existing mailboxes",
+      aliases: ["-f"]
+    )
+    method_option(
+      "profile",
+      type: :string,
+      banner: "the name of the Thunderbird profile to copy emails to",
+      aliases: ["-p"]
+    )
+    def export_to_thunderbird(email)
+      opts = symbolized(options)
+      force = opts.key?(:force) ? opts[:force] : false
+      profile_name = opts[:profile]
+
+      connection = connection(email)
+      profile = thunderbird_profile(profile_name)
+
+      if !profile
+        if profile_name
+          raise "Thunderbird profile '#{profile_name}' not found"
+        else
+          raise "Default Thunderbird profile not found"
+        end
+      end
+
+      connection.local_folders.each do |serializer, _folder|
+        Thunderbird::MailboxExporter.new(
+          email, serializer, profile, force: force
+        ).run
+      end
+    end
+
+    no_commands do
+      def do_ignore_folder_history(folder, serializer)
+        uids = folder.uids - serializer.uids
+        Imap::Backup.logger.info "Folder '#{folder.name}' - #{uids.length} messages"
+
+        serializer.apply_uid_validity(folder.uid_validity)
+
+        uids.each do |uid|
+          message = <<~MESSAGE
+            From: #{FAKE_EMAIL}
+            Subject: Message #{uid} not backed up
+            Skipped #{uid}
+          MESSAGE
+
+          serializer.save(uid, message)
+        end
+      end
+
+      def thunderbird_profile(name = nil)
+        profiles = Thunderbird::Profiles.new
+        if name
+          profiles.profile(name)
+        else
+          if profiles.installs.count > 1
+            raise <<~MESSAGE
+              Thunderbird has multiple installs, so no default profile exists.
+              Please supply a profile name
+            MESSAGE
+          end
+
+          profiles.installs[0].default
+        end
+      end
+    end
+  end
+end

data/lib/imap/backup/cli.rb

@@ -13,6 +13,7 @@ module Imap::Backup
     autoload :Restore, "imap/backup/cli/restore"
     autoload :Setup, "imap/backup/cli/setup"
     autoload :Status, "imap/backup/cli/status"
+    autoload :Utils, "imap/backup/cli/utils"
 
     include Helpers
 
@@ -73,7 +74,7 @@ module Imap::Backup
       Configure email accounts to back up.
     DESC
     def setup
-      Setup.new().run
+      Setup.new.run
     end
 
     desc "status", "Show backup status"
@@ -87,5 +88,8 @@ module Imap::Backup
 
     desc "local SUBCOMMAND [OPTIONS]", "View local info"
     subcommand "local", Local
+
+    desc "utils SUBCOMMAND [OPTIONS]", "Various utilities"
+    subcommand "utils", Utils
   end
 end

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

@@ -0,0 +1,11 @@
+require "imap/backup/client/default"
+
+module Imap::Backup
+  class Client::AppleMail < Client::Default
+    # With Apple Mails's IMAP, passing "/" to list
+    # results in an empty list
+    def provider_root
+      ""
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "forwardable"
+require "net/imap"
+
+module Imap::Backup
+  module Client; end
+
+  class Client::Default
+    extend Forwardable
+    def_delegators :imap, *%i(
+      append authenticate create disconnect examine
+      login responses uid_fetch uid_search
+    )
+
+    attr_reader :args
+
+    def initialize(*args)
+      @args = args
+    end
+
+    def list
+      root = provider_root
+      mailbox_lists = imap.list(root, "*")
+
+      return [] if mailbox_lists.nil?
+
+      mailbox_lists.map { |ml| extract_name(ml) }
+    end
+
+    private
+
+    def imap
+      @imap ||= Net::IMAP.new(*args)
+    end
+
+    def extract_name(mailbox_list)
+      utf7_encoded = mailbox_list.name
+      Net::IMAP.decode_utf7(utf7_encoded)
+    end
+
+    # 6.3.8. LIST Command
+    # An empty ("" string) mailbox name argument is a special request to
+    # return the hierarchy delimiter and the root name of the name given
+    # in the reference.
+    def provider_root
+      @provider_root ||= begin
+        root_info = imap.list("", "")[0]
+        root_info.name
+      end
+    end
+  end
+end

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

@@ -147,10 +147,12 @@ module Imap::Backup
 
     def default_server(username)
       provider = Email::Provider.for_address(username)
-      if provider.provider == :default
+
+      if provider.is_a?(Email::Provider::Default)
         Kernel.puts "Can't decide provider for email address '#{username}'"
         return nil
       end
+
       provider.host
     end
   end

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

@@ -3,7 +3,7 @@ module Imap::Backup
 
   module Configuration::ConnectionTester
     def self.test(account)
-      Account::Connection.new(account).imap
+      Account::Connection.new(account).client
       "Connection successful"
     rescue Net::IMAP::NoResponseError
       "No response"

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

@@ -1,4 +1,5 @@
 require "json"
+require "os"
 
 module Imap::Backup
   module Configuration; end
@@ -25,11 +26,12 @@ module Imap::Backup
     end
 
     def save
-      mkdir_private path
+      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)) }
-      FileUtils.chmod 0o600, pathname
+      FileUtils.chmod(0o600, pathname) if !windows?
     end
 
     def accounts
@@ -54,7 +56,7 @@ module Imap::Backup
       @data ||=
         begin
           if File.exist?(pathname)
-            Utils.check_permissions pathname, 0o600
+            Utils.check_permissions(pathname, 0o600) if !windows?
             contents = File.read(pathname)
             data = JSON.parse(contents, symbolize_names: true)
           else
@@ -73,9 +75,12 @@ module Imap::Backup
       accounts.reject! { |a| a[:delete] }
     end
 
-    def mkdir_private(path)
-      FileUtils.mkdir(path) if !File.directory?(path)
+    def make_private(path)
       FileUtils.chmod(0o700, path) if Utils.mode(path) != 0o700
     end
+
+    def windows?
+      OS.windows?
+    end
   end
 end

data/lib/imap/backup/downloader.rb

@@ -13,16 +13,15 @@ module Imap::Backup
       count = uids.count
       Imap::Backup.logger.debug "[#{folder.name}] #{count} new messages"
       uids.each.with_index do |uid, i|
-        message = folder.fetch(uid)
+        body = folder.fetch(uid)
         log_prefix = "[#{folder.name}] uid: #{uid} (#{i + 1}/#{count}) -"
-        if message.nil?
+        if body.nil?
           Imap::Backup.logger.debug("#{log_prefix} not available - skipped")
           next
         end
         Imap::Backup.logger.debug(
-          "#{log_prefix} #{message['RFC822'].size} bytes"
+          "#{log_prefix} #{body.size} bytes"
         )
-        body = message["RFC822"]
         serializer.save(uid, body)
       end
     end

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

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

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

@@ -121,6 +121,14 @@ module Imap::Backup
       @folder = new_name
     end
 
+    def mbox_pathname
+      absolute_path("#{folder}.mbox")
+    end
+
+    def imap_pathname
+      absolute_path("#{folder}.imap")
+    end
+
     private
 
     def do_load
@@ -205,13 +213,5 @@ module Imap::Backup
     def absolute_path(relative_path)
       File.join(path, relative_path)
     end
-
-    def mbox_pathname
-      absolute_path("#{folder}.mbox")
-    end
-
-    def imap_pathname
-      absolute_path("#{folder}.imap")
-    end
   end
 end

data/lib/imap/backup/thunderbird/mailbox_exporter.rb

@@ -0,0 +1,58 @@
+require "thunderbird/local_folder"
+require "thunderbird/profiles"
+
+module Imap::Backup
+  class Thunderbird::MailboxExporter
+    EXPORT_PREFIX = "imap-backup".freeze
+
+    attr_reader :email
+    attr_reader :serializer
+    attr_reader :profile
+    attr_reader :force
+
+    def initialize(email, serializer, profile, force: false)
+      @email = email
+      @serializer = serializer
+      @profile = profile
+      @force = force
+    end
+
+    def run
+      local_folder_ok = local_folder.set_up
+      return if !local_folder_ok
+
+      if local_folder.msf_exists?
+        if force
+          Kernel.puts "Deleting '#{local_folder.msf_path}' as --force option was supplied"
+          File.unlink local_folder.msf_path
+        else
+          Kernel.puts "Skipping export of '#{serializer.folder}' as '#{local_folder.msf_path}' exists"
+          return false
+        end
+      end
+
+      if local_folder.exists?
+        if force
+          Kernel.puts "Overwriting '#{local_folder.path}' as --force option was supplied"
+        else
+          Kernel.puts "Skipping export of '#{serializer.folder}' as '#{local_folder.path}' exists"
+          return false
+        end
+      end
+
+      FileUtils.cp serializer.mbox_pathname, local_folder.full_path
+
+      true
+    end
+
+    private
+
+    def local_folder
+      @local_folder ||= begin
+        top_level_folders = [EXPORT_PREFIX, email]
+        prefixed_folder_path = File.join(top_level_folders, serializer.folder)
+        Thunderbird::LocalFolder.new(profile, prefixed_folder_path)
+      end
+    end
+  end
+end

data/lib/imap/backup/version.rb

@@ -3,7 +3,7 @@ module Imap; end
 module Imap::Backup
   MAJOR    = 4
   MINOR    = 0
-  REVISION = 0
+  REVISION = 4
   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/lib/thunderbird/install.rb

@@ -0,0 +1,16 @@
+require "thunderbird/profiles"
+
+class Thunderbird::Install
+  attr_reader :title
+  attr_reader :entries
+
+  # entries are lines from profile.ini
+  def initialize(title, entries)
+    @title = title
+    @entries = entries
+  end
+
+  def default
+    Thunderbird::Profiles.new.profile_for_path(entries[:Default])
+  end
+end

data/lib/thunderbird/local_folder.rb

@@ -0,0 +1,65 @@
+require "thunderbird/profile"
+require "thunderbird/subdirectory"
+
+# A local folder is a file containing emails
+class Thunderbird::LocalFolder
+  attr_reader :path
+  attr_reader :profile
+
+  def initialize(profile, path)
+    @profile = profile
+    @path = path
+  end
+
+  def set_up
+    return if path_elements.empty?
+
+    return true if !in_subdirectory?
+
+    subdirectory.set_up
+  end
+
+  def full_path
+    if in_subdirectory?
+      File.join(subdirectory.full_path, folder_name)
+    else
+      folder_name
+    end
+  end
+
+  def exists?
+    File.exist?(full_path)
+  end
+
+  def msf_path
+    "#{path}.msf"
+  end
+
+  def msf_exists?
+    File.exist?(msf_path)
+  end
+
+  private
+
+  def in_subdirectory?
+    path_elements.count > 1
+  end
+
+  def subdirectory
+    return nil if !in_subdirectory?
+
+    Thunderbird::Subdirectory.new(profile, subdirectory_path)
+  end
+
+  def path_elements
+    path.split(File::SEPARATOR)
+  end
+
+  def subdirectory_path
+    File.join(path_elements[0..-2])
+  end
+
+  def folder_name
+    path_elements[-1]
+  end
+end

data/lib/thunderbird/profile.rb

@@ -0,0 +1,30 @@
+require "thunderbird"
+
+class Thunderbird::Profile
+  attr_reader :title
+  attr_reader :entries
+
+  # entries are lines from profile.ini
+  def initialize(title, entries)
+    @title = title
+    @entries = entries
+  end
+
+  def root
+    if relative?
+      File.join(Thunderbird.new.data_path, entries[:Path])
+    else
+      entries[:Path]
+    end
+  end
+
+  def local_folders_path
+    File.join(root, "Mail", "Local Folders")
+  end
+
+  private
+
+  def relative?
+    entries[:IsRelative] == "1"
+  end
+end

data/lib/thunderbird/profiles.rb

@@ -0,0 +1,71 @@
+require "thunderbird"
+require "thunderbird/install"
+require "thunderbird/profile"
+
+# http://kb.mozillazine.org/Profiles.ini_file
+class Thunderbird::Profiles
+  def profile_for_path(path)
+    title, entries = blocks.find { |_name, entries| entries[:Path] == path }
+
+    Thunderbird::Profile.new(title, entries) if title
+  end
+
+  def profile(name)
+    title, entries = blocks.find { |_name, entries| entries[:Name] == name }
+
+    Thunderbird::Profile.new(title, entries) if title
+  end
+
+  def installs
+    @installs ||= begin
+      pairs = blocks.filter { |name, _entries| name.start_with?("Install") }
+      pairs.map { |title, entries| Thunderbird::Install.new(title, entries) }
+    end
+  end
+
+  private
+
+  # Parse profiles.ini.
+  # Blocks start with a title, e.g. '[Abc]'
+  # and are followed by a number of lines
+  def blocks
+    @blocks ||= begin
+      blocks = {}
+      File.open(profiles_ini_path, "rb") do |f|
+        title = nil
+        entries = nil
+
+        loop do
+          line = f.gets
+          if !line
+            blocks[title] = entries if title
+            break
+          end
+
+          line.chomp!
+
+          # Is this line the start of a new block
+          match = line.match(/\A\[([A-Za-z0-9]+)\]\z/)
+          if match
+            # Store what we got before this title as a new block
+            blocks[title] = entries if title
+
+            # Start a new block
+            title = match[1]
+            entries = {}
+          elsif line != ""
+            # Collect entries until we get to the next title
+            key, value = line.split("=")
+            entries[key.to_sym] = value
+          end
+        end
+      end
+
+      blocks
+    end
+  end
+
+  def profiles_ini_path
+    File.join(Thunderbird.new.data_path, "profiles.ini")
+  end
+end

data/lib/thunderbird/subdirectory.rb

@@ -0,0 +1,96 @@
+require "thunderbird/subdirectory_placeholder"
+
+class Thunderbird::Subdirectory
+  # `path` is the UI path, it doesn't have the '.sbd' extensions
+  # that are present in the real, file system path
+  attr_reader :path
+  attr_reader :profile
+
+  def initialize(profile, path)
+    @profile = profile
+    @path = path
+  end
+
+  def set_up
+    raise "Cannot create a subdirectory without a path" if !sub_directory?
+
+    if sub_sub_directory?
+      parent_ok = parent.set_up
+      return false if !parent_ok
+    end
+
+    ok = check
+    return false if !ok
+
+    FileUtils.mkdir_p full_path
+    placeholder.touch
+
+    true
+  end
+
+  # subdirectory relative path is 'Foo.sbd/Bar.sbd/Baz.sbd'
+  def full_path
+    relative_path = File.join(subdirectories)
+    File.join(profile.local_folders_path, relative_path)
+  end
+
+  private
+
+  def sub_directory?
+    path_elements.any?
+  end
+
+  def sub_sub_directory?
+    path_elements.count > 1
+  end
+
+  def parent
+    return nil if !sub_sub_directory?
+
+    self.class.new(profile, File.join(path_elements[0..-2]))
+  end
+
+  # placeholder relative path is 'Foo.sbd/Bar.sbd/Baz'
+  def placeholder
+    @placeholder = begin
+      relative_path = File.join(subdirectories[0..-2], path_elements[-1])
+      path = File.join(profile.local_folders_path, relative_path)
+      Thunderbird::SubdirectoryPlaceholder.new(path)
+    end
+  end
+
+  def path_elements
+    path.split(File::SEPARATOR)
+  end
+
+  def exists?
+    File.exist?(full_path)
+  end
+
+  def directory?
+    File.directory?(full_path)
+  end
+
+  def subdirectories
+    path_elements.map { |p| "#{p}.sbd" }
+  end
+
+  def check
+    case
+    when placeholder.exists? && !exists?
+      Kernel.puts "Can't set up folder '#{folder_path}': '#{placeholder.path}' exists, but '#{full_path}' is missing"
+      false
+    when exists? && !placeholder.exists?
+      Kernel.puts "Can't set up folder '#{folder_path}': '#{full_path}' exists, but '#{placeholder.path}' is missing"
+      false
+    when placeholder.exists? && !placeholder.regular?
+      Kernel.puts "Can't set up folder '#{folder_path}': '#{placeholder.path}' exists, but it is not a regular file"
+      false
+    when exists? && !directory?
+      Kernel.puts "Can't set up folder '#{folder_path}': '#{full_path}' exists, but it is not a directory"
+      false
+    else
+      true
+    end
+  end
+end