Add parsing of simple conditionals

At the moment this only supports direct boolean dictionary lookups.

Author: urfeex

include/ur_client_library/control/script_reader.h

@@ -50,18 +50,33 @@ class ScriptReader
     RobotType robot_type;
   };
 
-  using DataDict = std::unordered_map<std::string, std::variant<std::string, double, int>>;
+  using DataDict = std::unordered_map<std::string, std::variant<std::string, double, int, bool>>;
 
   ScriptReader() = default;
 
   std::string readScriptFile(const std::string& filename, const DataDict& data = DataDict());
 
 private:
+  enum BlockType
+  {
+    IF,
+    ELIF,
+    ELSE
+  };
+  struct BlockState
+  {
+    BlockType type;
+    bool condition_matched;  // Has any previous condition in this block matched?
+    bool should_render;      // Should this block render?
+    bool parent_render;      // Is the parent block rendering?
+  };
+
   std::filesystem::path script_path_;
 
   std::string readFileContent(const std::string& filename);
   void replaceIncludes(std::string& script_code);
   void replaceVariables(std::string& script_code, const DataDict& data);
+  void replaceConditionals(std::string& script_code, const DataDict& data);
 };
 }  // namespace control
-}  // namespace urcl
+}  // namespace urcl

include/ur_client_library/exceptions.h

@@ -213,5 +213,17 @@ class UnsupportedMotionType : public UrException
   {
   }
 };
+
+class UnknownVariable : public UrException
+{
+private:
+  std::string text_;
+
+public:
+  explicit UnknownVariable() = delete;
+  explicit UnknownVariable(const std::string& variable_name) : std::runtime_error("Unknown variable: " + variable_name)
+  {
+  }
+};
 }  // namespace urcl
-#endif  // ifndef UR_CLIENT_LIBRARY_EXCEPTIONS_H_INCLUDED
+#endif  // ifndef UR_CLIENT_LIBRARY_EXCEPTIONS_H_INCLUDED

src/control/script_reader.cpp

@@ -46,6 +46,7 @@ std::string ScriptReader::readScriptFile(const std::string& filename, const Data
 
   replaceIncludes(script_code);
   replaceVariables(script_code, data);
+  replaceConditionals(script_code, data);
 
   return script_code;
 }
@@ -93,13 +94,12 @@ void ScriptReader::replaceVariables(std::string& script_code, const DataDict& da
   while (std::regex_search(script_code, match, pattern))
   {
     std::string key = match[1];
-    URCL_LOG_INFO("Found replacement pattern %s", match[0].str().c_str());
     if (data.find(key) == data.end())
     {
       std::stringstream ss;
       ss << "Variable '" << key << "' not found in data.";
       URCL_LOG_ERROR(ss.str().c_str());
-      throw UrException(ss.str().c_str());
+      throw UnknownVariable(ss.str().c_str());
     }
     std::string replaced_value;
 
@@ -115,8 +115,13 @@ void ScriptReader::replaceVariables(std::string& script_code, const DataDict& da
     {
       replaced_value = std::to_string(std::get<int>(data.at(key)));
     }
+    else if (std::holds_alternative<bool>(data.at(key)))
+    {
+      std::get<bool>(data.at(key)) ? replaced_value = "True" : replaced_value = "False";
+    }
     else
     {
+      // This is more of a reminder if we add types to the variant and forget to add it here.
       std::stringstream ss;
       ss << "Unsupported type for variable '" << key << "'.";
       URCL_LOG_ERROR(ss.str().c_str());
@@ -126,5 +131,79 @@ void ScriptReader::replaceVariables(std::string& script_code, const DataDict& da
   }
 }
 
+void ScriptReader::replaceConditionals(std::string& script_code, const DataDict& data)
+{
+  std::istringstream stream(script_code);
+  std::ostringstream output;
+  std::string line;
+  std::stack<BlockState> block_stack;
+
+  std::regex if_pattern(R"(\{\%\s*if\s+([^\s].*[^\s])\s+\%\})");
+  std::regex elif_pattern(R"(\{\%\s*elif\s+([^\s].*[^\s])\s+\%\})");
+  std::regex else_pattern(R"(\{\%\s*else\s*\%\})");
+  std::regex endif_pattern(R"(\{\%\s*endif\s*\%\})");
+  std::smatch match;
+
+  while (std::getline(stream, line))
+  {
+    if (std::regex_search(line, match, if_pattern))
+    {
+      std::string condition = match[1];
+      bool result = data.count(condition) && std::holds_alternative<bool>(data.at(condition)) &&
+                    std::get<bool>(data.at(condition));
+      bool parent_render = block_stack.empty() ? true : block_stack.top().should_render;
+      block_stack.push({ IF, result, parent_render && result, parent_render });
+    }
+    else if (std::regex_search(line, match, elif_pattern))
+    {
+      if (!block_stack.empty())
+      {
+        BlockState& top = block_stack.top();
+        if (top.type == ELSE)
+          continue;
+        std::string condition = match[1];
+        bool result = data.count(condition) && std::holds_alternative<bool>(data.at(condition)) &&
+                      std::get<bool>(data.at(condition));
+        top.type = ELIF;
+        if (!top.condition_matched && result)
+        {
+          top.condition_matched = true;
+          top.should_render = top.parent_render;
+        }
+        else
+        {
+          top.should_render = false;
+        }
+      }
+    }
+    else if (std::regex_search(line, match, else_pattern))
+    {
+      if (!block_stack.empty())
+      {
+        BlockState& top = block_stack.top();
+        top.type = ELSE;
+        top.should_render = top.parent_render && !top.condition_matched;
+      }
+    }
+    else if (std::regex_search(line, match, endif_pattern))
+    {
+      if (!block_stack.empty())
+      {
+        block_stack.pop();
+      }
+    }
+    else
+    {
+      bool render = block_stack.empty() ? true : block_stack.top().should_render;
+      if (render)
+      {
+        output << line << "\n";
+      }
+    }
+  }
+
+  script_code = output.str();
+}
+
 }  // namespace control
-}  // namespace urcl
+}  // namespace urcl

tests/test_script_reader.cpp

@@ -28,6 +28,8 @@
 // POSSIBILITY OF SUCH DAMAGE.
 // -- END LICENSE BLOCK ------------------------------------------------
 
+#include "ur_client_library/exceptions.h"
+
 #include <gtest/gtest.h>
 #include "ur_client_library/control/script_reader.h"
 
@@ -82,7 +84,7 @@ TEST_F(ScriptReaderTest, ReadValidScript)
 {
   ScriptReader reader;
   std::string content = reader.readScriptFile(valid_script_path_);
-  EXPECT_EQ(content, simple_script_.str());
+  EXPECT_EQ(content, simple_script_.str() + "\n");
 }
 
 TEST_F(ScriptReaderTest, ReadEmptyScript)
@@ -127,7 +129,7 @@ TEST_F(ScriptReaderTest, ReplaceIncludes)
   ofs_included.close();
 
   std::string processed_script = reader.readScriptFile(existing_script_file);
-  EXPECT_EQ(processed_script, "movej([1,2,3,4,5,6])");
+  EXPECT_EQ(processed_script, "movej([1,2,3,4,5,6])\n");
 
   std::remove(existing_script_file);
   std::remove(existing_include_file);
@@ -140,6 +142,8 @@ TEST_F(ScriptReaderTest, ReplaceVariables)
   data["VAR1"] = "value1";
   data["VAR2"] = 42;
   data["VAR3"] = 6.28;
+  data["VAR4"] = true;
+  data["VAR5"] = false;
 
   char existing_script_file[] = "main_script.XXXXXX";
   std::ignore = mkstemp(existing_script_file);
@@ -150,11 +154,85 @@ TEST_F(ScriptReaderTest, ReplaceVariables)
     GTEST_FAIL();
   }
   ofs << "movej([{{VAR1}}, {{VAR2}}, {{VAR3}}, 0, 0, 0])" << std::endl;
+  ofs << "local is_true = {{VAR4}}" << std::endl;
+  ofs << "local is_false = {{VAR5}}" << std::endl;
   ofs << "This is just a line without any replacement" << std::endl;
   ofs.close();
 
   std::string script = reader.readScriptFile(existing_script_file, data);
 
   // By default std::to_string will convert double to 6 decimal places
-  EXPECT_EQ(script, "movej([value1, 42, 6.280000, 0, 0, 0])\nThis is just a line without any replacement\n");
+  EXPECT_EQ(script, "movej([value1, 42, 6.280000, 0, 0, 0])\nlocal is_true = True\nlocal is_false = False\nThis is "
+                    "just a line without any replacement\n");
+}
+
+TEST_F(ScriptReaderTest, VariableNotInDictThrowsError)
+{
+  ScriptReader reader;
+  ScriptReader::DataDict data;
+  data["VAR1"] = "value1";
+
+  char existing_script_file[] = "main_script.XXXXXX";
+  std::ignore = mkstemp(existing_script_file);
+  std::ofstream ofs(existing_script_file);
+  if (ofs.bad())
+  {
+    std::cout << "Failed to create temporary files" << std::endl;
+    GTEST_FAIL();
+  }
+  ofs << "movej([{{VAR1}}, {{VAR2}}, {{VAR3}}, 0, 0, 0])" << std::endl;
+  ofs << "This is just a line without any replacement" << std::endl;
+  ofs.close();
+
+  EXPECT_THROW(reader.readScriptFile(existing_script_file, data), urcl::UnknownVariable);
 }
+
+TEST_F(ScriptReaderTest, ReplaceConditionals)
+{
+  ScriptReader reader;
+  ScriptReader::DataDict data;
+  data["is_logged_in"] = true;
+  data["is_guest"] = false;
+  data["has_username"] = true;
+  data["username"] = "test_user";
+
+  char existing_script_file[] = "main_script.XXXXXX";
+  std::ignore = mkstemp(existing_script_file);
+  std::ofstream ofs(existing_script_file);
+  if (ofs.bad())
+  {
+    std::cout << "Failed to create temporary files" << std::endl;
+    GTEST_FAIL();
+  }
+  ofs <<
+      R"({% if is_logged_in %}
+Welcome back, {{ username }}!
+{% elif is_guest %}
+  {% if has_username %}
+Welcome, {{ username }}!
+  {%else %}
+Welcome, guest!
+  {% endif %}
+{% else %}
+Please log in.
+{% endif %}
+)";
+  ofs.close();
+
+  std::string script = reader.readScriptFile(existing_script_file, data);
+
+  EXPECT_EQ(script, "Welcome back, test_user!\n");
+
+  data["is_logged_in"] = false;
+  data["is_guest"] = true;
+  script = reader.readScriptFile(existing_script_file, data);
+  EXPECT_EQ(script, "Welcome, test_user!\n");
+
+  data["has_username"] = false;
+  script = reader.readScriptFile(existing_script_file, data);
+  EXPECT_EQ(script, "Welcome, guest!\n");
+
+  data["is_guest"] = false;
+  script = reader.readScriptFile(existing_script_file, data);
+  EXPECT_EQ(script, "Please log in.\n");
+}