imap-backup 2.2.2 → 3.2.1

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

@@ -56,9 +56,11 @@ module Imap::Backup
           )
         else
           account[:username] = username
+          # rubocop:disable Style/IfUnlessModifier
           if account[:server].nil? || (account[:server] == "")
             account[:server] = default_server(username)
           end
+          # rubocop:enable Style/IfUnlessModifier
           account[:modified] = true
         end
       end
@@ -66,7 +68,13 @@ module Imap::Backup
 
     def modify_password(menu)
       menu.choice("modify password") do
-        password = Configuration::Asker.password
+        password =
+          if account[:server] == Email::Provider::GMAIL_IMAP_SERVER
+            Configuration::GmailOauth2.new(account).run
+          else
+            Configuration::Asker.password
+          end
+
         if !password.nil?
           account[:password] = password
           account[:modified] = true

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/configuration/gmail_oauth2.rb

@@ -0,0 +1,82 @@
+module Imap::Backup
+  module Configuration; end
+
+  class Configuration::GmailOauth2
+    BANNER = <<~BANNER.freeze
+      GMail OAuth2 Setup
+
+      You need to authorize imap_backup to get access to your email.
+      To do so, please follow the instructions here:
+
+      https://github.com/joeyates/imap-backup/blob/main/docs/setting-up-gmail.md
+
+    BANNER
+
+    GMAIL_READ_SCOPE = "https://mail.google.com/".freeze
+    OOB_URI = "urn:ietf:wg:oauth:2.0:oob".freeze
+
+    attr_reader :account
+    attr_reader :client_id
+    attr_reader :client_secret
+
+    def initialize(account)
+      @account = account
+    end
+
+    def run
+      Kernel.system("clear")
+      Kernel.puts BANNER
+      @client_id = highline.ask("client_id: ")
+      @client_secret = highline.ask("client_secret: ")
+
+      Kernel.puts <<~MESSAGE
+
+        Open the following URL in your browser
+
+        #{authorization_url}
+
+        Then copy the success code
+
+      MESSAGE
+
+      @code = highline.ask("success code: ")
+      @credentials = authorizer.get_and_store_credentials_from_code(
+        user_id: email, code: @code, base_url: OOB_URI
+      )
+
+      raise "Failed" if !@credentials
+
+      token = JSON.parse(token_store.load(email))
+      token["client_secret"] = client_secret
+      token.to_json
+    end
+
+    private
+
+    def email
+      account[:username]
+    end
+
+    def highline
+      Configuration::Setup.highline
+    end
+
+    def auth_client_id
+      @auth_client_id = Google::Auth::ClientId.new(client_id, client_secret)
+    end
+
+    def authorizer
+      @authorizer ||= Google::Auth::UserAuthorizer.new(
+        auth_client_id, GMAIL_READ_SCOPE, token_store
+      )
+    end
+
+    def token_store
+      @token_store ||= Google::Auth::Stores::InMemoryTokenStore.new
+    end
+
+    def authorization_url
+      authorizer.get_authorization_url(base_url: OOB_URI)
+    end
+  end
+end

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

@@ -75,7 +75,10 @@ module Imap::Backup
         password: "",
         local_path: File.join(config.path, username.tr("@", "_")),
         folders: []
-      }
+      }.tap do |c|
+        server = Email::Provider.for_address(username)
+        c[:server] = server.host if server.host
+      end
     end
 
     def edit_account(username)

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

@@ -51,18 +51,18 @@ module Imap::Backup
     private
 
     def data
-      return @data if @data
-
-      if File.exist?(pathname)
-        Utils.check_permissions pathname, 0o600
-        contents = File.read(pathname)
-        @data = JSON.parse(contents, symbolize_names: true)
-      else
-        @data = {accounts: []}
-      end
-      @data[:debug] = false unless @data.include?(:debug)
-      @data[:debug] = false unless [true, false].include?(@data[:debug])
-      @data
+      @data ||=
+        begin
+          if File.exist?(pathname)
+            Utils.check_permissions pathname, 0o600
+            contents = File.read(pathname)
+            data = JSON.parse(contents, symbolize_names: true)
+          else
+            data = {accounts: []}
+          end
+          data[:debug] = data.key?(:debug) ? data[:debug] == true : false
+          data
+        end
     end
 
     def remove_modified_flags

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

@@ -161,7 +161,7 @@ module Imap::Backup
     def load_nth(index)
       enumerator = Serializer::MboxEnumerator.new(mbox_pathname)
       enumerator.each.with_index do |raw, i|
-        next unless i == index
+        next if i != index
 
         return Email::Mboxrd::Message.from_serialized(raw)
       end
@@ -169,7 +169,7 @@ module Imap::Backup
     end
 
     def imap_looks_like_json?
-      return false unless imap_exist?
+      return false if !imap_exist?
 
       content = File.read(imap_pathname)
       content.start_with?("{")

data/lib/imap/backup/version.rb

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

data/lib/retry_on_error.rb

@@ -0,0 +1,14 @@
+module RetryOnError
+  def retry_on_error(errors:, limit: 10)
+    tries ||= 1
+    yield
+  rescue *errors => e
+    if tries < limit
+      message = "#{e}, attempt #{tries} of #{limit}"
+      Imap::Backup.logger.debug message
+      tries += 1
+      retry
+    end
+    raise e
+  end
+end

data/spec/features/backup_spec.rb

@@ -38,7 +38,7 @@ RSpec.describe "backup", type: :feature, docker: true do
     end
 
     it "saves a file version" do
-      expect(imap_metadata[:version].to_s).to match(/^[0-9\.]$/)
+      expect(imap_metadata[:version].to_s).to match(/^[0-9.]$/)
     end
 
     it "records IMAP ids" do

data/spec/fixtures/connection.yml

@@ -2,6 +2,6 @@
 :username: 'address@example.org'
 :password: 'pass'
 :connection_options:
-  :port: 8993
+  :port: <%= ENV.fetch("DOCKER_IMAP_SERVER", 993) %>
   :ssl:
     :verify_mode: 0

data/spec/support/fixtures.rb

@@ -1,6 +1,11 @@
+require "erb"
+require "yaml"
+
 def fixture(name)
   spec_root = File.expand_path("..", File.dirname(__FILE__))
   fixture_path = File.join(spec_root, "fixtures", "#{name}.yml")
-  fixture = File.read(fixture_path)
-  YAML.safe_load(fixture, [Symbol])
+  content = File.read(fixture_path)
+  template = ERB.new(content)
+  yaml = template.result(binding)
+  YAML.safe_load(yaml, [Symbol])
 end

data/spec/unit/gmail/authenticator_spec.rb

@@ -0,0 +1,138 @@
+require "gmail/authenticator"
+require "googleauth"
+
+describe Gmail::Authenticator do
+  ACCESS_TOKEN = "access_token".freeze
+  AUTHORIZATION_URL = "authorization_url".freeze
+  CLIENT_ID = "client_id".freeze
+  CLIENT_SECRET = "client_secret".freeze
+  CODE = "code".freeze
+  CREDENTIALS = "credentials".freeze
+  EMAIL = "email".freeze
+  EXPIRATION_TIME_MILLIS = "expiration_time_millis".freeze
+  GMAIL_READ_SCOPE = "https://mail.google.com/".freeze
+  IMAP_BACKUP_TOKEN = "imap_backup_token".freeze
+  OOB_URI = "urn:ietf:wg:oauth:2.0:oob".freeze
+  REFRESH_TOKEN = "refresh_token".freeze
+
+  subject { described_class.new(**params) }
+
+  let(:params) do
+    {
+      email: EMAIL,
+      token: IMAP_BACKUP_TOKEN
+    }
+  end
+
+  let(:authorizer) do
+    instance_double(Google::Auth::UserAuthorizer)
+  end
+
+  let(:imap_backup_token) do
+    instance_double(
+      Gmail::Authenticator::ImapBackupToken,
+      access_token: ACCESS_TOKEN,
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET,
+      expiration_time_millis: EXPIRATION_TIME_MILLIS,
+      refresh_token: REFRESH_TOKEN,
+      valid?: true
+    )
+  end
+
+  let(:token_store) do
+    instance_double(Google::Auth::Stores::InMemoryTokenStore)
+  end
+
+  let(:credentials) do
+    instance_double(Google::Auth::UserRefreshCredentials, refresh!: true)
+  end
+
+  let(:expired) { false }
+
+  before do
+    allow(Google::Auth::UserAuthorizer).
+      to receive(:new).
+        with(
+          instance_of(Google::Auth::ClientId),
+          GMAIL_READ_SCOPE,
+          token_store
+        ) { authorizer }
+    allow(authorizer).to receive(:get_authorization_url).
+      with(base_url: OOB_URI) { AUTHORIZATION_URL }
+    allow(authorizer).to receive(:get_credentials).
+      with(EMAIL) { credentials }
+    allow(authorizer).to receive(:get_credentials_from_code).
+      with(user_id: EMAIL, code: CODE, base_url: OOB_URI) { CREDENTIALS }
+
+    allow(Google::Auth::UserRefreshCredentials).
+      to receive(:new) { credentials }
+    allow(credentials).to receive(:expired?) { expired }
+
+    allow(Google::Auth::Stores::InMemoryTokenStore).
+      to receive(:new) { token_store }
+    allow(token_store).to receive(:store).
+      with(EMAIL, anything) # TODO: use a JSON matcher
+    allow(Gmail::Authenticator::ImapBackupToken).
+      to receive(:new).
+        with(IMAP_BACKUP_TOKEN) { imap_backup_token }
+  end
+
+  describe "#initialize" do
+    [:email, :token].each do |param|
+      context "parameter #{param}" do
+        let(:params) { super().dup.reject { |k| k == param } }
+
+        it "is expected" do
+          expect { subject }.to raise_error(
+            ArgumentError, /missing keyword: :?#{param}/
+          )
+        end
+      end
+    end
+  end
+
+  describe "#credentials" do
+    let!(:result) { subject.credentials }
+
+    it "attempts to get credentials" do
+      expect(authorizer).to have_received(:get_credentials)
+    end
+
+    it "returns the result" do
+      expect(result).to eq(credentials)
+    end
+
+    context "when the access_token has expired" do
+      let(:expired) { true }
+
+      it "refreshes it" do
+        expect(credentials).to have_received(:refresh!)
+      end
+    end
+  end
+
+  describe "#authorization_url" do
+    let!(:result) { subject.authorization_url }
+
+    it "requests an authorization URL" do
+      expect(authorizer).to have_received(:get_authorization_url)
+    end
+
+    it "returns the result" do
+      expect(result).to eq(AUTHORIZATION_URL)
+    end
+  end
+
+  describe "#credentials_from_code" do
+    let!(:result) { subject.credentials_from_code(CODE) }
+
+    it "requests credentials" do
+      expect(authorizer).to have_received(:get_credentials_from_code)
+    end
+
+    it "returns credentials" do
+      expect(result).to eq(CREDENTIALS)
+    end
+  end
+end

data/spec/unit/google/auth/stores/in_memory_token_store_spec.rb

@@ -0,0 +1,15 @@
+require "google/auth/stores/in_memory_token_store"
+
+describe Google::Auth::Stores::InMemoryTokenStore do
+  KEY = "key".freeze
+  VALUE = "value".freeze
+
+  subject { described_class.new }
+
+  describe "#load" do
+    it "returns an item's value" do
+      subject[KEY] = VALUE
+      expect(subject.load(KEY)).to eq(VALUE)
+    end
+  end
+end