Stanza.h

// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include <filesystem>
#include <functional>
#include <iostream>
#include <numeric>
#include <set>
#include <vector>
 
#include "Pattern.h"
#include "Person.h"
 
namespace SlKernCVS {

class Stanza {
public:
    using TranslateEmail = std::function<std::string (std::string_view sv)>;
    using Maintainers = std::vector<Person>;
 
    Stanza() = default;
    Stanza(std::string name) : m_name(std::move(name)) {}
    Stanza(std::string n, std::string name, std::string email)
        : m_name(std::move(n)), m_maintainers{Person(RoleType::Maintainer, std::move(name),
                                 std::move(email))} { }
 
    Stanza(const Stanza &) = delete;
    Stanza(Stanza &&) = default;

    unsigned match_path(const std::filesystem::path &path) const {
        return std::accumulate(m_patterns.cbegin(), m_patterns.cend(), 0u,
                       [&path](unsigned m, const Pattern &p) {
            return std::max(m, p.match(path));
        });
    }

    void add_maintainer_and_store(std::string_view maintainer,
                      std::set<std::string> &suse_users,
                      const TranslateEmail &translateEmail) {
        if (auto m = Person::parsePerson(maintainer, RoleType::Maintainer)) {
            suse_users.insert(m->userName());
            // TODO
            m->setEmail(translateEmail(m->email()));
            // END TODO
            m_maintainers.push_back(std::move(*m));
        } else
            std::cerr << "MAINTAINERS: contact " << maintainer <<
                     " cannot be parsed into name and email!\n";
    }

    void add_backporter(const std::string &name, std::string_view email,
                unsigned cnt, const TranslateEmail &translateEmail) {
        m_maintainers.push_back(Person(RoleType::Maintainer, name,
                           /*TODO*/ translateEmail(email), cnt));
    }

    void add_maintainer_if(std::string_view maintainer,
                   const std::set<std::string> &suse_users,
                   const TranslateEmail &translateEmail) {
        if (auto m = Person::parsePerson(maintainer, RoleType::Upstream)) {
            // TODO
            m->setEmail(translateEmail(m->email()));
            // END TODO
            if (suse_users.contains(m->userName()))
                m_maintainers.push_back(std::move(*m));
        } else
            std::cerr << "Upstream MAINTAINERS: contact " << maintainer <<
                     " cannot be parsed into name and email!\n";
    }

    bool add_pattern(std::string pattern) {
        auto p = Pattern::create(std::move(pattern));
        if (!p)
            return false;
        m_patterns.push_back(std::move(*p));
        return true;
    }

    bool empty() const {
        return m_name.empty() || m_maintainers.empty() || m_patterns.empty();
    }

    const Maintainers &maintainers() const { return m_maintainers; }

    void new_entry(std::string n) {
        m_name = std::move(n);
        m_maintainers.clear();
        m_patterns.clear();
    }

    const std::string &name() const { return m_name; }
private:
    std::string m_name;
    Maintainers m_maintainers;
    std::vector<Pattern> m_patterns;
};
 
} // namespace