all: reformat with ktfmt

Signed-off-by: Harsh Shandilya <me@msfjarvis.dev>

8 files changed, 296 insertions, 300 deletions

diff --git a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/BreakOutOfDetached.kt b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/BreakOutOfDetached.kt
index 4b3f0154..196d6d48 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/BreakOutOfDetached.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/BreakOutOfDetached.kt
@@ -13,44 +13,45 @@ import org.eclipse.jgit.lib.RepositoryState
 
 class BreakOutOfDetached(callingActivity: ContinuationContainerActivity) : GitOperation(callingActivity) {
 
-    private val merging = repository.repositoryState == RepositoryState.MERGING
-    private val resetCommands = arrayOf(
-        // git checkout -b conflict-branch
-        git.checkout().setCreateBranch(true).setName("conflicting-$remoteBranch-${System.currentTimeMillis()}"),
-        // push the changes
-        git.push().setRemote("origin"),
-        // switch back to ${gitBranch}
-        git.checkout().setName(remoteBranch),
+  private val merging = repository.repositoryState == RepositoryState.MERGING
+  private val resetCommands =
+    arrayOf(
+      // git checkout -b conflict-branch
+      git.checkout().setCreateBranch(true).setName("conflicting-$remoteBranch-${System.currentTimeMillis()}"),
+      // push the changes
+      git.push().setRemote("origin"),
+      // switch back to ${gitBranch}
+      git.checkout().setName(remoteBranch),
     )
 
-    override val commands by lazy(LazyThreadSafetyMode.NONE) {
-        if (merging) {
-            // We need to run some non-command operations first
-            repository.writeMergeCommitMsg(null)
-            repository.writeMergeHeads(null)
-            arrayOf(
-                // reset hard back to our local HEAD
-                git.reset().setMode(ResetCommand.ResetType.HARD),
-                *resetCommands,
-            )
-        } else {
-            arrayOf(
-                // abort the rebase
-                git.rebase().setOperation(RebaseCommand.Operation.ABORT),
-                *resetCommands,
-            )
-        }
+  override val commands by lazy(LazyThreadSafetyMode.NONE) {
+    if (merging) {
+      // We need to run some non-command operations first
+      repository.writeMergeCommitMsg(null)
+      repository.writeMergeHeads(null)
+      arrayOf(
+        // reset hard back to our local HEAD
+        git.reset().setMode(ResetCommand.ResetType.HARD),
+        *resetCommands,
+      )
+    } else {
+      arrayOf(
+        // abort the rebase
+        git.rebase().setOperation(RebaseCommand.Operation.ABORT),
+        *resetCommands,
+      )
     }
+  }
 
-    override fun preExecute() = if (!git.repository.repositoryState.isRebasing && !merging) {
-        MaterialAlertDialogBuilder(callingActivity)
-            .setTitle(callingActivity.resources.getString(R.string.git_abort_and_push_title))
-            .setMessage(callingActivity.resources.getString(R.string.git_break_out_of_detached_unneeded))
-            .setPositiveButton(callingActivity.resources.getString(R.string.dialog_ok)) { _, _ ->
-                callingActivity.finish()
-            }.show()
-        false
+  override fun preExecute() =
+    if (!git.repository.repositoryState.isRebasing && !merging) {
+      MaterialAlertDialogBuilder(callingActivity)
+        .setTitle(callingActivity.resources.getString(R.string.git_abort_and_push_title))
+        .setMessage(callingActivity.resources.getString(R.string.git_break_out_of_detached_unneeded))
+        .setPositiveButton(callingActivity.resources.getString(R.string.dialog_ok)) { _, _ -> callingActivity.finish() }
+        .show()
+      false
     } else {
-        true
+      true
     }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/CloneOperation.kt b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/CloneOperation.kt
index 3efc9088..a5a4f5d0 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/CloneOperation.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/CloneOperation.kt
@@ -16,7 +16,8 @@ import org.eclipse.jgit.api.GitCommand
  */
 class CloneOperation(callingActivity: ContinuationContainerActivity, uri: String) : GitOperation(callingActivity) {
 
-    override val commands: Array<GitCommand<out Any>> = arrayOf(
-        Git.cloneRepository().setBranch(remoteBranch).setDirectory(repository.workTree).setURI(uri),
+  override val commands: Array<GitCommand<out Any>> =
+    arrayOf(
+      Git.cloneRepository().setBranch(remoteBranch).setDirectory(repository.workTree).setURI(uri),
     )
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/CredentialFinder.kt b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/CredentialFinder.kt
index 0833d935..40869cf2 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/CredentialFinder.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/CredentialFinder.kt
@@ -24,80 +24,71 @@ import dev.msfjarvis.aps.util.settings.PreferenceKeys
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 
-class CredentialFinder(
-    val callingActivity: FragmentActivity,
-    val authMode: AuthMode
-) : InteractivePasswordFinder() {
+class CredentialFinder(val callingActivity: FragmentActivity, val authMode: AuthMode) : InteractivePasswordFinder() {
 
-    override fun askForPassword(cont: Continuation<String?>, isRetry: Boolean) {
-        val gitOperationPrefs = callingActivity.getEncryptedGitPrefs()
-        val credentialPref: String
-        @StringRes val messageRes: Int
-        @StringRes val hintRes: Int
-        @StringRes val rememberRes: Int
-        @StringRes val errorRes: Int
-        when (authMode) {
-            AuthMode.SshKey -> {
-                credentialPref = PreferenceKeys.SSH_KEY_LOCAL_PASSPHRASE
-                messageRes = R.string.passphrase_dialog_text
-                hintRes = R.string.ssh_keygen_passphrase
-                rememberRes = R.string.git_operation_remember_passphrase
-                errorRes = R.string.git_operation_wrong_passphrase
-            }
-            AuthMode.Password -> {
-                // Could be either an SSH or an HTTPS password
-                credentialPref = PreferenceKeys.HTTPS_PASSWORD
-                messageRes = R.string.password_dialog_text
-                hintRes = R.string.git_operation_hint_password
-                rememberRes = R.string.git_operation_remember_password
-                errorRes = R.string.git_operation_wrong_password
-            }
-            else -> throw IllegalStateException("Only SshKey and Password connection mode ask for passwords")
-        }
-        if (isRetry)
-            gitOperationPrefs.edit { remove(credentialPref) }
-        val storedCredential = gitOperationPrefs.getString(credentialPref, null)
-        if (storedCredential == null) {
-            val layoutInflater = LayoutInflater.from(callingActivity)
+  override fun askForPassword(cont: Continuation<String?>, isRetry: Boolean) {
+    val gitOperationPrefs = callingActivity.getEncryptedGitPrefs()
+    val credentialPref: String
+    @StringRes val messageRes: Int
+    @StringRes val hintRes: Int
+    @StringRes val rememberRes: Int
+    @StringRes val errorRes: Int
+    when (authMode) {
+      AuthMode.SshKey -> {
+        credentialPref = PreferenceKeys.SSH_KEY_LOCAL_PASSPHRASE
+        messageRes = R.string.passphrase_dialog_text
+        hintRes = R.string.ssh_keygen_passphrase
+        rememberRes = R.string.git_operation_remember_passphrase
+        errorRes = R.string.git_operation_wrong_passphrase
+      }
+      AuthMode.Password -> {
+        // Could be either an SSH or an HTTPS password
+        credentialPref = PreferenceKeys.HTTPS_PASSWORD
+        messageRes = R.string.password_dialog_text
+        hintRes = R.string.git_operation_hint_password
+        rememberRes = R.string.git_operation_remember_password
+        errorRes = R.string.git_operation_wrong_password
+      }
+      else -> throw IllegalStateException("Only SshKey and Password connection mode ask for passwords")
+    }
+    if (isRetry) gitOperationPrefs.edit { remove(credentialPref) }
+    val storedCredential = gitOperationPrefs.getString(credentialPref, null)
+    if (storedCredential == null) {
+      val layoutInflater = LayoutInflater.from(callingActivity)
 
-            @SuppressLint("InflateParams")
-            val dialogView = layoutInflater.inflate(R.layout.git_credential_layout, null)
-            val credentialLayout = dialogView.findViewById<TextInputLayout>(R.id.git_auth_passphrase_layout)
-            val editCredential = dialogView.findViewById<TextInputEditText>(R.id.git_auth_credential)
-            editCredential.setHint(hintRes)
-            val rememberCredential = dialogView.findViewById<MaterialCheckBox>(R.id.git_auth_remember_credential)
-            rememberCredential.setText(rememberRes)
-            if (isRetry) {
-                credentialLayout.error = callingActivity.resources.getString(errorRes)
-                // Reset error when user starts entering a password
-                editCredential.doOnTextChanged { _, _, _, _ -> credentialLayout.error = null }
-            }
-            MaterialAlertDialogBuilder(callingActivity).run {
-                setTitle(R.string.passphrase_dialog_title)
-                setMessage(messageRes)
-                setView(dialogView)
-                setPositiveButton(R.string.dialog_ok) { _, _ ->
-                    val credential = editCredential.text.toString()
-                    if (rememberCredential.isChecked) {
-                        gitOperationPrefs.edit {
-                            putString(credentialPref, credential)
-                        }
-                    }
-                    cont.resume(credential)
-                }
-                setNegativeButton(R.string.dialog_cancel) { _, _ ->
-                    cont.resume(null)
-                }
-                setOnCancelListener {
-                    cont.resume(null)
-                }
-                create()
-            }.run {
-                requestInputFocusOnView<TextInputEditText>(R.id.git_auth_credential)
-                show()
+      @SuppressLint("InflateParams") val dialogView = layoutInflater.inflate(R.layout.git_credential_layout, null)
+      val credentialLayout = dialogView.findViewById<TextInputLayout>(R.id.git_auth_passphrase_layout)
+      val editCredential = dialogView.findViewById<TextInputEditText>(R.id.git_auth_credential)
+      editCredential.setHint(hintRes)
+      val rememberCredential = dialogView.findViewById<MaterialCheckBox>(R.id.git_auth_remember_credential)
+      rememberCredential.setText(rememberRes)
+      if (isRetry) {
+        credentialLayout.error = callingActivity.resources.getString(errorRes)
+        // Reset error when user starts entering a password
+        editCredential.doOnTextChanged { _, _, _, _ -> credentialLayout.error = null }
+      }
+      MaterialAlertDialogBuilder(callingActivity)
+        .run {
+          setTitle(R.string.passphrase_dialog_title)
+          setMessage(messageRes)
+          setView(dialogView)
+          setPositiveButton(R.string.dialog_ok) { _, _ ->
+            val credential = editCredential.text.toString()
+            if (rememberCredential.isChecked) {
+              gitOperationPrefs.edit { putString(credentialPref, credential) }
             }
-        } else {
-            cont.resume(storedCredential)
+            cont.resume(credential)
+          }
+          setNegativeButton(R.string.dialog_cancel) { _, _ -> cont.resume(null) }
+          setOnCancelListener { cont.resume(null) }
+          create()
+        }
+        .run {
+          requestInputFocusOnView<TextInputEditText>(R.id.git_auth_credential)
+          show()
         }
+    } else {
+      cont.resume(storedCredential)
     }
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/GitOperation.kt b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/GitOperation.kt
index 128ca578..0d0dac9c 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/GitOperation.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/GitOperation.kt
@@ -50,170 +50,167 @@ import org.eclipse.jgit.transport.URIish
  */
 abstract class GitOperation(protected val callingActivity: FragmentActivity) {
 
-    abstract val commands: Array<GitCommand<out Any>>
-    private val hostKeyFile = callingActivity.filesDir.resolve(".host_key")
-    private var sshSessionFactory: SshjSessionFactory? = null
-
-    protected val repository = PasswordRepository.getRepository(null)!!
-    protected val git = Git(repository)
-    protected val remoteBranch = GitSettings.branch
-    private val authActivity get() = callingActivity as ContinuationContainerActivity
-
-    private class HttpsCredentialsProvider(private val passwordFinder: PasswordFinder) : CredentialsProvider() {
-
-        private var cachedPassword: CharArray? = null
-
-        override fun isInteractive() = true
-
-        override fun get(uri: URIish?, vararg items: CredentialItem): Boolean {
-            for (item in items) {
-                when (item) {
-                    is CredentialItem.Username -> item.value = uri?.user
-                    is CredentialItem.Password -> {
-                        item.value = cachedPassword?.clone()
-                            ?: passwordFinder.reqPassword(null).also {
-                                cachedPassword = it.clone()
-                            }
-                    }
-                    else -> UnsupportedCredentialItem(uri, item.javaClass.name)
-                }
-            }
-            return true
-        }
-
-        override fun supports(vararg items: CredentialItem) = items.all {
-            it is CredentialItem.Username || it is CredentialItem.Password
-        }
-
-        override fun reset(uri: URIish?) {
-            cachedPassword?.fill(0.toChar())
-            cachedPassword = null
+  abstract val commands: Array<GitCommand<out Any>>
+  private val hostKeyFile = callingActivity.filesDir.resolve(".host_key")
+  private var sshSessionFactory: SshjSessionFactory? = null
+
+  protected val repository = PasswordRepository.getRepository(null)!!
+  protected val git = Git(repository)
+  protected val remoteBranch = GitSettings.branch
+  private val authActivity
+    get() = callingActivity as ContinuationContainerActivity
+
+  private class HttpsCredentialsProvider(private val passwordFinder: PasswordFinder) : CredentialsProvider() {
+
+    private var cachedPassword: CharArray? = null
+
+    override fun isInteractive() = true
+
+    override fun get(uri: URIish?, vararg items: CredentialItem): Boolean {
+      for (item in items) {
+        when (item) {
+          is CredentialItem.Username -> item.value = uri?.user
+          is CredentialItem.Password -> {
+            item.value =
+              cachedPassword?.clone() ?: passwordFinder.reqPassword(null).also { cachedPassword = it.clone() }
+          }
+          else -> UnsupportedCredentialItem(uri, item.javaClass.name)
         }
+      }
+      return true
     }
 
-    private fun getSshKey(make: Boolean) {
-        runCatching {
-            val intent = if (make) {
-                Intent(callingActivity.applicationContext, SshKeyGenActivity::class.java)
-            } else {
-                Intent(callingActivity.applicationContext, SshKeyImportActivity::class.java)
-            }
-            callingActivity.startActivity(intent)
-        }.onFailure { e ->
-            e(e)
-        }
-    }
+    override fun supports(vararg items: CredentialItem) =
+      items.all { it is CredentialItem.Username || it is CredentialItem.Password }
 
-    private fun registerAuthProviders(authMethod: SshAuthMethod, credentialsProvider: CredentialsProvider? = null) {
-        sshSessionFactory = SshjSessionFactory(authMethod, hostKeyFile)
-        commands.filterIsInstance<TransportCommand<*, *>>().forEach { command ->
-            command.setTransportConfigCallback { transport: Transport ->
-                (transport as? SshTransport)?.sshSessionFactory = sshSessionFactory
-                credentialsProvider?.let { transport.credentialsProvider = it }
-            }
-            command.setTimeout(CONNECT_TIMEOUT)
-        }
+    override fun reset(uri: URIish?) {
+      cachedPassword?.fill(0.toChar())
+      cachedPassword = null
     }
-
-    /**
-     * Executes the GitCommand in an async task.
-     */
-    suspend fun execute(): Result<Unit, Throwable> {
-        if (!preExecute()) {
-            return Ok(Unit)
+  }
+
+  private fun getSshKey(make: Boolean) {
+    runCatching {
+      val intent =
+        if (make) {
+          Intent(callingActivity.applicationContext, SshKeyGenActivity::class.java)
+        } else {
+          Intent(callingActivity.applicationContext, SshKeyImportActivity::class.java)
         }
-        val operationResult = GitCommandExecutor(
-            callingActivity,
-            this,
-        ).execute()
-        postExecute()
-        return operationResult
+      callingActivity.startActivity(intent)
     }
-
-    private fun onMissingSshKeyFile() {
-        MaterialAlertDialogBuilder(callingActivity)
-            .setMessage(callingActivity.resources.getString(R.string.ssh_preferences_dialog_text))
-            .setTitle(callingActivity.resources.getString(R.string.ssh_preferences_dialog_title))
-            .setPositiveButton(callingActivity.resources.getString(R.string.ssh_preferences_dialog_import)) { _, _ ->
-                getSshKey(false)
-            }
-            .setNegativeButton(callingActivity.resources.getString(R.string.ssh_preferences_dialog_generate)) { _, _ ->
-                getSshKey(true)
-            }
-            .setNeutralButton(callingActivity.resources.getString(R.string.dialog_cancel)) { _, _ ->
-                // Finish the blank GitActivity so user doesn't have to press back
-                callingActivity.finish()
-            }.show()
+      .onFailure { e -> e(e) }
+  }
+
+  private fun registerAuthProviders(authMethod: SshAuthMethod, credentialsProvider: CredentialsProvider? = null) {
+    sshSessionFactory = SshjSessionFactory(authMethod, hostKeyFile)
+    commands.filterIsInstance<TransportCommand<*, *>>().forEach { command ->
+      command.setTransportConfigCallback { transport: Transport ->
+        (transport as? SshTransport)?.sshSessionFactory = sshSessionFactory
+        credentialsProvider?.let { transport.credentialsProvider = it }
+      }
+      command.setTimeout(CONNECT_TIMEOUT)
     }
+  }
 
-    suspend fun executeAfterAuthentication(authMode: AuthMode): Result<Unit, Throwable> {
-        when (authMode) {
-            AuthMode.SshKey -> if (SshKey.exists) {
-                if (SshKey.mustAuthenticate) {
-                    val result = withContext(Dispatchers.Main) {
-                        suspendCoroutine<BiometricAuthenticator.Result> { cont ->
-                            BiometricAuthenticator.authenticate(callingActivity, R.string.biometric_prompt_title_ssh_auth) {
-                                if (it !is BiometricAuthenticator.Result.Failure)
-                                    cont.resume(it)
-                            }
-                        }
-                    }
-                    when (result) {
-                        is BiometricAuthenticator.Result.Success -> {
-                            registerAuthProviders(SshAuthMethod.SshKey(authActivity))
-                        }
-                        is BiometricAuthenticator.Result.Cancelled -> {
-                            return Err(SSHException(DisconnectReason.AUTH_CANCELLED_BY_USER))
-                        }
-                        is BiometricAuthenticator.Result.Failure -> {
-                            throw IllegalStateException("Biometric authentication failures should be ignored")
-                        }
-                        else -> {
-                            // There is a chance we succeed if the user recently confirmed
-                            // their screen lock. Doing so would have a potential to confuse
-                            // users though, who might deduce that the screen lock
-                            // protection is not effective. Hence, we fail with an error.
-                            Toast.makeText(callingActivity.applicationContext, R.string.biometric_auth_generic_failure, Toast.LENGTH_LONG).show()
-                            callingActivity.finish()
-                        }
-                    }
-                } else {
-                    registerAuthProviders(SshAuthMethod.SshKey(authActivity))
+  /** Executes the GitCommand in an async task. */
+  suspend fun execute(): Result<Unit, Throwable> {
+    if (!preExecute()) {
+      return Ok(Unit)
+    }
+    val operationResult =
+      GitCommandExecutor(
+          callingActivity,
+          this,
+        )
+        .execute()
+    postExecute()
+    return operationResult
+  }
+
+  private fun onMissingSshKeyFile() {
+    MaterialAlertDialogBuilder(callingActivity)
+      .setMessage(callingActivity.resources.getString(R.string.ssh_preferences_dialog_text))
+      .setTitle(callingActivity.resources.getString(R.string.ssh_preferences_dialog_title))
+      .setPositiveButton(callingActivity.resources.getString(R.string.ssh_preferences_dialog_import)) { _, _ ->
+        getSshKey(false)
+      }
+      .setNegativeButton(callingActivity.resources.getString(R.string.ssh_preferences_dialog_generate)) { _, _ ->
+        getSshKey(true)
+      }
+      .setNeutralButton(callingActivity.resources.getString(R.string.dialog_cancel)) { _, _ ->
+        // Finish the blank GitActivity so user doesn't have to press back
+        callingActivity.finish()
+      }
+      .show()
+  }
+
+  suspend fun executeAfterAuthentication(authMode: AuthMode): Result<Unit, Throwable> {
+    when (authMode) {
+      AuthMode.SshKey ->
+        if (SshKey.exists) {
+          if (SshKey.mustAuthenticate) {
+            val result =
+              withContext(Dispatchers.Main) {
+                suspendCoroutine<BiometricAuthenticator.Result> { cont ->
+                  BiometricAuthenticator.authenticate(callingActivity, R.string.biometric_prompt_title_ssh_auth) {
+                    if (it !is BiometricAuthenticator.Result.Failure) cont.resume(it)
+                  }
                 }
-            } else {
-                onMissingSshKeyFile()
-                // This would correctly cancel the operation but won't surface a user-visible
-                // error, allowing users to make the SSH key selection.
+              }
+            when (result) {
+              is BiometricAuthenticator.Result.Success -> {
+                registerAuthProviders(SshAuthMethod.SshKey(authActivity))
+              }
+              is BiometricAuthenticator.Result.Cancelled -> {
                 return Err(SSHException(DisconnectReason.AUTH_CANCELLED_BY_USER))
+              }
+              is BiometricAuthenticator.Result.Failure -> {
+                throw IllegalStateException("Biometric authentication failures should be ignored")
+              }
+              else -> {
+                // There is a chance we succeed if the user recently confirmed
+                // their screen lock. Doing so would have a potential to confuse
+                // users though, who might deduce that the screen lock
+                // protection is not effective. Hence, we fail with an error.
+                Toast.makeText(
+                    callingActivity.applicationContext,
+                    R.string.biometric_auth_generic_failure,
+                    Toast.LENGTH_LONG
+                  )
+                  .show()
+                callingActivity.finish()
+              }
             }
-            AuthMode.OpenKeychain -> registerAuthProviders(SshAuthMethod.OpenKeychain(authActivity))
-            AuthMode.Password -> {
-                val httpsCredentialProvider = HttpsCredentialsProvider(CredentialFinder(callingActivity, AuthMode.Password))
-                registerAuthProviders(SshAuthMethod.Password(authActivity), httpsCredentialProvider)
-            }
-            AuthMode.None -> {
-            }
+          } else {
+            registerAuthProviders(SshAuthMethod.SshKey(authActivity))
+          }
+        } else {
+          onMissingSshKeyFile()
+          // This would correctly cancel the operation but won't surface a user-visible
+          // error, allowing users to make the SSH key selection.
+          return Err(SSHException(DisconnectReason.AUTH_CANCELLED_BY_USER))
         }
-        return execute()
+      AuthMode.OpenKeychain -> registerAuthProviders(SshAuthMethod.OpenKeychain(authActivity))
+      AuthMode.Password -> {
+        val httpsCredentialProvider = HttpsCredentialsProvider(CredentialFinder(callingActivity, AuthMode.Password))
+        registerAuthProviders(SshAuthMethod.Password(authActivity), httpsCredentialProvider)
+      }
+      AuthMode.None -> {}
     }
+    return execute()
+  }
 
-    /**
-     * Called before execution of the Git operation.
-     * Return false to cancel.
-     */
-    open fun preExecute() = true
+  /** Called before execution of the Git operation. Return false to cancel. */
+  open fun preExecute() = true
 
-    private suspend fun postExecute() {
-        withContext(Dispatchers.IO) {
-            sshSessionFactory?.close()
-        }
-    }
+  private suspend fun postExecute() {
+    withContext(Dispatchers.IO) { sshSessionFactory?.close() }
+  }
 
-    companion object {
+  companion object {
 
-        /**
-         * Timeout in seconds before [TransportCommand] will abort a stalled IO operation.
-         */
-        private const val CONNECT_TIMEOUT = 10
-    }
+    /** Timeout in seconds before [TransportCommand] will abort a stalled IO operation. */
+    private const val CONNECT_TIMEOUT = 10
+  }
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/PullOperation.kt b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/PullOperation.kt
index e517aac0..394b7cb4 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/PullOperation.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/PullOperation.kt
@@ -8,27 +8,28 @@ import dev.msfjarvis.aps.util.git.sshj.ContinuationContainerActivity
 import org.eclipse.jgit.api.GitCommand
 
 class PullOperation(
-    callingActivity: ContinuationContainerActivity,
-    rebase: Boolean,
+  callingActivity: ContinuationContainerActivity,
+  rebase: Boolean,
 ) : GitOperation(callingActivity) {
 
-    /**
-     * The story of why the pull operation is committing files goes like this: Once upon a time when
-     * the world was burning and Blade Runner 2049 was real life (in the worst way), we were made
-     * aware that Bitbucket is actually bad, and disables a neat OpenSSH feature called multiplexing.
-     * So now, rather than being able to do a [SyncOperation], we'd have to first do a [PullOperation]
-     * and then a [PushOperation]. To make the behavior identical despite this suboptimal situation,
-     * we opted to replicate [SyncOperation]'s committing flow within [PullOperation], almost exactly
-     * replicating [SyncOperation] but leaving the pushing part to [PushOperation].
-     */
-    override val commands: Array<GitCommand<out Any>> = arrayOf(
-        // Stage all files
-        git.add().addFilepattern("."),
-        // Populate the changed files count
-        git.status(),
-        // Commit everything! If needed, obviously.
-        git.commit().setAll(true).setMessage("[Android Password Store] Sync"),
-        // Pull and rebase on top of the remote branch
-        git.pull().setRebase(rebase).setRemote("origin"),
+  /**
+   * The story of why the pull operation is committing files goes like this: Once upon a time when
+   * the world was burning and Blade Runner 2049 was real life (in the worst way), we were made
+   * aware that Bitbucket is actually bad, and disables a neat OpenSSH feature called multiplexing.
+   * So now, rather than being able to do a [SyncOperation], we'd have to first do a [PullOperation]
+   * and then a [PushOperation]. To make the behavior identical despite this suboptimal situation,
+   * we opted to replicate [SyncOperation]'s committing flow within [PullOperation], almost exactly
+   * replicating [SyncOperation] but leaving the pushing part to [PushOperation].
+   */
+  override val commands: Array<GitCommand<out Any>> =
+    arrayOf(
+      // Stage all files
+      git.add().addFilepattern("."),
+      // Populate the changed files count
+      git.status(),
+      // Commit everything! If needed, obviously.
+      git.commit().setAll(true).setMessage("[Android Password Store] Sync"),
+      // Pull and rebase on top of the remote branch
+      git.pull().setRebase(rebase).setRemote("origin"),
     )
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/PushOperation.kt b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/PushOperation.kt
index de07087e..a9f168ad 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/PushOperation.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/PushOperation.kt
@@ -9,7 +9,8 @@ import org.eclipse.jgit.api.GitCommand
 
 class PushOperation(callingActivity: ContinuationContainerActivity) : GitOperation(callingActivity) {
 
-    override val commands: Array<GitCommand<out Any>> = arrayOf(
-        git.push().setPushAll().setRemote("origin"),
+  override val commands: Array<GitCommand<out Any>> =
+    arrayOf(
+      git.push().setPushAll().setRemote("origin"),
     )
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/ResetToRemoteOperation.kt b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/ResetToRemoteOperation.kt
index 80848602..dccd69b0 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/ResetToRemoteOperation.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/ResetToRemoteOperation.kt
@@ -9,15 +9,18 @@ import org.eclipse.jgit.api.ResetCommand
 
 class ResetToRemoteOperation(callingActivity: ContinuationContainerActivity) : GitOperation(callingActivity) {
 
-    override val commands = arrayOf(
-        // Stage all files
-        git.add().addFilepattern("."),
-        // Fetch everything from the origin remote
-        git.fetch().setRemote("origin"),
-        // Do a hard reset to the remote branch. Equivalent to git reset --hard origin/$remoteBranch
-        git.reset().setRef("origin/$remoteBranch").setMode(ResetCommand.ResetType.HARD),
-        // Force-create $remoteBranch if it doesn't exist. This covers the case where you switched
-        // branches from 'master' to anything else.
-        git.branchCreate().setName(remoteBranch).setForce(true),
+  override val commands =
+    arrayOf(
+      // Stage all files
+      git.add().addFilepattern("."),
+      // Fetch everything from the origin remote
+      git.fetch().setRemote("origin"),
+      // Do a hard reset to the remote branch. Equivalent to git reset --hard
+      // origin/$remoteBranch
+      git.reset().setRef("origin/$remoteBranch").setMode(ResetCommand.ResetType.HARD),
+      // Force-create $remoteBranch if it doesn't exist. This covers the case where you
+      // switched
+      // branches from 'master' to anything else.
+      git.branchCreate().setName(remoteBranch).setForce(true),
     )
 }
diff --git a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/SyncOperation.kt b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/SyncOperation.kt
index fc63ce0c..589c6305 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/git/operation/SyncOperation.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/git/operation/SyncOperation.kt
@@ -7,20 +7,21 @@ package dev.msfjarvis.aps.util.git.operation
 import dev.msfjarvis.aps.util.git.sshj.ContinuationContainerActivity
 
 class SyncOperation(
-    callingActivity: ContinuationContainerActivity,
-    rebase: Boolean,
+  callingActivity: ContinuationContainerActivity,
+  rebase: Boolean,
 ) : GitOperation(callingActivity) {
 
-    override val commands = arrayOf(
-        // Stage all files
-        git.add().addFilepattern("."),
-        // Populate the changed files count
-        git.status(),
-        // Commit everything! If needed, obviously.
-        git.commit().setAll(true).setMessage("[Android Password Store] Sync"),
-        // Pull and rebase on top of the remote branch
-        git.pull().setRebase(rebase).setRemote("origin"),
-        // Push it all back
-        git.push().setPushAll().setRemote("origin"),
+  override val commands =
+    arrayOf(
+      // Stage all files
+      git.add().addFilepattern("."),
+      // Populate the changed files count
+      git.status(),
+      // Commit everything! If needed, obviously.
+      git.commit().setAll(true).setMessage("[Android Password Store] Sync"),
+      // Pull and rebase on top of the remote branch
+      git.pull().setRebase(rebase).setRemote("origin"),
+      // Push it all back
+      git.push().setPushAll().setRemote("origin"),
     )
 }