Update Glue (#43)

* update CPM

* update extension

* v1.9

* update tests

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
 # ---- Project ----
 
 project(LarsParser 
-  VERSION 1.8
+  VERSION 1.9
   LANGUAGES CXX
 )
 
@@ -35,7 +35,7 @@ if(${LARS_PARSER_BUILD_GLUE_EXTENSION})
   CPMAddPackage(
     NAME Glue
     GIT_REPOSITORY https://github.com/TheLartians/Glue.git
-    VERSION 0.5 
+    VERSION 0.7
   )
 endif()
 

cmake/CPM.cmake

@@ -2,8 +2,9 @@
 # =================================================
 # See https://github.com/TheLartians/CPM for usage and update instructions.
 #
-#   MIT License
-#[[ -----------
+# MIT License
+# ----------- 
+#[[
   Copyright (c) 2019 Lars Melchior
 
   Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -27,12 +28,23 @@
 
 cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
 
+set(CURRENT_CPM_VERSION 0.8.1) 
+
 if(CPM_DIRECTORY)
   if(NOT ${CPM_DIRECTORY} MATCHES ${CMAKE_CURRENT_LIST_DIR})
+    if (${CPM_VERSION} VERSION_LESS ${CURRENT_CPM_VERSION})
+      message(AUTHOR_WARNING "${CPM_INDENT} \
+A dependency is using a more recent CPM (${CURRENT_CPM_VERSION}) than the current project (${CPM_VERSION}). \
+It is recommended to upgrade CPM to the most recent version. \
+See https://github.com/TheLartians/CPM for more information.\
+")  
+    endif()
     return()
   endif()
 endif()
 
+set(CPM_VERSION ${CURRENT_CPM_VERSION} CACHE INTERNAL "")
+
 set(CPM_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} CACHE INTERNAL "")
 set(CPM_PACKAGES "" CACHE INTERNAL "")
 
@@ -46,13 +58,9 @@ if(NOT CPM_INDENT)
   set(CPM_INDENT "CPM:")
 endif()
 
-function(CPM_REGISTER_PACKAGE PACKAGE VERSION)
-  LIST(APPEND CPM_PACKAGES ${CPM_ARGS_NAME})
+function(CPMRegisterPackage PACKAGE VERSION)
+  list(APPEND CPM_PACKAGES ${PACKAGE})
   set(CPM_PACKAGES ${CPM_PACKAGES} CACHE INTERNAL "")
-  CPM_SET_PACKAGE_VERSION(${PACKAGE} ${VERSION})
-endfunction()
-
-function(CPM_SET_PACKAGE_VERSION PACKAGE VERSION)
   set("CPM_PACKAGE_${PACKAGE}_VERSION" ${VERSION} CACHE INTERNAL "")
 endfunction()
 
@@ -70,11 +78,11 @@ function(CPM_PARSE_OPTION OPTION)
 endfunction()
 
 function(CPMAddPackage)
-
   set(oneValueArgs
     NAME
     VERSION
     GIT_TAG
+    DOWNLOAD_ONLY
   )
 
   set(multiValueArgs
@@ -108,6 +116,12 @@ function(CPMAddPackage)
     set(CPM_ARGS_GIT_TAG v${CPM_ARGS_VERSION})
   endif()
 
+  if(CPM_ARGS_DOWNLOAD_ONLY)
+    set(DOWNLOAD_ONLY ${CPM_ARGS_DOWNLOAD_ONLY})
+  else()
+    set(DOWNLOAD_ONLY NO)
+  endif()
+
   if (${CPM_ARGS_NAME} IN_LIST CPM_PACKAGES)
     CPM_GET_PACKAGE_VERSION(${CPM_ARGS_NAME})
     if(${CPM_PACKAGE_VERSION} VERSION_LESS ${CPM_ARGS_VERSION})
@@ -121,11 +135,11 @@ function(CPMAddPackage)
         endif()
       endforeach()
     endif()
-    CPM_FETCH_PACKAGE(${CPM_ARGS_NAME})
+    CPM_FETCH_PACKAGE(${CPM_ARGS_NAME} ${DOWNLOAD_ONLY})
     return()
   endif()
 
-  CPM_REGISTER_PACKAGE(${CPM_ARGS_NAME} ${CPM_ARGS_VERSION})
+  CPMRegisterPackage(${CPM_ARGS_NAME} ${CPM_ARGS_VERSION})
 
   if (CPM_ARGS_OPTIONS)
     foreach(OPTION ${CPM_ARGS_OPTIONS})
@@ -135,7 +149,7 @@ function(CPMAddPackage)
   endif()
 
   CPM_DECLARE_PACKAGE(${CPM_ARGS_NAME} ${CPM_ARGS_VERSION} ${CPM_ARGS_GIT_TAG} "${CPM_ARGS_UNPARSED_ARGUMENTS}")
-  CPM_FETCH_PACKAGE(${CPM_ARGS_NAME})
+  CPM_FETCH_PACKAGE(${CPM_ARGS_NAME} ${DOWNLOAD_ONLY})
 endfunction()
 
 function (CPM_DECLARE_PACKAGE PACKAGE VERSION GIT_TAG)
@@ -148,9 +162,15 @@ function (CPM_DECLARE_PACKAGE PACKAGE VERSION GIT_TAG)
   )
 endfunction()
 
-function (CPM_FETCH_PACKAGE PACKAGE)  
+function (CPM_FETCH_PACKAGE PACKAGE DOWNLOAD_ONLY)  
   set(CPM_OLD_INDENT "${CPM_INDENT}")
   set(CPM_INDENT "${CPM_INDENT} ${PACKAGE}:")
-  FetchContent_MakeAvailable(${PACKAGE})
+  if(${DOWNLOAD_ONLY})
+    if(NOT "${PACKAGE}_POPULATED")
+      FetchContent_Populate(${PACKAGE})
+    endif()
+  else()
+    FetchContent_MakeAvailable(${PACKAGE})
+  endif()
   set(CPM_INDENT "${CPM_OLD_INDENT}")
 endfunction()

include/lars/parser/extension.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <lars/glue.h>
+#include <glue/element.h>
 
 namespace lars{
-  namespace extensions{
-    std::shared_ptr<Extension> parser();
+  namespace glue {
+    ::glue::Element parser();
   }
 }

source/extension.cpp

@@ -3,72 +3,75 @@
 #include <stdexcept>
 #include <lars/log.h>
 
-std::shared_ptr<lars::Extension> lars::extensions::parser(){
+::glue::Element lars::glue::parser(){
   using namespace lars;
+  using namespace ::glue;
 
-  using ParserGenerator = lars::ParserGenerator<Any,Any&>;
+  using ParserGenerator = lars::ParserGenerator<Any,const Any &>;
   using Expression = ParserGenerator::Expression;
 
-  auto expressionExtension = std::make_shared<Extension>();
-  expressionExtension->set_class<ParserGenerator::Expression>();
-  
-  expressionExtension->add_function("evaluate", [](Expression &e,Any &d){
+  Element expression;
+  setClass<Expression>(expression);
+
+  expression["evaluate"] = [](Expression &e,const Any &d){
     return e.evaluate(d);
-  });
+  };
 
-  expressionExtension->add_function("size", [](Expression &e)->unsigned{
+  expression["size"] = [](Expression &e)->unsigned{
     return e.size();
-  });
+  };
 
-  expressionExtension->add_function("get", [](Expression &e, unsigned i){ 
+  expression["get"] = [](Expression &e, unsigned i){
     if (i < e.size()) {
       return e[i];
     } else {
       throw std::runtime_error("invalid expression index");
     }
-  });
-  
-  expressionExtension->add_function("string", [](Expression &e){
+  };
+
+  expression["string"] = [](Expression &e){
     return e.string();
-  });
+  };
 
-  expressionExtension->add_function("position", [](Expression &e)->unsigned{
+  expression["position"] = [](Expression &e)->unsigned{
     return e.position();
-  });
+  };
 
-  expressionExtension->add_function("length", [](Expression &e)->unsigned{
+  expression["length"] = [](Expression &e)->unsigned{
     return e.length();
-  });
+  };
+
 
-  auto parserGeneratorExtension = std::make_shared<Extension>();
-  parserGeneratorExtension->set_class<ParserGenerator>();
-  parserGeneratorExtension->add_function("create", [](){ return ParserGenerator(); });
+  Element program;
+  setClass<ParserGenerator>(program);
+
+  program["create"] = [](){ return ParserGenerator(); };
 
-  parserGeneratorExtension->add_function("run", [](ParserGenerator &g, const std::string &str, Any& arg){
+  program["run"] = [](ParserGenerator &g, const std::string &str, const Any& arg){
     return g.run(str, arg);
-  });
+  };
 
-  parserGeneratorExtension->add_function("setRule",[](ParserGenerator &g, const std::string &name, const std::string &grammar){
+  program["setRule"] = [](ParserGenerator &g, const std::string &name, const std::string &grammar){
     return g.setRule(name, grammar);
-  });
+  };
 
-  parserGeneratorExtension->add_function("setRuleWithCallback",[](ParserGenerator &g, const std::string &name, const std::string &grammar, AnyFunction callback){
-    return g.setRule(name, grammar, [callback](auto e, Any v){
+  program["setRuleWithCallback"] = [](ParserGenerator &g, const std::string &name, const std::string &grammar, AnyFunction callback){
+    return g.setRule(name, grammar, [callback](auto e, const Any &v)->Any{
       return callback(e, v);
     });
-  });
+  };
 
-  parserGeneratorExtension->add_function("setStartRule", [](ParserGenerator &g, const std::string &name){
+  program["setStartRule"] = [](ParserGenerator &g, const std::string &name){
     g.setStart(g.getRule(name));
-  });
+  };
 
-  parserGeneratorExtension->add_function("setSeparatorRule", [](ParserGenerator &g, const std::string &name){
+  program["setSeparatorRule"] = [](ParserGenerator &g, const std::string &name){
     g.setSeparator(g.getRule(name));
-  });
+  };
 
-  auto extension = std::make_shared<Extension>();
-  extension->add_extension("Program", parserGeneratorExtension);
-  extension->add_extension("Expression", expressionExtension);
-
-  return extension;
+  Element parser;
+  parser["Program"] = program;
+  parser["Expression"] = expression;
+  
+  return parser;
 }

tests/CMakeLists.txt

@@ -10,33 +10,31 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   find_package(LarsParser REQUIRED)
 endif()
 
-include(FetchContent)
+include(../cmake/CPM.cmake)
 
-FetchContent_Declare(
-  Catch2
+CPMAddPackage(
+  NAME Catch2
   GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-  GIT_TAG        v2.5.0
+  VERSION 2.5.0
 )
 
-FetchContent_MakeAvailable(Catch2)
-
 # ---- Create binary ----
 
 file(GLOB tests_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
-add_executable(lars-parser-tests ${tests_sources})
-target_link_libraries(lars-parser-tests PUBLIC LarsParser Catch2)
-set_target_properties(lars-parser-tests PROPERTIES CXX_STANDARD 17 COMPILE_FLAGS "-Wall -pedantic -Wextra -Werror")
+add_executable(LarsParserTests ${tests_sources})
+target_link_libraries(LarsParserTests PUBLIC LarsParser Catch2)
+set_target_properties(LarsParserTests PROPERTIES CXX_STANDARD 17 COMPILE_FLAGS "-Wall -pedantic -Wextra -Werror")
 
 # ---- Add tests ----
 
 ENABLE_TESTING() 
-ADD_TEST(lars-parser-tests lars-parser-tests)
+ADD_TEST(LarsParserTests LarsParserTests)
 
 # ---- code coverage ----
 
 if (${ENABLE_TEST_COVERAGE})
   set_target_properties(LarsParser PROPERTIES CXX_STANDARD 17 COMPILE_FLAGS "-O0 -g -fprofile-arcs -ftest-coverage --coverage")
   target_link_options(LarsParser PUBLIC "--coverage")
-  set_target_properties(lars-parser-tests PROPERTIES CXX_STANDARD 17 COMPILE_FLAGS "-O0 -g -fprofile-arcs -ftest-coverage --coverage")
-  target_link_options(lars-parser-tests PUBLIC "--coverage")
+  set_target_properties(LarsParserTests PROPERTIES CXX_STANDARD 17 COMPILE_FLAGS "-O0 -g -fprofile-arcs -ftest-coverage --coverage")
+  target_link_options(LarsParserTests PUBLIC "--coverage")
 endif()

tests/extension.cpp

@@ -5,24 +5,26 @@
 
 TEST_CASE("Extension"){
   using namespace lars;
-  auto extension = lars::extensions::parser();
+  auto extension = lars::glue::parser();
 
-  auto programExtension = extension->get_extension("Program");
-  auto expressionExtension = extension->get_extension("Expression");
+  auto programExtension = extension["Program"];
+  auto expressionExtension = extension["Expression"];
 
-  auto createProgram = programExtension->get_function("create");
-  auto setRule = programExtension->get_function("setRule");
-  auto setSeparator = programExtension->get_function("setSeparatorRule");
-  auto setStart = programExtension->get_function("setStartRule");
-  auto setRuleWithCallback = programExtension->get_function("setRuleWithCallback");
-  auto run = programExtension->get_function("run");
-  auto evaluate = expressionExtension->get_function("evaluate");
-  auto get = expressionExtension->get_function("get");
-  auto string = expressionExtension->get_function("string");
-  auto size = expressionExtension->get_function("size");
-  auto position = expressionExtension->get_function("position");
-  auto length = expressionExtension->get_function("length");
+  auto createProgram = programExtension["create"];
+  auto setRule = programExtension["setRule"];
+  auto setSeparator = programExtension["setSeparatorRule"];
+  auto setStart = programExtension["setStartRule"];
+  auto setRuleWithCallback = programExtension["setRuleWithCallback"];
+  auto run = programExtension["run"];
+  auto evaluate = expressionExtension["evaluate"];
+  auto get = expressionExtension["get"];
+  auto string = expressionExtension["string"];
+  auto size = expressionExtension["size"];
+  auto position = expressionExtension["position"];
+  auto length = expressionExtension["length"];
 
+  using VariableMap = std::unordered_map<std::string, float> ;
+
   auto program = createProgram();
   REQUIRE_NOTHROW(setRule(program, "Whitespace", "[\t ]"));
   REQUIRE_NOTHROW(setSeparator(program, "Whitespace"));
@@ -31,35 +33,35 @@ TEST_CASE("Extension"){
   REQUIRE_NOTHROW(setRule(program, "Product", "Multiply | Divide | Atomic"));
   REQUIRE_NOTHROW(setRule(program, "Atomic", "Number | '(' Sum ')'"));
 
-  REQUIRE_NOTHROW(setRuleWithCallback(program, "Add", "Sum '+' Product", lars::AnyFunction([=](lars::Any e,lars::Any &d){
+  REQUIRE_NOTHROW(setRuleWithCallback(program, "Add", "Sum '+' Product", lars::AnyFunction([=](const lars::Any &e,VariableMap &d){
     return evaluate(get(e,0),d).get<float>() + evaluate(get(e,1),d).get<float>();
   })));
 
-  REQUIRE_NOTHROW(setRuleWithCallback(program, "Subtract", "Sum '-' Product", lars::AnyFunction([=](lars::Any e,lars::Any &d){
+  REQUIRE_NOTHROW(setRuleWithCallback(program, "Subtract", "Sum '-' Product", lars::AnyFunction([=](const lars::Any &e,VariableMap &d){
     return evaluate(get(e,0),d).get<float>() - evaluate(get(e,1),d).get<float>();
   })));
 
-  REQUIRE_NOTHROW(setRuleWithCallback(program, "Multiply", "Product '*' Atomic", lars::AnyFunction([=](lars::Any e,lars::Any &d){
+  REQUIRE_NOTHROW(setRuleWithCallback(program, "Multiply", "Product '*' Atomic", lars::AnyFunction([=](const lars::Any &e,VariableMap &d){
     return evaluate(get(e,0),d).get<float>() * evaluate(get(e,1),d).get<float>();
   })));
 
-  REQUIRE_NOTHROW(setRuleWithCallback(program, "Divide", "Product '/' Atomic", lars::AnyFunction([=](lars::Any e,lars::Any &d){
+  REQUIRE_NOTHROW(setRuleWithCallback(program, "Divide", "Product '/' Atomic", lars::AnyFunction([=](const lars::Any &e,VariableMap &d){
     return evaluate(get(e,0),d).get<float>() / evaluate(get(e,1),d).get<float>();
   })));
 
-  REQUIRE_NOTHROW(setRuleWithCallback(program, "Number", "'-'? [0-9]+ ('.' [0-9]+)?", lars::AnyFunction([=](lars::Any e,lars::Any &){
-    REQUIRE(size(e).get_numeric() == 0);
-    REQUIRE(position(e).get_numeric() >= 0);
-    REQUIRE(length(e).get_numeric() == string(e).get<std::string>().size());
+  REQUIRE_NOTHROW(setRuleWithCallback(program, "Number", "'-'? [0-9]+ ('.' [0-9]+)?", lars::AnyFunction([=](const lars::Any &e,VariableMap &){
+    REQUIRE(size(e).get<int>() == 0);
+    REQUIRE(position(e).get<int>() >= 0);
+    REQUIRE(length(e).get<int>() == string(e).get<std::string>().size());
     return float(stof(string(e).get<std::string>()));
   })));
 
-  REQUIRE_NOTHROW(setRuleWithCallback(program, "Variable", "[a-zA-Z]+", lars::AnyFunction([=](lars::Any e,lars::Any &d){
-    auto &vars = d.get<std::unordered_map<std::string, float>>();
+  REQUIRE_NOTHROW(setRuleWithCallback(program, "Variable", "[a-zA-Z]+", lars::AnyFunction([=](const lars::Any &e,VariableMap &d){
+    auto &vars = d;
     return vars[string(e).get<std::string>()];
   })));
 
-  std::unordered_map<std::string, float> variables;
+  VariableMap variables;
   REQUIRE(run(program,"42",variables).get<float>() == Approx(42));
   REQUIRE(run(program,"2+3",variables).get<float>() == Approx(5));
   REQUIRE(run(program,"2*3",variables).get<float>() == Approx(6));