Add arg flag and join arguments

Author: Rollczi

Writerside/images/argument/arg/giveCommandExample.mp4

@@ -8,13 +8,16 @@
 
     <toc-element topic="Introdution.md">
         <toc-element topic="Dependency.md"/>
-        <toc-element topic="Configuration.md"/>
     </toc-element>
     <toc-element topic="Platforms.md">
         <toc-element topic="SENDER.md"/>
     </toc-element>
+    <toc-element topic="Configuration.md"/>
     <toc-element topic="Command.md"/>
     <toc-element topic="Arguments.md">
+        <toc-element topic="Arg.md"/>
+        <toc-element topic="Flag.md"/>
+        <toc-element topic="Join-Argument.md"/>
         <toc-element topic="Supported-Types.md"/>
         <toc-element topic="Unsupported-Types-TODO.md"/>
         <toc-element topic="Custom-Types.md"/>

Writerside/images/argument/flag/muteCommandExample.mp4

@@ -0,0 +1,43 @@
+# @Arg Argument
+
+The `@Arg` annotation in the LiteCommands framework is used to define command method
+parameters that represent required arguments. Arguments are essential pieces of information
+that the user must provide when invoking a command. The `@Arg` annotation helps structure
+and validate these inputs within the command method.
+
+## Usage
+
+The `@Arg` annotation is applied to parameters within a command method that represent
+required arguments. Here is an example of how to use the `@Arg` annotation:
+
+`/give <player> <type> <amount>`
+
+```java
+@Command(name = "give")
+public class GiveCommand {
+    @Execute
+    void give(@Arg Player target, @Arg Material type, @Arg int amount) {
+        // Command implementation
+    }
+}
+```
+
+In this example:
+
+- `@Arg Player` target represents a required argument for a player.
+- `@Arg Item` item represents a required argument for an item.
+- `@Arg int` amount represents a required argument for an integer value.
+
+## Example
+
+Let's consider the following command usage:
+
+```
+/give JohnDoe diamond 3
+```
+
+In this case, the `target` parameter will represent the player "JohnDoe," 
+the `item` parameter will represent the material DIAMOND,
+and the `amount` parameter will represent the integer value 3.
+
+<video src="../images/argument/arg/giveCommandExample.mp4" controls/>

Writerside/litecommands.tree

@@ -1,48 +1,8 @@
 # Argument
 
-Arguments are used to get the values from the command sender.
+Arguments are used to parse the command sender's input and complete the command.
 
-## @Arg Argument
 
-`@Arg` is the most common argument. It is used to get the value from the command sender.
-
-```java
-@Command(name = "ban")
-public class BanCommand {
-    @Execute
-    public void ban(@Arg Player player) {
-        // ...
-    }
-}
-```
-
-## @Flag Argument
-
-`@Flag` is used to get the value from the command sender, but it is optional.
-
-```java
-@Command(name = "ban")
-public class BanCommand {
-    @Execute
-    public void ban(@Flag("-s") boolean isSilent) {
-        // ...
-    }
-}
-```
-
-## @Join Argument
-
-`@Join` is used to get the value from the command sender, it joins all arguments into one string.
-
-```java
-@Command(name = "ban")
-public class BanCommand {
-    @Execute
-    public void ban(@Join String reason) {
-        // ...
-    }
-}
-```
 
 Sometimes you may want to limit the number of arguments that will be joined.
 ```java

Writerside/topics/Arg.md

@@ -1,23 +1,46 @@
 # Command
 
-<tldr>
-    <p>
-        Annotations <shortcut>@Command</shortcut> <shortcut>@Execute</shortcut>
-    </p>
-</tldr>
-
 The command structure is the most important part of the command. It is the structure that determines how the command will be executed.
 
-For example, the command `/time day` 
+For example, the command `/time set day` 
 
 ```java
 @Command(name = "time")
 public class TimeCommand {
 
+    @Execute(name = "set day")
+    public void day() {
+        // ... /time set day
+    }
+    
+}
+```
+
+You can do the same thing with the other way:
+    
+```java
+@Command(name = "time set")
+public class TimeSetCommand {
+    
     @Execute(name = "day")
     public void day() {
-        // ... set time to day
+        // ... /time set day
     }
 
 }
 ```
+
+It not requires to use the `name` parameter in the `@Execute` annotation.
+For example `/day` command:
+
+```java
+@Command(name = "day")
+public class DayCommand {
+    
+    @Execute
+    public void day() {
+        // ... /day
+    }
+    
+}
+```

Writerside/topics/Arguments.md

@@ -1,4 +1,4 @@
-# Configuration
+# Builder Configuration
 
 Create a new instance of `LiteCommands` using specific factory for your platform.
 

Writerside/topics/Command.md

@@ -0,0 +1,46 @@
+# @Flag Argument
+
+The @Flag annotation in the LiteCommands framework is used to define flags for command methods. 
+Flags are optional parameters that modify the behavior of a command. 
+They are specified by adding certain keywords or symbols (flags) to the command input. 
+Flags in LiteCommands provide a convenient way to enable 
+or disable specific functionalities within a command.
+
+## Usage
+
+The `@Flag` annotation is applied to boolean parameters within a command method. 
+Here is an example of how to use the `@Flag` annotation:
+
+`/mute <player> -s`
+
+```java
+@Command(name = "mute")
+public class MuteCommand {
+    @Execute
+    public void mute(
+        @Arg Player player,
+        @Flag("-s") boolean isSilent
+    ) {
+        // ..
+    }
+}
+```
+
+- `@Flag("-s")` declares a flag with the identifier `-s`.
+- `boolean isSilent` is the corresponding parameter that will be set to true if the -s flag is provided in the command input. If the flag is not present, the parameter will be set to false by default.
+- The identifier for the flag, typically a string starting with a symbol like `-` or `--`.
+
+Example of command input and the corresponding result:
+
+```
+input: /mute Notch
+result: isSilent = false
+
+input: /mute Notch -s
+result: isSilent = true
+```
+
+> The order of flags in the input does matter.
+{ style="warning" }
+> 
+<video src="../images/argument/flag/muteCommandExample.mp4" controls/>

Writerside/topics/Configuration.md

@@ -0,0 +1,42 @@
+# @Join Argument
+
+The `@Join` annotation in the LiteCommands framework is used to concatenate
+multiple arguments into a single string. This annotation is particularly
+useful when you want to combine several input parameters into a cohesive
+text representation, such as creating a reason for a ban command.
+
+## Usage
+The `@Join` annotation is applied to a parameter within a command method
+that should be treated as a concatenated string. Here is an example of
+how to use the `@Join` annotation:
+
+```Java
+@Command(name = "ban")
+public class BanCommand {
+    @Execute
+    public void ban(
+        @Arg Player target,
+        @Join String reason
+    ) {
+        // Command implementation
+    }
+}
+```
+
+## Example
+Let's consider the following command usage:
+
+```
+/ban JohnDoe Offensive language and behavior
+In this case, the `target` parameter will represent the player "JohnDoe", and the `reason` parameter will represent the string "Offensive language and behavior." The @Join annotation automatically combines all the remaining text arguments into the reason parameter.
+```
+
+## Notes
+- The `@Join `annotation is particularly useful when you want to capture a variable number of arguments into a single string.
+- The joined string includes spaces between the original arguments, making it suitable for textual descriptions or reasons.
+
+## Additional Options
+
+
+
+In LiteCommands, the @Join annotation offers additional options for customization, namely limit and separator. The limit option allows developers to specify the maximum number of arguments to include in the joined string, providing control over the length of the concatenated result. On the other hand, the separator option enables developers to define a custom string that separates each joined argument, allowing for fine-grained control over formatting. These options enhance the flexibility of the @Join annotation, allowing developers to tailor the concatenated string output to their specific needs.