All stuff fixed.

Author: Zen0x7

CMakeLists.txt

@@ -11,15 +11,43 @@ INCLUDE(FetchContent)
 INCLUDE_DIRECTORIES(lib/headers)
 
 FILE(GLOB_RECURSE SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/lib/sources/*.cpp")
-file(GLOB_RECURSE TESTS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/tests/*.cc")
+FILE(GLOB_RECURSE TESTS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/tests/*.cc")
 
 ADD_LIBRARY(expressions STATIC ${SOURCES})
 
-TARGET_INCLUDE_DIRECTORIES(expressions PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/lib/headers)
+TARGET_INCLUDE_DIRECTORIES(expressions PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/lib/headers>
+        $<INSTALL_INTERFACE:include>
+)
 
-INSTALL(TARGETS expressions DESTINATION lib)
 INSTALL(DIRECTORY lib/headers/ DESTINATION include)
 
+INSTALL(TARGETS expressions
+        EXPORT ExpressionsTargets
+        LIBRARY DESTINATION lib
+        ARCHIVE DESTINATION lib
+        RUNTIME DESTINATION bin
+        INCLUDES DESTINATION include
+)
+
+INSTALL(EXPORT ExpressionsTargets
+        FILE ExpressionsTargets.cmake
+        NAMESPACE expressions::
+        DESTINATION lib/cmake/Expressions
+)
+
+INCLUDE(CMakePackageConfigHelpers)
+CONFIGURE_PACKAGE_CONFIG_FILE(
+        cmake/ExpressionsConfig.cmake.in
+        ${CMAKE_CURRENT_BINARY_DIR}/ExpressionsConfig.cmake
+        INSTALL_DESTINATION lib/cmake/Expressions
+)
+
+INSTALL(FILES
+        ${CMAKE_CURRENT_BINARY_DIR}/ExpressionsConfig.cmake
+        DESTINATION lib/cmake/Expressions
+)
+
 SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin)
 
 if (BUILD_TESTS)

README.md

@@ -15,17 +15,19 @@ make install
 ## Usage
 
 ```c++
-#include <expression/expression.hpp>
+#include <expressions/container.hpp>
 
 using namespace std;
 
-auto it = expression::from_string("/api/servers/{server}/status");
+auto _container = expressions::container::from_string("/api/servers/{server}/status");
 
-auto result = it->query("/api/servers/production/status");
+auto _result = _container->query("/api/servers/production/status");
 
-cout << result->matches() << endl;
+cout << _result->matches() << endl;
 // 1
 
-cout << result->bindings()->at("server") << endl;
+cout << _result->bindings()->at("server") << endl;
 // production
-```
+```
+
+See more [examples](https://github.com/ZenAlgorithms/Expressions/blob/master/tests/implementation_test.cc) ...

cmake/ExpressionsConfig.cmake.in

@@ -0,0 +1,6 @@
+@PACKAGE_INIT@
+
+INCLUDE(CMakeFindDependencyMacro)
+
+# Incluir el archivo de objetivos
+INCLUDE("${CMAKE_CURRENT_LIST_DIR}/ExpressionsTargets.cmake")

lib/headers/expression.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <regex>
+
+#include <expressions/result.hpp>
+
+namespace expressions {
+    class container : public std::enable_shared_from_this<container> {
+        std::string regex_;
+        std::vector<std::string> arguments_{};
+
+    public:
+        /**
+         * Expression constructor
+         *
+         * @param regex
+         * @param arguments
+         */
+        container(
+            std::string regex,
+            std::vector<std::string> arguments
+        );
+
+        /**
+         * Get the regex
+         *
+         * @return std::string
+         */
+        std::string
+        get_regex() const;
+
+        /**
+         * Get the arguments
+         *
+         * @return std::vector<std::string>
+         */
+        std::vector<std::string>
+        get_arguments() const;
+
+        /**
+         * Query the expression
+         *
+         * @param input
+         * @return
+         */
+        std::shared_ptr<result>
+        query(const std::string &input);
+
+        /**
+         * Creates a expression from strings
+         *
+         * @param input
+         * @return std::shared_ptr<expression>
+         */
+        static std::shared_ptr<container>
+        from_string(const std::string &input);
+    };
+}

lib/headers/expression_result.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+
+namespace expressions {
+    class result : public std::enable_shared_from_this<result> {
+        bool _matches = false;
+        std::unordered_map<std::string, std::string> _bindings;
+
+    public:
+        /**
+         * Expression result constructor
+         *
+         * @param matches
+         * @param bindings
+         */
+        result(
+            bool matches,
+            std::unordered_map<std::string, std::string> bindings
+        );
+
+        /**
+         * Get matches
+         *
+         * @return
+         */
+        bool
+        matches() const;
+
+        /**
+         * Get bindings
+         *
+         * @return
+         */
+        std::unordered_map<std::string, std::string>
+        bindings() const;
+    };
+}

lib/headers/expressions/container.hpp

@@ -0,0 +1,63 @@
+#include <expressions/container.hpp>
+
+namespace expressions {
+    container::container(std::string regex, std::vector<std::string> arguments)
+        : regex_(std::move(regex)), arguments_(std::move(arguments)) {
+    }
+
+    std::string container::get_regex() const {
+        return regex_;
+    }
+
+    std::vector<std::string> container::get_arguments() const {
+        return arguments_;
+    }
+
+    std::shared_ptr<result> container::query(const std::string &input) {
+        std::unordered_map<std::string, std::string> _bindings;
+        const std::regex _pattern(regex_);
+        bool _matches = false;
+        if (std::smatch _match; std::regex_match(input, _match, _pattern)) {
+            _matches = true;
+            auto _iterator = _match.begin();
+            ++_iterator;
+            for (auto &_key: arguments_) {
+                _bindings[_key] = *_iterator;
+                ++_iterator;
+            }
+        }
+        return std::make_shared<result>(_matches, _bindings);
+    }
+
+    std::shared_ptr<container> container::from_string(const std::string &input) {
+        std::size_t _open = input.find('{');
+        std::size_t _close = input.find('}');
+        std::size_t _position = 0;
+
+        std::vector<std::string> _arguments;
+        std::string _regex;
+
+        if (_open == std::string::npos && _close == std::string::npos)
+            return std::make_shared<container>(std::string{input.data()}, _arguments);
+
+        while (_open != std::string::npos && _close != std::string::npos) {
+            _regex.append(input.substr(_position, _open - _position));
+            std::string _value{input.substr(_open + 1, _close - _open - 1)};
+
+            if (std::find(_arguments.begin(), _arguments.end(), _value) != _arguments.end())
+                throw std::runtime_error("groups can't be repeated ... ");
+
+            _regex.append(R"(([a-zA-Z0-9\-_]+))");
+            _arguments.emplace_back(_value);
+
+            _position = _close + 1;
+            _open = input.find('{', _close);
+            _close = input.find('}', _open);
+
+            if (_open == std::string::npos && _close == std::string::npos && _position != input.size())
+                _regex.append(input.substr(_position, input.size() - _position));
+        }
+
+        return std::make_shared<container>(_regex, _arguments);
+    }
+}