all: reformat with ktfmt

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

1 files changed, 147 insertions, 170 deletions

diff --git a/app/src/main/java/dev/msfjarvis/aps/util/settings/GitSettings.kt b/app/src/main/java/dev/msfjarvis/aps/util/settings/GitSettings.kt
index 79ee13d5..3a508e45 100644
--- a/app/src/main/java/dev/msfjarvis/aps/util/settings/GitSettings.kt
+++ b/app/src/main/java/dev/msfjarvis/aps/util/settings/GitSettings.kt
@@ -17,191 +17,168 @@ import java.io.File
 import org.eclipse.jgit.transport.URIish
 
 enum class Protocol(val pref: String) {
-    Ssh("ssh://"),
-    Https("https://"),
-    ;
+  Ssh("ssh://"),
+  Https("https://"),
+  ;
 
-    companion object {
+  companion object {
 
-        private val map = values().associateBy(Protocol::pref)
-        fun fromString(type: String?): Protocol {
-            return map[type ?: return Ssh]
-                ?: throw IllegalArgumentException("$type is not a valid Protocol")
-        }
+    private val map = values().associateBy(Protocol::pref)
+    fun fromString(type: String?): Protocol {
+      return map[type ?: return Ssh] ?: throw IllegalArgumentException("$type is not a valid Protocol")
     }
+  }
 }
 
 enum class AuthMode(val pref: String) {
-    SshKey("ssh-key"),
-    Password("username/password"),
-    OpenKeychain("OpenKeychain"),
-    None("None"),
-    ;
-
-    companion object {
-
-        private val map = values().associateBy(AuthMode::pref)
-        fun fromString(type: String?): AuthMode {
-            return map[type ?: return SshKey]
-                ?: throw IllegalArgumentException("$type is not a valid AuthMode")
-        }
+  SshKey("ssh-key"),
+  Password("username/password"),
+  OpenKeychain("OpenKeychain"),
+  None("None"),
+  ;
+
+  companion object {
+
+    private val map = values().associateBy(AuthMode::pref)
+    fun fromString(type: String?): AuthMode {
+      return map[type ?: return SshKey] ?: throw IllegalArgumentException("$type is not a valid AuthMode")
     }
+  }
 }
 
 object GitSettings {
 
-    private const val DEFAULT_BRANCH = "master"
-
-    private val settings by lazy(LazyThreadSafetyMode.PUBLICATION) { Application.instance.sharedPrefs }
-    private val encryptedSettings by lazy(LazyThreadSafetyMode.PUBLICATION) { Application.instance.getEncryptedGitPrefs() }
-    private val proxySettings by lazy(LazyThreadSafetyMode.PUBLICATION) { Application.instance.getEncryptedProxyPrefs() }
-    private val hostKeyPath by lazy(LazyThreadSafetyMode.NONE) { "${Application.instance.filesDir}/.host_key" }
-
-    var authMode
-        get() = AuthMode.fromString(settings.getString(PreferenceKeys.GIT_REMOTE_AUTH))
-        private set(value) {
-            settings.edit {
-                putString(PreferenceKeys.GIT_REMOTE_AUTH, value.pref)
-            }
-        }
-
-    var url
-        get() = settings.getString(PreferenceKeys.GIT_REMOTE_URL)
-        private set(value) {
-            require(value != null)
-            if (value == url)
-                return
-            settings.edit {
-                putString(PreferenceKeys.GIT_REMOTE_URL, value)
-            }
-            if (PasswordRepository.isInitialized)
-                PasswordRepository.addRemote("origin", value, true)
-            // When the server changes, remote password, multiplexing support and host key file
-            // should be deleted/reset.
-            useMultiplexing = true
-            encryptedSettings.edit { remove(PreferenceKeys.HTTPS_PASSWORD) }
-            clearSavedHostKey()
-        }
-
-    var authorName
-        get() = settings.getString(PreferenceKeys.GIT_CONFIG_AUTHOR_NAME) ?: ""
-        set(value) {
-            settings.edit {
-                putString(PreferenceKeys.GIT_CONFIG_AUTHOR_NAME, value)
-            }
-        }
-
-    var authorEmail
-        get() = settings.getString(PreferenceKeys.GIT_CONFIG_AUTHOR_EMAIL) ?: ""
-        set(value) {
-            settings.edit {
-                putString(PreferenceKeys.GIT_CONFIG_AUTHOR_EMAIL, value)
-            }
-        }
-
-    var branch
-        get() = settings.getString(PreferenceKeys.GIT_BRANCH_NAME) ?: DEFAULT_BRANCH
-        private set(value) {
-            settings.edit {
-                putString(PreferenceKeys.GIT_BRANCH_NAME, value)
-            }
-        }
-
-    var useMultiplexing
-        get() = settings.getBoolean(PreferenceKeys.GIT_REMOTE_USE_MULTIPLEXING, true)
-        set(value) {
-            settings.edit {
-                putBoolean(PreferenceKeys.GIT_REMOTE_USE_MULTIPLEXING, value)
-            }
-        }
-
-    var proxyHost
-        get() = proxySettings.getString(PreferenceKeys.PROXY_HOST)
-        set(value) {
-            proxySettings.edit {
-                putString(PreferenceKeys.PROXY_HOST, value)
-            }
-        }
-
-    var proxyPort
-        get() = proxySettings.getInt(PreferenceKeys.PROXY_PORT, -1)
-        set(value) {
-            proxySettings.edit {
-                putInt(PreferenceKeys.PROXY_PORT, value)
-            }
-        }
-
-    var proxyUsername
-        get() = settings.getString(PreferenceKeys.PROXY_USERNAME)
-        set(value) {
-            proxySettings.edit {
-                putString(PreferenceKeys.PROXY_USERNAME, value)
-            }
-        }
-
-    var proxyPassword
-        get() = proxySettings.getString(PreferenceKeys.PROXY_PASSWORD)
-        set(value) {
-            proxySettings.edit {
-                putString(PreferenceKeys.PROXY_PASSWORD, value)
-            }
-        }
-
-    var rebaseOnPull
-        get() = settings.getBoolean(PreferenceKeys.REBASE_ON_PULL, true)
-        set(value) {
-            settings.edit {
-                putBoolean(PreferenceKeys.REBASE_ON_PULL, value)
-            }
-        }
-
-    sealed class UpdateConnectionSettingsResult {
-        class MissingUsername(val newProtocol: Protocol) : UpdateConnectionSettingsResult()
-        class AuthModeMismatch(val newProtocol: Protocol, val validModes: List<AuthMode>) : UpdateConnectionSettingsResult()
-        object Valid : UpdateConnectionSettingsResult()
-        object FailedToParseUrl : UpdateConnectionSettingsResult()
+  private const val DEFAULT_BRANCH = "master"
+
+  private val settings by lazy(LazyThreadSafetyMode.PUBLICATION) { Application.instance.sharedPrefs }
+  private val encryptedSettings by lazy(LazyThreadSafetyMode.PUBLICATION) {
+    Application.instance.getEncryptedGitPrefs()
+  }
+  private val proxySettings by lazy(LazyThreadSafetyMode.PUBLICATION) { Application.instance.getEncryptedProxyPrefs() }
+  private val hostKeyPath by lazy(LazyThreadSafetyMode.NONE) { "${Application.instance.filesDir}/.host_key" }
+
+  var authMode
+    get() = AuthMode.fromString(settings.getString(PreferenceKeys.GIT_REMOTE_AUTH))
+    private set(value) {
+      settings.edit { putString(PreferenceKeys.GIT_REMOTE_AUTH, value.pref) }
+    }
+
+  var url
+    get() = settings.getString(PreferenceKeys.GIT_REMOTE_URL)
+    private set(value) {
+      require(value != null)
+      if (value == url) return
+      settings.edit { putString(PreferenceKeys.GIT_REMOTE_URL, value) }
+      if (PasswordRepository.isInitialized) PasswordRepository.addRemote("origin", value, true)
+      // When the server changes, remote password, multiplexing support and host key file
+      // should be deleted/reset.
+      useMultiplexing = true
+      encryptedSettings.edit { remove(PreferenceKeys.HTTPS_PASSWORD) }
+      clearSavedHostKey()
+    }
+
+  var authorName
+    get() = settings.getString(PreferenceKeys.GIT_CONFIG_AUTHOR_NAME) ?: ""
+    set(value) {
+      settings.edit { putString(PreferenceKeys.GIT_CONFIG_AUTHOR_NAME, value) }
+    }
+
+  var authorEmail
+    get() = settings.getString(PreferenceKeys.GIT_CONFIG_AUTHOR_EMAIL) ?: ""
+    set(value) {
+      settings.edit { putString(PreferenceKeys.GIT_CONFIG_AUTHOR_EMAIL, value) }
+    }
+
+  var branch
+    get() = settings.getString(PreferenceKeys.GIT_BRANCH_NAME) ?: DEFAULT_BRANCH
+    private set(value) {
+      settings.edit { putString(PreferenceKeys.GIT_BRANCH_NAME, value) }
     }
 
-    fun updateConnectionSettingsIfValid(newAuthMode: AuthMode, newUrl: String, newBranch: String): UpdateConnectionSettingsResult {
-        val parsedUrl = runCatching {
-            URIish(newUrl)
-        }.getOrElse {
-            return UpdateConnectionSettingsResult.FailedToParseUrl
-        }
-        val newProtocol = when (parsedUrl.scheme) {
-            in listOf("http", "https") -> Protocol.Https
-            in listOf("ssh", null) -> Protocol.Ssh
-            else -> return UpdateConnectionSettingsResult.FailedToParseUrl
-        }
-        if (newAuthMode != AuthMode.None && parsedUrl.user.isNullOrBlank())
-            return UpdateConnectionSettingsResult.MissingUsername(newProtocol)
-
-        val validHttpsAuth = listOf(AuthMode.None, AuthMode.Password)
-        val validSshAuth = listOf(AuthMode.OpenKeychain, AuthMode.Password, AuthMode.SshKey)
-        when {
-            newProtocol == Protocol.Https && newAuthMode !in validHttpsAuth -> {
-                return UpdateConnectionSettingsResult.AuthModeMismatch(newProtocol, validHttpsAuth)
-            }
-            newProtocol == Protocol.Ssh && newAuthMode !in validSshAuth -> {
-                return UpdateConnectionSettingsResult.AuthModeMismatch(newProtocol, validSshAuth)
-            }
-        }
-
-        url = newUrl
-        authMode = newAuthMode
-        branch = newBranch
-        return UpdateConnectionSettingsResult.Valid
+  var useMultiplexing
+    get() = settings.getBoolean(PreferenceKeys.GIT_REMOTE_USE_MULTIPLEXING, true)
+    set(value) {
+      settings.edit { putBoolean(PreferenceKeys.GIT_REMOTE_USE_MULTIPLEXING, value) }
     }
 
-    /**
-     * Deletes a previously saved SSH host key
-     */
-    fun clearSavedHostKey() {
-        File(hostKeyPath).delete()
+  var proxyHost
+    get() = proxySettings.getString(PreferenceKeys.PROXY_HOST)
+    set(value) {
+      proxySettings.edit { putString(PreferenceKeys.PROXY_HOST, value) }
     }
 
-    /**
-     * Returns true if a host key was previously saved
-     */
-    fun hasSavedHostKey(): Boolean = File(hostKeyPath).exists()
+  var proxyPort
+    get() = proxySettings.getInt(PreferenceKeys.PROXY_PORT, -1)
+    set(value) {
+      proxySettings.edit { putInt(PreferenceKeys.PROXY_PORT, value) }
+    }
+
+  var proxyUsername
+    get() = settings.getString(PreferenceKeys.PROXY_USERNAME)
+    set(value) {
+      proxySettings.edit { putString(PreferenceKeys.PROXY_USERNAME, value) }
+    }
+
+  var proxyPassword
+    get() = proxySettings.getString(PreferenceKeys.PROXY_PASSWORD)
+    set(value) {
+      proxySettings.edit { putString(PreferenceKeys.PROXY_PASSWORD, value) }
+    }
+
+  var rebaseOnPull
+    get() = settings.getBoolean(PreferenceKeys.REBASE_ON_PULL, true)
+    set(value) {
+      settings.edit { putBoolean(PreferenceKeys.REBASE_ON_PULL, value) }
+    }
+
+  sealed class UpdateConnectionSettingsResult {
+    class MissingUsername(val newProtocol: Protocol) : UpdateConnectionSettingsResult()
+    class AuthModeMismatch(val newProtocol: Protocol, val validModes: List<AuthMode>) :
+      UpdateConnectionSettingsResult()
+    object Valid : UpdateConnectionSettingsResult()
+    object FailedToParseUrl : UpdateConnectionSettingsResult()
+  }
+
+  fun updateConnectionSettingsIfValid(
+    newAuthMode: AuthMode,
+    newUrl: String,
+    newBranch: String
+  ): UpdateConnectionSettingsResult {
+    val parsedUrl =
+      runCatching { URIish(newUrl) }.getOrElse {
+        return UpdateConnectionSettingsResult.FailedToParseUrl
+      }
+    val newProtocol =
+      when (parsedUrl.scheme) {
+        in listOf("http", "https") -> Protocol.Https
+        in listOf("ssh", null) -> Protocol.Ssh
+        else -> return UpdateConnectionSettingsResult.FailedToParseUrl
+      }
+    if (newAuthMode != AuthMode.None && parsedUrl.user.isNullOrBlank())
+      return UpdateConnectionSettingsResult.MissingUsername(newProtocol)
+
+    val validHttpsAuth = listOf(AuthMode.None, AuthMode.Password)
+    val validSshAuth = listOf(AuthMode.OpenKeychain, AuthMode.Password, AuthMode.SshKey)
+    when {
+      newProtocol == Protocol.Https && newAuthMode !in validHttpsAuth -> {
+        return UpdateConnectionSettingsResult.AuthModeMismatch(newProtocol, validHttpsAuth)
+      }
+      newProtocol == Protocol.Ssh && newAuthMode !in validSshAuth -> {
+        return UpdateConnectionSettingsResult.AuthModeMismatch(newProtocol, validSshAuth)
+      }
+    }
+
+    url = newUrl
+    authMode = newAuthMode
+    branch = newBranch
+    return UpdateConnectionSettingsResult.Valid
+  }
+
+  /** Deletes a previously saved SSH host key */
+  fun clearSavedHostKey() {
+    File(hostKeyPath).delete()
+  }
+
+  /** Returns true if a host key was previously saved */
+  fun hasSavedHostKey(): Boolean = File(hostKeyPath).exists()
 }