Fix a bunch of formatting issues

These are caught by a newer version of ktlint

Author: xenomachina

src/main/kotlin/com/xenomachina/argparser/ArgParser.kt

@@ -35,9 +35,11 @@ import kotlin.reflect.KProperty
  * @param helpFormatter if non-null, creates `--help` and `-h` options that trigger a [ShowHelpException] which will use
  * the supplied [HelpFormatter] to generate a help message.
  */
-class ArgParser(args: Array<out String>,
-                mode: Mode = Mode.GNU,
-                helpFormatter: HelpFormatter? = DefaultHelpFormatter()) {
+class ArgParser(
+    args: Array<out String>,
+    mode: Mode = Mode.GNU,
+    helpFormatter: HelpFormatter? = DefaultHelpFormatter()
+) {
 
     enum class Mode {
         /** For GNU-style option parsing, where options may appear after positional arguments. */
@@ -79,10 +81,10 @@ class ArgParser(args: Array<out String>,
      * Creates a Delegate for a single-argument option that stores and returns the option's (transformed) argument.
      */
     fun <T> storing(
-            vararg names: String,
-            help: String,
-            argName: String? = null,
-            transform: String.() -> T
+        vararg names: String,
+        help: String,
+        argName: String? = null,
+        transform: String.() -> T
     ): Delegate<T> {
         val nonNullArgName = argName ?: optionNameToArgName(selectRepresentativeOptionName(names))
         return option(
@@ -96,9 +98,9 @@ class ArgParser(args: Array<out String>,
      * Creates a DelegateProvider for a single-argument option that stores and returns the option's (transformed) argument.
      */
     fun <T> storing(
-            help: String,
-            argName: String? = null,
-            transform: String.() -> T
+        help: String,
+        argName: String? = null,
+        transform: String.() -> T
     ) = DelegateProvider { identifier -> storing(identifierToOptionName(identifier), help = help, argName = argName, transform = transform) }
 
     /**
@@ -119,11 +121,11 @@ class ArgParser(args: Array<out String>,
      * MutableCollection each time the option appears in args, and returns said MutableCollection.
      */
     fun <E, T : MutableCollection<E>> adding(
-            vararg names: String,
-            help: String,
-            argName: String? = null,
-            initialValue: T,
-            transform: String.() -> E
+        vararg names: String,
+        help: String,
+        argName: String? = null,
+        initialValue: T,
+        transform: String.() -> E
     ): Delegate<T> {
         val nonNullArgName = argName ?: optionNameToArgName(selectRepresentativeOptionName(names))
         return option<T>(
@@ -142,10 +144,10 @@ class ArgParser(args: Array<out String>,
      * MutableCollection each time the option appears in args, and returns said MutableCollection.
      */
     fun <E, T : MutableCollection<E>> adding(
-            help: String,
-            argName: String? = null,
-            initialValue: T,
-            transform: String.() -> E
+        help: String,
+        argName: String? = null,
+        initialValue: T,
+        transform: String.() -> E
     ) = DelegateProvider { identifier ->
                 adding(identifierToOptionName(identifier), help = help, argName = argName, initialValue = initialValue, transform = transform) }
 
@@ -154,20 +156,20 @@ class ArgParser(args: Array<out String>,
      * MutableList each time the option appears in args, and returns said MutableCollection.
      */
     fun <T> adding(
-            vararg names: String,
-            help: String,
-            argName: String? = null,
-            transform: String.() -> T
+        vararg names: String,
+        help: String,
+        argName: String? = null,
+        transform: String.() -> T
     ) = adding(*names, help = help, argName = argName, initialValue = mutableListOf(), transform = transform)
 
     /**
      * Creates a DelegateProvider for a single-argument option that adds the option's (transformed) argument to a
      * MutableList each time the option appears in args, and returns said MutableCollection.
      */
     fun <T> adding(
-            help: String,
-            argName: String? = null,
-            transform: String.() -> T
+        help: String,
+        argName: String? = null,
+        transform: String.() -> T
     ) = DelegateProvider { identifier ->
         adding(identifierToOptionName(identifier), help = help, argName = argName, transform = transform) }
 
@@ -219,13 +221,13 @@ class ArgParser(args: Array<out String>,
      * @param handler a function that computes the value of this option from an [OptionInvocation]
      */
     fun <T> option(
-            // TODO: add optionalArg: Boolean
-            vararg names: String,
-            help: String,
-            errorName: String? = null,
-            argNames: List<String> = emptyList(),
-            isRepeating: Boolean = false,
-            handler: OptionInvocation<T>.() -> T
+        // TODO: add optionalArg: Boolean
+        vararg names: String,
+        help: String,
+        errorName: String? = null,
+        argNames: List<String> = emptyList(),
+        isRepeating: Boolean = false,
+        handler: OptionInvocation<T>.() -> T
     ): Delegate<T> {
         val delegate = OptionDelegate<T>(
                 parser = this,
@@ -253,9 +255,9 @@ class ArgParser(args: Array<out String>,
      * Creates a Delegate for a single positional argument which returns the argument's transformed value.
      */
     fun <T> positional(
-            name: String,
-            help: String,
-            transform: String.() -> T
+        name: String,
+        help: String,
+        transform: String.() -> T
     ): Delegate<T> {
         return WrappingDelegate(
                 positionalList(name, help = help, sizeRange = 1..1, transform = transform)
@@ -266,36 +268,36 @@ class ArgParser(args: Array<out String>,
      * Creates a DelegateProvider for a single positional argument which returns the argument's transformed value.
      */
     fun <T> positional(
-            help: String,
-            transform: String.() -> T
+        help: String,
+        transform: String.() -> T
     ) = DelegateProvider { identifier -> positional(identifierToArgName(identifier), help = help, transform = transform) }
 
     /**
      * Creates a Delegate for a sequence of positional arguments which returns a List containing the arguments.
      */
     fun positionalList(
-            name: String,
-            help: String,
-            sizeRange: IntRange = 1..Int.MAX_VALUE
+        name: String,
+        help: String,
+        sizeRange: IntRange = 1..Int.MAX_VALUE
     ) = positionalList(name, help = help, sizeRange = sizeRange) { this }
 
     /**
      * Creates a DelegateProvider for a sequence of positional arguments which returns a List containing the arguments.
      */
     fun positionalList(
-            help: String,
-            sizeRange: IntRange = 1..Int.MAX_VALUE
+        help: String,
+        sizeRange: IntRange = 1..Int.MAX_VALUE
     ) = DelegateProvider { identifier -> positionalList(identifierToArgName(identifier), help = help, sizeRange = sizeRange) }
 
     /**
      * Creates a Delegate for a sequence of positional arguments which returns a List containing the transformed
      * arguments.
      */
     fun <T> positionalList(
-            name: String,
-            help: String,
-            sizeRange: IntRange = 1..Int.MAX_VALUE,
-            transform: String.() -> T
+        name: String,
+        help: String,
+        sizeRange: IntRange = 1..Int.MAX_VALUE,
+        transform: String.() -> T
     ): Delegate<List<T>> {
         sizeRange.run {
             if (step != 1)
@@ -318,9 +320,9 @@ class ArgParser(args: Array<out String>,
      * arguments.
      */
     fun <T> positionalList(
-            help: String,
-            sizeRange: IntRange = 1..Int.MAX_VALUE,
-            transform: String.() -> T
+        help: String,
+        sizeRange: IntRange = 1..Int.MAX_VALUE,
+        transform: String.() -> T
     ) = DelegateProvider { identifier -> positionalList(identifierToArgName(identifier), help, sizeRange, transform) }
 
     abstract class Delegate<out T> internal constructor() {
@@ -381,8 +383,8 @@ class ArgParser(args: Array<out String>,
      * specifying a name explicitly.
      */
     class DelegateProvider<out T>(
-            private val default: (() -> T)? = null,
-            internal val ctor: (identifier: String) -> Delegate<T>
+        private val default: (() -> T)? = null,
+        internal val ctor: (identifier: String) -> Delegate<T>
     ) {
         operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): Delegate<T> {
             val delegate = ctor(prop.name)
@@ -397,11 +399,12 @@ class ArgParser(args: Array<out String>,
      * @property arguments the arguments supplied for this option
      */
     data class OptionInvocation<T> internal constructor(
-            // Internal constructor so future versions can add properties
-            // without breaking compatibility.
-            val value: Holder<T>?,
-            val optionName: String,
-            val arguments: List<String>)
+        // Internal constructor so future versions can add properties
+        // without breaking compatibility.
+        val value: Holder<T>?,
+        val optionName: String,
+        val arguments: List<String>
+    )
 
     private val shortOptionDelegates = mutableMapOf<Char, OptionDelegate<*>>()
     private val longOptionDelegates = mutableMapOf<String, OptionDelegate<*>>()

src/main/kotlin/com/xenomachina/argparser/DefaultHelpFormatter.kt

@@ -59,16 +59,16 @@ import com.xenomachina.text.term.wrapText
  * @property epilogue Text that should appear at the end of the help.
  */
 class DefaultHelpFormatter(
-        val prologue: String? = null,
-        val epilogue: String? = null
+    val prologue: String? = null,
+    val epilogue: String? = null
 ) : HelpFormatter {
     val indent = "  "
     val indentWidth = indent.codePointWidth()
 
     override fun format(
-            programName: String?,
-            columns: Int,
-            values: List<HelpFormatter.Value>
+        programName: String?,
+        columns: Int,
+        values: List<HelpFormatter.Value>
     ): String {
         val effectiveColumns = when {
             columns < 0 -> throw IllegalArgumentException("columns must be non-negative")
@@ -121,11 +121,11 @@ class DefaultHelpFormatter(
     }
 
     private fun appendSection(
-            sb: StringBuilder,
-            usageColumns: Int,
-            columns: Int,
-            name: String,
-            values: List<HelpFormatter.Value>
+        sb: StringBuilder,
+        usageColumns: Int,
+        columns: Int,
+        name: String,
+        values: List<HelpFormatter.Value>
     ) {
 
         if (!values.isEmpty()) {

src/main/kotlin/com/xenomachina/argparser/Exceptions.kt

@@ -25,8 +25,8 @@ import java.io.Writer
  * `--help` option, for example).
  */
 class ShowHelpException internal constructor(
-        private val helpFormatter: HelpFormatter,
-        private val delegates: List<ArgParser.Delegate<*>>
+    private val helpFormatter: HelpFormatter,
+    private val delegates: List<ArgParser.Delegate<*>>
 ) : SystemExitException("Help was requested", 0) {
     override fun printUserMessage(writer: Writer, programName: String?, columns: Int) {
         writer.write(helpFormatter.format(programName, columns, delegates.map { it.toHelpFormatterValue() }))
@@ -61,9 +61,11 @@ open class InvalidArgumentException(message: String) : SystemExitException(messa
  * @property argName the name of the missing argument, or null
  */
 open class OptionMissingRequiredArgumentException(val optName: String, val argName: String? = null) :
-        SystemExitException("option '$optName' is missing "
-                + (if (argName == null) "a required argument" else "the required argument $argName"),
-                2)
+        SystemExitException(
+            "option '$optName' is missing " + (
+                if (argName == null) "a required argument"
+                else "the required argument $argName"),
+            2)
 
 /**
  * Indicates that a required positional argument was not supplied.

src/main/kotlin/com/xenomachina/argparser/HelpFormatter.kt

@@ -43,9 +43,10 @@ interface HelpFormatter {
      * @param help help text provided at Delegate construction time
      */
     data class Value(
-            val usages: List<String>,
-            val isRequired: Boolean,
-            val isRepeating: Boolean,
-            val isPositional: Boolean,
-            val help: String)
+        val usages: List<String>,
+        val isRequired: Boolean,
+        val isRepeating: Boolean,
+        val isPositional: Boolean,
+        val help: String
+    )
 }

src/main/kotlin/com/xenomachina/argparser/OptionDelegate.kt

@@ -21,13 +21,14 @@ package com.xenomachina.argparser
 import com.xenomachina.common.Holder
 
 internal class OptionDelegate<T>(
-        parser: ArgParser,
-        errorName: String,
-        help: String,
-        val optionNames: List<String>,
-        val argNames: List<String>,
-        val isRepeating: Boolean,
-        val handler: ArgParser.OptionInvocation<T>.() -> T) : ParsingDelegate<T>(parser, errorName, help) {
+    parser: ArgParser,
+    errorName: String,
+    help: String,
+    val optionNames: List<String>,
+    val argNames: List<String>,
+    val isRepeating: Boolean,
+    val handler: ArgParser.OptionInvocation<T>.() -> T
+) : ParsingDelegate<T>(parser, errorName, help) {
     init {
         for (optionName in optionNames) {
             if (!OPTION_NAME_RE.matches(optionName)) {

src/main/kotlin/com/xenomachina/argparser/ParsingDelegate.kt

@@ -21,9 +21,10 @@ package com.xenomachina.argparser
 import com.xenomachina.common.Holder
 
 internal abstract class ParsingDelegate<T>(
-        override val parser: ArgParser,
-        override val errorName: String,
-        override val help: String) : ArgParser.Delegate<T>() {
+    override val parser: ArgParser,
+    override val errorName: String,
+    override val help: String
+) : ArgParser.Delegate<T>() {
 
     protected var holder: Holder<T>? = null
 

src/main/kotlin/com/xenomachina/argparser/PositionalDelegate.kt

@@ -21,11 +21,12 @@ package com.xenomachina.argparser
 import com.xenomachina.common.Holder
 
 internal class PositionalDelegate<T>(
-        parser: ArgParser,
-        argName: String,
-        val sizeRange: IntRange,
-        help: String,
-        val transform: String.() -> T) : ParsingDelegate<List<T>>(parser, argName, help) {
+    parser: ArgParser,
+    argName: String,
+    val sizeRange: IntRange,
+    help: String,
+    val transform: String.() -> T
+) : ParsingDelegate<List<T>>(parser, argName, help) {
 
     init {
         if (!ARG_NAME_RE.matches(argName)) {

src/main/kotlin/com/xenomachina/argparser/WrappingDelegate.kt

@@ -19,8 +19,8 @@
 package com.xenomachina.argparser
 
 internal class WrappingDelegate<U, W>(
-        private val inner: ArgParser.Delegate<U>,
-        private val wrap: (U) -> W
+    private val inner: ArgParser.Delegate<U>,
+    private val wrap: (U) -> W
 ) : ArgParser.Delegate<W>() {
 
     override val parser: ArgParser

src/test/kotlin/com/xenomachina/argparser/ArgParserTest.kt

@@ -32,9 +32,9 @@ import java.io.StringWriter
 val TEST_HELP = "test help message"
 
 fun parserOf(
-        vararg args: String,
-        mode: ArgParser.Mode = ArgParser.Mode.GNU,
-        helpFormatter: HelpFormatter? = DefaultHelpFormatter()
+    vararg args: String,
+    mode: ArgParser.Mode = ArgParser.Mode.GNU,
+    helpFormatter: HelpFormatter? = DefaultHelpFormatter()
 ) = ArgParser(args, mode, helpFormatter)
 
 enum class Color { RED, GREEN, BLUE }