Remove Optional<> return from parsers.

Author: devoxin

build.gradle

@@ -5,7 +5,7 @@ plugins {
 }
 
 group 'me.devoxin'
-version '3.0.6'
+version '4.0.0'
 
 repositories {
     maven {

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> {

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}`"
             }
         }
 

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
         }
     }
 

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()
     }
 }

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 {

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()
     }
 }

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()
     }
 }

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()
     }
 }

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()
     }
 }