registry test

fictiveworks · Sep 18, 2023 · c7fff2a · c7fff2a
1 parent be07efb
commit c7fff2a
Show file tree

Hide file tree

Showing 10 changed files with 73 additions and 23 deletions.
diff --git a/src/production/uniform_branch.cpp b/src/production/uniform_branch.cpp
@@ -16,7 +16,7 @@ UniformBranch::UniformBranch(const UniformBranch& old)
 }
 
 std::optional<UniformBranch>
-UniformBranch::parse(std::vector<String_t> raw, const Registry& registry, ErrorHolder& errors)
+UniformBranch::parse(const std::vector<String_t>& raw, const Registry& registry, ErrorHolder& errors)
 {
     std::vector<std::shared_ptr<Production>> choices;
 

diff --git a/src/production/uniform_branch.h b/src/production/uniform_branch.h
@@ -20,7 +20,7 @@ namespace calyx
 
         ~UniformBranch() = default;
 
-        static std::optional<UniformBranch> parse(std::vector<String_t> raw, const Registry& registry, ErrorHolder& errors);
+        static std::optional<UniformBranch> parse(const std::vector<String_t>& raw, const Registry& registry, ErrorHolder& errors);
 
         std::optional<Expansion> evaluate(
             Registry& registry,

diff --git a/src/registry.cpp b/src/registry.cpp
@@ -38,7 +38,7 @@ Registry::defineRule(String_t term, std::vector<String_t> production, ErrorHolde
         return;
     }
 
-    _rules.emplace(term, std::make_shared<Rule>(*rule));
+    _rules.emplace(std::move(term), std::make_shared<Rule>(*rule));
 }
 
 std::optional<Expansion>

diff --git a/src/rule.cpp b/src/rule.cpp
@@ -6,15 +6,9 @@
 
 using namespace calyx;
 
-Rule::Rule(String_t term, std::shared_ptr<ProductionBranch> production)
-    : _production(production),
-    _term(term)
-{
-}
-
-Rule::Rule(const Rule& other)
-    : _production(other._production),
-    _term(other._term)
+Rule::Rule(String_t term, std::shared_ptr<ProductionBranch> production):
+    _term(std::move(term)),
+    _production(production)
 {
 }
 
@@ -25,7 +19,7 @@ Rule::empty(String_t term)
 }
 
 std::optional<Rule>
-Rule::build(String_t term, std::vector<String_t> productions, const Registry& registry, ErrorHolder& errors)
+Rule::build(String_t term, const std::vector<String_t>& productions, const Registry& registry, ErrorHolder& errors)
 {
     std::optional<UniformBranch> branch = UniformBranch::parse(productions, registry, errors);
 
@@ -34,7 +28,7 @@ Rule::build(String_t term, std::vector<String_t> productions, const Registry& re
         return {};
     }
 
-    return Rule(term, std::make_unique<UniformBranch>(*branch));
+    return Rule(std::move(term), std::make_unique<UniformBranch>(*branch));
 }
 
 std::optional<Expansion>

diff --git a/src/rule.h b/src/rule.h
@@ -26,15 +26,15 @@ namespace calyx
          */
         Rule(String_t term, std::shared_ptr<ProductionBranch> production);
 
-        Rule(const Rule& other);
+        Rule(const Rule& other) = default;
 
         Rule(Rule&& other) = default;
 
         ~Rule() = default;
 
         static Rule empty(String_t term);
 
-        static std::optional<Rule> build(String_t term, std::vector<String_t> productions, const Registry& registry, ErrorHolder& errors);
+        static std::optional<Rule> build(String_t term, const std::vector<String_t>& productions, const Registry& registry, ErrorHolder& errors);
 
         std::optional<Expansion> evaluate(
             Registry& registry,

diff --git a/src/syntax/expression_node.cpp b/src/syntax/expression_node.cpp
@@ -1,11 +1,12 @@
 #include "expression_node.h"
 
+
 using namespace calyx;
 
 #define MEMO_SIGIL '@'
 #define UNIQUE_SIGIL '$'
 
-ExpressionNode::ExpressionNode(const String_t reference)
+ExpressionNode::ExpressionNode(String_t reference)
     : _reference(reference)
 {
 

diff --git a/src/syntax/expression_node.h b/src/syntax/expression_node.h
@@ -13,7 +13,7 @@ namespace calyx
     class ExpressionNode : public Production
     {
     public:
-        ExpressionNode(const String_t reference);
+        ExpressionNode(String_t reference);
 
         ~ExpressionNode() = default;
 

diff --git a/src/syntax/template_node.cpp b/src/syntax/template_node.cpp
@@ -16,11 +16,13 @@ using namespace calyx;
 
 
 std::vector<std::string>
-split(const std::string& s, const char delim) {
+split(const std::string& s, const char delim)
+{
     std::vector<std::string> tokens;
     std::string token;
     std::istringstream tokenStream(s);
-    while (std::getline(tokenStream, token, delim)) {
+    while (std::getline(tokenStream, token, delim))
+    {
         tokens.push_back(token);
     }
     return tokens;
@@ -68,7 +70,6 @@ TemplateNode::fragmentString(const std::string& raw)
 TemplateNode::TemplateNode(std::vector<std::shared_ptr<Production>> concatNodes)
     : _concatNodes(concatNodes)
 {
-
 }
 
 std::optional<TemplateNode>
@@ -91,7 +92,7 @@ TemplateNode::parse(const String_t& raw, const Registry& registry, ErrorHolder&
         if (atom.starts_with(START_TOKEN) && atom.ends_with(END_TOKEN))
         {
             // remove the braces
-            std::string expression = atom.substr(1, atom.size() - 1);
+            std::string expression = atom.substr(1, atom.size() - 2);
 
             std::vector<std::string> components = split(expression, DEREF_TOKEN);
 
@@ -101,7 +102,7 @@ TemplateNode::parse(const String_t& raw, const Registry& registry, ErrorHolder&
             }
             else
             {
-                auto prod = ExpressionNode::parse(convertedAtom, registry, errors);
+                auto prod = ExpressionNode::parse(ops.fromString(expression), registry, errors);
 
                 if (!prod)
                 {

diff --git a/test/registry_test.cpp b/test/registry_test.cpp
@@ -0,0 +1,53 @@
+#include <iostream>
+#include <catch2/catch_all.hpp>
+
+#include <include/calyx.h>
+#include <registry.h>
+
+using namespace calyx;
+
+TEST_CASE("Evaluate start rule")
+{
+    Registry registry;
+    ErrorHolder errs;
+    const Options& ops = registry.getOptions();
+    String_t atom = ops.fromString("atom");
+    String_t start = ops.fromString("start");
+
+    registry.defineRule(
+        start,
+        std::vector { atom },
+        errs
+    );
+
+    REQUIRE_FALSE(errs.hasError());
+
+    std::optional<Expansion> exp = registry.evaluate(start, errs);
+
+    REQUIRE_FALSE(errs.hasError());
+    REQUIRE(exp.has_value());
+    REQUIRE(exp->getSymbol() == Exp::RESULT);
+    REQUIRE(exp->flatten(ops) == atom);
+}
+
+TEST_CASE("Evaluate recursive rules")
+{
+    Registry registry;
+    ErrorHolder errs;
+    const Options& ops = registry.getOptions();
+    String_t start = ops.fromString("start");
+    String_t prod = ops.fromString("{atom}");
+    String_t atom = ops.fromString("atom");
+
+    registry.defineRule(start, std::vector { prod }, errs);
+    REQUIRE_FALSE(errs.hasError());
+    registry.defineRule(atom, std::vector { atom }, errs);
+    REQUIRE_FALSE(errs.hasError());
+
+    std::optional<Expansion> exp = registry.evaluate(start, errs);
+
+    REQUIRE_FALSE(errs.hasError());
+    REQUIRE(exp.has_value());
+    REQUIRE(exp->getSymbol() == Exp::RESULT);
+    REQUIRE(exp->flatten(ops) == atom);
+}
diff --git a/vsxmake2019/test/test.vcxproj b/vsxmake2019/test/test.vcxproj
@@ -128,6 +128,7 @@ xmake version 2.7.8+master.d6ee79eed
       <CompileAs>CompileAsCpp</CompileAs>
     </ClCompile>
     <ClCompile Include="..\..\test\options_test.cpp" />
+    <ClCompile Include="..\..\test\registry_test.cpp" />