Matcher.hpp

Go to the documentation of this file.

// //          Copyright Dominic (DNKpp) Koepke 2024 - 2024.
// // Distributed under the Boost Software License, Version 1.0.
// //    (See accompanying file LICENSE_1_0.txt or copy at
// //          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef MIMICPP_MATCHER_HPP
#define MIMICPP_MATCHER_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/Printer.hpp"
#include "mimic++/String.hpp"
#include "mimic++/TypeTraits.hpp"
#include "mimic++/Utility.hpp"
 
#include <algorithm>
#include <concepts>
#include <functional>
#include <optional>
#include <ranges>
#include <tuple>
#include <type_traits>
 
namespace mimicpp::custom
{
    template <typename Matcher>
    struct matcher_traits;
}
 
namespace mimicpp::detail::matches_hook
{
    template <typename Matcher, typename T>
    [[nodiscard]]
    constexpr bool matches_impl(
        const Matcher& matcher,
        T& target,
        [[maybe_unused]] const priority_tag<1>
    )
        requires requires
        {
            {
                custom::matcher_traits<Matcher>{}.matches(matcher, target)
            } -> std::convertible_to<bool>;
        }
    {
        return custom::matcher_traits<Matcher>{}.matches(matcher, target);
    }
 
    template <typename Matcher, typename T>
    [[nodiscard]]
    constexpr bool matches_impl(
        const Matcher& matcher,
        T& target,
        [[maybe_unused]] const priority_tag<0>
    )
        requires requires { { matcher.matches(target) } -> std::convertible_to<bool>; }
    {
        return matcher.matches(target);
    }
 
    constexpr priority_tag<1> maxTag;
 
    template <typename Matcher, typename T>
    [[nodiscard]]
    constexpr bool matches(const Matcher& matcher, T& target)
        requires requires { { matches_impl(matcher, target, maxTag) } -> std::convertible_to<bool>; }
    {
        return matches_impl(matcher, target, maxTag);
    }
}
 
namespace mimicpp::detail::describe_hook
{
    template <typename Matcher>
    [[nodiscard]]
    constexpr decltype(auto) describe_impl(
        const Matcher& matcher,
        [[maybe_unused]] const priority_tag<1>
    )
        requires requires
        {
            {
                custom::matcher_traits<Matcher>{}.describe(matcher)
            } -> std::convertible_to<StringViewT>;
        }
    {
        return custom::matcher_traits<Matcher>{}.describe(matcher);
    }
 
    template <typename Matcher>
    [[nodiscard]]
    constexpr decltype(auto) describe_impl(
        const Matcher& matcher,
        [[maybe_unused]] const priority_tag<0>
    )
        requires requires { { matcher.describe() } -> std::convertible_to<StringViewT>; }
    {
        return matcher.describe();
    }
 
    constexpr priority_tag<1> maxTag;
 
    template <typename Matcher>
    [[nodiscard]]
    constexpr decltype(auto) describe(const Matcher& matcher)
        requires requires { { describe_impl(matcher, maxTag) } -> std::convertible_to<StringViewT>; }
    {
        return describe_impl(matcher, maxTag);
    }
}
 
namespace mimicpp
{
    template <typename T, typename Target>
    concept matcher_for = std::same_as<T, std::remove_cvref_t<T>>
                        && std::is_move_constructible_v<T>
                        && std::destructible<T>
                        && requires(const T& matcher, Target& target)
                        {
                            { detail::matches_hook::matches(matcher, target) } -> std::convertible_to<bool>;
                            { detail::describe_hook::describe(matcher) } -> std::convertible_to<StringViewT>;
                        };
 
    namespace detail
    {
        template <typename Arg, typename MatchesProjection = std::identity, typename DescribeProjection = PrintFn>
        struct arg_storage
        {
            using matches_reference = std::invoke_result_t<MatchesProjection, const Arg&>;
            using describe_reference = std::invoke_result_t<DescribeProjection, const Arg&>;
 
            Arg arg;
 
            decltype(auto) as_matches_arg() const noexcept(std::is_nothrow_invocable_v<MatchesProjection, const Arg&>)
            {
                return std::invoke(MatchesProjection{}, arg);
            }
 
            decltype(auto) as_describe_arg() const noexcept(std::is_nothrow_invocable_v<DescribeProjection, const Arg&>)
            {
                return std::invoke(DescribeProjection{}, arg);
            }
        };
 
        template <typename T>
        struct to_arg_storage
        {
            using type = arg_storage<T>;
        };
 
        template <typename Arg, typename MatchesProjection, typename DescribeProjection>
        struct to_arg_storage<arg_storage<Arg, MatchesProjection, DescribeProjection>>
        {
            using type = arg_storage<Arg, MatchesProjection, DescribeProjection>;
        };
 
        template <typename T>
        using to_arg_storage_t = typename to_arg_storage<T>::type;
    }
 
    template <typename Predicate, typename... AdditionalArgs>
        requires std::is_move_constructible_v<Predicate>
                && (... && std::is_move_constructible_v<AdditionalArgs>)
    class PredicateMatcher
    {
    private:
        using storage_t = std::tuple<detail::to_arg_storage_t<AdditionalArgs>...>;
        template <typename T>
        using matches_reference_t = typename detail::to_arg_storage_t<T>::matches_reference;
 
    public:
        [[nodiscard]]
        explicit constexpr PredicateMatcher(
            Predicate predicate,
            StringT fmt,
            StringT invertedFmt,
            std::tuple<AdditionalArgs...> additionalArgs = {}
        ) noexcept(std::is_nothrow_move_constructible_v<Predicate>
                    && (... && std::is_nothrow_move_constructible_v<AdditionalArgs>))
            : m_Predicate{std::move(predicate)},
            m_FormatString{std::move(fmt)},
            m_InvertedFormatString{std::move(invertedFmt)},
            m_AdditionalArgs{std::move(additionalArgs)}
        {
        }
 
        template <typename T>
            requires std::predicate<
                const Predicate&,
                T&,
                matches_reference_t<AdditionalArgs>...>
        [[nodiscard]]
        constexpr bool matches(
            T& target
        ) const noexcept(std::is_nothrow_invocable_v<const Predicate&, T&, matches_reference_t<AdditionalArgs>...>)
        {
            return std::apply(
                [&, this](auto&... additionalArgs)
                {
                    return std::invoke(
                        m_Predicate,
                        target,
                        additionalArgs.as_matches_arg()...);
                },
                m_AdditionalArgs);
        }
 
        [[nodiscard]]
        constexpr StringT describe() const
        {
            return std::apply(
                [&, this](auto&... additionalArgs)
                {
                    return format::vformat(
                        m_FormatString,
                        format::make_format_args(
                            std::invoke(
                                // std::make_format_args requires lvalue-refs, so let's transform rvalue-refs to const lvalue-refs
                                [](auto&& val) noexcept -> const auto& { return val; },
                                additionalArgs.as_describe_arg())
                            ...));
                },
                m_AdditionalArgs);
        }
 
        [[nodiscard]]
        constexpr auto operator !() const &
            requires std::is_copy_constructible_v<Predicate>
                    && std::is_copy_constructible_v<storage_t>
        {
            return make_inverted(
                m_Predicate,
                m_InvertedFormatString,
                m_FormatString,
                m_AdditionalArgs);
        }
 
        [[nodiscard]]
        constexpr auto operator !() &&
        {
            return make_inverted(
                std::move(m_Predicate),
                std::move(m_InvertedFormatString),
                std::move(m_FormatString),
                std::move(m_AdditionalArgs));
        }
 
    private:
        [[no_unique_address]] Predicate m_Predicate;
        StringT m_FormatString;
        StringT m_InvertedFormatString;
        storage_t m_AdditionalArgs;
 
        template <typename Fn>
        [[nodiscard]]
        static constexpr auto make_inverted(
            Fn&& fn,
            StringT fmt,
            StringT invertedFmt,
            storage_t tuple
        )
        {
            using NotFnT = decltype(std::not_fn(std::forward<Fn>(fn)));
            return PredicateMatcher<NotFnT, detail::to_arg_storage_t<AdditionalArgs>...>{
                std::not_fn(std::forward<Fn>(fn)),
                std::move(fmt),
                std::move(invertedFmt),
                std::move(tuple)
            };
        }
    };
 
    class WildcardMatcher
    {
    public:
        static constexpr bool matches([[maybe_unused]] auto&& target) noexcept
        {
            return true;
        }
 
        static constexpr StringViewT describe() noexcept
        {
            return "has no constraints";
        }
    };
}
 
namespace mimicpp::matches
{
    [[maybe_unused]] inline constexpr WildcardMatcher _{};
 
    template <typename T>
    [[nodiscard]]
    constexpr auto eq(T&& value)
    {
        return PredicateMatcher{
            std::equal_to{},
            "== {}",
            "!= {}",
            std::tuple{std::forward<T>(value)}
        };
    }
 
    template <typename T>
    [[nodiscard]]
    constexpr auto ne(T&& value)
    {
        return PredicateMatcher{
            std::not_equal_to{},
            "!= {}",
            "== {}",
            std::tuple{std::forward<T>(value)}
        };
    }
 
    template <typename T>
    [[nodiscard]]
    constexpr auto lt(T&& value)
    {
        return PredicateMatcher{
            std::less{},
            "< {}",
            ">= {}",
            std::tuple{std::forward<T>(value)}
        };
    }
 
    template <typename T>
    [[nodiscard]]
    constexpr auto le(T&& value)
    {
        return PredicateMatcher{
            std::less_equal{},
            "<= {}",
            "> {}",
            std::tuple{std::forward<T>(value)}
        };
    }
 
    template <typename T>
    [[nodiscard]]
    constexpr auto gt(T&& value)
    {
        return PredicateMatcher{
            std::greater{},
            "> {}",
            "<= {}",
            std::tuple{std::forward<T>(value)}
        };
    }
 
    template <typename T>
    [[nodiscard]]
    constexpr auto ge(T&& value)
    {
        return PredicateMatcher{
            std::greater_equal{},
            ">= {}",
            "< {}",
            std::tuple{std::forward<T>(value)}
        };
    }
 
    template <typename UnaryPredicate>
    [[nodiscard]]
    constexpr auto predicate(
        UnaryPredicate&& predicate,
        StringT description = "passes predicate",
        StringT invertedDescription = "fails predicate"
    )
    {
        return PredicateMatcher{
            std::forward<UnaryPredicate>(predicate),
            std::move(description),
            std::move(invertedDescription),
        };
    }
 
    template <satisfies<std::is_lvalue_reference> T>
    [[nodiscard]]
    constexpr auto instance(T&& instance)  // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        return PredicateMatcher{
            [](const std::remove_cvref_t<T>& target, const auto* instancePtr) noexcept
            {
                return std::addressof(target) == instancePtr;
            },
            "is instance at {}",
            "is not instance at {}",
            std::tuple{std::addressof(instance)}
        };
    }
 
}
 
namespace mimicpp
{
    struct case_insensitive_t
    {
    } constexpr case_insensitive{};
}
 
namespace mimicpp::matches::detail
{
    template <string String>
    [[nodiscard]]
    constexpr auto make_view(String&& str)
    {
        using traits_t = string_traits<std::remove_cvref_t<String>>;
        return traits_t::view(std::forward<String>(str));
    }
 
    template <case_foldable_string String>
    [[nodiscard]]
    constexpr auto make_case_folded_string(String&& str)
    {
        return std::invoke(
            string_case_fold_converter<string_char_t<String>>{},
            detail::make_view(std::forward<String>(str)));
    }
 
    template <string Target, string Pattern>
    constexpr void check_string_compatibility() noexcept
    {
        static_assert(
            std::same_as<
                string_char_t<Target>,
                string_char_t<Pattern>>,
            "Pattern and target string must have the same character-type.");
    }
}
 
namespace mimicpp::matches::str
{
    template <string Pattern>
    [[nodiscard]]
    constexpr auto eq(Pattern&& pattern)
    {
        return PredicateMatcher{
            []<string T, typename Stored>(T&& target, Stored&& stored)
            {
                detail::check_string_compatibility<T, Pattern>();
 
                return std::ranges::equal(
                    detail::make_view(std::forward<T>(target)),
                    detail::make_view(std::forward<Stored>(stored)));
            },
            "is equal to {}",
            "is not equal to {}",
            std::tuple{std::forward<Pattern>(pattern)}
        };
    }
 
    template <case_foldable_string Pattern>
    [[nodiscard]]
    constexpr auto eq(Pattern&& pattern, [[maybe_unused]] const case_insensitive_t)
    {
        return PredicateMatcher{
            []<case_foldable_string T, typename Stored>(T&& target, Stored&& stored)
            {
                detail::check_string_compatibility<T, Pattern>();
 
                return std::ranges::equal(
                    detail::make_case_folded_string(std::forward<T>(target)),
                    detail::make_case_folded_string(std::forward<Stored>(stored)));
            },
            "is case-insensitively equal to {}",
            "is case-insensitively not equal to {}",
            std::tuple{std::forward<Pattern>(pattern)}
        };
    }
 
    template <string Pattern>
    [[nodiscard]]
    constexpr auto starts_with(Pattern&& pattern)
    {
        return PredicateMatcher{
            []<string T, typename Stored>(T&& target, Stored&& stored)
            {
                detail::check_string_compatibility<T, Pattern>();
 
                auto patternView = detail::make_view(std::forward<Stored>(stored));
                const auto [ignore, patternIter] = std::ranges::mismatch(
                    detail::make_view(std::forward<T>(target)),
                    patternView);
 
                return patternIter == std::ranges::end(patternView);
            },
            "starts with {}",
            "starts not with {}",
            std::tuple{std::forward<Pattern>(pattern)}
        };
    }
 
    template <string Pattern>
    [[nodiscard]]
    constexpr auto starts_with(Pattern&& pattern, [[maybe_unused]] const case_insensitive_t)
    {
        return PredicateMatcher{
            []<string T, typename Stored>(T&& target, Stored&& stored)
            {
                detail::check_string_compatibility<T, Pattern>();
 
                auto caseFoldedPattern = detail::make_case_folded_string(std::forward<Stored>(stored));
                const auto [ignore, patternIter] = std::ranges::mismatch(
                    detail::make_case_folded_string(std::forward<T>(target)),
                    caseFoldedPattern);
 
                return patternIter == std::ranges::end(caseFoldedPattern);
            },
            "case-insensitively starts with {}",
            "case-insensitively starts not with {}",
            std::tuple{std::forward<Pattern>(pattern)}
        };
    }
 
    template <string Pattern>
    [[nodiscard]]
    constexpr auto ends_with(Pattern&& pattern)
    {
        return PredicateMatcher{
            []<string T, typename Stored>(T&& target, Stored&& stored)
            {
                detail::check_string_compatibility<T, Pattern>();
 
                auto patternView = detail::make_view(std::forward<Stored>(stored))
                                    | std::views::reverse;
                const auto [ignore, patternIter] = std::ranges::mismatch(
                    detail::make_view(std::forward<T>(target)) | std::views::reverse,
                    patternView);
 
                return patternIter == std::ranges::end(patternView);
            },
            "ends with {}",
            "ends not with {}",
            std::tuple{std::forward<Pattern>(pattern)}
        };
    }
 
    template <string Pattern>
    [[nodiscard]]
    constexpr auto ends_with(Pattern&& pattern, [[maybe_unused]] const case_insensitive_t)
    {
        return PredicateMatcher{
            []<string T, typename Stored>(T&& target, Stored&& stored)
            {
                detail::check_string_compatibility<T, Pattern>();
 
                auto caseFoldedPattern = detail::make_case_folded_string(std::forward<Stored>(stored))
                                        | std::views::reverse;
                const auto [ignore, patternIter] = std::ranges::mismatch(
                    detail::make_case_folded_string(std::forward<T>(target)) | std::views::reverse,
                    caseFoldedPattern);
 
                return patternIter == std::ranges::end(caseFoldedPattern);
            },
            "case-insensitively ends with {}",
            "case-insensitively ends not with {}",
            std::tuple{std::forward<Pattern>(pattern)}
        };
    }
 
    template <string Pattern>
    [[nodiscard]]
    constexpr auto contains(Pattern&& pattern)
    {
        return PredicateMatcher{
            []<string T, typename Stored>(T&& target, Stored&& stored)
            {
                detail::check_string_compatibility<T, Pattern>();
 
                auto patternView = detail::make_view(std::forward<Stored>(stored));
                return std::ranges::empty(patternView)
                        || !std::ranges::empty(
                            std::ranges::search(
                                detail::make_view(std::forward<T>(target)),
                                std::move(patternView)));
            },
            "contains {}",
            "contains not {}",
            std::tuple{std::forward<Pattern>(pattern)}
        };
    }
 
    template <string Pattern>
    [[nodiscard]]
    constexpr auto contains(Pattern&& pattern, [[maybe_unused]] const case_insensitive_t)
    {
        return PredicateMatcher{
            []<string T, typename Stored>(T&& target, Stored&& stored)
            {
                detail::check_string_compatibility<T, Pattern>();
 
                auto patternView = detail::make_case_folded_string(std::forward<Stored>(stored));
                auto targetView = detail::make_case_folded_string(std::forward<T>(target));
                return std::ranges::empty(patternView)
                        || !std::ranges::empty(std::ranges::search(targetView, patternView));
            },
            "case-insensitively contains {}",
            "case-insensitively contains not {}",
            std::tuple{std::forward<Pattern>(pattern)}
        };
    }
 
}
 
namespace mimicpp::matches::range
{
    template <std::ranges::forward_range Range, typename Comparator = std::equal_to<>>
    [[nodiscard]]
    constexpr auto eq(Range&& expected, Comparator comparator = Comparator{})
    {
        return PredicateMatcher{
            [comp = std::move(comparator)]
            <typename Target>(Target&& target, auto& range)  // NOLINT(cppcoreguidelines-missing-std-forward)
                requires std::predicate<
                    const Comparator&,
                    std::ranges::range_reference_t<Target>,
                    std::ranges::range_reference_t<Range>>
            {
                return std::ranges::equal(
                    target,
                    range,
                    std::ref(comp));
            },
            "elements are {}",
            "elements are not {}",
            std::tuple{std::views::all(std::forward<Range>(expected))}
        };
    }
 
    template <std::ranges::forward_range Range, typename Comparator = std::equal_to<>>
    [[nodiscard]]
    constexpr auto unordered_eq(Range&& expected, Comparator comparator = Comparator{})
    {
        return PredicateMatcher{
            [comp = std::move(comparator)]<typename Target
            >(Target&& target, auto& range)  // NOLINT(cppcoreguidelines-missing-std-forward)
                requires std::predicate<
                    const Comparator&,
                    std::ranges::range_reference_t<Target>,
                    std::ranges::range_reference_t<Range>>
            {
                return std::ranges::is_permutation(
                    target,
                    range,
                    std::ref(comp));
            },
            "is a permutation of {}",
            "is not a permutation of {}",
            std::tuple{std::views::all(std::forward<Range>(expected))}
        };
    }
 
    template <typename Relation = std::ranges::less>
    [[nodiscard]]
    constexpr auto is_sorted(Relation relation = Relation{})
    {
        return PredicateMatcher{
            [rel = std::move(relation)]<typename Target>(Target&& target)  // NOLINT(cppcoreguidelines-missing-std-forward)
                requires std::equivalence_relation<
                    const Relation&,
                    std::ranges::range_reference_t<Target>,
                    std::ranges::range_reference_t<Target>>
            {
                return std::ranges::is_sorted(
                    target,
                    std::ref(rel));
            },
            "is a sorted range",
            "is an unsorted range"
        };
    }
 
    [[nodiscard]]
    constexpr auto is_empty()
    {
        return PredicateMatcher{
            [](std::ranges::range auto&& target)
            {
                return std::ranges::empty(target);
            },
            "is an empty range",
            "is not an empty range"
        };
    }
 
    [[nodiscard]]
    constexpr auto has_size(const std::integral auto expected)
    {
        return PredicateMatcher{
            [](std::ranges::range auto&& target, const std::integral auto size)
            {
                return std::cmp_equal(
                    size,
                    std::ranges::size(target));
            },
            "has size of {}",
            "has different size than {}",
            std::tuple{expected}
        };
    }
 
    template <typename Matcher>
    [[nodiscard]]
    constexpr auto each_element(Matcher&& matcher)
    {
        using MatcherT = std::remove_cvref_t<Matcher>;
        return PredicateMatcher{
            [](std::ranges::range auto&& target, const MatcherT& m)
            {
                return std::ranges::all_of(
                    target,
                    [&](const auto& element) { return m.matches(element); });
            },
            "each el in range: el {}",
            "not each el in range: el {}",
            std::tuple{
                mimicpp::detail::arg_storage<
                    MatcherT,
                    std::identity,
                    decltype([](const auto& m) { return mimicpp::detail::describe_hook::describe(m); })>{
                    std::forward<MatcherT>(matcher)
                }
            }
        };
    }
 
    template <typename Matcher>
    [[nodiscard]]
    constexpr auto any_element(Matcher&& matcher)
    {
        using MatcherT = std::remove_cvref_t<Matcher>;
        return PredicateMatcher{
            [](std::ranges::range auto&& target, const MatcherT& m)
            {
                return std::ranges::any_of(
                    target,
                    [&](const auto& element) { return m.matches(element); });
            },
            "any el in range: el {}",
            "none el in range: el {}",
            std::tuple{
                mimicpp::detail::arg_storage<
                    MatcherT,
                    std::identity,
                    decltype([](const auto& m) { return mimicpp::detail::describe_hook::describe(m); })>{
                    std::forward<MatcherT>(matcher)
                }
            }
        };
    }
 
}
 
#endif