Common: offer suggested on correct spelling

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

Author: f3sch

Common/Utils/include/CommonUtils/ConfigurableParamHelper.h

@@ -16,18 +16,56 @@
 
 #include "CommonUtils/ConfigurableParam.h"
 
+#include <algorithm>
 #include <memory>
+#include <numeric>
+#include <string_view>
 #include <TClass.h>
 #include <TFile.h>
 #include <TDataMember.h>
 #include <type_traits>
 #include <typeinfo>
+#include <utility>
 
 namespace o2::conf
 {
 
 // ----------------------------------------------------------------
 
+inline std::size_t damerauLevenshteinDistance(std::string_view a, std::string_view b)
+{
+  const std::size_t n = a.size();
+  const std::size_t m = b.size();
+  if (n == 0) {
+    return m;
+  }
+  if (m == 0) {
+    return n;
+  }
+  std::vector<std::size_t> prev(m + 1), curr(m + 1), prev2(m + 1);
+  std::iota(prev.begin(), prev.end(), 0);
+  for (std::size_t i = 1; i <= n; ++i) {
+    curr[0] = i;
+    for (std::size_t j = 1; j <= m; ++j) {
+      std::size_t cost = (a[i - 1] == b[j - 1]) ? 0 : 1;
+      curr[j] = std::min({
+        prev[j] + 1,
+        curr[j - 1] + 1,
+        prev[j - 1] + cost});
+      if (i > 1 && j > 1 && a[i - 1] == b[j - 2] &&
+          a[i - 2] == b[j - 1]) {
+        curr[j] = std::min(curr[j], prev2[j - 2] + 1);
+      }
+    }
+    prev2 = std::move(prev);
+    prev = std::move(curr);
+    curr.assign(m + 1, 0);
+  }
+  return prev[m];
+}
+
+// ----------------------------------------------------------------
+
 // Utility structure for passing around ConfigurableParam data member info
 // (where value is the string representation)
 struct ParamDataMember {

Common/Utils/src/ConfigurableParam.cxx

@@ -13,6 +13,7 @@
 
 #include "CommonUtils/ConfigurableParam.h"
 #include <cstddef>
+#include "CommonUtils/ConfigurableParamHelper.h"
 #include "CommonUtils/StringUtils.h"
 #include "CommonUtils/KeyValParam.h"
 #include "CommonUtils/ConfigurableParamReaders.h"
@@ -433,6 +434,60 @@ const ContainerHandler* getContainerHandler(const std::type_info& type)
   return iter == handlers.end() ? nullptr : &iter->second;
 }
 
+std::pair<std::string_view, std::string_view> splitConfigurableParamKey(std::string_view key)
+{
+  const auto separator = key.find('.');
+  if (separator == std::string_view::npos) {
+    return {key, {}};
+  }
+  return {key.substr(0, separator), key.substr(separator + 1)};
+}
+
+std::string findClosestConfigurableParamKey(const std::string& requestedKey,
+                                            const std::map<std::string, std::pair<std::type_info const&, void*>>& storageMap)
+{
+  if (storageMap.empty()) {
+    return {};
+  }
+
+  const auto [requestedMainKey, requestedSubKey] = splitConfigurableParamKey(requestedKey);
+  bool mainKeyExists = false;
+  for (const auto& entry : storageMap) {
+    const auto mainKey = splitConfigurableParamKey(entry.first).first;
+    if (mainKey == requestedMainKey) {
+      mainKeyExists = true;
+      break;
+    }
+  }
+
+  std::string closest;
+  std::size_t closestDistance = std::numeric_limits<std::size_t>::max();
+  for (const auto& entry : storageMap) {
+    const auto& key = entry.first;
+    const auto [mainKey, subKey] = splitConfigurableParamKey(key);
+    if (mainKeyExists && mainKey != requestedMainKey) {
+      continue;
+    }
+    const auto distance = mainKeyExists ? damerauLevenshteinDistance(requestedSubKey, subKey) : damerauLevenshteinDistance(requestedKey, key);
+    if (distance < closestDistance || (distance == closestDistance && (closest.empty() || key < closest))) {
+      closest = key;
+      closestDistance = distance;
+    }
+  }
+  return closest;
+}
+
+std::string formatUnknownConfigurableParamKeyMessage(const std::string& prefix, const std::string& key,
+                                                     const std::map<std::string, std::pair<std::type_info const&, void*>>& storageMap)
+{
+  std::string message = prefix + key;
+  auto closest = findClosestConfigurableParamKey(key, storageMap);
+  if (!closest.empty()) {
+    message += ". Did you mean '" + closest + "'?";
+  }
+  return message;
+}
+
 } // namespace
 
 // ------------------------------------------------------------------
@@ -978,10 +1033,10 @@ void ConfigurableParam::setValues(std::vector<std::pair<std::string, std::string
 
     if (!keyInTree(sPtree, key)) {
       if (nonFatal) {
-        LOG(warn) << "Ignoring non-existent ConfigurableParam key: " << key;
+        LOG(warn) << formatUnknownConfigurableParamKeyMessage("Ignoring non-existent ConfigurableParam key: ", key, *sKeyToStorageMap);
         continue;
       }
-      LOG(fatal) << "Inexistent ConfigurableParam key: " << key;
+      LOG(fatal) << formatUnknownConfigurableParamKeyMessage("Inexistent ConfigurableParam key: ", key, *sKeyToStorageMap);
     }
 
     auto iter = sKeyToStorageMap->find(key);

Common/Utils/test/testConfigurableParam.cxx

@@ -17,6 +17,7 @@
 
 #include <boost/test/unit_test.hpp>
 #include <boost/property_tree/ptree.hpp>
+#include <cstdlib>
 #include <filesystem>
 
 #include "CommonUtils/ConfigurableParamTest.h"
@@ -199,6 +200,27 @@ BOOST_AUTO_TEST_CASE(ConfigurableParam_ContainerParserMap)
   BOOST_CHECK_EQUAL(m["beta"], 0.3);
 }
 
+BOOST_AUTO_TEST_CASE(ConfigurableParam_DamerauLevenshteinDistance)
+{
+  BOOST_CHECK_EQUAL(damerauLevenshteinDistance("TestParam.iValue", "TestParam.iValue"), 0);
+  BOOST_CHECK_EQUAL(damerauLevenshteinDistance("TestParam.iValu", "TestParam.iValue"), 1);
+  BOOST_CHECK_EQUAL(damerauLevenshteinDistance("TestParam.jValue", "TestParam.iValue"), 1);
+  BOOST_CHECK_EQUAL(damerauLevenshteinDistance("TestParam.iVaule", "TestParam.iValue"), 1);
+}
+
+BOOST_AUTO_TEST_CASE(ConfigurableParam_UnknownKeySuggestionsNonFatal)
+{
+  setenv("ALICEO2_CONFIGURABLEPARAM_WRONGKEYISNONFATAL", "1", 1);
+  ConfigurableParam::setValue("TestParam.iValue", "222");
+  ConfigurableParam::setValue("TestParam.caValue[1]", "33");
+  ConfigurableParam::setValues({{"TestParam.iValu", "777"},
+                                {"TstParam.iValue", "888"},
+                                {"TestParam.caValue[", "999"}});
+  BOOST_CHECK_EQUAL(TestParam::Instance().iValue, 222);
+  BOOST_CHECK_EQUAL(TestParam::Instance().caValue[1], 33);
+  unsetenv("ALICEO2_CONFIGURABLEPARAM_WRONGKEYISNONFATAL");
+}
+
 BOOST_AUTO_TEST_CASE(ConfigurableParam_Container_FileIO_ROOT)
 {
   // test for root file serialization