imap-backup 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e4037b31fc56dcf88f312506ff2814b1c3fb516ae13cf9dbb4c8a772928b5fa
-  data.tar.gz: 0465b9bf0b7a6a9dadc5c6c35b1a4dd65db058ab1ed37158d9fedf2dc093f777
+  metadata.gz: a62efa6b4c2e63180629e4a9770cf6b636eb48fa1aaad0177d7bab975ce3f251
+  data.tar.gz: ab0dee2784879df462e8fa1d622436b4a23f332dc731dd34ce353451a7164ce9
 SHA512:
-  metadata.gz: 459620b79228707291d0b3be5037830e7100da42ecc920a1b5e19797fd1cc9aa9bc8fa667f5a5a7f89cc5d2647f47df5ae7e384a575c62a9bf4a13c25c70dd4b
-  data.tar.gz: 8ac9d67819df8f957ffbc6a93be59aa401bdec704d75fa637c186012d2f15e23c3efa5c68ca8dc8918c97de3d90623ee5627d3cb8107615ee108e76588afd054
+  metadata.gz: ffe7443b8450980b05b170e8b4ed2d8cdaa093b17a60bf72c6c87c07e30752de1010aa444da3d4aea1b4348cbdd7b4fff0f2793e100f66de592796a8fa9885b6
+  data.tar.gz: 5779c9d8bc98070cba06a68c571b849cdb33fb994954f6f3cf320642d1d49023ab9db5c6f713db26c413703caf046745589a61e5d4cde2e2c6bce751e7d6f3a1

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

@@ -18,7 +18,7 @@ module Imap::Backup
       @username = options[:username]
       @password = options[:password]
       @local_path = options[:local_path]
-      @backup_folders = options[:folders]
+      @config_folders = options[:folders]
       @server = options[:server]
       @connection_options = options[:connection_options] || {}
       @folders = nil
@@ -29,21 +29,24 @@ module Imap::Backup
       @folders ||=
         begin
           root = provider_root
-          @folders = imap.list(root, "*")
-          if @folders.nil?
-            Imap::Backup.logger.warn(
-              "Unable to get folder list for account #{username}"
-            )
+          mailbox_lists = imap.list(root, "*")
+
+          if mailbox_lists.nil?
+            message = "Unable to get folder list for account #{username}"
+            Imap::Backup.logger.info message
+            raise message
           end
-          @folders
+
+          utf7_encoded = mailbox_lists.map(&:name)
+          utf7_encoded.map { |n| Net::IMAP.decode_utf7(n) }
         end
     end
 
     def status
-      backup_folders.map do |folder|
-        f = Account::Folder.new(self, folder[:name])
-        s = Serializer::Mbox.new(local_path, folder[:name])
-        {name: folder[:name], local: s.uids, remote: f.uids}
+      backup_folders.map do |backup_folder|
+        f = Account::Folder.new(self, backup_folder[:name])
+        s = Serializer::Mbox.new(local_path, backup_folder[:name])
+        {name: backup_folder[:name], local: s.uids, remote: f.uids}
       end
     end
 
@@ -105,18 +108,12 @@ module Imap::Backup
       @server = provider.host
     end
 
-    def backup_folders
-      return @backup_folders if @backup_folders && !@backup_folders.empty?
-
-      (folders || []).map { |f| {name: f.name} }
-    end
-
     private
 
     def each_folder
-      backup_folders.each do |folder_info|
-        folder = Account::Folder.new(self, folder_info[:name])
-        serializer = Serializer::Mbox.new(local_path, folder_info[:name])
+      backup_folders.each do |backup_folder|
+        folder = Account::Folder.new(self, backup_folder[:name])
+        serializer = Serializer::Mbox.new(local_path, backup_folder[:name])
         yield folder, serializer
       end
     end
@@ -175,6 +172,17 @@ module Imap::Backup
       end
     end
 
+    def backup_folders
+      @backup_folders ||=
+        begin
+          if @config_folders && @config_folders.any?
+            @config_folders
+          else
+            folders.map { |name| {name: name} }
+          end
+        end
+    end
+
     def provider
       @provider ||= Email::Provider.for_address(username)
     end

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

@@ -36,7 +36,7 @@ module Imap::Backup
     def create
       return if exist?
 
-      imap.create(name)
+      imap.create(utf7_encoded_name)
     end
 
     def uid_validity
@@ -81,22 +81,27 @@ module Imap::Backup
     def append(message)
       body = message.imap_body
       date = message.date&.to_time
-      response = imap.append(name, body, nil, date)
+      response = imap.append(utf7_encoded_name, body, nil, date)
       extract_uid(response)
     end
 
     private
 
     def examine
-      imap.examine(name)
+      imap.examine(utf7_encoded_name)
     rescue Net::IMAP::NoResponseError
-      Imap::Backup.logger.warn "Folder '#{name}' does not exist"
-      raise FolderNotFound, "Folder '#{name}' does not exist"
+      Imap::Backup.logger.warn "Folder '#{name}' does not exist on server"
+      raise FolderNotFound, "Folder '#{name}' does not exist on server"
     end
 
     def extract_uid(response)
       @uid_validity, uid = response.data.code.data.split(" ").map(&:to_i)
       uid
     end
+
+    def utf7_encoded_name
+      @utf7_encoded_name ||=
+        Net::IMAP.encode_utf7(name).force_encoding("ASCII-8BIT")
+    end
   end
 end

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

@@ -15,7 +15,7 @@ module Imap::Backup
         return
       end
 
-      if folders.nil?
+      if imap_folders.nil?
         Imap::Backup.logger.warn "Unable to get folder list"
         highline.ask "Press a key "
         return
@@ -44,29 +44,28 @@ module Imap::Backup
     end
 
     def add_folders(menu)
-      folders.each do |folder|
-        name = folder.name
-        mark = selected?(name) ? "+" : "-"
-        menu.choice("#{mark} #{name}") do
-          toggle_selection name
+      imap_folders.each do |folder|
+        mark = selected?(folder) ? "+" : "-"
+        menu.choice("#{mark} #{folder}") do
+          toggle_selection folder
         end
       end
     end
 
     def selected?(folder_name)
-      backup_folders = account[:folders]
-      return false if backup_folders.nil?
+      config_folders = account[:folders]
+      return false if config_folders.nil?
 
-      backup_folders.find { |f| f[:name] == folder_name }
+      config_folders.find { |f| f[:name] == folder_name }
     end
 
     def remove_missing
       removed = []
-      backup_folders = []
+      config_folders = []
       account[:folders].each do |f|
-        found = folders.find { |folder| folder.name == f[:name] }
+        found = imap_folders.find { |folder| folder == f[:name] }
         if found
-          backup_folders << f
+          config_folders << f
         else
           removed << f[:name]
         end
@@ -74,7 +73,7 @@ module Imap::Backup
 
       return if removed.empty?
 
-      account[:folders] = backup_folders
+      account[:folders] = config_folders
       account[:modified] = true
 
       Kernel.puts <<~MESSAGE
@@ -101,8 +100,8 @@ module Imap::Backup
       nil
     end
 
-    def folders
-      @folders ||= connection.folders
+    def imap_folders
+      @imap_folders ||= connection.folders
     end
 
     def highline

data/lib/imap/backup/version.rb

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

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

@@ -23,11 +23,11 @@ describe Imap::Backup::Account::Connection do
       username: USERNAME,
       password: PASSWORD,
       local_path: LOCAL_PATH,
-      folders: backup_folders,
+      folders: config_folders,
       server: server
     }
   end
-  let(:backup_folders) { [FOLDER_CONFIG] }
+  let(:config_folders) { [FOLDER_CONFIG] }
   let(:root_info) do
     instance_double(Net::IMAP::MailboxList, name: ROOT_NAME)
   end
@@ -62,7 +62,6 @@ describe Imap::Backup::Account::Connection do
       [:username, USERNAME],
       [:password, PASSWORD],
       [:local_path, LOCAL_PATH],
-      [:backup_folders, [FOLDER_CONFIG]],
       [:server, SERVER]
     ].each do |attr, expected|
       it "expects #{attr}" do
@@ -144,11 +143,21 @@ describe Imap::Backup::Account::Connection do
 
   describe "#folders" do
     let(:imap_folders) do
-      [instance_double(Net::IMAP::MailboxList)]
+      [instance_double(Net::IMAP::MailboxList, name: BACKUP_FOLDER)]
     end
 
     it "returns the list of folders" do
-      expect(subject.folders).to eq(imap_folders)
+      expect(subject.folders).to eq([BACKUP_FOLDER])
+    end
+
+    context "with non-ASCII folder names" do
+      let(:imap_folders) do
+        [instance_double(Net::IMAP::MailboxList, name: "Gel&APY-scht")]
+      end
+
+      it "converts them to UTF-8" do
+        expect(subject.folders).to eq(["Gelöscht"])
+      end
     end
   end
 
@@ -198,7 +207,7 @@ describe Imap::Backup::Account::Connection do
         with(LOCAL_PATH, BACKUP_FOLDER) { serializer }
     end
 
-    context "with supplied backup_folders" do
+    context "with supplied config_folders" do
       it "runs the downloader" do
         expect(downloader).to receive(:run)
 
@@ -216,7 +225,7 @@ describe Imap::Backup::Account::Connection do
       end
     end
 
-    context "without supplied backup_folders" do
+    context "without supplied config_folders" do
       let(:imap_folders) do
         [instance_double(Net::IMAP::MailboxList, name: ROOT_NAME)]
       end
@@ -228,8 +237,8 @@ describe Imap::Backup::Account::Connection do
           with(LOCAL_PATH, ROOT_NAME) { serializer }
       end
 
-      context "when supplied backup_folders is nil" do
-        let(:backup_folders) { nil }
+      context "when supplied config_folders is nil" do
+        let(:config_folders) { nil }
 
         it "runs the downloader for each folder" do
           expect(downloader).to receive(:run).exactly(:once)
@@ -238,8 +247,8 @@ describe Imap::Backup::Account::Connection do
         end
       end
 
-      context "when supplied backup_folders is an empty list" do
-        let(:backup_folders) { [] }
+      context "when supplied config_folders is an empty list" do
+        let(:config_folders) { [] }
 
         it "runs the downloader for each folder" do
           expect(downloader).to receive(:run).exactly(:once)
@@ -249,11 +258,13 @@ describe Imap::Backup::Account::Connection do
       end
 
       context "when the imap server doesn't return folders" do
-        let(:backup_folders) { nil }
+        let(:config_folders) { nil }
         let(:imap_folders) { nil }
 
-        it "does not fail" do
-          expect { subject.run_backup }.to_not raise_error
+        it "fails" do
+          expect do
+            subject.run_backup
+          end.to raise_error(RuntimeError, /Unable to get folder list/)
         end
       end
     end

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

@@ -1,7 +1,10 @@
 # rubocop:disable RSpec/PredicateMatcher
 
 describe Imap::Backup::Account::Folder do
-  subject { described_class.new(connection, "my_folder") }
+  FOLDER_NAME = "Gelöscht"
+  ENCODED_FOLDER_NAME = "Gel&APY-scht"
+
+  subject { described_class.new(connection, FOLDER_NAME) }
 
   let(:imap) do
     instance_double(
@@ -16,7 +19,7 @@ describe Imap::Backup::Account::Folder do
     instance_double(Imap::Backup::Account::Connection, imap: imap)
   end
   let(:missing_mailbox_data) do
-    OpenStruct.new(text: "Unknown Mailbox: my_folder")
+    OpenStruct.new(text: "Unknown Mailbox: #{FOLDER_NAME}")
   end
   let(:missing_mailbox_response) { OpenStruct.new(data: missing_mailbox_data) }
   let(:missing_mailbox_error) do
@@ -36,7 +39,8 @@ describe Imap::Backup::Account::Folder do
 
     context "with missing mailboxes" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "returns an empty array" do
@@ -50,7 +54,8 @@ describe Imap::Backup::Account::Folder do
       end
 
       before do
-        allow(imap).to receive(:examine).and_raise(no_method_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "returns an empty array" do
@@ -82,7 +87,8 @@ describe Imap::Backup::Account::Folder do
 
     context "when the mailbox doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "is nil" do
@@ -101,7 +107,7 @@ describe Imap::Backup::Account::Folder do
 
   describe "#folder" do
     it "is the name" do
-      expect(subject.folder).to eq("my_folder")
+      expect(subject.folder).to eq(FOLDER_NAME)
     end
   end
 
@@ -114,7 +120,8 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "is false" do
@@ -134,14 +141,21 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
-      it "is does not create the folder" do
+      it "creates the folder" do
         expect(imap).to receive(:create)
 
         subject.create
       end
+
+      it "encodes the folder name" do
+        expect(imap).to receive(:create).with(ENCODED_FOLDER_NAME)
+
+        subject.create
+      end
     end
   end
 
@@ -154,7 +168,8 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "raises an error" do

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

@@ -6,11 +6,11 @@ describe Imap::Backup::Configuration::FolderChooser do
 
     let(:connection) do
       instance_double(
-        Imap::Backup::Account::Connection, folders: remote_folders
+        Imap::Backup::Account::Connection, folders: connection_folders
       )
     end
     let(:account) { {folders: []} }
-    let(:remote_folders) { [] }
+    let(:connection_folders) { [] }
     let!(:highline_streams) { prepare_highline }
     let(:input) { highline_streams[0] }
     let(:output) { highline_streams[1] }
@@ -37,15 +37,9 @@ describe Imap::Backup::Configuration::FolderChooser do
 
     describe "folder listing" do
       let(:account) { {folders: [{name: "my_folder"}]} }
-      let(:remote_folders) do
-        # this one is already backed up:
-        folder1 = instance_double(
-          Imap::Backup::Account::Folder, name: "my_folder"
-        )
-        folder2 = instance_double(
-          Imap::Backup::Account::Folder, name: "another_folder"
-        )
-        [folder1, folder2]
+      let(:connection_folders) do
+        # N.B. my_folder is already backed up
+        %w(my_folder another_folder)
       end
 
       describe "display" do
@@ -93,7 +87,7 @@ describe Imap::Backup::Configuration::FolderChooser do
       let(:account) do
         {folders: [{name: "on_server"}, {name: "not_on_server"}]}
       end
-      let(:remote_folders) do
+      let(:connection_folders) do
         [
           instance_double(Imap::Backup::Account::Folder, name: "on_server")
         ]
@@ -112,7 +106,7 @@ describe Imap::Backup::Configuration::FolderChooser do
     end
 
     context "when folders are not available" do
-      let(:remote_folders) { nil }
+      let(:connection_folders) { nil }
 
       before do
         allow(Imap::Backup::Configuration::Setup.highline).

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: imap-backup
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Joe Yates