From c3c8b9eb4cb90f8138881ce8fcec8a55cff72fa1 Mon Sep 17 00:00:00 2001 From: Michael Rittmeister Date: Mon, 18 Jan 2021 10:20:12 +0100 Subject: [PATCH 1/2] Add Arguments types for all primitives - Add ability to change radix for integer arguments --- .../kotlin/argument/primitive/ByteArgument.kt | 29 ++++++++++++++++++ .../argument/primitive/FloatArgument.kt | 26 ++++++++++++++++ .../kotlin/argument/primitive/IntArgument.kt | 15 ++++++---- .../kotlin/argument/primitive/LongArgument.kt | 15 ++++++---- .../argument/primitive/ShortArgument.kt | 30 +++++++++++++++++++ 5 files changed, 103 insertions(+), 12 deletions(-) create mode 100644 runtime/src/main/kotlin/argument/primitive/ByteArgument.kt create mode 100644 runtime/src/main/kotlin/argument/primitive/FloatArgument.kt create mode 100644 runtime/src/main/kotlin/argument/primitive/ShortArgument.kt diff --git a/runtime/src/main/kotlin/argument/primitive/ByteArgument.kt b/runtime/src/main/kotlin/argument/primitive/ByteArgument.kt new file mode 100644 index 0000000..1de6454 --- /dev/null +++ b/runtime/src/main/kotlin/argument/primitive/ByteArgument.kt @@ -0,0 +1,29 @@ +package dev.kord.x.commands.argument.primitive + +import dev.kord.x.commands.argument.SingleWordArgument +import dev.kord.x.commands.argument.result.WordResult + +internal class InternalByteArgument( + override val name: String = "Number", + private val radix: Int = 10 +) : + SingleWordArgument() { + + override suspend fun parse(word: String, context: Any?): WordResult = + when (val number = word.toByteOrNull(radix)) { + null -> failure("Expected a number.") + else -> success(number) + } +} + +/** + * Argument that matches against a single world, emitting success when the word is a valid [Byte] value. + */ +val ByteArgument: dev.kord.x.commands.argument.Argument = InternalByteArgument() + +/** + * Argument with [name] and [radix] that matches against a single world, emitting success when the word is a valid [Byte] value. + */ +@Suppress("FunctionName") +fun ByteArgument(name: String, radix: Int = 10): dev.kord.x.commands.argument.Argument = + InternalByteArgument(name, radix) \ No newline at end of file diff --git a/runtime/src/main/kotlin/argument/primitive/FloatArgument.kt b/runtime/src/main/kotlin/argument/primitive/FloatArgument.kt new file mode 100644 index 0000000..e203d52 --- /dev/null +++ b/runtime/src/main/kotlin/argument/primitive/FloatArgument.kt @@ -0,0 +1,26 @@ +package dev.kord.x.commands.argument.primitive + +import dev.kord.x.commands.argument.SingleWordArgument +import dev.kord.x.commands.argument.result.WordResult + +internal class InternalFloatArgument(override val name: String = "Number") : + SingleWordArgument() { + + override suspend fun parse(word: String, context: Any?): WordResult = + when (val number = word.toFloatOrNull()) { + null -> failure("Expected a number.") + else -> success(number) + } +} + +/** + * Argument that matches against a single world, emitting success when the word is a valid [Float] value. + */ +val FloatArgument: dev.kord.x.commands.argument.Argument = InternalFloatArgument() + +/** + * Argument with [name] that matches against a single world, emitting success when the word is a valid [Float] value. + */ +@Suppress("FunctionName") +fun FloatArgument(name: String): dev.kord.x.commands.argument.Argument = + InternalFloatArgument(name) \ No newline at end of file diff --git a/runtime/src/main/kotlin/argument/primitive/IntArgument.kt b/runtime/src/main/kotlin/argument/primitive/IntArgument.kt index 64e784d..f92598b 100644 --- a/runtime/src/main/kotlin/argument/primitive/IntArgument.kt +++ b/runtime/src/main/kotlin/argument/primitive/IntArgument.kt @@ -3,12 +3,15 @@ package dev.kord.x.commands.argument.primitive import dev.kord.x.commands.argument.SingleWordArgument import dev.kord.x.commands.argument.result.WordResult -internal class InternalIntArgument(override val name: String = "Number") : +internal class InternalIntArgument( + override val name: String = "Number", + private val radix: Int = 10 +) : SingleWordArgument() { override suspend fun parse( word: String, context: Any? - ): WordResult = when (val number = word.toIntOrNull()) { + ): WordResult = when (val number = word.toIntOrNull(radix)) { null -> failure("Expected a whole number.") else -> success(number) } @@ -16,13 +19,13 @@ internal class InternalIntArgument(override val name: String = "Number") : } /** - * Argument that matches against a single world, emitting success when the word is a valid integer value. + * Argument that matches against a single world, emitting success when the word is a valid [Int] value. */ val IntArgument: dev.kord.x.commands.argument.Argument = InternalIntArgument() /** - * Argument with [name] that matches against a single world, emitting success when the word is a valid integer value. + * Argument with [name] and [radix] that matches against a single world, emitting success when the word is a valid [Int] value. */ @Suppress("FunctionName") -fun IntArgument(name: String): dev.kord.x.commands.argument.Argument = - InternalIntArgument(name) +fun IntArgument(name: String, radix: Int = 10): dev.kord.x.commands.argument.Argument = + InternalIntArgument(name, radix) diff --git a/runtime/src/main/kotlin/argument/primitive/LongArgument.kt b/runtime/src/main/kotlin/argument/primitive/LongArgument.kt index 0978403..d80a43e 100644 --- a/runtime/src/main/kotlin/argument/primitive/LongArgument.kt +++ b/runtime/src/main/kotlin/argument/primitive/LongArgument.kt @@ -3,13 +3,16 @@ package dev.kord.x.commands.argument.primitive import dev.kord.x.commands.argument.SingleWordArgument import dev.kord.x.commands.argument.result.WordResult -internal class InternalLongArgument(override val name: String = "Number") : +internal class InternalLongArgument( + override val name: String = "Number", + private val radix: Int = 10 +) : SingleWordArgument() { override suspend fun parse( word: String, context: Any? - ): WordResult = when (val number = word.toLongOrNull()) { + ): WordResult = when (val number = word.toLongOrNull(radix)) { null -> failure("Expected a number.") else -> success(number) } @@ -17,13 +20,13 @@ internal class InternalLongArgument(override val name: String = "Number") : } /** - * Argument that matches against a single world, emitting success when the word is a valid long value. + * Argument that matches against a single world, emitting success when the word is a valid [Long] value. */ val LongArgument: dev.kord.x.commands.argument.Argument = InternalLongArgument() /** - * Argument with [name] that matches against a single world, emitting success when the word is a valid long value. + * Argument with [name] and [radix] that matches against a single world, emitting success when the word is a valid [Long] value. */ @Suppress("FunctionName") -fun LongArgument(name: String): dev.kord.x.commands.argument.Argument = - InternalLongArgument(name) +fun LongArgument(name: String, radix: Int = 10): dev.kord.x.commands.argument.Argument = + InternalLongArgument(name, radix) diff --git a/runtime/src/main/kotlin/argument/primitive/ShortArgument.kt b/runtime/src/main/kotlin/argument/primitive/ShortArgument.kt new file mode 100644 index 0000000..6300379 --- /dev/null +++ b/runtime/src/main/kotlin/argument/primitive/ShortArgument.kt @@ -0,0 +1,30 @@ +package dev.kord.x.commands.argument.primitive + +import dev.kord.x.commands.argument.SingleWordArgument +import dev.kord.x.commands.argument.result.WordResult + +internal class InternalShortArgument(override val name: String = "Number", private val radix: Int) : + SingleWordArgument() { + + override suspend fun parse(word: String, context: Any?): WordResult = + when (val number = word.toShortOrNull(radix)) { + null -> failure("Expected a number.") + else -> success(number) + } +} + +/** + * Argument that matches against a single world, emitting success when the word is a valid [Short] value. + */ +val ShortArgument: dev.kord.x.commands.argument.Argument = + InternalShortArgument(radix = 10) + +/** + * Argument with [name] and [radix] that matches against a single world, emitting success when the word is a valid [Short] value. + */ +@Suppress("FunctionName") +fun ShortArgument( + name: String, + radix: Int = 10 +): dev.kord.x.commands.argument.Argument = + InternalShortArgument(name, radix) \ No newline at end of file From 5c2d07b801ba8737a69edba0d167d05f3328c72c Mon Sep 17 00:00:00 2001 From: Michael Rittmeister Date: Mon, 18 Jan 2021 10:25:59 +0100 Subject: [PATCH 2/2] Fix detekt issues --- .../src/main/kotlin/argument/primitive/ByteArgument.kt | 8 +++++--- .../src/main/kotlin/argument/primitive/FloatArgument.kt | 2 +- runtime/src/main/kotlin/argument/primitive/IntArgument.kt | 6 ++++-- .../src/main/kotlin/argument/primitive/LongArgument.kt | 6 ++++-- .../src/main/kotlin/argument/primitive/ShortArgument.kt | 8 +++++--- 5 files changed, 19 insertions(+), 11 deletions(-) diff --git a/runtime/src/main/kotlin/argument/primitive/ByteArgument.kt b/runtime/src/main/kotlin/argument/primitive/ByteArgument.kt index 1de6454..1d4ef48 100644 --- a/runtime/src/main/kotlin/argument/primitive/ByteArgument.kt +++ b/runtime/src/main/kotlin/argument/primitive/ByteArgument.kt @@ -17,13 +17,15 @@ internal class InternalByteArgument( } /** - * Argument that matches against a single world, emitting success when the word is a valid [Byte] value. + * Argument that matches against a single world, + * emitting success when the word is a valid [Byte] value. */ val ByteArgument: dev.kord.x.commands.argument.Argument = InternalByteArgument() /** - * Argument with [name] and [radix] that matches against a single world, emitting success when the word is a valid [Byte] value. + * Argument with [name] and [radix] that matches against a single world, + * emitting success when the word is a valid [Byte] value. */ @Suppress("FunctionName") fun ByteArgument(name: String, radix: Int = 10): dev.kord.x.commands.argument.Argument = - InternalByteArgument(name, radix) \ No newline at end of file + InternalByteArgument(name, radix) diff --git a/runtime/src/main/kotlin/argument/primitive/FloatArgument.kt b/runtime/src/main/kotlin/argument/primitive/FloatArgument.kt index e203d52..09362f3 100644 --- a/runtime/src/main/kotlin/argument/primitive/FloatArgument.kt +++ b/runtime/src/main/kotlin/argument/primitive/FloatArgument.kt @@ -23,4 +23,4 @@ val FloatArgument: dev.kord.x.commands.argument.Argument = Internal */ @Suppress("FunctionName") fun FloatArgument(name: String): dev.kord.x.commands.argument.Argument = - InternalFloatArgument(name) \ No newline at end of file + InternalFloatArgument(name) diff --git a/runtime/src/main/kotlin/argument/primitive/IntArgument.kt b/runtime/src/main/kotlin/argument/primitive/IntArgument.kt index f92598b..142ad3c 100644 --- a/runtime/src/main/kotlin/argument/primitive/IntArgument.kt +++ b/runtime/src/main/kotlin/argument/primitive/IntArgument.kt @@ -19,12 +19,14 @@ internal class InternalIntArgument( } /** - * Argument that matches against a single world, emitting success when the word is a valid [Int] value. + * Argument that matches against a single world, + * emitting success when the word is a valid [Int] value. */ val IntArgument: dev.kord.x.commands.argument.Argument = InternalIntArgument() /** - * Argument with [name] and [radix] that matches against a single world, emitting success when the word is a valid [Int] value. + * Argument with [name] and [radix] that matches against a single world, + * emitting success when the word is a valid [Int] value. */ @Suppress("FunctionName") fun IntArgument(name: String, radix: Int = 10): dev.kord.x.commands.argument.Argument = diff --git a/runtime/src/main/kotlin/argument/primitive/LongArgument.kt b/runtime/src/main/kotlin/argument/primitive/LongArgument.kt index d80a43e..a1fd49d 100644 --- a/runtime/src/main/kotlin/argument/primitive/LongArgument.kt +++ b/runtime/src/main/kotlin/argument/primitive/LongArgument.kt @@ -20,12 +20,14 @@ internal class InternalLongArgument( } /** - * Argument that matches against a single world, emitting success when the word is a valid [Long] value. + * Argument that matches against a single world, + * emitting success when the word is a valid [Long] value. */ val LongArgument: dev.kord.x.commands.argument.Argument = InternalLongArgument() /** - * Argument with [name] and [radix] that matches against a single world, emitting success when the word is a valid [Long] value. + * Argument with [name] and [radix] that matches against a single world, + * emitting success when the word is a valid [Long] value. */ @Suppress("FunctionName") fun LongArgument(name: String, radix: Int = 10): dev.kord.x.commands.argument.Argument = diff --git a/runtime/src/main/kotlin/argument/primitive/ShortArgument.kt b/runtime/src/main/kotlin/argument/primitive/ShortArgument.kt index 6300379..79e64f6 100644 --- a/runtime/src/main/kotlin/argument/primitive/ShortArgument.kt +++ b/runtime/src/main/kotlin/argument/primitive/ShortArgument.kt @@ -14,17 +14,19 @@ internal class InternalShortArgument(override val name: String = "Number", priva } /** - * Argument that matches against a single world, emitting success when the word is a valid [Short] value. + * Argument that matches against a single world, + * emitting success when the word is a valid [Short] value. */ val ShortArgument: dev.kord.x.commands.argument.Argument = InternalShortArgument(radix = 10) /** - * Argument with [name] and [radix] that matches against a single world, emitting success when the word is a valid [Short] value. + * Argument with [name] and [radix] that matches against a single world, + * emitting success when the word is a valid [Short] value. */ @Suppress("FunctionName") fun ShortArgument( name: String, radix: Int = 10 ): dev.kord.x.commands.argument.Argument = - InternalShortArgument(name, radix) \ No newline at end of file + InternalShortArgument(name, radix)