Remove Optional<> return from parsers.

devoxin · devoxin · commit 7d6f1aba12ee · 2023-11-18T22:59:52.000Z
diff --git a/build.gradle b/build.gradle
@@ -5,7 +5,7 @@ plugins {
 }
 
 group 'me.devoxin'
-version '3.0.6'
+version '4.0.0'
 
 repositories {
     maven {
diff --git a/src/main/kotlin/me/devoxin/flight/api/context/MessageContext.kt b/src/main/kotlin/me/devoxin/flight/api/context/MessageContext.kt
@@ -137,9 +137,10 @@ class MessageContext(
      *        The content of the message.
      */
     fun sendPrivate(content: String) {
-        author.openPrivateChannel().submit()
-            .thenCompose { it.sendMessage(content).submit() }
-            .thenCompose { it.channel.asPrivateChannel().delete().submit() }
+        author.openPrivateChannel()
+            .flatMap { it.sendMessage(content) }
+            .flatMap { it.channel.asPrivateChannel().delete() }
+            .queue()
     }
 
     /**
@@ -153,9 +154,10 @@ class MessageContext(
      * @return The message that was sent.
      */
     fun sendPrivate(message: MessageCreateData) {
-        author.openPrivateChannel().submit()
-            .thenCompose { it.sendMessage(message).submit() }
-            .thenCompose { it.channel.asPrivateChannel().delete().submit() }
+        author.openPrivateChannel()
+            .flatMap { it.sendMessage(message) }
+            .flatMap { it.channel.asPrivateChannel().delete() }
+            .queue()
     }
 
     private fun send0(messageOpts: (MessageCreateBuilder.() -> Unit)? = null, vararg files: FileUpload): RestAction<Message> {
diff --git a/src/main/kotlin/me/devoxin/flight/internal/arguments/ArgParser.kt b/src/main/kotlin/me/devoxin/flight/internal/arguments/ArgParser.kt
@@ -88,9 +88,7 @@ class ArgParser(
         val parser = parsers[arg.type]
             ?: throw ParserNotRegistered("No parsers registered for `${arg.type}`")
         val (argument, original) = getNextArgument(arg.greedy)
-        val result = if (argument.isEmpty()) {
-            Optional.empty()
-        } else {
+        val result = argument.takeIf { it.isNotEmpty() }?.let {
             try {
                 parser.parse(ctx, argument)
             } catch (e: Throwable) {
@@ -101,9 +99,9 @@ class ArgParser(
         val canSubstitute = arg.isTentative || arg.isNullable || (arg.optional && argument.isEmpty())
         val (rangeCheck, rangeMessage) = checkRange(arg, result)
 
-        if (!result.isPresent || !rangeCheck) {
+        if (result == null || !rangeCheck) {
             if (!canSubstitute) { // canSubstitute -> Whether we can pass null or the default value.
-                val cause = if (result.isPresent && rangeCheck) null else IllegalArgumentException(rangeMessage)
+                val cause = rangeMessage?.let(::IllegalArgumentException)
                 // This should throw if the result is not present, and one of the following is not true:
                 // - The arg is marked tentative (isTentative)
                 // - The arg can use null (isNullable)
@@ -118,12 +116,11 @@ class ArgParser(
             }
         }
 
-        return result.takeIf { rangeCheck }?.orElse(null)
+        return result.takeIf { rangeCheck }
     }
 
-    private fun checkRange(arg: Argument, parsed: Optional<out Any?>): Pair<Boolean, String?> {
+    private fun <T : Any?> checkRange(arg: Argument, res: T): Pair<Boolean, String?> {
         arg.range ?: return true to null
-        val res = parsed.orElse(null)
 
         if (res !is Number && res !is String) {
             return false to null
@@ -138,21 +135,21 @@ class ArgParser(
             return when (double.size) {
                 1 -> (dbl >= double[0]) to "`${arg.name}` must be at least ${double[0]} or bigger."
                 2 -> (dbl >= double[0] && dbl <= double[1]) to "`${arg.name}` must be within range ${double.joinToString("-")}."
-                else -> false to "<Invalid range for `${arg.name}:double`>"
+                else -> false to "Invalid double range for `${arg.name}`"
             }
         } else if (long.isNotEmpty() && res is Number) {
             val lng = res.toLong()
             return when (long.size) {
                 1 -> (lng >= long[0]) to "`${arg.name}` must be at least ${long[0]} or bigger."
                 2 -> (lng >= long[0] && lng <= long[1]) to "`${arg.name}` must be within range ${long.joinToString("-")}."
-                else -> false to "<Invalid range for `${arg.name}:long`>"
+                else -> false to "Invalid long range for `${arg.name}`"
             }
         } else if (string.isNotEmpty() && res is String) {
             val lth = res.length
             return when (string.size) {
                 1 -> (lth >= string[0]) to "`${arg.name}` must be at least ${string[0]} character${TextUtils.plural(string[0])} or longer."
                 2 -> (lth >= string[0] && lth <= string[1]) to "`${arg.name}` must be within the range of ${string.joinToString("-")} characters."
-                else -> false to "<Invalid range for `${arg.name}:string`>"
+                else -> false to "Invalid string range for `${arg.name}`"
             }
         }
 
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/BooleanParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/BooleanParser.kt
@@ -4,11 +4,11 @@ import me.devoxin.flight.api.context.MessageContext
 import java.util.*
 
 class BooleanParser : Parser<Boolean> {
-    override fun parse(ctx: MessageContext, param: String): Optional<Boolean> {
+    override fun parse(ctx: MessageContext, param: String): Boolean? {
         return when (param) {
-            in trueExpr -> Optional.of(true)
-            in falseExpr -> Optional.of(false)
-            else -> Optional.empty()
+            in trueExpr -> true
+            in falseExpr -> false
+            else -> null
         }
     }
 
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/DoubleParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/DoubleParser.kt
@@ -4,7 +4,7 @@ import me.devoxin.flight.api.context.MessageContext
 import java.util.*
 
 class DoubleParser : Parser<Double> {
-    override fun parse(ctx: MessageContext, param: String): Optional<Double> {
-        return Optional.ofNullable(param.toDoubleOrNull())
+    override fun parse(ctx: MessageContext, param: String): Double? {
+        return param.toDoubleOrNull()
     }
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/EmojiParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/EmojiParser.kt
@@ -6,18 +6,18 @@ import java.util.*
 
 class EmojiParser : Parser<Emoji> {
     // TODO: Support unicode emoji?
-    override fun parse(ctx: MessageContext, param: String): Optional<Emoji> {
+    override fun parse(ctx: MessageContext, param: String): Emoji? {
         val match = EMOJI_PATTERN.matcher(param)
 
         if (match.find()) {
             val isAnimated = match.group(1) != null
             val name = match.group(2)
             val id = match.group(3).toLong()
 
-            return Optional.of(Emoji(name, id, isAnimated))
+            return Emoji(name, id, isAnimated)
         }
 
-        return Optional.empty()
+        return null
     }
 
     companion object {
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/FloatParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/FloatParser.kt
@@ -4,7 +4,7 @@ import me.devoxin.flight.api.context.MessageContext
 import java.util.*
 
 class FloatParser : Parser<Float> {
-    override fun parse(ctx: MessageContext, param: String): Optional<Float> {
-        return Optional.ofNullable(param.toFloatOrNull())
+    override fun parse(ctx: MessageContext, param: String): Float? {
+        return param.toFloatOrNull()
     }
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/IntParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/IntParser.kt
@@ -4,7 +4,7 @@ import me.devoxin.flight.api.context.MessageContext
 import java.util.*
 
 class IntParser : Parser<Int> {
-    override fun parse(ctx: MessageContext, param: String): Optional<Int> {
-        return Optional.ofNullable(param.toIntOrNull())
+    override fun parse(ctx: MessageContext, param: String): Int? {
+        return param.toIntOrNull()
     }
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/InviteParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/InviteParser.kt
@@ -5,18 +5,18 @@ import me.devoxin.flight.api.arguments.types.Invite
 import java.util.*
 
 class InviteParser : Parser<Invite> {
-    override fun parse(ctx: MessageContext, param: String): Optional<Invite> {
+    override fun parse(ctx: MessageContext, param: String): Invite? {
         val match = INVITE_PATTERN.matcher(param)
 
         if (match.find()) {
             val code = match.group(1)
-            return Optional.of(Invite(ctx.jda, match.group(), code))
+            return Invite(ctx.jda, match.group(), code)
         }
 
-        return Optional.empty()
+        return null
     }
 
     companion object {
-        val INVITE_PATTERN = "(?:https?://)?discord(?:(?:app)?\\.com/invite|\\.gg)/([a-zA-Z\\d]{1,16})".toPattern()
+        val INVITE_PATTERN = "discord(?:(?:app)?\\.com/invite|\\.gg)/([a-zA-Z\\d]{1,16})".toPattern()
     }
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/LongParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/LongParser.kt
@@ -4,7 +4,7 @@ import me.devoxin.flight.api.context.MessageContext
 import java.util.*
 
 class LongParser : Parser<Long> {
-    override fun parse(ctx: MessageContext, param: String): Optional<Long> {
-        return Optional.ofNullable(param.toLongOrNull())
+    override fun parse(ctx: MessageContext, param: String): Long? {
+        return param.toLongOrNull()
     }
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/MemberParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/MemberParser.kt
@@ -5,8 +5,8 @@ import net.dv8tion.jda.api.entities.Member
 import java.util.*
 
 class MemberParser : Parser<Member> {
-    override fun parse(ctx: MessageContext, param: String): Optional<Member> {
-        val snowflake = SnowflakeParser.INSTANCE.parse(ctx, param).takeIf { it.isPresent }?.get()?.resolved
+    override fun parse(ctx: MessageContext, param: String): Member? {
+        val snowflake = SnowflakeParser.INSTANCE.parse(ctx, param)?.resolved
 
         val member = when {
             snowflake != null -> ctx.message.mentions.members.firstOrNull { it.user.idLong == snowflake } ?: ctx.guild?.getMemberById(snowflake)
@@ -17,6 +17,6 @@ class MemberParser : Parser<Member> {
             else -> ctx.guild?.memberCache?.firstOrNull { it.user.name == param }
         }
 
-        return Optional.ofNullable(member)
+        return member
     }
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/Parser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/Parser.kt
@@ -4,5 +4,5 @@ import me.devoxin.flight.api.context.MessageContext
 import java.util.*
 
 interface Parser<T> {
-    fun parse(ctx: MessageContext, param: String): Optional<T>
+    fun parse(ctx: MessageContext, param: String): T?
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/RoleParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/RoleParser.kt
@@ -5,12 +5,12 @@ import net.dv8tion.jda.api.entities.Role
 import java.util.*
 
 class RoleParser : Parser<Role> {
-    override fun parse(ctx: MessageContext, param: String): Optional<Role> {
-        val snowflake = SnowflakeParser.INSTANCE.parse(ctx, param).takeIf { it.isPresent }?.get()?.resolved
+    override fun parse(ctx: MessageContext, param: String): Role? {
+        val snowflake = SnowflakeParser.INSTANCE.parse(ctx, param)?.resolved
 
         return when {
-            snowflake != null -> Optional.ofNullable(ctx.guild?.getRoleById(snowflake))
-            else -> Optional.ofNullable(ctx.guild?.roleCache?.firstOrNull { it.name == param })
+            snowflake != null -> ctx.guild?.getRoleById(snowflake)
+            else -> ctx.guild?.roleCache?.firstOrNull { it.name == param }
         }
     }
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/SnowflakeParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/SnowflakeParser.kt
@@ -5,15 +5,15 @@ import me.devoxin.flight.api.arguments.types.Snowflake
 import java.util.*
 
 class SnowflakeParser : Parser<Snowflake> {
-    override fun parse(ctx: MessageContext, param: String): Optional<Snowflake> {
+    override fun parse(ctx: MessageContext, param: String): Snowflake? {
         val match = SNOWFLAKE_PATTERN.matcher(param)
 
         if (match.matches()) {
             val id = match.group("sid") ?: match.group("id")
-            return Optional.of(Snowflake(id.toLong()))
+            return Snowflake(id.toLong())
         }
 
-        return Optional.empty()
+        return null
     }
 
     companion object {
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/StringParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/StringParser.kt
@@ -4,11 +4,7 @@ import me.devoxin.flight.api.context.MessageContext
 import java.util.*
 
 class StringParser : Parser<String> {
-    override fun parse(ctx: MessageContext, param: String): Optional<String> {
-        if (param.isEmpty() || param.isBlank()) {
-            return Optional.empty()
-        }
-
-        return Optional.of(param)
+    override fun parse(ctx: MessageContext, param: String): String? {
+        return param.takeIf { it.isNotEmpty() && it.isNotBlank() }
     }
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/TextChannelParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/TextChannelParser.kt
@@ -5,12 +5,12 @@ import net.dv8tion.jda.api.entities.channel.concrete.TextChannel
 import java.util.*
 
 class TextChannelParser : Parser<TextChannel> {
-    override fun parse(ctx: MessageContext, param: String): Optional<TextChannel> {
-        val snowflake = SnowflakeParser.INSTANCE.parse(ctx, param).takeIf { it.isPresent }?.get()?.resolved
+    override fun parse(ctx: MessageContext, param: String): TextChannel? {
+        val snowflake = SnowflakeParser.INSTANCE.parse(ctx, param)?.resolved
 
         return when {
-            snowflake != null -> Optional.ofNullable(ctx.guild?.getTextChannelById(snowflake))
-            else -> Optional.ofNullable(ctx.guild?.textChannelCache?.firstOrNull { it.name == param })
+            snowflake != null -> ctx.guild?.getTextChannelById(snowflake)
+            else -> ctx.guild?.textChannelCache?.firstOrNull { it.name == param }
         }
     }
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/UrlParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/UrlParser.kt
@@ -5,11 +5,11 @@ import java.net.URL
 import java.util.*
 
 class UrlParser : Parser<URL> {
-    override fun parse(ctx: MessageContext, param: String): Optional<URL> {
+    override fun parse(ctx: MessageContext, param: String): URL? {
         return try {
-            Optional.of(URL(param))
+            URL(param)
         } catch (e: Throwable) {
-            Optional.empty()
+            null
         }
     }
 }
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/UserParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/UserParser.kt
@@ -5,8 +5,8 @@ import net.dv8tion.jda.api.entities.User
 import java.util.*
 
 class UserParser : Parser<User> {
-    override fun parse(ctx: MessageContext, param: String): Optional<User> {
-        val snowflake = snowflakeParser.parse(ctx, param).takeIf { it.isPresent }?.get()?.resolved
+    override fun parse(ctx: MessageContext, param: String): User? {
+        val snowflake = snowflakeParser.parse(ctx, param)?.resolved
 
         val user = when {
             snowflake != null -> ctx.message.mentions.users.firstOrNull { it.idLong == snowflake } ?: ctx.jda.getUserById(snowflake)
@@ -17,7 +17,7 @@ class UserParser : Parser<User> {
             else -> ctx.jda.userCache.find { it.name == param }
         }
 
-        return Optional.ofNullable(user)
+        return user
     }
 
     companion object {
diff --git a/src/main/kotlin/me/devoxin/flight/internal/parsers/VoiceChannelParser.kt b/src/main/kotlin/me/devoxin/flight/internal/parsers/VoiceChannelParser.kt
@@ -5,12 +5,12 @@ import net.dv8tion.jda.api.entities.channel.concrete.VoiceChannel
 import java.util.*
 
 class VoiceChannelParser : Parser<VoiceChannel> {
-    override fun parse(ctx: MessageContext, param: String): Optional<VoiceChannel> {
-        val snowflake = SnowflakeParser.INSTANCE.parse(ctx, param).takeIf { it.isPresent }?.get()?.resolved
+    override fun parse(ctx: MessageContext, param: String): VoiceChannel? {
+        val snowflake = SnowflakeParser.INSTANCE.parse(ctx, param)?.resolved
 
         return when {
-            snowflake != null -> Optional.ofNullable(ctx.guild?.getVoiceChannelById(snowflake))
-            else -> Optional.ofNullable(ctx.guild?.voiceChannelCache?.firstOrNull { it.name == param })
+            snowflake != null -> ctx.guild?.getVoiceChannelById(snowflake)
+            else -> ctx.guild?.voiceChannelCache?.firstOrNull { it.name == param }
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ plugins {`
`5`	`5`	`}`
`6`	`6`
`7`	`7`	`group 'me.devoxin'`
`8`		`-version '3.0.6'`
	`8`	`+version '4.0.0'`
`9`	`9`
`10`	`10`	`repositories {`
`11`	`11`	`maven {`
Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,11 @@ import me.devoxin.flight.api.context.MessageContext`
`4`	`4`	`import java.util.*`
`5`	`5`
`6`	`6`	`class BooleanParser : Parser<Boolean> {`
`7`		`- override fun parse(ctx: MessageContext, param: String): Optional<Boolean> {`
	`7`	`+ override fun parse(ctx: MessageContext, param: String): Boolean? {`
`8`	`8`	`return when (param) {`
`9`		`- in trueExpr -> Optional.of(true)`
`10`		`- in falseExpr -> Optional.of(false)`
`11`		`- else -> Optional.empty()`
	`9`	`+ in trueExpr -> true`
	`10`	`+ in falseExpr -> false`
	`11`	`+ else -> null`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ import me.devoxin.flight.api.context.MessageContext`
`4`	`4`	`import java.util.*`
`5`	`5`
`6`	`6`	`class DoubleParser : Parser<Double> {`
`7`		`- override fun parse(ctx: MessageContext, param: String): Optional<Double> {`
`8`		`- return Optional.ofNullable(param.toDoubleOrNull())`
	`7`	`+ override fun parse(ctx: MessageContext, param: String): Double? {`
	`8`	`+ return param.toDoubleOrNull()`
`9`	`9`	`}`
`10`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ import me.devoxin.flight.api.context.MessageContext`
`4`	`4`	`import java.util.*`
`5`	`5`
`6`	`6`	`class FloatParser : Parser<Float> {`
`7`		`- override fun parse(ctx: MessageContext, param: String): Optional<Float> {`
`8`		`- return Optional.ofNullable(param.toFloatOrNull())`
	`7`	`+ override fun parse(ctx: MessageContext, param: String): Float? {`
	`8`	`+ return param.toFloatOrNull()`
`9`	`9`	`}`
`10`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ import me.devoxin.flight.api.context.MessageContext`
`4`	`4`	`import java.util.*`
`5`	`5`
`6`	`6`	`class IntParser : Parser<Int> {`
`7`		`- override fun parse(ctx: MessageContext, param: String): Optional<Int> {`
`8`		`- return Optional.ofNullable(param.toIntOrNull())`
	`7`	`+ override fun parse(ctx: MessageContext, param: String): Int? {`
	`8`	`+ return param.toIntOrNull()`
`9`	`9`	`}`
`10`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,18 +5,18 @@ import me.devoxin.flight.api.arguments.types.Invite`
`5`	`5`	`import java.util.*`
`6`	`6`
`7`	`7`	`class InviteParser : Parser<Invite> {`
`8`		`- override fun parse(ctx: MessageContext, param: String): Optional<Invite> {`
	`8`	`+ override fun parse(ctx: MessageContext, param: String): Invite? {`
`9`	`9`	`val match = INVITE_PATTERN.matcher(param)`
`10`	`10`
`11`	`11`	`if (match.find()) {`
`12`	`12`	`val code = match.group(1)`
`13`		`- return Optional.of(Invite(ctx.jda, match.group(), code))`
	`13`	`+ return Invite(ctx.jda, match.group(), code)`
`14`	`14`	`}`
`15`	`15`
`16`		`- return Optional.empty()`
	`16`	`+ return null`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`companion object {`
`20`		`- val INVITE_PATTERN = "(?:https?://)?discord(?:(?:app)?\\.com/invite\|\\.gg)/([a-zA-Z\\d]{1,16})".toPattern()`
	`20`	`+ val INVITE_PATTERN = "discord(?:(?:app)?\\.com/invite\|\\.gg)/([a-zA-Z\\d]{1,16})".toPattern()`
`21`	`21`	`}`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ import me.devoxin.flight.api.context.MessageContext`
`4`	`4`	`import java.util.*`
`5`	`5`
`6`	`6`	`class LongParser : Parser<Long> {`
`7`		`- override fun parse(ctx: MessageContext, param: String): Optional<Long> {`
`8`		`- return Optional.ofNullable(param.toLongOrNull())`
	`7`	`+ override fun parse(ctx: MessageContext, param: String): Long? {`
	`8`	`+ return param.toLongOrNull()`
`9`	`9`	`}`
`10`	`10`	`}`