imap-backup 4.0.0.rc1 → 4.0.0.rc5

data/docs/setting-up-gmail-with-oauth2.md

@@ -1,166 +0,0 @@
-# Setting up GMail Authentication for imap-backup
-
-# Create a Google project
-
-Go to https://console.developers.google.com
-
-Select "Credentials".
-
-![Credential screen](01-credentials-screen.png)
-
-Select "CREATE PROJECT".
-
-![New project](02-new-project.png)
-
-Set or accept the "Project name",
-
-And optionally do the same with the "Project ID",
-
-Leave "Location" on "No organization",
-
-Click "CREATE".
-
-![Initial project credentials](03-initial-credentials-for-project.png)
-
-Click "+ CREATE CREDENTIALS".
-
-![Credential type selection](04-credential-type-selection.png)
-
-Select "OAuth client ID".
-
-![Can't create credentials before setting up the consent screen](05-cant-create-without-consent-setup.png)
-
-Click "CONFIGURE CONSENT SCREEN".
-
-![User type selection](06-user-type-selection.png)
-
-Select "External",
-
-Click "CREATE".
-
-![Consent screen form](07-consent-screen-form.png)
-
-Fill in "App name",
-
-Select your email as "User support email",
-
-Type in your email at the bottom under "Developer contact information",
-
-Click "SAVE AND CONTINUE".
-
-![App scopes](08-app-scopes.png)
-
-Click "ADD OR REMOVE SCOPES".
-
-![Scope selection](09-scope-selection.png)
-
-Under "Manually add scopes", type "https://mail.google.com/",
-
-Click "ADD TO TABLE",
-
-Click "UPDATE".
-
-![Updated app scopes](10-updated-app-scopes.png)
-
-Click "SAVE AND CONTINUE".
-
-![Test users](11-test-users.png)
-
-Click "+ ADD USERS".
-
-![Add users](12-add-users.png)
-
-Type in your email,
-
-Click "SAVE AND CONTINUE",
-
-Click "BACK TO DASHBOARD",
-
-Click "Credentials" in the menu
-
-And then click "+ CREATE CREDENTIALS" again,
-
-And select "OAuth client ID" again.
-
-![Create OAuth client](13-create-oauth-client.png)
-
-This time you will be able to proceed.
-
-![Application details](14-application-details.png)
-
-Select "TVs and limited input devices",
-
-Click "CREATE",
-
-Copy both "Your Client ID"
-
-And "Your Client Secret".
-
-# Set up imap-backup
-
-Run `imap-backup setup`.
-
-![Initial imap-backup menu](16-initial-menu.png)
-
-Choose 'add account'.
-
-![Type in your email address](17-inputting-the-email-address.png)
-
-Type in your GMail address.
-
-Note: if you have a custom domain (GSuite) address,
-e.g. "me@mycompany.com", you now need to
-choose 'server' and
-type in 'imap.gmail.com'.
-
-![Choose password](18-choose-password.png)
-
-Choose `password`.
-
-![Supply client info](19-supply-client-info.png)
-
-Type your "Client ID" and "Client Secret",
-
-Next you will be shown a URL to open in your browser.
-
-![Choose GMail account](20-choose-gmail-account.png)
-
-If you have more than one GMail account you will need to choose which
-you are configuring.
-
-![Accept warnings](21-accept-warnings.png)
-
-As the project "app" is in test mode,
-you'll need to accept to ignore this warning.
-
-Click "Advanced",
-
-Then click "Go to XXXYYYZZZ (unsafe)"
-
-![Grant access](22-grant-access.png)
-
-Choose "Allow".
-
-![Confirm choices](24-confirm-choices.png)
-
-Choose "Allow".
-
-![Success code screen](25-success-code.png)
-
-Click on the copy logo to copy the success code.
-
-![Paste the code](26-type-code-into-imap_backup.png)
-
-Paste the success code into imap-backup.
-
-Finally, choose 'test connection'.
-
-If all has gone well you should see this:
-
-![Connection successful](27-success.png)
-
-Now choose 'return to main menu',
-
-Then 'save and exit'.
-
-Your imap-backup is now configured to back up your GMail.

data/lib/gmail/authenticator.rb

@@ -1,160 +0,0 @@
-require "googleauth"
-require "google/auth/stores/in_memory_token_store"
-
-module Gmail; end
-
-class Gmail::Authenticator
-  class MalformedImapBackupToken < StandardError; end
-
-  class ImapBackupToken
-    attr_reader :token
-
-    def self.from(
-      access_token:,
-      client_id:,
-      client_secret:,
-      expiration_time_millis:,
-      refresh_token:
-    )
-      {
-        access_token: access_token,
-        client_id: client_id,
-        client_secret: client_secret,
-        expiration_time_millis: expiration_time_millis,
-        refresh_token: refresh_token
-      }.to_json
-    end
-
-    def initialize(token)
-      @token = token
-    end
-
-    def valid?
-      return false if !body
-      return false if !access_token
-      return false if !client_id
-      return false if !client_secret
-      return false if !expiration_time_millis
-      return false if !refresh_token
-
-      true
-    end
-
-    def access_token
-      body["access_token"]
-    end
-
-    def client_id
-      body["client_id"]
-    end
-
-    def client_secret
-      body["client_secret"]
-    end
-
-    def expiration_time_millis
-      body["expiration_time_millis"]
-    end
-
-    def refresh_token
-      body["refresh_token"]
-    end
-
-    private
-
-    def body
-      @body ||= JSON.parse(token)
-    rescue JSON::ParserError
-      nil
-    end
-  end
-
-  GMAIL_READ_SCOPE = "https://mail.google.com/".freeze
-  OOB_URI = "urn:ietf:wg:oauth:2.0:oob".freeze
-
-  attr_reader :email
-  attr_reader :token
-
-  def self.refresh_token?(text)
-    ImapBackupToken.new(text).valid?
-  end
-
-  def initialize(email:, token:)
-    @email = email
-    @token = token
-  end
-
-  def authorization_url
-    authorizer.get_authorization_url(base_url: OOB_URI)
-  end
-
-  def credentials
-    authorizer.get_credentials(email).tap do |c|
-      c.refresh! if c.expired?
-    end
-  end
-
-  def credentials_from_code(code)
-    authorizer.get_credentials_from_code(
-      user_id: email,
-      code: code,
-      base_url: OOB_URI
-    )
-  end
-
-  private
-
-  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 access_token
-    imap_backup_token.access_token
-  end
-
-  def client_id
-    imap_backup_token.client_id
-  end
-
-  def client_secret
-    imap_backup_token.client_secret
-  end
-
-  def expiration_time_millis
-    imap_backup_token.expiration_time_millis
-  end
-
-  def refresh_token
-    imap_backup_token.refresh_token
-  end
-
-  def imap_backup_token
-    @imap_backup_token ||=
-      ImapBackupToken.new(token).tap do |t|
-        raise MalformedImapBackupToken if !t.valid?
-      end
-  end
-
-  def store_token
-    {
-      "client_id" => client_id,
-      "access_token" => access_token,
-      "refresh_token" => refresh_token,
-      "scope": [GMAIL_READ_SCOPE],
-      "expiration_time_millis": expiration_time_millis
-    }.to_json
-  end
-
-  def token_store
-    @token_store ||=
-      Google::Auth::Stores::InMemoryTokenStore.new.tap do |t|
-        t.store(email, store_token)
-      end
-  end
-end

data/lib/google/auth/stores/in_memory_token_store.rb

@@ -1,9 +0,0 @@
-module Google; end
-module Google::Auth; end
-module Google::Auth::Stores; end
-
-class Google::Auth::Stores::InMemoryTokenStore < Hash
-  def load(id)
-    self[id]
-  end
-end

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

@@ -1,102 +0,0 @@
-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-with-oauth2.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
-
-      keep = if token.valid?
-        highline.agree("Use existing client info?")
-      else
-        false
-      end
-
-      if keep
-        @client_id = token.client_id
-        @client_secret = token.client_secret
-      else
-        @client_id = highline.ask("client_id: ")
-        @client_secret = highline.ask("client_secret: ")
-      end
-
-      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
-
-      new_token = JSON.parse(token_store.load(email))
-      new_token["client_secret"] = client_secret
-      new_token.to_json
-    end
-
-    private
-
-    def email
-      account[:username]
-    end
-
-    def password
-      account[:password]
-    end
-
-    def token
-      @token ||= Gmail::Authenticator::ImapBackupToken.new(password)
-    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/spec/unit/gmail/authenticator_spec.rb

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

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