version_constraint.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <commons/semver.hpp>
#include <commons/types.hpp>
 
#include <algorithm>
#include <format>
#include <functional>
#include <ostream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
 
namespace comms {
 
class VersionConstraint {
    enum class Op { Any, Eq, Neq, Gt, Gte, Lt, Lte, Caret, Tilde };
 
    struct Matcher {
        Op op = Op::Any;
        SemVer ver;
    };
 
    std::string raw_;
    std::vector<Matcher> matchers_;
 
public:
    VersionConstraint() = default;
 
    [[nodiscard]] static VersionConstraint parse(const std::string_view s) {
        VersionConstraint vc;
        vc.raw_ = std::string{s};
 
        for (const auto part : split(s)) {
            vc.matchers_.push_back(parse_single(part));
        }
        if (vc.matchers_.empty()) {
            vc.matchers_.push_back(Matcher{});  // Op::Any by default
        }
        return vc;
    }
 
    [[nodiscard]] bool satisfies(const SemVer& v) const {
        return std::ranges::all_of(matchers_, [&v](const Matcher& m) { return matches(m, v); });
    }
 
    [[nodiscard]] const std::string& raw() const noexcept {
        return raw_;
    }
 
    [[nodiscard]] std::string to_string() const {
        return raw_;
    }
 
    [[nodiscard]] bool operator==(const VersionConstraint& o) const {
        return raw_ == o.raw_;
    }
 
private:
    [[nodiscard]] static bool matches(const Matcher& m, const SemVer& v) {
        switch (m.op) {
        case Op::Any:
            return true;
        case Op::Eq:
            return v == m.ver;
        case Op::Neq:
            return v != m.ver;
        case Op::Gt:
            return v > m.ver;
        case Op::Gte:
            return v >= m.ver;
        case Op::Lt:
            return v < m.ver;
        case Op::Lte:
            return v <= m.ver;
        case Op::Caret:
            return caret_matches(m.ver, v);
        case Op::Tilde:
            return tilde_matches(m.ver, v);
        }
        return false;
    }
 
    [[nodiscard]] static bool caret_matches(const SemVer& constraint, const SemVer& v) {
        if (v < constraint) {
            return false;
        }
        if (constraint.major != 0) {
            return v.major == constraint.major;
        }
        if (constraint.minor != 0) {
            return v.major == 0 && v.minor == constraint.minor;
        }
        return v.major == 0 && v.minor == 0 && v.patch == constraint.patch;
    }
 
    [[nodiscard]] static bool tilde_matches(const SemVer& constraint, const SemVer& v) {
        if (v < constraint) {
            return false;
        }
        return v.major == constraint.major && v.minor == constraint.minor;
    }
 
    [[nodiscard]] static Matcher parse_single(std::string_view s) {
        while (!s.empty() && s.front() == ' ') {
            s.remove_prefix(1);
        }
        while (!s.empty() && s.back() == ' ') {
            s.remove_suffix(1);
        }
 
        if (s.empty() || s == "*") {
            return Matcher{};  // Op::Any by default
        }
 
        // Two-char operators are checked before their one-char prefixes.
        if (s.starts_with(">=")) {
            return Matcher{.op = Op::Gte, .ver = require(s.substr(2), s)};
        }
        if (s.starts_with("<=")) {
            return Matcher{.op = Op::Lte, .ver = require(s.substr(2), s)};
        }
        if (s.starts_with("!=")) {
            return Matcher{.op = Op::Neq, .ver = require(s.substr(2), s)};
        }
        if (s.starts_with("^")) {
            return Matcher{.op = Op::Caret, .ver = require(s.substr(1), s)};
        }
        if (s.starts_with("~")) {
            return Matcher{.op = Op::Tilde, .ver = require(s.substr(1), s)};
        }
        if (s.starts_with(">")) {
            return Matcher{.op = Op::Gt, .ver = require(s.substr(1), s)};
        }
        if (s.starts_with("<")) {
            return Matcher{.op = Op::Lt, .ver = require(s.substr(1), s)};
        }
        return Matcher{.op = Op::Eq, .ver = require(s, s)};
    }
 
    [[nodiscard]] static SemVer require(const std::string_view ver, const std::string_view token) {
        const auto parsed = SemVer::parse(ver);
        if (!parsed) {
            throw std::invalid_argument{"commons: invalid version in constraint: " +
                                        std::string{token}};
        }
        return *parsed;
    }
 
    [[nodiscard]] static std::vector<std::string_view> split(std::string_view s) {
        std::vector<std::string_view> parts;
        while (!s.empty()) {
            while (!s.empty() && s.front() == ' ') {
                s.remove_prefix(1);
            }
            if (s.empty()) {
                break;
            }
 
            usize end = 0;
            bool in_version = false;
            for (usize i = 0; i < s.size(); ++i) {
                if (s[i] != ' ') {
                    continue;
                }
                usize next = i + 1;
                while (next < s.size() && s[next] == ' ') {
                    ++next;
                }
                if (next < s.size()) {
                    if (const char nc = s[next]; nc == '^' || nc == '~' || nc == '>' || nc == '<' ||
                                                 nc == '!' || nc == '=' ||
                                                 (nc >= '0' && nc <= '9')) {
                        end = i;
                        in_version = true;
                        break;
                    }
                }
            }
 
            if (in_version) {
                parts.push_back(s.substr(0, end));
                s.remove_prefix(end);
            } else {
                parts.push_back(s);
                break;
            }
        }
        return parts;
    }
};
 
// ---------------------------------------------------------------------------
// Text output: to_string + std::ostream insertion. (std::format support is the
// std::formatter specialization below, outside namespace comms.)
// ---------------------------------------------------------------------------
 
[[nodiscard]] inline std::string to_string(const VersionConstraint& v) {
    return v.to_string();
}
 
inline std::ostream& operator<<(std::ostream& os, const VersionConstraint& v) {
    return os << v.raw();
}
 
}  // namespace comms
 
// ---------------------------------------------------------------------------
// std::format and std::hash support. The specializations live in namespace std
// (the primary templates are visible), like nlohmann's adl_serializer route in
// json.hpp.
// ---------------------------------------------------------------------------
 
// This spec-less formatter reads no member state, but `std::formatter` requires
// `parse`/`format` to be non-static members — so silence the convert-to-static
// suggestion here.
// NOLINTBEGIN(readability-convert-member-functions-to-static)
 
template <>
struct std::formatter<comms::VersionConstraint> {
    constexpr auto parse(const std::format_parse_context& ctx) {
        const auto* it = ctx.begin();
        if (it != ctx.end() && *it != '}') {
            throw std::format_error("commons: VersionConstraint takes no format spec");
        }
        return it;
    }
 
    auto format(const comms::VersionConstraint& v, std::format_context& ctx) const {
        return std::format_to(ctx.out(), "{}", v.raw());
    }
};
 
// NOLINTEND(readability-convert-member-functions-to-static)
 
template <>
struct std::hash<comms::VersionConstraint> {
    [[nodiscard]] std::size_t operator()(const comms::VersionConstraint& v) const noexcept {
        return std::hash<std::string>{}(v.raw());
    }
};