better Args handling of individual char switches

flipcoder · flipcoder · commit d98aaf087ae6 · 2020-11-11T17:36:35.000-08:00
diff --git a/kit/args/args.cpp b/kit/args/args.cpp
@@ -18,7 +18,7 @@ void Args :: analyze()
         if(boost::starts_with(arg, "--"))
         {
             if(arg.length()==2)
-                after_sep = true;
+                after_sep = true; // empty -- is a separator
             
             if(!after_sep)
             {
@@ -34,14 +34,74 @@ void Args :: analyze()
                     if(!value.empty())
                         if(!m_Values.insert({key,value}).second)
                             throw exception(); // failed to insert
+                    
+                    m_Switches.insert(remove_dashes(key)); // insert key as switch
+                }
+                else
+                {
+                    m_Switches.insert(remove_dashes(arg)); // just a switch, --test is test
                 }
             }
         }
-        else if(not boost::starts_with(arg, "-"))
+        else if(boost::starts_with(arg, "-")) // only one dash? (above check is two)
+        {
+            string flags = arg.substr(1); // remove one dash
+            for(auto&& ch: flags)
+                m_Switches.insert(string()+ch); // add chars separately
+        }
+        else
+        {
+            // no - or --, assume its a filename
             m_Filenames.push_back(arg);
+        }
     }
 }
 
+string Args :: remove_dashes(string s, bool* success) // static
+{
+    if(success)
+        *success = false;
+    
+    if(boost::starts_with(s,"--"))
+    {
+        s = s.substr(2);
+        if(success)
+            *success = true;
+    }
+    else if(boost::starts_with(s,"-"))
+    {
+        s = s.substr(1);
+        if(success)
+            *success = true;
+    }
+    return s;
+}
+
+bool Args :: has(std::string op) const
+{
+    bool removed;
+    string flag = remove_dashes(op, &removed);
+    if(not removed)
+        return kit::has(m_Args, op);
+    
+    if(not flag.empty())
+        return kit::has(m_Switches, flag);
+    
+    assert(false);
+}
+
+bool Args :: has(char ch, std::string op) const
+{
+    if(boost::starts_with(op, "--"))
+        op = op.substr(2); // remove --
+    else if(boost::starts_with(op, "-"))
+        op = op.substr(1);
+    auto flag = string()+ch;
+    return (kit::has(m_Switches, flag) ||
+       (not op.empty() && kit::has(m_Switches, op))
+    );
+}
+
 void Args :: schema(std::string docstring)
 {
     if(docstring.empty())
diff --git a/kit/args/args.h b/kit/args/args.h
@@ -4,6 +4,7 @@
 #include <vector>
 #include <map>
 #include <string>
+#include <set>
 #include "../kit.h"
 #include <boost/algorithm/string.hpp>
 #include <boost/format.hpp>
@@ -66,9 +67,12 @@ class Args
                     return true;
             return false;
         }
-        bool has(const std::string& s) const {
-            return kit::has(m_Args, s);
-        }
+        
+        // [OLD]
+        //bool has(const std::string& s) const {
+        //    return kit::has(m_Args, s);
+        //}
+        
         bool has_before(
             const std::string& match, const std::string& sep
         ) const {
@@ -227,16 +231,26 @@ class Args
             }
         }
 
-        // tests for a switch and its associated char
-        bool has(char c, std::string s) const {
-            assert(not boost::starts_with(s, "--"));
-            return has(c) || has(std::string("--")+s);
-        }
-        bool has(char c) const {
-            std::string chs = chars();
-            return chs.find(c) != std::string::npos;
-        }
-        // returns string containing all provided char switches
+        // [OLD] tests for a switch and its associated char
+        //bool has(char c, std::string s) const {
+        //    if(boost::starts_with(s, "--"))
+        //        s = s.substr(2); // remove --
+        //    else if(boost::starts_with(s, "-"))
+        //        s = s.substr(1);
+        //    if(has(c) || has(std::string("--")+s)
+        //        return true;
+        //    if(option(c,s))
+        //        return true;
+        //    return false;
+        //}
+        
+        // [DEPRECATED]
+        //bool has(char c) const {
+        //    std::string chs = chars();
+        //    return chs.find(c) != std::string::npos;
+        //}
+                
+        // [DEPRECATED] returns string containing all provided char switches
         std::string chars() const {
             std::string r;
             for(auto&& a: m_Args)
@@ -288,8 +302,13 @@ class Args
             m_Filename = fn;
         }
 
+        bool has(std::string op) const;
+        bool has(char ch, std::string full = std::string()) const;
+
     private:
 
+        static std::string remove_dashes(std::string s, bool* success = nullptr);
+
         struct Schema
         {
             std::vector<std::string> allowed;
@@ -305,6 +324,12 @@ class Args
         std::map<std::string, std::string> m_Values;
         std::string m_Filename;
         boost::optional<Schema> m_Schema;
+
+        // all options broken down separately
+        //   ./program -abc --test
+        // will contain -a, -b, -c, and --test
+        // use has() to check this
+        std::set<std::string> m_Switches;
 };
 
 #endif
diff --git a/tests/args.test.cpp b/tests/args.test.cpp
@@ -29,18 +29,20 @@ TEST_CASE("Args","[args]") {
     SECTION("has") {
         // empty
         Args args;
-        REQUIRE(not args.has("foobar"));
+        REQUIRE(not args.has("foo"));
+        REQUIRE(not args.has("-f"));
+        REQUIRE(not args.has("--foobar"));
         
         // single arg
-        args = Args(vector<string>{"foobar"});
-        REQUIRE(args.has("foobar"));
-        REQUIRE(not args.has("foo"));
+        args = Args(vector<string>{"--foobar"});
+        REQUIRE(args.has("--foobar"));
+        REQUIRE(not args.has("--foo"));
         
         // multiple args
-        args = Args(vector<string>{"foo", "bar"});
-        REQUIRE(args.has("foo"));
-        REQUIRE(args.has("bar"));
-        REQUIRE(not args.has("baz"));
+        args = Args(vector<string>{"--foo", "--bar"});
+        REQUIRE(args.has("--foo"));
+        REQUIRE(args.has("--bar"));
+        REQUIRE(not args.has("--baz"));
 
         // switches
         args = Args();
@@ -52,25 +54,38 @@ TEST_CASE("Args","[args]") {
         REQUIRE(args.has('v', "verbose")); // single char
         REQUIRE(not args.has('n', "nope"));
 
-        // multiple char switches
-        args = Args(vector<string>{"-abc"}, "-a -b -c");
-        REQUIRE(args.has('a', "achar"));
-        REQUIRE(args.has('b', "bchar"));
-        REQUIRE(args.has('c', "cchar"));
-        args = Args(vector<string>{"-ac"}, "-a -b -c");
-        REQUIRE(args.has('a', "achar"));
-        REQUIRE(not args.has('b', "bchar"));
-        REQUIRE(args.has('c', "cchar"));
+        // multiple char switches (not combined)
+        //args = Args(vector<string>{"-abc"}, "-a -b -c");
+        //REQUIRE(args.has('a', "achar"));
+        //REQUIRE(args.has('b', "bchar"));
+        //REQUIRE(args.has('c', "cchar"));
+        //args = Args(vector<string>{"-ac"}, "-a -b -c");
+        //REQUIRE(args.has('a', "achar"));
+        //REQUIRE(not args.has('b', "bchar"));
+        //REQUIRE(args.has('c', "cchar"));
     }
 
+    SECTION("option") {
+        Args args;
+        args = Args(vector<string>{"-abc", "-d", "--go"});
+        REQUIRE(args.has('a'));
+        REQUIRE(args.has("-a"));
+        REQUIRE(args.has('b', "berry"));
+        REQUIRE(args.has('c'));
+        REQUIRE(args.has('d', "door"));
+        REQUIRE(not args.has('e'));
+        REQUIRE(not args.has('f', "foo"));
+        REQUIRE(args.has('g', "go"));
+    }
+    
     SECTION("any") {
         Args args;
-        args = Args(vector<string>{"foo", "bar"});
-        REQUIRE(not args.any({"bin"}));
-        REQUIRE(not args.any({"bin","baz"}));
-        REQUIRE(args.any({"bar","bin"}));
-        REQUIRE(args.any({"bin","bar"}));
-        REQUIRE(args.any({"foo","bar"}));
+        args = Args(vector<string>{"--foo", "--bar"});
+        REQUIRE(not args.any({"--bin"}));
+        REQUIRE(not args.any({"--bin","--baz"}));
+        REQUIRE(args.any({"--bar","--bin"}));
+        REQUIRE(args.any({"--bin","--bar"}));
+        REQUIRE(args.any({"--foo","--bar"}));
     }
 
     SECTION("key-value") {
