From b6df9f63e920527ac5970493d27fd05165d799b8 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Wed, 5 Jun 2024 22:23:05 +0100
Subject: [PATCH 01/23] refactor: Start creating MiniCLI

---
 .../net/marcellperger/mathexpr/cli/CLI.java   |  9 ++++
 .../cli/minicli/BooleanCLIOption.java         | 18 +++++++
 .../mathexpr/cli/minicli/CLIOption.java       | 33 ++++++++++++
 .../mathexpr/cli/minicli/MiniCLI.java         | 54 +++++++++++++++++++
 .../mathexpr/cli/minicli/StringCLIOption.java | 14 +++++
 5 files changed, 128 insertions(+)
 create mode 100644 src/main/java/net/marcellperger/mathexpr/cli/CLI.java
 create mode 100644 src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
 create mode 100644 src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
 create mode 100644 src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
 create mode 100644 src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/CLI.java b/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
new file mode 100644
index 0000000..6cc880c
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
@@ -0,0 +1,9 @@
+package net.marcellperger.mathexpr.cli;
+
+import java.util.Arrays;
+
+public class CLI {
+    public static void main(String[] args) {
+        System.out.println("args = " + Arrays.stream(args).map(s -> "`" + s + "`").toList());
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
new file mode 100644
index 0000000..f1e11af
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
@@ -0,0 +1,18 @@
+package net.marcellperger.mathexpr.cli.minicli;
+
+import java.util.List;
+
+public class BooleanCLIOption extends CLIOption<Boolean> {
+    public BooleanCLIOption(List<String> optionNames) {
+        super(Boolean.class, optionNames);
+    }
+
+    @Override
+    public void setValueFromString(String s) {
+        setValue(switch (s.strip().toLowerCase()) {
+            case "0", "no", "false" -> false;
+            case "1", "yes", "true" -> true;
+            case String s2 -> throw new IllegalArgumentException("Bad boolean value '" + s2 + "'");  // TODO special CLIParseException
+        });
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
new file mode 100644
index 0000000..94101b2
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
@@ -0,0 +1,33 @@
+package net.marcellperger.mathexpr.cli.minicli;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public abstract class CLIOption<T> {
+    List<String> names;
+    Class<T> type;
+    @Nullable T value;
+
+    public CLIOption(Class<T> valueType, List<String> optionNames) {
+        names = optionNames;
+        type = valueType;
+    }
+
+    public List<String> getNames() {
+        return names;
+    }
+
+    public @Nullable T getValue() {
+        return value;
+    }
+    public void setValue(@Nullable T value) {
+        this.value = value;
+    }
+
+    public abstract void setValueFromString(String s);
+
+    public void reset() {
+        value = null;
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
new file mode 100644
index 0000000..7438686
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -0,0 +1,54 @@
+package net.marcellperger.mathexpr.cli.minicli;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class MiniCLI {
+    Map<String, CLIOption<?>> options = new HashMap<>();
+    List<String> positionalArgs = new ArrayList<>();
+
+    public MiniCLI() {
+
+    }
+
+    @Contract("_ -> new")
+    public CLIOption<String> addStringOption(String @NotNull ... names) {
+        // First validate all of them so we don't mutate unless all are valid
+        for(String name : names) {
+            if (!name.startsWith("-")) throw new IllegalArgumentException("Option name must start with '-'");
+            if (options.containsKey(name)) {
+                throw new IllegalStateException("Argument '%s' has already been registered".formatted(name));
+            }
+        }
+        CLIOption<String> opt = new StringCLIOption(List.of(names));
+        for(String name : names) {
+            options.put(name, opt);
+        }
+        return opt;
+    }
+
+
+    @Contract("_ -> this")
+    public MiniCLI parseArgs(String[] args) {
+        return parseArgs(List.of(args));
+    }
+    @Contract("_ -> this")
+    public MiniCLI parseArgs(List<String> args) {
+
+        return this;
+    }
+    private enum ArgType {
+        NORMAL, SINGLE, DOUBLE;
+        public static ArgType fromArg(String arg) {
+            if(arg.startsWith("--")) return DOUBLE;
+            if(arg.startsWith("-")) return SINGLE;
+            return NORMAL;
+        }
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
new file mode 100644
index 0000000..5ce4f0f
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
@@ -0,0 +1,14 @@
+package net.marcellperger.mathexpr.cli.minicli;
+
+import java.util.List;
+
+public class StringCLIOption extends CLIOption<String> {
+    public StringCLIOption(List<String> keys) {
+        super(String.class, keys);
+    }
+
+    @Override
+    public void setValueFromString(String s) {
+        setValue(s);
+    }
+}

From 148e3ceec03b132e8f6e775f76559404bed08453 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 6 Jun 2024 22:36:24 +0100
Subject: [PATCH 02/23] feat: Do most (not all yet) of the core CLI parsing
 stuff [WIP]

---
 .idea/inspectionProfiles/Project_Default.xml  |  3 +
 .../cli/minicli/BooleanCLIOption.java         | 21 ++++--
 .../mathexpr/cli/minicli/CLIOption.java       | 20 +++++-
 .../cli/minicli/CLIParseException.java        | 18 +++++
 .../mathexpr/cli/minicli/MiniCLI.java         | 70 ++++++++++++++++++-
 .../mathexpr/cli/minicli/OptionValueMode.java | 31 ++++++++
 .../mathexpr/cli/minicli/StringCLIOption.java |  4 +-
 7 files changed, 160 insertions(+), 7 deletions(-)
 create mode 100644 src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIParseException.java
 create mode 100644 src/main/java/net/marcellperger/mathexpr/cli/minicli/OptionValueMode.java

diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index 637f013..c6332e8 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -3,6 +3,9 @@
     <option name="myName" value="Project Default" />
     <inspection_tool class="CatchMayIgnoreException" enabled="true" level="TEXT ATTRIBUTES" enabled_by_default="true" editorAttributes="CONSIDERATION_ATTRIBUTES" />
     <inspection_tool class="SuspiciousLiteralUnderscore" enabled="true" level="WEAK WARNING" enabled_by_default="true" editorAttributes="INFO_ATTRIBUTES" />
+    <inspection_tool class="UnnecessarySemicolon" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoreAfterEnumConstants" value="true" />
+    </inspection_tool>
     <inspection_tool class="UnusedReturnValue" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="IGNORE_BUILDER_PATTERN" value="true" />
       <option name="highestModifier" value="package-private" />
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
index f1e11af..6275db0 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
@@ -1,5 +1,7 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
+import org.jetbrains.annotations.Nullable;
+
 import java.util.List;
 
 public class BooleanCLIOption extends CLIOption<Boolean> {
@@ -8,11 +10,22 @@ public BooleanCLIOption(List<String> optionNames) {
     }
 
     @Override
-    public void setValueFromString(String s) {
-        setValue(switch (s.strip().toLowerCase()) {
+    protected void _setValueFromString(@Nullable String s) {
+        if(s == null) setValue(true);
+        else setValue(switch (s.strip().toLowerCase()) {
             case "0", "no", "false" -> false;
-            case "1", "yes", "true" -> true;
-            case String s2 -> throw new IllegalArgumentException("Bad boolean value '" + s2 + "'");  // TODO special CLIParseException
+            case "", "1", "yes", "true" -> true;
+            case String s2 -> throw new CLIParseException("Bad boolean value '" + s2 + "'");
         });
     }
+
+    @Override
+    public boolean supportsSeparateValueAfterShortForm() {
+        return false;  // cannot have `foo -r no` (use `-r=no` / `--long-form=no`
+    }
+
+    @Override
+    public OptionValueMode getValueMode() {
+        return OptionValueMode.OPTIONAL;
+    }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
index 94101b2..5e1815e 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
@@ -1,8 +1,10 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
+import java.util.Objects;
 
 public abstract class CLIOption<T> {
     List<String> names;
@@ -25,7 +27,23 @@ public void setValue(@Nullable T value) {
         this.value = value;
     }
 
-    public abstract void setValueFromString(String s);
+    // Nullable because we need a way to distinguish `--foo=''` and `--foo`
+    protected abstract void _setValueFromString(@Nullable String s);
+    public void setValueFromString(@Nullable String s) {
+        getValueMode().validateHasValue(s == null);
+        _setValueFromString(s);
+    }
+
+    public OptionValueMode getValueMode() {
+        return OptionValueMode.REQUIRED;
+    }
+
+    /**
+     * @return True if it supports `-b arg`, False to make `-b arg` into `-b`,`arg`
+     */
+    public boolean supportsSeparateValueAfterShortForm() {
+        return getValueMode() != OptionValueMode.NONE;
+    }
 
     public void reset() {
         value = null;
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIParseException.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIParseException.java
new file mode 100644
index 0000000..e4ed256
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIParseException.java
@@ -0,0 +1,18 @@
+package net.marcellperger.mathexpr.cli.minicli;
+
+public class CLIParseException extends IllegalArgumentException {
+    public CLIParseException() {
+    }
+
+    public CLIParseException(String s) {
+        super(s);
+    }
+
+    public CLIParseException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public CLIParseException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index 7438686..20535f2 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -1,5 +1,7 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
+import net.marcellperger.mathexpr.util.Pair;
+import net.marcellperger.mathexpr.util.Util;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -8,6 +10,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 
 public class MiniCLI {
     Map<String, CLIOption<?>> options = new HashMap<>();
@@ -40,8 +43,73 @@ public MiniCLI parseArgs(String[] args) {
     }
     @Contract("_ -> this")
     public MiniCLI parseArgs(List<String> args) {
-
+        new Parser(args).parse();
         return this;
+    }
+    private @NotNull CLIOption<?> lookupOption(String opt) {
+        CLIOption<?> out = options.get(opt);
+        if(out == null) throw new CLIParseException("'%s' is not a valid option".formatted(opt));
+        return out;
+    }
+    private class Parser {
+        @Nullable CLIOption<?> prev = null;
+        List<String> args;
+
+        public Parser(List<String> args) {
+            this.args = args;
+        }
+
+        public void parse() {
+            args.forEach(this::pumpSingleArg);
+            // TODO: finalize: check prev, handle if not null
+        }
+
+        // Make this public as it could be useful for making stream-ing type stuff
+        public void pumpSingleArg(String arg) {
+            ArgType argT = ArgType.fromArg(arg);
+            if(prev != null && prev.getValueMode() == OptionValueMode.REQUIRED) {
+                // We NEED a value so force it, even if it looks like a flag
+                flushPrevWithValue(arg);
+                return;
+            }
+            switch (argT) {
+                case NORMAL -> {
+                    if (prev == null) positionalArgs.add(arg);
+                    else flushPrevWithValue(arg);
+                }
+                case SINGLE -> {
+                    if(prev != null) flushPrev();
+                    if(arg.contains("=")) {
+                        Pair<String, String> kv = Pair.ofArray(arg.split("=", 2));
+                        CLIOption<?> opt = lookupOption(kv.left);
+                        opt.setValueFromString(kv.right);
+                    } else {
+                        prev = lookupOption(arg);
+                        // flush immediately if next one cannot be a value
+                        if(!prev.supportsSeparateValueAfterShortForm()) flushPrev();
+                    }
+                }
+                case DOUBLE -> {
+                    if(prev != null) flushPrev();
+
+                    // TODO lookup here
+                    prev = null;
+                }
+            }
+        }
+
+        private void flushPrev() {
+            Util.realAssert(prev != null, "flushPrev must have a `prev` to flush");
+            prev = null;
+        }
+        private void flushPrevWithValue(String value) {
+            Util.realAssert(prev != null, "flushPrevWithValue must have a `prev` to flush");
+            prev.setValueFromString(value);
+            prev = null;
+        }
+    }
+    private record PrevState(CLIOption<?> option, @Nullable String value) {
+
     }
     private enum ArgType {
         NORMAL, SINGLE, DOUBLE;
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/OptionValueMode.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/OptionValueMode.java
new file mode 100644
index 0000000..a8a3f7e
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/OptionValueMode.java
@@ -0,0 +1,31 @@
+package net.marcellperger.mathexpr.cli.minicli;
+
+/**
+ * Controls if a value is required for an option
+ */
+public enum OptionValueMode {
+    /**
+     * Specifying a value is not allowed (e.g. {@code --foo} is allowed, {@code --foo=76} is not)
+     */
+    NONE,
+    /**
+     * Specifying a value is optional (e.g. {@code --foo} and {@code --foo=76} are both allowed)
+     */
+    OPTIONAL,
+    /**
+     * Specifying a value is required (e.g. {@code --foo=76} is allowed, {@code --foo} is not)
+     */
+    REQUIRED,
+    ;
+    public void validateHasValue(boolean hasValue) {
+        switch (this) {
+            case NONE -> {
+                if(hasValue) throw new CLIParseException("Specifying a value for this option is not allowed");
+            }
+            case OPTIONAL -> {}
+            case REQUIRED -> {
+                if(!hasValue) throw new CLIParseException("This option requires a value to be passed");
+            }
+        }
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
index 5ce4f0f..9d63e0d 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
@@ -1,5 +1,7 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
+import org.jetbrains.annotations.Nullable;
+
 import java.util.List;
 
 public class StringCLIOption extends CLIOption<String> {
@@ -8,7 +10,7 @@ public StringCLIOption(List<String> keys) {
     }
 
     @Override
-    public void setValueFromString(String s) {
+    protected void _setValueFromString(@Nullable String s) {
         setValue(s);
     }
 }

From 003752ada82d9c0b9be93acb69e20836a7258fa6 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 7 Jun 2024 21:51:46 +0100
Subject: [PATCH 03/23] feat: Finish `MiniCLI.Parser`

---
 .../mathexpr/cli/minicli/MiniCLI.java         | 40 ++++++++++++-------
 1 file changed, 26 insertions(+), 14 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index 20535f2..ab45345 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -60,8 +60,12 @@ public Parser(List<String> args) {
         }
 
         public void parse() {
+            pumpAllArgs();
+            finish();
+        }
+
+        public void pumpAllArgs() {
             args.forEach(this::pumpSingleArg);
-            // TODO: finalize: check prev, handle if not null
         }
 
         // Make this public as it could be useful for making stream-ing type stuff
@@ -74,16 +78,12 @@ public void pumpSingleArg(String arg) {
             }
             switch (argT) {
                 case NORMAL -> {
-                    if (prev == null) positionalArgs.add(arg);
-                    else flushPrevWithValue(arg);
+                    if (prev != null) flushPrevWithValue(arg);
+                    else positionalArgs.add(arg);
                 }
                 case SINGLE -> {
                     if(prev != null) flushPrev();
-                    if(arg.contains("=")) {
-                        Pair<String, String> kv = Pair.ofArray(arg.split("=", 2));
-                        CLIOption<?> opt = lookupOption(kv.left);
-                        opt.setValueFromString(kv.right);
-                    } else {
+                    if(!setFromKeyEqualsValue(arg)) {
                         prev = lookupOption(arg);
                         // flush immediately if next one cannot be a value
                         if(!prev.supportsSeparateValueAfterShortForm()) flushPrev();
@@ -91,13 +91,28 @@ public void pumpSingleArg(String arg) {
                 }
                 case DOUBLE -> {
                     if(prev != null) flushPrev();
-
-                    // TODO lookup here
-                    prev = null;
+                    if(!setFromKeyEqualsValue(arg)) {
+                        lookupOption(arg).setValueFromString(null);
+                    }
                 }
             }
         }
 
+        public void finish() {
+            if(prev != null) flushPrev();
+        }
+
+        // Makes more logical sense reading the code
+        // (`if (![did]setFromKeyEqualValue(arg)) {...}` )
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+        private boolean /*return success?*/ setFromKeyEqualsValue(String arg) {
+            if(!arg.contains("=")) return false;
+            Pair<String, String> kv = Pair.ofArray(arg.split("=", 2));
+            CLIOption<?> opt = lookupOption(kv.left);
+            opt.setValueFromString(kv.right);
+            return true;
+        }
+
         private void flushPrev() {
             Util.realAssert(prev != null, "flushPrev must have a `prev` to flush");
             prev = null;
@@ -107,9 +122,6 @@ private void flushPrevWithValue(String value) {
             prev.setValueFromString(value);
             prev = null;
         }
-    }
-    private record PrevState(CLIOption<?> option, @Nullable String value) {
-
     }
     private enum ArgType {
         NORMAL, SINGLE, DOUBLE;

From 0252b13596dc4e349ae306a892fa5c49001b8b39 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 7 Jun 2024 21:57:07 +0100
Subject: [PATCH 04/23] refactor: Fix some warnings

---
 .../marcellperger/mathexpr/cli/minicli/CLIOption.java |  2 --
 .../marcellperger/mathexpr/cli/minicli/MiniCLI.java   |  1 -
 .../java/net/marcellperger/mathexpr/util/Util.java    | 11 -----------
 3 files changed, 14 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
index 5e1815e..3969eec 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
@@ -1,10 +1,8 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
-import java.util.Objects;
 
 public abstract class CLIOption<T> {
     List<String> names;
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index ab45345..65988f9 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -10,7 +10,6 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 
 public class MiniCLI {
     Map<String, CLIOption<?>> options = new HashMap<>();
diff --git a/src/main/java/net/marcellperger/mathexpr/util/Util.java b/src/main/java/net/marcellperger/mathexpr/util/Util.java
index 0e8ffe2..23fa619 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Util.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Util.java
@@ -108,17 +108,6 @@ public static void expectOrFail(boolean cond) {
         if(!cond) throw new AssertionError("Assertion failed in expectOrFail");
     }
 
-//    @Contract("_, _ -> param1")
-//    public static<T> T expectOrFail(T value, @NotNull Predicate<T> predicate, ) {
-//        if(!predicate.test(value)) throw new AssertionError("Assertion failed in expectOrFail");
-//        return value;
-//    }
-//    @Contract("_, true -> param1; _, false -> fail")
-//    public static<T> T expectOrFail(T value, boolean cond) {
-//        if(!cond) throw new AssertionError("Assertion failed in expectOrFail");
-//        return value;
-//    }
-
     @Contract("_, _ -> param1")
     public static<T extends Throwable> @NotNull T withCause(@NotNull T exc, @Nullable Throwable cause) {
         if(cause != null) exc.initCause(cause);

From dc6cb68f5342fb493e75b920d9b51ec20fe50dc4 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 7 Jun 2024 22:04:26 +0100
Subject: [PATCH 05/23] refactor: Add `MiniCLI.addBooleanOption`

---
 .../marcellperger/mathexpr/cli/minicli/MiniCLI.java | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index 65988f9..95287e2 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -10,6 +10,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
 
 public class MiniCLI {
     Map<String, CLIOption<?>> options = new HashMap<>();
@@ -21,6 +22,16 @@ public MiniCLI() {
 
     @Contract("_ -> new")
     public CLIOption<String> addStringOption(String @NotNull ... names) {
+        return addOptionFromFactory(names, StringCLIOption::new);
+    }
+    @Contract("_ -> new")
+    public CLIOption<Boolean> addBooleanOption(String @NotNull ... names) {
+        return addOptionFromFactory(names, BooleanCLIOption::new);
+    }
+
+    protected <T> CLIOption<T> addOptionFromFactory(
+            String @NotNull[] names,
+            Function<? super List<String>, ? extends CLIOption<T>> optionFactory) {
         // First validate all of them so we don't mutate unless all are valid
         for(String name : names) {
             if (!name.startsWith("-")) throw new IllegalArgumentException("Option name must start with '-'");
@@ -28,7 +39,7 @@ public CLIOption<String> addStringOption(String @NotNull ... names) {
                 throw new IllegalStateException("Argument '%s' has already been registered".formatted(name));
             }
         }
-        CLIOption<String> opt = new StringCLIOption(List.of(names));
+        CLIOption<T> opt = optionFactory.apply(List.of(names));
         for(String name : names) {
             options.put(name, opt);
         }

From d968fda22a4d251ebdae27f3dbe82160a7061524 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 7 Jun 2024 22:42:14 +0100
Subject: [PATCH 06/23] feat: Add `MiniCLI.setPositionalArgCount`

---
 .../net/marcellperger/mathexpr/IntRange.java  | 33 +++++++++++++++++
 .../net/marcellperger/mathexpr/UIntRange.java | 36 +++++++++++++++++++
 .../cli/minicli/BooleanCLIOption.java         |  2 +-
 .../mathexpr/cli/minicli/MiniCLI.java         | 24 ++++++++++++-
 .../mathexpr/cli/minicli/StringCLIOption.java |  2 +-
 5 files changed, 94 insertions(+), 3 deletions(-)
 create mode 100644 src/main/java/net/marcellperger/mathexpr/IntRange.java
 create mode 100644 src/main/java/net/marcellperger/mathexpr/UIntRange.java

diff --git a/src/main/java/net/marcellperger/mathexpr/IntRange.java b/src/main/java/net/marcellperger/mathexpr/IntRange.java
new file mode 100644
index 0000000..d877f15
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/IntRange.java
@@ -0,0 +1,33 @@
+package net.marcellperger.mathexpr;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+public class IntRange {
+    int lo, hi;
+
+    protected IntRange(int min, int max, int ignoredMarker) {
+        if(min > max) throw new IllegalArgumentException("min must be grater than max");
+        lo = min;
+        hi = max;
+    }
+    public IntRange(@Nullable Integer min, @Nullable Integer max) {
+        this(Objects.requireNonNullElse(min, Integer.MIN_VALUE),
+            Objects.requireNonNullElse(max, Integer.MAX_VALUE), /*marker*/0);
+    }
+    public IntRange() {
+        this(null, null);
+    }
+
+    public int getMin() {
+        return lo;
+    }
+    public int getMax() {
+        return hi;
+    }
+
+    public boolean includes(int v) {
+        return lo <= v && v <= hi;
+    }
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/UIntRange.java b/src/main/java/net/marcellperger/mathexpr/UIntRange.java
new file mode 100644
index 0000000..1c051f7
--- /dev/null
+++ b/src/main/java/net/marcellperger/mathexpr/UIntRange.java
@@ -0,0 +1,36 @@
+package net.marcellperger.mathexpr;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+public class UIntRange extends IntRange {
+    protected UIntRange(int min, int max, int ignoredMarker) {
+        super(workaround(() -> {
+            if(min < 0 || max < 0) throw new IllegalArgumentException();
+        }, min), max, ignoredMarker);
+    }
+
+    public UIntRange(@Nullable Integer min, @Nullable Integer max) {
+        this(Objects.requireNonNullElse(min, 0),
+            Objects.requireNonNullElse(max, Integer.MAX_VALUE), /*marker*/0);
+    }
+
+    public UIntRange() {
+        this(null, null);
+    }
+
+    /**
+     * Workaround to allow us to run code before super() call.
+     * This is required because java insists that super() be this first statement!
+     * So not even static stuff can be ran!
+     */
+    @Contract("_, _ -> param2")
+    private static <T> T workaround(@NotNull Runnable r, T returnValue) {
+        r.run();
+        return returnValue;
+    }
+
+}
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
index 6275db0..1245232 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
@@ -4,7 +4,7 @@
 
 import java.util.List;
 
-public class BooleanCLIOption extends CLIOption<Boolean> {
+class BooleanCLIOption extends CLIOption<Boolean> {
     public BooleanCLIOption(List<String> optionNames) {
         super(Boolean.class, optionNames);
     }
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index 95287e2..cae4a1c 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -1,5 +1,7 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
+import net.marcellperger.mathexpr.IntRange;
+import net.marcellperger.mathexpr.UIntRange;
 import net.marcellperger.mathexpr.util.Pair;
 import net.marcellperger.mathexpr.util.Util;
 import org.jetbrains.annotations.Contract;
@@ -10,16 +12,29 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.function.Function;
 
 public class MiniCLI {
     Map<String, CLIOption<?>> options = new HashMap<>();
+    UIntRange nPositionalArgs = new UIntRange();
     List<String> positionalArgs = new ArrayList<>();
 
     public MiniCLI() {
 
     }
 
+    public void setPositionalArgCount(UIntRange range) {
+        nPositionalArgs = range;
+    }
+    public void setPositionalArgCount(@Nullable Integer min, @Nullable Integer max) {
+        setPositionalArgCount(new UIntRange(min, max));
+    }
+    public void setPositionalArgCount(@Nullable /*null=any*/ Integer value) {
+        if(value == null) setPositionalArgCount(new UIntRange());
+        else setPositionalArgCount(value, value);
+    }
+
     @Contract("_ -> new")
     public CLIOption<String> addStringOption(String @NotNull ... names) {
         return addOptionFromFactory(names, StringCLIOption::new);
@@ -89,7 +104,7 @@ public void pumpSingleArg(String arg) {
             switch (argT) {
                 case NORMAL -> {
                     if (prev != null) flushPrevWithValue(arg);
-                    else positionalArgs.add(arg);
+                    else addPositionalArg(arg);
                 }
                 case SINGLE -> {
                     if(prev != null) flushPrev();
@@ -132,6 +147,13 @@ private void flushPrevWithValue(String value) {
             prev.setValueFromString(value);
             prev = null;
         }
+
+        private void addPositionalArg(String arg) {
+            int newSize = positionalArgs.size() + 1;
+            int maxArgc = nPositionalArgs.getMax();
+            if(newSize > maxArgc)
+                throw new CLIParseException("Too many positional args (expected max %d, got %d)".formatted(maxArgc, newSize));
+        }
     }
     private enum ArgType {
         NORMAL, SINGLE, DOUBLE;
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
index 9d63e0d..729d0e4 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
@@ -4,7 +4,7 @@
 
 import java.util.List;
 
-public class StringCLIOption extends CLIOption<String> {
+class StringCLIOption extends CLIOption<String> {
     public StringCLIOption(List<String> keys) {
         super(String.class, keys);
     }

From 3efd55ae6b10b8fe14b35fcc7f4bd8de599f58ad Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Tue, 11 Jun 2024 21:42:57 +0100
Subject: [PATCH 07/23] fix: Add checking for number of positional args

---
 src/main/java/net/marcellperger/mathexpr/IntRange.java   | 5 +++++
 .../net/marcellperger/mathexpr/cli/minicli/MiniCLI.java  | 9 ++++++---
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/IntRange.java b/src/main/java/net/marcellperger/mathexpr/IntRange.java
index d877f15..f94cacc 100644
--- a/src/main/java/net/marcellperger/mathexpr/IntRange.java
+++ b/src/main/java/net/marcellperger/mathexpr/IntRange.java
@@ -30,4 +30,9 @@ public int getMax() {
     public boolean includes(int v) {
         return lo <= v && v <= hi;
     }
+
+    public String fancyRepr() {
+        if(lo == hi) return "exactly %d".formatted(lo);
+        return "%d to %d".formatted(lo, hi);
+    }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index cae4a1c..37677f2 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -1,6 +1,5 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
-import net.marcellperger.mathexpr.IntRange;
 import net.marcellperger.mathexpr.UIntRange;
 import net.marcellperger.mathexpr.util.Pair;
 import net.marcellperger.mathexpr.util.Util;
@@ -12,7 +11,6 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.function.Function;
 
 public class MiniCLI {
@@ -124,7 +122,11 @@ public void pumpSingleArg(String arg) {
         }
 
         public void finish() {
-            if(prev != null) flushPrev();
+            if(prev != null) flushPrev();  // TODO handle required kw-args
+            int nArgs = positionalArgs.size();
+            if(!nPositionalArgs.includes(nArgs))
+                throw new CLIParseException("Incorrect number of positional args (required %s, got %d)"
+                    .formatted(nPositionalArgs.fancyRepr(), nArgs));
         }
 
         // Makes more logical sense reading the code
@@ -153,6 +155,7 @@ private void addPositionalArg(String arg) {
             int maxArgc = nPositionalArgs.getMax();
             if(newSize > maxArgc)
                 throw new CLIParseException("Too many positional args (expected max %d, got %d)".formatted(maxArgc, newSize));
+            positionalArgs.add(arg);
         }
     }
     private enum ArgType {

From 634ca420d907eeae82c20c8a23a66c963789c15d Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Tue, 11 Jun 2024 23:03:42 +0100
Subject: [PATCH 08/23] feat: Finish most of MiniCLI

Still a TON of TODOs left
TODO: add help/version
Also bug: `-R 99` doesn't work
---
 .../net/marcellperger/mathexpr/cli/CLI.java   | 10 ++++++
 .../cli/minicli/BooleanCLIOption.java         |  1 +
 .../mathexpr/cli/minicli/CLIOption.java       | 35 +++++++++++++++++--
 .../mathexpr/cli/minicli/MiniCLI.java         | 12 +++----
 .../mathexpr/cli/minicli/StringCLIOption.java | 29 +++++++++++++--
 5 files changed, 77 insertions(+), 10 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/CLI.java b/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
index 6cc880c..3e64a9e 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
@@ -1,9 +1,19 @@
 package net.marcellperger.mathexpr.cli;
 
+import net.marcellperger.mathexpr.cli.minicli.CLIOption;
+import net.marcellperger.mathexpr.cli.minicli.MiniCLI;
+
 import java.util.Arrays;
 
 public class CLI {
     public static void main(String[] args) {
+        MiniCLI cli = new MiniCLI();
+        CLIOption<Boolean> interactive = cli.addBooleanOption("-i", "--interactive");
+        CLIOption<String> rounding = cli.addStringOption("-R", "--round-sf").setDefault("12");
+        cli.setPositionalArgCount(0, 1);
+        cli.parseArgs(args);
+        System.out.println("interactive = " + interactive.getValue());
+        System.out.println("rounding = " + rounding.getValue());
         System.out.println("args = " + Arrays.stream(args).map(s -> "`" + s + "`").toList());
     }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
index 1245232..f53bdbd 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
@@ -7,6 +7,7 @@
 class BooleanCLIOption extends CLIOption<Boolean> {
     public BooleanCLIOption(List<String> optionNames) {
         super(Boolean.class, optionNames);
+        setDefault(false);
     }
 
     @Override
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
index 3969eec..075eb0a 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
@@ -1,26 +1,57 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import javax.naming.OperationNotSupportedException;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Objects;
 
 public abstract class CLIOption<T> {
     List<String> names;
     Class<T> type;
-    @Nullable T value;
+    T value;
+    boolean isRequired;
+    @Nullable T defaultIfAbsent;
 
     public CLIOption(Class<T> valueType, List<String> optionNames) {
         names = optionNames;
         type = valueType;
     }
 
+    @Contract("_ -> this")
+    public CLIOption<T> setRequired(boolean required) {
+        isRequired = required;
+        return this;
+    }
+    @Contract("_ -> this")
+    public CLIOption<T> setDefault(T defaultIfAbsent) {
+        this.defaultIfAbsent = defaultIfAbsent;
+        return this;
+    }
+    @Contract("_ -> this")
+    public CLIOption<T> setDefaultNoValue(T defaultIfNoValue) {
+        throw new UnsupportedOperationException("CLIOption<T>.setDefaultValue");
+    }
+
+    // TODO default value!
+
     public List<String> getNames() {
         return names;
     }
 
-    public @Nullable T getValue() {
+    public T getValue() {
         return value;
     }
+
+    public void finish() {
+        if(value != null) return;  // All good
+        if(isRequired) throw new CLIParseException("This argument is required");  // TODO detail!
+        value = defaultIfAbsent;
+    }
+
     public void setValue(@Nullable T value) {
         this.value = value;
     }
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index 37677f2..93f6584 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -7,14 +7,12 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.function.Function;
 
 public class MiniCLI {
     Map<String, CLIOption<?>> options = new HashMap<>();
+    Set<CLIOption<?>> optionSet = new HashSet<>();
     UIntRange nPositionalArgs = new UIntRange();
     List<String> positionalArgs = new ArrayList<>();
 
@@ -53,6 +51,7 @@ protected <T> CLIOption<T> addOptionFromFactory(
             }
         }
         CLIOption<T> opt = optionFactory.apply(List.of(names));
+        optionSet.add(opt);
         for(String name : names) {
             options.put(name, opt);
         }
@@ -92,7 +91,7 @@ public void pumpAllArgs() {
         }
 
         // Make this public as it could be useful for making stream-ing type stuff
-        public void pumpSingleArg(String arg) {
+        public void pumpSingleArg(@NotNull String arg) {
             ArgType argT = ArgType.fromArg(arg);
             if(prev != null && prev.getValueMode() == OptionValueMode.REQUIRED) {
                 // We NEED a value so force it, even if it looks like a flag
@@ -122,11 +121,12 @@ public void pumpSingleArg(String arg) {
         }
 
         public void finish() {
-            if(prev != null) flushPrev();  // TODO handle required kw-args
+            if(prev != null) flushPrev();
             int nArgs = positionalArgs.size();
             if(!nPositionalArgs.includes(nArgs))
                 throw new CLIParseException("Incorrect number of positional args (required %s, got %d)"
                     .formatted(nPositionalArgs.fancyRepr(), nArgs));
+            optionSet.forEach(CLIOption::finish);  // Handle options
         }
 
         // Makes more logical sense reading the code
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
index 729d0e4..c08b0ce 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
@@ -1,16 +1,41 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
 class StringCLIOption extends CLIOption<String> {
-    public StringCLIOption(List<String> keys) {
+    @Nullable String defaultIfNoValue;
+
+    public StringCLIOption(List<String> keys, @Nullable String defaultIfNoValue) {
         super(String.class, keys);
+        this.defaultIfNoValue = defaultIfNoValue;
+    }
+    public StringCLIOption(List<String> keys) {
+        this(keys, null);
+    }
+
+    @Override
+    public CLIOption<String> setDefaultNoValue(String defaultIfNoValue) {
+        this.defaultIfNoValue = defaultIfNoValue;
+        return this;
     }
 
     @Override
     protected void _setValueFromString(@Nullable String s) {
-        setValue(s);
+        setValue(s == null ? getDefaultIfNoValue() : s);
+    }
+
+    @Override
+    public OptionValueMode getValueMode() {
+        return defaultIfNoValue == null ? OptionValueMode.REQUIRED : OptionValueMode.OPTIONAL;
+    }
+
+    protected @NotNull String getDefaultIfNoValue() {
+        if (defaultIfNoValue == null) {  // TODO valueMode should handle this?
+            throw new CLIParseException("This argument requires a value");  // TODO some way of specifying which to use a display?
+        }
+        return defaultIfNoValue;
     }
 }

From 6fc0f9225ec9fcfb70c8e105812264bc22a24a9b Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Tue, 11 Jun 2024 23:07:38 +0100
Subject: [PATCH 09/23] fix: Fix bug

---
 .../java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
index 075eb0a..6faa249 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
@@ -59,7 +59,7 @@ public void setValue(@Nullable T value) {
     // Nullable because we need a way to distinguish `--foo=''` and `--foo`
     protected abstract void _setValueFromString(@Nullable String s);
     public void setValueFromString(@Nullable String s) {
-        getValueMode().validateHasValue(s == null);
+        getValueMode().validateHasValue(s != null);
         _setValueFromString(s);
     }
 

From 5333ebe882bea6a1c40d9114fc151cac70786753 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 13 Jun 2024 21:00:44 +0100
Subject: [PATCH 10/23] fix: Make plain `-R` give an error

---
 .../java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java    | 1 +
 .../net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index 93f6584..173e582 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -142,6 +142,7 @@ public void finish() {
 
         private void flushPrev() {
             Util.realAssert(prev != null, "flushPrev must have a `prev` to flush");
+            prev.setValueFromString(null);
             prev = null;
         }
         private void flushPrevWithValue(String value) {
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
index c08b0ce..be2f955 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
@@ -6,7 +6,7 @@
 import java.util.List;
 
 class StringCLIOption extends CLIOption<String> {
-    @Nullable String defaultIfNoValue;
+    @Nullable String defaultIfNoValue;  // TODO should this really be here - makes more sense in CLIOption
 
     public StringCLIOption(List<String> keys, @Nullable String defaultIfNoValue) {
         super(String.class, keys);

From 33a68014a6de7040fd39e7656d7232dc95d85775 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 13 Jun 2024 21:03:11 +0100
Subject: [PATCH 11/23] fix: Fix unused imports

---
 .../net/marcellperger/mathexpr/cli/minicli/CLIOption.java     | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
index 6faa249..ba07371 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
@@ -1,13 +1,9 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
 import org.jetbrains.annotations.Contract;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import javax.naming.OperationNotSupportedException;
-import java.util.Iterator;
 import java.util.List;
-import java.util.Objects;
 
 public abstract class CLIOption<T> {
     List<String> names;

From 905cfc408f3454522867a947b5473301590be8b5 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Fri, 14 Jun 2024 21:12:58 +0100
Subject: [PATCH 12/23] refactor: Add `Option.expect(Throwable)`

---
 .../mathexpr/util/rs/Option.java              |  7 +++
 .../mathexpr/util/rs/OptionTest.java          | 48 +++++++++++++++++++
 2 files changed, 55 insertions(+)

diff --git a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
index aa6140d..88b96ef 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/rs/Option.java
@@ -1,5 +1,6 @@
 package net.marcellperger.mathexpr.util.rs;
 
+import net.marcellperger.mathexpr.util.ThrowingSupplier;
 import net.marcellperger.mathexpr.util.Util;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
@@ -143,6 +144,12 @@ default T expect(String msg) {
             throw new OptionPanicException(msg);
         });
     }
+    default <E extends Throwable> T expect(E excIfNone) throws E {
+        return switch (this) {
+            case None() -> throw excIfNone;
+            case Some(T value) -> value;
+        };
+    }
     default T unwrap() {
         return expect("Option.unwrap() got None value");
     }
diff --git a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
index 10fe2af..8f50740 100644
--- a/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
+++ b/src/test/java/net/marcellperger/mathexpr/util/rs/OptionTest.java
@@ -227,6 +227,54 @@ void expect() {
         assertNull(exc.getCause(), "Expected no cause for Option.expect()");
     }
 
+    @SuppressWarnings("unused")
+    static class MyCustomException extends RuntimeException {
+        public MyCustomException() {}
+        public MyCustomException(String message) {
+            super(message);
+        }
+        public MyCustomException(String message, Throwable cause) {
+            super(message, cause);
+        }
+        public MyCustomException(Throwable cause) {
+            super(cause);
+        }
+    }
+
+    @SuppressWarnings("unused")
+    static class MyCustomCheckedException extends RuntimeException {
+        public MyCustomCheckedException() {}
+        public MyCustomCheckedException(String message) {
+            super(message);
+        }
+        public MyCustomCheckedException(String message, Throwable cause) {
+            super(message, cause);
+        }
+        public MyCustomCheckedException(Throwable cause) {
+            super(cause);
+        }
+    }
+
+    @Test
+    void expect_exc() {
+        {
+            MyCustomException actualExc = new MyCustomException("unchecked exc");
+            assertEquals(314, assertDoesNotThrow(() -> getSome().expect(actualExc)));
+            Option<Integer> err = getNone();
+            MyCustomException exc = assertThrows(
+                MyCustomException.class, () -> err.expect(actualExc));
+            assertEquals(exc, actualExc);
+        }
+        {
+            MyCustomCheckedException actualExc = new MyCustomCheckedException("checked exc");
+            assertEquals(314, assertDoesNotThrow(() -> getSome().expect(actualExc)));
+            Option<Integer> err = getNone();
+            MyCustomCheckedException exc = assertThrows(
+                MyCustomCheckedException.class, () -> err.expect(actualExc));
+            assertEquals(exc, actualExc);
+        }
+    }
+
     @Test
     void unwrap() {
         assertEquals(314, assertDoesNotThrow(() -> getSome().unwrap()));

From 555d6cee8101f4ad7bebbf1d2a0a9ffe020521eb Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 15 Jun 2024 22:54:43 +0100
Subject: [PATCH 13/23] fix: Clean up and fix code

---
 .../cli/minicli/BooleanCLIOption.java         | 16 ++--
 .../mathexpr/cli/minicli/CLIOption.java       | 89 ++++++++++++++-----
 .../mathexpr/cli/minicli/MiniCLI.java         | 19 +++-
 .../mathexpr/cli/minicli/StringCLIOption.java | 30 ++-----
 .../{OptionValueMode.java => ValueMode.java}  |  2 +-
 5 files changed, 97 insertions(+), 59 deletions(-)
 rename src/main/java/net/marcellperger/mathexpr/cli/minicli/{OptionValueMode.java => ValueMode.java} (96%)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
index f53bdbd..662ee9e 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
@@ -1,6 +1,6 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
-import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
@@ -8,14 +8,15 @@ class BooleanCLIOption extends CLIOption<Boolean> {
     public BooleanCLIOption(List<String> optionNames) {
         super(Boolean.class, optionNames);
         setDefault(false);
+        setDefaultIfNoValue(true);
+        setValueMode(ValueMode.OPTIONAL);
     }
 
     @Override
-    protected void _setValueFromString(@Nullable String s) {
-        if(s == null) setValue(true);
-        else setValue(switch (s.strip().toLowerCase()) {
+    protected void _setValueFromString(@NotNull String s) {
+        setValue(switch (s.strip().toLowerCase()) {
             case "0", "no", "false" -> false;
-            case "", "1", "yes", "true" -> true;
+            case "1", "yes", "true" -> true;
             case String s2 -> throw new CLIParseException("Bad boolean value '" + s2 + "'");
         });
     }
@@ -24,9 +25,4 @@ else setValue(switch (s.strip().toLowerCase()) {
     public boolean supportsSeparateValueAfterShortForm() {
         return false;  // cannot have `foo -r no` (use `-r=no` / `--long-form=no`
     }
-
-    @Override
-    public OptionValueMode getValueMode() {
-        return OptionValueMode.OPTIONAL;
-    }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
index ba07371..7e1e78c 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
@@ -1,76 +1,121 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
+import net.marcellperger.mathexpr.util.Util;
+import net.marcellperger.mathexpr.util.rs.Option;
 import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
+import java.util.Objects;
 
 public abstract class CLIOption<T> {
-    List<String> names;
     Class<T> type;
+    List<String> names;
+    @NotNull Option<ValueMode> valueMode = Option.newNone();
+    @NotNull Option<T> defaultIfNoValue = Option.newNone();
+    @NotNull Option<T> defaultIfAbsent = Option.newNone();
     T value;
-    boolean isRequired;
-    @Nullable T defaultIfAbsent;
+    boolean hasValue;
 
     public CLIOption(Class<T> valueType, List<String> optionNames) {
         names = optionNames;
         type = valueType;
     }
 
-    @Contract("_ -> this")
-    public CLIOption<T> setRequired(boolean required) {
-        isRequired = required;
+    @Contract(" -> this")
+    public CLIOption<T> setRequired() {
+        defaultIfAbsent = Option.newNone();
         return this;
     }
     @Contract("_ -> this")
-    public CLIOption<T> setDefault(T defaultIfAbsent) {
-        this.defaultIfAbsent = defaultIfAbsent;
+    public CLIOption<T> setDefault(T defaultIfAbsent_) {
+        defaultIfAbsent = Option.newSome(defaultIfAbsent_);
         return this;
     }
     @Contract("_ -> this")
-    public CLIOption<T> setDefaultNoValue(T defaultIfNoValue) {
-        throw new UnsupportedOperationException("CLIOption<T>.setDefaultValue");
+    public CLIOption<T> setDefaultIfNoValue(T defaultIfNoValue_) {
+        defaultIfNoValue = Option.newSome(defaultIfNoValue_);
+        return this;
+    }
+    public boolean isRequired() {
+        return defaultIfAbsent.isNone();
     }
-
-    // TODO default value!
 
     public List<String> getNames() {
         return names;
     }
 
     public T getValue() {
+        Util.realAssert(hasValue, "value should've been set before getValue() is called");
         return value;
     }
 
+    public void begin() {
+        switch (getValueMode()) {
+            case OPTIONAL, NONE -> defaultIfNoValue.expect(
+                new IllegalStateException("defaultIfNoValue must be provided for OPTIONAL/NONE valueModes"));
+            case REQUIRED -> {
+                if (defaultIfNoValue.isSome()) {
+                    throw new IllegalStateException("defaultIfNoValue should not be specified with a REQUIRED valueMode");
+                }
+            }
+        }
+    }
     public void finish() {
-        if(value != null) return;  // All good
-        if(isRequired) throw new CLIParseException("This argument is required");  // TODO detail!
-        value = defaultIfAbsent;
+        if (!hasValue)
+            setValue(defaultIfAbsent.expect(new CLIParseException("This argument is required")));  // TODO detail!
     }
 
-    public void setValue(@Nullable T value) {
-        this.value = value;
+    public void setValue(T value_) {
+        value = value_;
+        hasValue = true;
     }
 
     // Nullable because we need a way to distinguish `--foo=''` and `--foo`
-    protected abstract void _setValueFromString(@Nullable String s);
+    protected abstract void _setValueFromString(@NotNull String s);
     public void setValueFromString(@Nullable String s) {
-        getValueMode().validateHasValue(s != null);
+        if(s == null) setValueFromNoValue();
+        else setValueFromString_hasValue(s);
+    }
+
+    public void setValueFromString_hasValue(@NotNull String s) {
+        Objects.requireNonNull(s);
+        getValueMode().validateHasValue(true);
         _setValueFromString(s);
     }
+    public void setValueFromNoValue() {
+        getValueMode().validateHasValue(false);
+        setValue(_expectGetDefaultIfNoValue());
+    }
+    protected T _expectGetDefaultIfNoValue() {
+        return defaultIfNoValue.expect(new CLIParseException("This argument requires a value"));
+    }
 
-    public OptionValueMode getValueMode() {
-        return OptionValueMode.REQUIRED;
+    public ValueMode getDefaultValueMode() {
+        return ValueMode.REQUIRED;
+    }
+    public ValueMode getValueMode() {
+        return valueMode.unwrapOr(getDefaultValueMode());
+    }
+    public Option<ValueMode> getDeclaredValueMode() {
+        return valueMode;
+    }
+    @Contract("_ -> this")
+    public CLIOption<T> setValueMode(ValueMode mode) {
+        valueMode = Option.newSome(mode);
+        return this;
     }
 
     /**
      * @return True if it supports `-b arg`, False to make `-b arg` into `-b`,`arg`
      */
     public boolean supportsSeparateValueAfterShortForm() {
-        return getValueMode() != OptionValueMode.NONE;
+        return getValueMode() != ValueMode.NONE;
     }
 
     public void reset() {
         value = null;
+        hasValue = false;
     }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index 173e582..48cc7f9 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -58,6 +58,17 @@ protected <T> CLIOption<T> addOptionFromFactory(
         return opt;
     }
 
+    public void reset() {
+        positionalArgs.clear();
+        optionSet.forEach(CLIOption::reset);
+    }
+
+    // TODO support `--`
+
+    // TODO better positional arg handling (just dumping an array on the user is a bit meh)
+    public List<String> getPositionalArgs() {
+        return positionalArgs;
+    }
 
     @Contract("_ -> this")
     public MiniCLI parseArgs(String[] args) {
@@ -65,6 +76,7 @@ public MiniCLI parseArgs(String[] args) {
     }
     @Contract("_ -> this")
     public MiniCLI parseArgs(List<String> args) {
+        reset();
         new Parser(args).parse();
         return this;
     }
@@ -82,6 +94,7 @@ public Parser(List<String> args) {
         }
 
         public void parse() {
+            begin();
             pumpAllArgs();
             finish();
         }
@@ -93,7 +106,7 @@ public void pumpAllArgs() {
         // Make this public as it could be useful for making stream-ing type stuff
         public void pumpSingleArg(@NotNull String arg) {
             ArgType argT = ArgType.fromArg(arg);
-            if(prev != null && prev.getValueMode() == OptionValueMode.REQUIRED) {
+            if(prev != null && prev.getValueMode() == ValueMode.REQUIRED) {
                 // We NEED a value so force it, even if it looks like a flag
                 flushPrevWithValue(arg);
                 return;
@@ -120,6 +133,10 @@ public void pumpSingleArg(@NotNull String arg) {
             }
         }
 
+        public void begin() {
+            optionSet.forEach(CLIOption::begin);
+        }
+
         public void finish() {
             if(prev != null) flushPrev();
             int nArgs = positionalArgs.size();
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
index be2f955..04d4d01 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
@@ -1,41 +1,21 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
 class StringCLIOption extends CLIOption<String> {
-    @Nullable String defaultIfNoValue;  // TODO should this really be here - makes more sense in CLIOption
-
-    public StringCLIOption(List<String> keys, @Nullable String defaultIfNoValue) {
-        super(String.class, keys);
-        this.defaultIfNoValue = defaultIfNoValue;
-    }
     public StringCLIOption(List<String> keys) {
-        this(keys, null);
-    }
-
-    @Override
-    public CLIOption<String> setDefaultNoValue(String defaultIfNoValue) {
-        this.defaultIfNoValue = defaultIfNoValue;
-        return this;
+        super(String.class, keys);
     }
 
     @Override
-    protected void _setValueFromString(@Nullable String s) {
-        setValue(s == null ? getDefaultIfNoValue() : s);
+    protected void _setValueFromString(@NotNull String s) {
+        setValue(s);
     }
 
     @Override
-    public OptionValueMode getValueMode() {
-        return defaultIfNoValue == null ? OptionValueMode.REQUIRED : OptionValueMode.OPTIONAL;
-    }
-
-    protected @NotNull String getDefaultIfNoValue() {
-        if (defaultIfNoValue == null) {  // TODO valueMode should handle this?
-            throw new CLIParseException("This argument requires a value");  // TODO some way of specifying which to use a display?
-        }
-        return defaultIfNoValue;
+    public ValueMode getDefaultValueMode() {
+        return defaultIfNoValue.isNone() ? ValueMode.REQUIRED : ValueMode.OPTIONAL;
     }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/OptionValueMode.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/ValueMode.java
similarity index 96%
rename from src/main/java/net/marcellperger/mathexpr/cli/minicli/OptionValueMode.java
rename to src/main/java/net/marcellperger/mathexpr/cli/minicli/ValueMode.java
index a8a3f7e..c4f46c2 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/OptionValueMode.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/ValueMode.java
@@ -3,7 +3,7 @@
 /**
  * Controls if a value is required for an option
  */
-public enum OptionValueMode {
+public enum ValueMode {
     /**
      * Specifying a value is not allowed (e.g. {@code --foo} is allowed, {@code --foo=76} is not)
      */

From e1acca3d065db556efb5c7e9485417141fecdbf7 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sat, 15 Jun 2024 23:05:30 +0100
Subject: [PATCH 14/23] test: Start test

---
 .../mathexpr/cli/minicli/MiniCLITest.java     | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java

diff --git a/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java b/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
new file mode 100644
index 0000000..0d429d9
--- /dev/null
+++ b/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
@@ -0,0 +1,53 @@
+package net.marcellperger.mathexpr.cli.minicli;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MiniCLITest {
+    @Nested
+    class ParseArgsE2E_MathexprCLI {
+        @Test
+        void testMathexprCLI() {
+            MiniCLI cli = new MiniCLI();
+            CLIOption<String> rounding = cli.addStringOption("-R", "--round-sf").setDefault("12");
+            CLIOption<Boolean> interactive = cli.addBooleanOption("-i", "--interactive");
+            cli.setPositionalArgCount(0, 1);
+            cli.parseArgs(new String[]{});
+            assertEquals("12", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of(), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"1+1 * 2"});
+            assertEquals("12", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"-i", "1+1 * 2"});
+            assertEquals("12", rounding.getValue());
+            assertEquals(true, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"--interactive", "1+1 * 2"});
+            assertEquals("12", rounding.getValue());
+            assertEquals(true, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"-R", "6", "1+1 * 2"});
+            assertEquals("6", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"-R", "-9", "1+1 * 2"});
+            assertEquals("-9", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"--round-sf=99", "1+1 * 2"});
+            assertEquals("99", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            // TODO 2nd arg cannot be -8 here as it is interpreted as a flag so
+            //  need to support `-` or need to see if this doesn't match any option (nut then adding an option would be breaking)
+            assertThrows(CLIParseException.class, () -> cli.parseArgs(new String[]{"1+2", "*8"}));
+        }
+    }
+
+}
\ No newline at end of file

From 38dc05efaf482a18ab909029e89a68c23da2ff6b Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 16 Jun 2024 21:21:30 +0100
Subject: [PATCH 15/23] test: Add more tests

---
 .../mathexpr/cli/minicli/MiniCLITest.java     | 39 ++++++++++++++++++-
 1 file changed, 37 insertions(+), 2 deletions(-)

diff --git a/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java b/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
index 0d429d9..a0a6a64 100644
--- a/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
+++ b/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
@@ -2,6 +2,7 @@
 
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
 
 import java.util.List;
 
@@ -32,10 +33,34 @@ void testMathexprCLI() {
             assertEquals("12", rounding.getValue());
             assertEquals(true, interactive.getValue());
             assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"--interactive=false", "1+1 * 2"});
+            assertEquals("12", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"--interactive=true", "1+1 * 2"});
+            assertEquals("12", rounding.getValue());
+            assertEquals(true, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"-i=yes", "1+1 * 2"});
+            assertEquals("12", rounding.getValue());
+            assertEquals(true, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"-i=0", "1+1 * 2"});
+            assertEquals("12", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"-i", "0"});
+            assertEquals("12", rounding.getValue());
+            assertEquals(true, interactive.getValue());
+            assertEquals(List.of("0"), cli.getPositionalArgs());
             cli.parseArgs(new String[]{"-R", "6", "1+1 * 2"});
             assertEquals("6", rounding.getValue());
             assertEquals(false, interactive.getValue());
             assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{ "1+1 * 2", "-R", "6"});
+            assertEquals("6", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
             cli.parseArgs(new String[]{"-R", "-9", "1+1 * 2"});
             assertEquals("-9", rounding.getValue());
             assertEquals(false, interactive.getValue());
@@ -45,9 +70,19 @@ void testMathexprCLI() {
             assertEquals(false, interactive.getValue());
             assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
             // TODO 2nd arg cannot be -8 here as it is interpreted as a flag so
-            //  need to support `-` or need to see if this doesn't match any option (nut then adding an option would be breaking)
-            assertThrows(CLIParseException.class, () -> cli.parseArgs(new String[]{"1+2", "*8"}));
+            //  need to support `--` or need to see if this doesn't match any option
+            //  (but then adding an option would be a breaking change)
+            assertThrowsAndMsgContains(CLIParseException.class, "positional args",
+                () -> cli.parseArgs(new String[]{"1+2", "*8"}));
+            assertThrowsAndMsgContains(CLIParseException.class, "Bad boolean value",
+                () -> cli.parseArgs(new String[]{"--interactive=abc"}));
         }
     }
 
+    <T extends Throwable> void assertThrowsAndMsgContains(@SuppressWarnings("SameParameterValue") Class<T> cls,
+                                                          String containsMsg, Executable fn) {
+        T exc = assertThrows(cls, fn);
+        assertTrue(exc.getMessage().contains(containsMsg), () ->
+            "Expected error message ('%s') to contain %s".formatted(exc.getMessage(), containsMsg));
+    }
 }
\ No newline at end of file

From 5ac9424f2ddb384de9af98e4d3b3b58102cc2ff3 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Sun, 16 Jun 2024 22:01:43 +0100
Subject: [PATCH 16/23] refactor: Add detail to error messages

---
 .../mathexpr/cli/minicli/BooleanCLIOption.java    |  2 +-
 .../mathexpr/cli/minicli/CLIOption.java           | 15 +++++++++++----
 .../mathexpr/cli/minicli/ValueMode.java           |  6 +++---
 .../mathexpr/cli/minicli/MiniCLITest.java         |  6 ++++--
 4 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
index 662ee9e..d8bab6c 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
@@ -17,7 +17,7 @@ protected void _setValueFromString(@NotNull String s) {
         setValue(switch (s.strip().toLowerCase()) {
             case "0", "no", "false" -> false;
             case "1", "yes", "true" -> true;
-            case String s2 -> throw new CLIParseException("Bad boolean value '" + s2 + "'");
+            case String s2 -> throw fmtNewParseExcWithName("Bad boolean value '%s' for %%s".formatted(s2));
         });
     }
 
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
index 7e1e78c..d42e869 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
@@ -23,6 +23,13 @@ public CLIOption(Class<T> valueType, List<String> optionNames) {
         type = valueType;
     }
 
+    public String getDisplayName() {
+        return names.isEmpty() ? "<unnamed option>" : String.join("/", names.toArray(String[]::new));
+    }
+    public CLIParseException fmtNewParseExcWithName(@NotNull String fmt) {
+        return new CLIParseException(fmt.formatted(getDisplayName()));
+    }
+
     @Contract(" -> this")
     public CLIOption<T> setRequired() {
         defaultIfAbsent = Option.newNone();
@@ -64,7 +71,7 @@ public void begin() {
     }
     public void finish() {
         if (!hasValue)
-            setValue(defaultIfAbsent.expect(new CLIParseException("This argument is required")));  // TODO detail!
+            setValue(defaultIfAbsent.expect(fmtNewParseExcWithName("The %s option is required")));
     }
 
     public void setValue(T value_) {
@@ -81,15 +88,15 @@ public void setValueFromString(@Nullable String s) {
 
     public void setValueFromString_hasValue(@NotNull String s) {
         Objects.requireNonNull(s);
-        getValueMode().validateHasValue(true);
+        getValueMode().validateHasValue(this, true);
         _setValueFromString(s);
     }
     public void setValueFromNoValue() {
-        getValueMode().validateHasValue(false);
+        getValueMode().validateHasValue(this, false);
         setValue(_expectGetDefaultIfNoValue());
     }
     protected T _expectGetDefaultIfNoValue() {
-        return defaultIfNoValue.expect(new CLIParseException("This argument requires a value"));
+        return defaultIfNoValue.expect(fmtNewParseExcWithName("The %s option requires a value"));
     }
 
     public ValueMode getDefaultValueMode() {
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/ValueMode.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/ValueMode.java
index c4f46c2..d44fbf4 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/ValueMode.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/ValueMode.java
@@ -17,14 +17,14 @@ public enum ValueMode {
      */
     REQUIRED,
     ;
-    public void validateHasValue(boolean hasValue) {
+    public void validateHasValue(CLIOption<?> opt, boolean hasValue) {
         switch (this) {
             case NONE -> {
-                if(hasValue) throw new CLIParseException("Specifying a value for this option is not allowed");
+                if(hasValue) throw opt.fmtNewParseExcWithName("Specifying a value for the %s option is not allowed");
             }
             case OPTIONAL -> {}
             case REQUIRED -> {
-                if(!hasValue) throw new CLIParseException("This option requires a value to be passed");
+                if(!hasValue) throw opt.fmtNewParseExcWithName("The %s option requires a value");
             }
         }
     }
diff --git a/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java b/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
index a0a6a64..3bb160f 100644
--- a/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
+++ b/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
@@ -72,9 +72,11 @@ void testMathexprCLI() {
             // TODO 2nd arg cannot be -8 here as it is interpreted as a flag so
             //  need to support `--` or need to see if this doesn't match any option
             //  (but then adding an option would be a breaking change)
+            assertThrowsAndMsgContains(CLIParseException.class, "-R/--round-sf option requires a value",
+                () -> cli.parseArgs(new String[]{"1+1", "-R"}));
             assertThrowsAndMsgContains(CLIParseException.class, "positional args",
                 () -> cli.parseArgs(new String[]{"1+2", "*8"}));
-            assertThrowsAndMsgContains(CLIParseException.class, "Bad boolean value",
+            assertThrowsAndMsgContains(CLIParseException.class, "Bad boolean value 'abc' for -i/--interactive",
                 () -> cli.parseArgs(new String[]{"--interactive=abc"}));
         }
     }
@@ -83,6 +85,6 @@ <T extends Throwable> void assertThrowsAndMsgContains(@SuppressWarnings("SamePar
                                                           String containsMsg, Executable fn) {
         T exc = assertThrows(cls, fn);
         assertTrue(exc.getMessage().contains(containsMsg), () ->
-            "Expected error message ('%s') to contain %s".formatted(exc.getMessage(), containsMsg));
+            "Expected \"%s\" to contain \"%s\"".formatted(exc.getMessage(), containsMsg));
     }
 }
\ No newline at end of file

From 43603be06696c9454467176dd3911a1569c46011 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 20 Jun 2024 21:23:11 +0100
Subject: [PATCH 17/23] feat: Add support for `--` in CLI arguments

---
 .../mathexpr/cli/minicli/MiniCLI.java         | 12 ++++-
 .../mathexpr/cli/minicli/MiniCLITest.java     | 44 ++++++++++++++++---
 2 files changed, 47 insertions(+), 9 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index 48cc7f9..4f128bf 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -63,8 +63,6 @@ public void reset() {
         optionSet.forEach(CLIOption::reset);
     }
 
-    // TODO support `--`
-
     // TODO better positional arg handling (just dumping an array on the user is a bit meh)
     public List<String> getPositionalArgs() {
         return positionalArgs;
@@ -86,7 +84,9 @@ public MiniCLI parseArgs(List<String> args) {
         return out;
     }
     private class Parser {
+        // NOTE: Do not strip ANYTHING! - the shell does that for us and it also removes quotes
         @Nullable CLIOption<?> prev = null;
+        boolean finishedOptions = false;
         List<String> args;
 
         public Parser(List<String> args) {
@@ -105,6 +105,14 @@ public void pumpAllArgs() {
 
         // Make this public as it could be useful for making stream-ing type stuff
         public void pumpSingleArg(@NotNull String arg) {
+            if(finishedOptions) {  // No more options so *must* be positional
+                addPositionalArg(arg);
+                return;
+            }
+            if(arg.equals("--")) {
+                finishedOptions = true;
+                return;
+            }
             ArgType argT = ArgType.fromArg(arg);
             if(prev != null && prev.getValueMode() == ValueMode.REQUIRED) {
                 // We NEED a value so force it, even if it looks like a flag
diff --git a/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java b/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
index 3bb160f..d89a393 100644
--- a/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
+++ b/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
@@ -1,5 +1,6 @@
 package net.marcellperger.mathexpr.cli.minicli;
 
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.function.Executable;
@@ -11,12 +12,20 @@
 class MiniCLITest {
     @Nested
     class ParseArgsE2E_MathexprCLI {
+        MiniCLI cli;
+        CLIOption<String> rounding;
+        CLIOption<Boolean> interactive;
+
+        @BeforeEach
+        void setUp() {
+            cli = new MiniCLI();
+            rounding = cli.addStringOption("-R", "--round-sf").setDefault("12");
+            interactive = cli.addBooleanOption("-i", "--interactive");
+            cli.setPositionalArgCount(0, 1);
+        }
+
         @Test
         void testMathexprCLI() {
-            MiniCLI cli = new MiniCLI();
-            CLIOption<String> rounding = cli.addStringOption("-R", "--round-sf").setDefault("12");
-            CLIOption<Boolean> interactive = cli.addBooleanOption("-i", "--interactive");
-            cli.setPositionalArgCount(0, 1);
             cli.parseArgs(new String[]{});
             assertEquals("12", rounding.getValue());
             assertEquals(false, interactive.getValue());
@@ -69,15 +78,36 @@ void testMathexprCLI() {
             assertEquals("99", rounding.getValue());
             assertEquals(false, interactive.getValue());
             assertEquals(List.of("1+1 * 2"), cli.getPositionalArgs());
-            // TODO 2nd arg cannot be -8 here as it is interpreted as a flag so
-            //  need to support `--` or need to see if this doesn't match any option
-            //  (but then adding an option would be a breaking change)
+
             assertThrowsAndMsgContains(CLIParseException.class, "-R/--round-sf option requires a value",
                 () -> cli.parseArgs(new String[]{"1+1", "-R"}));
             assertThrowsAndMsgContains(CLIParseException.class, "positional args",
                 () -> cli.parseArgs(new String[]{"1+2", "*8"}));
             assertThrowsAndMsgContains(CLIParseException.class, "Bad boolean value 'abc' for -i/--interactive",
                 () -> cli.parseArgs(new String[]{"--interactive=abc"}));
+
+        }
+
+        @Test
+        void doubleDashHandling() {
+            cli.parseArgs(new String[]{"--", "-1+1 * 2"});
+            assertEquals("12", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("-1+1 * 2"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"--", "-i"});
+            assertEquals("12", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("-i"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"--round-sf=3", "--", "--"});
+            assertEquals("3", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("--"), cli.getPositionalArgs());
+            cli.parseArgs(new String[]{"--round-sf=3", "--", "--"});
+            assertEquals("3", rounding.getValue());
+            assertEquals(false, interactive.getValue());
+            assertEquals(List.of("--"), cli.getPositionalArgs());
+            assertThrowsAndMsgContains(CLIParseException.class, "positional args",
+                () -> cli.parseArgs(new String[]{"--", "--interactive", "6+2"}));
         }
     }
 

From 0272fa05cd7c605d04782dbe26f678da70890779 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 20 Jun 2024 21:31:26 +0100
Subject: [PATCH 18/23] refactor: Ensure that setting defaultIfNoValue also
 sets the valueMode (unless specified otherwise)

---
 .../marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java | 1 -
 .../net/marcellperger/mathexpr/cli/minicli/CLIOption.java    | 2 +-
 .../marcellperger/mathexpr/cli/minicli/StringCLIOption.java  | 5 -----
 3 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
index d8bab6c..bdafcee 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/BooleanCLIOption.java
@@ -9,7 +9,6 @@ public BooleanCLIOption(List<String> optionNames) {
         super(Boolean.class, optionNames);
         setDefault(false);
         setDefaultIfNoValue(true);
-        setValueMode(ValueMode.OPTIONAL);
     }
 
     @Override
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
index d42e869..e886eeb 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
@@ -100,7 +100,7 @@ protected T _expectGetDefaultIfNoValue() {
     }
 
     public ValueMode getDefaultValueMode() {
-        return ValueMode.REQUIRED;
+        return defaultIfNoValue.isSome() ? ValueMode.OPTIONAL : ValueMode.REQUIRED;
     }
     public ValueMode getValueMode() {
         return valueMode.unwrapOr(getDefaultValueMode());
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
index 04d4d01..5bbeba2 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/StringCLIOption.java
@@ -13,9 +13,4 @@ public StringCLIOption(List<String> keys) {
     protected void _setValueFromString(@NotNull String s) {
         setValue(s);
     }
-
-    @Override
-    public ValueMode getDefaultValueMode() {
-        return defaultIfNoValue.isNone() ? ValueMode.REQUIRED : ValueMode.OPTIONAL;
-    }
 }

From 2f78522d916871c496a067e3a90813cd64a193d0 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 20 Jun 2024 21:56:31 +0100
Subject: [PATCH 19/23] refactor: .validate method, more tests

---
 .../mathexpr/cli/minicli/CLIOption.java       |  6 +++++-
 .../mathexpr/cli/minicli/MiniCLI.java         |  5 +++++
 .../mathexpr/cli/minicli/MiniCLITest.java     | 19 +++++++++++++++++++
 3 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
index e886eeb..c63c1d7 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/CLIOption.java
@@ -58,7 +58,7 @@ public T getValue() {
         return value;
     }
 
-    public void begin() {
+    public void validate() {
         switch (getValueMode()) {
             case OPTIONAL, NONE -> defaultIfNoValue.expect(
                 new IllegalStateException("defaultIfNoValue must be provided for OPTIONAL/NONE valueModes"));
@@ -69,6 +69,10 @@ public void begin() {
             }
         }
     }
+
+    public void begin() {
+        validate();
+    }
     public void finish() {
         if (!hasValue)
             setValue(defaultIfAbsent.expect(fmtNewParseExcWithName("The %s option is required")));
diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index 4f128bf..a836e72 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -63,6 +63,10 @@ public void reset() {
         optionSet.forEach(CLIOption::reset);
     }
 
+    public void validate() {
+        optionSet.forEach(CLIOption::validate);
+    }
+
     // TODO better positional arg handling (just dumping an array on the user is a bit meh)
     public List<String> getPositionalArgs() {
         return positionalArgs;
@@ -94,6 +98,7 @@ public Parser(List<String> args) {
         }
 
         public void parse() {
+            validate();
             begin();
             pumpAllArgs();
             finish();
diff --git a/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java b/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
index d89a393..83e486e 100644
--- a/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
+++ b/src/test/java/net/marcellperger/mathexpr/cli/minicli/MiniCLITest.java
@@ -111,6 +111,25 @@ void doubleDashHandling() {
         }
     }
 
+    @Test
+    void test_miniCli_options_notParsing() {
+        {
+            MiniCLI cli = new MiniCLI();
+            cli.addStringOption("--abc", "-a", "-b");
+            assertThrowsAndMsgContains(IllegalStateException.class, "already been registered",
+                () -> cli.addBooleanOption("--qwerty", "-a"));
+        }
+        {
+            MiniCLI cli = new MiniCLI();
+            assertThrowsAndMsgContains(IllegalStateException.class,
+                "defaultIfNoValue should not be specified with a REQUIRED valueMode",
+                () -> {
+                    cli.addStringOption("-a").setValueMode(ValueMode.REQUIRED).setDefaultIfNoValue("v");
+                    cli.validate();
+                });
+        }
+    }
+
     <T extends Throwable> void assertThrowsAndMsgContains(@SuppressWarnings("SameParameterValue") Class<T> cls,
                                                           String containsMsg, Executable fn) {
         T exc = assertThrows(cls, fn);

From 95201e2829e7dc14226901b7fb17b0898c05ff63 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 20 Jun 2024 22:00:05 +0100
Subject: [PATCH 20/23] style: Prefer separate imports in non-test code

---
 .../net/marcellperger/mathexpr/cli/minicli/MiniCLI.java   | 7 ++++++-
 src/main/java/net/marcellperger/mathexpr/util/Util.java   | 8 +++++++-
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
index a836e72..d678686 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/minicli/MiniCLI.java
@@ -7,7 +7,12 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.function.Function;
 
 public class MiniCLI {
diff --git a/src/main/java/net/marcellperger/mathexpr/util/Util.java b/src/main/java/net/marcellperger/mathexpr/util/Util.java
index 23fa619..9cf2250 100644
--- a/src/main/java/net/marcellperger/mathexpr/util/Util.java
+++ b/src/main/java/net/marcellperger/mathexpr/util/Util.java
@@ -6,7 +6,13 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.*;
+import java.util.AbstractMap;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.SequencedCollection;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;

From e978ee9c9d1d842fea824a8e25db13e80b0f1ae1 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 20 Jun 2024 22:26:04 +0100
Subject: [PATCH 21/23] feat: Finish CLI

---
 .../net/marcellperger/mathexpr/cli/CLI.java   | 65 ++++++++++++++++---
 .../interactive/MathCommandHandler.java       |  2 +-
 .../mathexpr/interactive/Shell.java           |  9 +++
 3 files changed, 67 insertions(+), 9 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/CLI.java b/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
index 3e64a9e..b1f8ef2 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
@@ -1,19 +1,68 @@
 package net.marcellperger.mathexpr.cli;
 
+import net.marcellperger.mathexpr.MathSymbol;
 import net.marcellperger.mathexpr.cli.minicli.CLIOption;
+import net.marcellperger.mathexpr.cli.minicli.CLIParseException;
 import net.marcellperger.mathexpr.cli.minicli.MiniCLI;
+import net.marcellperger.mathexpr.interactive.Shell;
+import net.marcellperger.mathexpr.parser.ExprParseException;
+import net.marcellperger.mathexpr.parser.Parser;
+import net.marcellperger.mathexpr.util.MathUtil;
+import net.marcellperger.mathexpr.util.Util;
 
-import java.util.Arrays;
 
 public class CLI {
-    public static void main(String[] args) {
-        MiniCLI cli = new MiniCLI();
-        CLIOption<Boolean> interactive = cli.addBooleanOption("-i", "--interactive");
-        CLIOption<String> rounding = cli.addStringOption("-R", "--round-sf").setDefault("12");
+    MiniCLI cli;
+    CLIOption<Boolean> interactive;
+    CLIOption<String> rounding;
+
+    public CLI() {
+        cli = new MiniCLI();
+        interactive = cli.addBooleanOption("-i", "--interactive");
+        rounding = cli.addStringOption("-R", "--round-sf").setDefault("12");
         cli.setPositionalArgCount(0, 1);
+    }
+
+    public void run(String[] args) {
+        try {
+            _run(args);
+        } catch (CLIParseException exc) {
+            System.err.println("Invalid CLI arguments: " + exc);
+        }
+    }
+    public void _run(String[] args) {
         cli.parseArgs(args);
-        System.out.println("interactive = " + interactive.getValue());
-        System.out.println("rounding = " + rounding.getValue());
-        System.out.println("args = " + Arrays.stream(args).map(s -> "`" + s + "`").toList());
+        int roundSf;
+        try {
+            roundSf = Integer.parseInt(rounding.getValue());
+        } catch (NumberFormatException e) {
+            throw new CLIParseException(e);
+        }
+        if(interactive.getValue()) runInteractive(roundSf);
+        else runEvaluateExpr(roundSf);
+    }
+
+    private void runEvaluateExpr(int roundSf) {
+        if(cli.getPositionalArgs().isEmpty())
+            throw new CLIParseException("1 argument expected without -i/--interactive");
+        MathSymbol sym;
+        try {
+            sym = new Parser(cli.getPositionalArgs().getFirst()).parse();
+        } catch (ExprParseException exc) {
+            // TODO this is a bit meh solution here
+            Util.throwAsUnchecked(exc);  // Trick Java but I want call-site checked exceptions
+            return;
+        }
+        System.out.println(MathUtil.roundToSigFigs(sym.calculateValue(), roundSf));
+    }
+
+    private void runInteractive(int roundSf) {
+        if(!cli.getPositionalArgs().isEmpty())
+            throw new CLIParseException("No argument expected with -i/--interactive");
+        new Shell(roundSf).run();
+    }
+
+    public static void main(String[] args) {
+        new CLI().run(args);
     }
 }
diff --git a/src/main/java/net/marcellperger/mathexpr/interactive/MathCommandHandler.java b/src/main/java/net/marcellperger/mathexpr/interactive/MathCommandHandler.java
index 83bda28..91c7f26 100644
--- a/src/main/java/net/marcellperger/mathexpr/interactive/MathCommandHandler.java
+++ b/src/main/java/net/marcellperger/mathexpr/interactive/MathCommandHandler.java
@@ -12,7 +12,7 @@ public class MathCommandHandler implements ShellCommandHandler {
     public boolean run(String cmd, Shell sh) {
         try {
             MathSymbol sym = parseOrPrintError(cmd, sh);
-            sh.out.println(MathUtil.roundToSigFigs(sym.calculateValue(), 12));
+            sh.out.println(MathUtil.roundToSigFigs(sym.calculateValue(), sh.roundToSf));
         } catch (ControlFlowBreak _parseErrorAlreadyPrinted) {}
         return true;  // Always continue
     }
diff --git a/src/main/java/net/marcellperger/mathexpr/interactive/Shell.java b/src/main/java/net/marcellperger/mathexpr/interactive/Shell.java
index 4f8621b..cb00650 100644
--- a/src/main/java/net/marcellperger/mathexpr/interactive/Shell.java
+++ b/src/main/java/net/marcellperger/mathexpr/interactive/Shell.java
@@ -9,14 +9,23 @@ public class Shell {
     public Input in;
     public PrintStream out;
     ShellCommandParser commandParser;
+    int roundToSf;
 
     public Shell() {
+        this(12);
+    }
+    public Shell(int roundToSf) {
         in = new Input();
         out = System.out;
         commandParser = new ShellCommandParser(this);
+        this.roundToSf = roundToSf;
     }
 
     public static void main(String[] args) {
+        main();
+    }
+    @SuppressWarnings("ConfusingMainMethod")
+    public static void main() {
         new Shell().run();
     }
 

From ae69ddf4d1935188b8345f42076fe9fb31403840 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 20 Jun 2024 22:32:28 +0100
Subject: [PATCH 22/23] fix: Make no positional args default to interactive

---
 .../java/net/marcellperger/mathexpr/cli/CLI.java     | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/main/java/net/marcellperger/mathexpr/cli/CLI.java b/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
index b1f8ef2..bfc91a6 100644
--- a/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
+++ b/src/main/java/net/marcellperger/mathexpr/cli/CLI.java
@@ -15,6 +15,7 @@ public class CLI {
     MiniCLI cli;
     CLIOption<Boolean> interactive;
     CLIOption<String> rounding;
+    Integer roundSf;
 
     public CLI() {
         cli = new MiniCLI();
@@ -30,16 +31,19 @@ public void run(String[] args) {
             System.err.println("Invalid CLI arguments: " + exc);
         }
     }
-    public void _run(String[] args) {
+    protected void _run(String[] args) {
+        parseArgs(args);
+        if(interactive.getValue() || cli.getPositionalArgs().isEmpty()) runInteractive(roundSf);
+        else runEvaluateExpr(roundSf);
+    }
+
+    private void parseArgs(String[] args) {
         cli.parseArgs(args);
-        int roundSf;
         try {
             roundSf = Integer.parseInt(rounding.getValue());
         } catch (NumberFormatException e) {
             throw new CLIParseException(e);
         }
-        if(interactive.getValue()) runInteractive(roundSf);
-        else runEvaluateExpr(roundSf);
     }
 
     private void runEvaluateExpr(int roundSf) {

From 1bc9308a3448b2e122127c462dc1569b97b2b2a3 Mon Sep 17 00:00:00 2001
From: Marcell Perger <marcell.perger.1@gmail.com>
Date: Thu, 20 Jun 2024 22:33:16 +0100
Subject: [PATCH 23/23] feat: Add `runcli.sh`

---
 runcli.sh | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 runcli.sh

diff --git a/runcli.sh b/runcli.sh
new file mode 100644
index 0000000..c3588b2
--- /dev/null
+++ b/runcli.sh
@@ -0,0 +1 @@
+java -classpath ./target/classes/ net.marcellperger.mathexpr.cli.CLI "$@"