Issue 47

src/CMakeLists.txt

@@ -20,6 +20,7 @@ add_subdirectory(gwhisper)
 add_subdirectory(version)
 add_subdirectory(utils)
 add_subdirectory(libLocalDescriptorCache)
+add_subdirectory(gWhisperSetting)
 
 get_filename_component(BIN_DIR_ABS ${CMAKE_BINARY_DIR}/. DIRECTORY)
 get_filename_component(SRC_DIR_ABS ${CMAKE_SOURCE_DIR}/. DIRECTORY)

src/gWhisperSetting/CMakeLists.txt

@@ -0,0 +1,37 @@
+# Copyright 2022 IBM Corporation
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+include(FetchContent)
+FetchContent_Declare(json URL https://github.com/nlohmann/json/releases/download/v3.10.5/json.tar.xz)
+FetchContent_MakeAvailable(json)
+
+set(TARGET_NAME "gWhisperSetting")
+set(TARGET_SRC
+    GWhisperSetting.cpp
+    )
+add_library(${TARGET_NAME} ${TARGET_SRC})
+
+target_link_libraries ( ${TARGET_NAME}
+    PRIVATE
+    reflection
+    protoDoc
+    )
+target_link_libraries ( ${TARGET_NAME}
+    PUBLIC
+    gwhisperUtils
+    DescDbProxy
+    ArgParse
+    nlohmann_json::nlohmann_json
+)
+target_include_directories(${TARGET_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

src/gWhisperSetting/GWhisperSetting.cpp

@@ -0,0 +1,146 @@
+// Copyright 2022 IBM Corporation
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fstream>
+#include <iostream>
+#include <nlohmann/json.hpp>
+
+#include "GWhisperSetting.hpp"
+#include "libArgParse/ArgParse.hpp"
+
+using json = nlohmann::json;
+
+void gWhisperSetting::parseConfigFile(const std::string &f_inputFile){
+    // Parse JSON File into member SON object
+    std::ifstream ifs(f_inputFile.c_str());
+
+    if (!ifs.is_open())
+    {
+        std::cout << "Error while opening config file at: " << f_inputFile << std::endl;
+        exit(EXIT_FAILURE);
+    }
+    // TODO: check for empty value with  nlohmann::isempty()
+    ifs >> m_config;
+    ifs.close();
+
+}
+
+void gWhisperSetting::retrieveConfigParameters(json &f_startElement){
+    //recursively go over config file and retrieve all parameter keys
+    if(f_startElement.is_structured())
+    {
+         for (const auto &item : f_startElement.items())
+        {
+            m_configParameters.push_back(item.key());
+
+            if (item.value().is_object())
+            {
+                retrieveConfigParameters(item.value());
+            }
+        }
+    }
+}
+
+json gWhisperSetting::findParameterSettingInConfig(const std::string &f_parameter,const  json &f_startElement)
+{
+    // TODO: If enough time, optimmize for
+    bool containsParameter = false;
+    json setting;
+
+    for (const auto& item : f_startElement.items())
+    {
+        if (item.value().contains(f_parameter))
+        {
+            //Abbruchkrit
+
+            setting[f_parameter] = item.value().at(f_parameter);
+            break;
+        }
+
+        for(auto &innerElement : item.value().items())
+        {   
+            if (innerElement.key() == "")
+            {
+                break; 
+            }
+
+            // Only Call recursion, if current element contains further elements
+            if(innerElement.value().is_structured())
+            {
+                json tempElement;
+                tempElement[innerElement.key()] = innerElement.value();
+                return findParameterSettingInConfig(f_parameter, tempElement);
+            }
+            else
+            {
+                continue;
+            }
+        }
+    }
+    return setting;
+}
+
+// f_paramaetr entrpricht label des Grammatik Elements in ParseTree
+std::string gWhisperSetting::lookUpSetting(const std::string &f_parameter, ArgParse::ParsedElement &f_parseTree)
+{
+    bool containsParameter;
+    std::string setting;
+    json someJson;
+
+    if (f_parseTree.findFirstChild(f_parameter) != "")
+    {
+        setting = f_parseTree.findFirstChild(f_parameter);
+    }
+    else
+    {
+        someJson = findParameterSettingInConfig(f_parameter, m_config); //copy
+        if (!someJson.is_null())
+        {    
+            if (!someJson.at(f_parameter).is_null())
+            {
+                containsParameter = true;
+                setting = someJson.at(f_parameter);
+            }
+
+            if(someJson.at(f_parameter).is_null())
+            {
+                setting = ""; // TODO: Is this the right semantic for Timeout?
+            }
+        }
+    }
+    //std::cout << "Found setting for " << f_parameter << " : " << setting << std::endl;
+    return setting;
+}
+
+// Ersetze ParseTree beim Suchen -> f_parseTree.findFirstChild
+// Für Parameter, die nicht im config file stehen / keine optionen sind z.B. services
+gWhisperSetting::gWhisperSetting(ArgParse::ParsedElement &f_parseTree){ //ParameterKey
+    if(m_config.is_null())
+    {
+        bool useCustomPath = f_parseTree.findFirstChild("ConfigFile")!= "";
+        const char* home = std::getenv("HOME");
+        std::string defaultPath = "/.config/gWhisperConfig.json";
+        std::string inputFile = home + defaultPath;
+
+        if(useCustomPath)
+        {
+            inputFile = f_parseTree.findFirstChild("ConfigFilePath");
+        }
+
+        parseConfigFile(inputFile);
+    }
+    retrieveConfigParameters(m_config);
+}
+
+gWhisperSetting::~gWhisperSetting(){}

src/gWhisperSetting/GWhisperSetting.hpp

@@ -0,0 +1,40 @@
+// Copyright 2022 IBM Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#include <nlohmann/json.hpp>
+#include "libArgParse/ArgParse.hpp"
+
+using json = nlohmann::json;
+
+class gWhisperSetting{
+    public:
+    gWhisperSetting(ArgParse::ParsedElement &f_parseTree);
+    ~gWhisperSetting();
+
+    std::string lookUpSetting(const std::string &f_parameter, ArgParse::ParsedElement &f_parseTree);
+
+
+    private:
+    void parseConfigFile(const std::string &f_inputFile);
+    void retrieveConfigParameters(json &f_startElement);
+
+    /// Searches in all layers of config file, if config contains parameter
+    /// in
+    /// out: returns setting for parameter, if setting is found else returns null Json object (at the moment)
+    json findParameterSettingInConfig(const std::string &f_parameter, const json &f_startLayer);
+
+    json m_config;
+    std::vector<std::string> m_configParameters; 
+};

src/gwhisper/CMakeLists.txt

@@ -38,6 +38,7 @@ target_link_libraries ( ${TARGET_NAME}
     reflection
     version
     generateHelpString
+    gWhisperSetting
     )
 
 set_target_properties(

src/gwhisper/gwhisper.cpp

@@ -20,6 +20,7 @@
 #include <libCli/Call.hpp>
 #include <libCli/Completion.hpp>
 #include <versionDefine.h> // generated during build
+#include "GWhisperSetting.hpp"
 
 using namespace ArgParse;
 
@@ -51,19 +52,22 @@ int main(int argc, char **argv)
     // First we construct the initial Grammar for the CLI tool:
     Grammar grammarPool;
     GrammarElement *grammarRoot = cli::constructGrammar(grammarPool);
+
+    //Here: Build everything gWhisper provides. --> Config replacement here?
 
     // Now we parse the given arguments using the grammar:
     std::string args = getArgsAsString(argc, argv);
     ParsedElement parseTree;
-    ParseRc rc = grammarRoot->parse(args.c_str(), parseTree);
+    ParseRc rc = grammarRoot->parse(args.c_str(), parseTree); //braucht evtl. schon die config
+    gWhisperSetting paramProxy(parseTree); // look up on this element
 
     if (parseTree.findFirstChild("DotExport") != "")
     {
         std::cout << grammarPool.getDotGraph();
         return 0;
     }
 
-    if (parseTree.findFirstChild("Complete") != "")
+    if (paramProxy.lookUpSetting("Complete", parseTree) != "")
     {
         bool completeDebug = (parseTree.findFirstChild("CompleteDebug") != "");
         if (parseTree.findFirstChild("fish") != "")
@@ -113,7 +117,7 @@ int main(int argc, char **argv)
         {
             //printf("\nchoice:\n%s", candidate->getDebugString().c_str());
             printf("\n  '%s'", candidate->getMatchedString().c_str());
-        }
+        } 
         std::cout << std::endl;
     }
 

src/libCli/CMakeLists.txt

@@ -12,6 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+include(FetchContent)
+FetchContent_Declare(json URL https://github.com/nlohmann/json/releases/download/v3.10.5/json.tar.xz)
+FetchContent_MakeAvailable(json)
 
 set(TARGET_NAME "cli")
 set(TARGET_SRC
@@ -34,12 +37,14 @@ target_link_libraries ( ${TARGET_NAME}
     PRIVATE
     reflection
     protoDoc
+    nlohmann_json::nlohmann_json
     )
 target_link_libraries ( ${TARGET_NAME}
     PUBLIC
     gwhisperUtils
     DescDbProxy
     ArgParse
+    gWhisperSetting
 )
 target_include_directories(${TARGET_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})