Project initialized.

Author: Zen0x7

.gitignore

@@ -0,0 +1,3 @@
+/cmake-build-debug
+/bin
+.idea

CMakeLists.txt

@@ -0,0 +1,38 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 3.28)
+PROJECT(Expressions VERSION 1.0.0 LANGUAGES CXX)
+
+SET(CMAKE_CXX_STANDARD 23)
+SET(CMAKE_CXX_STANDARD_REQUIRED True)
+
+OPTION(BUILD_TESTS "Build tests" ON)
+
+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")
+
+ADD_LIBRARY(expressions STATIC ${SOURCES})
+
+TARGET_INCLUDE_DIRECTORIES(expressions PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/lib/headers)
+
+INSTALL(TARGETS expressions DESTINATION lib)
+INSTALL(DIRECTORY src/headers/ DESTINATION include)
+
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin)
+
+if (BUILD_TESTS)
+    FETCHCONTENT_DECLARE(
+            googletest
+            URL https://github.com/google/googletest/archive/b514bdc898e2951020cbdca1304b75f5950d1f59.zip
+    )
+    SET(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+    FETCHCONTENT_MAKEAVAILABLE(googletest)
+    ENABLE_TESTING()
+    ADD_EXECUTABLE(tests ${TESTS} ${SOURCES})
+    TARGET_LINK_LIBRARIES(tests GTest::gtest_main)
+    INCLUDE(GoogleTest)
+    GTEST_DISCOVER_TESTS(tests)
+endif()
+

lib/headers/expression.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <regex>
+
+#include <expression_result.hpp>
+
+class expression : public std::enable_shared_from_this<expression> {
+    std::string regex_;
+    std::vector<std::string> arguments_{};
+
+public:
+    /**
+     * Expression constructor
+     *
+     * @param regex
+     * @param arguments
+     */
+    expression(
+        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<expression_result>
+    query(const std::string &input);
+
+    /**
+     * Creates a expression from strings
+     *
+     * @param input
+     * @return std::shared_ptr<expression>
+     */
+    static std::shared_ptr<expression>
+    from_string(const std::string &input);
+};

lib/headers/expression_result.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+
+class expression_result : public std::enable_shared_from_this<expression_result> {
+    bool _matches = false;
+    std::unordered_map<std::string, std::string> _bindings;
+
+public:
+    /**
+     * Expression result constructor
+     *
+     * @param matches
+     * @param bindings 
+     */
+    expression_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/sources/expression.cpp

@@ -0,0 +1,61 @@
+#include <expression.hpp>
+
+expression::expression(std::string regex, std::vector<std::string> arguments)
+    : regex_(std::move(regex)), arguments_(std::move(arguments)) {
+}
+
+std::string expression::get_regex() const {
+    return regex_;
+}
+
+std::vector<std::string> expression::get_arguments() const {
+    return arguments_;
+}
+
+std::shared_ptr<expression_result> expression::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<expression_result>(_matches, _bindings);
+}
+
+std::shared_ptr<expression> expression::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<expression>(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<expression>(_regex, _arguments);
+}

lib/sources/expression_result.cpp

@@ -0,0 +1,13 @@
+#include <expression_result.hpp>
+
+expression_result::expression_result(const bool matches, std::unordered_map<std::string, std::string> bindings)
+    : _matches(matches), _bindings(std::move(bindings)) {
+}
+
+bool expression_result::matches() const {
+    return _matches;
+}
+
+std::unordered_map<std::string, std::string> expression_result::bindings() const {
+    return _bindings;
+}

tests/base_test.cc

@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+TEST(Base, Assertions) {
+    EXPECT_EQ(true, true);
+    EXPECT_NE(true, false);
+}

tests/expression_test.cc

@@ -0,0 +1,23 @@
+#include <gtest/gtest.h>
+#include <expression.hpp>
+
+TEST(Expression, Assertions) {
+    const auto _non_empty_expression = expression::from_string("/users/{user}/details");
+    ASSERT_FALSE(_non_empty_expression->get_arguments().empty());
+    ASSERT_EQ(_non_empty_expression->get_arguments().size(), 1);
+    ASSERT_EQ(_non_empty_expression->get_arguments().at(0), "user");
+
+    const auto _empty_expression = expression::from_string("/ping");
+    ASSERT_TRUE(_empty_expression->get_arguments().empty());
+    ASSERT_EQ(_empty_expression->get_regex(), "/ping");
+
+    const auto _non_empty_string_expression_result = _non_empty_expression->query("/users/80bdc6d1-524e-411a-b316-976a65a3ed3c/details");
+    ASSERT_TRUE(_non_empty_string_expression_result->matches());
+    ASSERT_FALSE(_non_empty_string_expression_result->bindings().empty());
+    ASSERT_EQ(_non_empty_string_expression_result->bindings().at("user"), "80bdc6d1-524e-411a-b316-976a65a3ed3c");
+
+    const auto _non_empty_integer_expression_result = _non_empty_expression->query("/users/1337/details");
+    ASSERT_TRUE(_non_empty_integer_expression_result->matches());
+    ASSERT_FALSE(_non_empty_integer_expression_result->bindings().empty());
+    ASSERT_EQ(_non_empty_integer_expression_result->bindings().at("user"), "1337");
+}