text.hpp

Go to the documentation of this file.

// text — the small string helpers the parsers share. The two trims differ on
// purpose, and each says what it removes: Markdown keeps a line end that
// matters to it, the other readers drop every kind of space. Header-only,
// plain C++ (ASCII only: no locale).
// Copyright (C) 2026 JigSawFr.  GPLv3-or-later (see LICENSE.GPL).
#pragma once
 
#include <cstring>
#include <string>
#include <vector>
 
namespace text
{
 
inline std::string trim_space(const std::string& s)
{
    const char* ws = " \t\n\v\f\r";
    const size_t a = s.find_first_not_of(ws);
    if (a == std::string::npos)
        return "";
    return s.substr(a, s.find_last_not_of(ws) - a + 1);
}
 
inline std::string trim_space_end(std::string s)
{
    const size_t last = s.find_last_not_of(" \t\n\v\f\r");
    s.erase(last == std::string::npos ? 0 : last + 1);
    return s;
}
 
inline std::string trim_blank(const std::string& s)
{
    const size_t a = s.find_first_not_of(" \t");
    if (a == std::string::npos)
        return "";
    return s.substr(a, s.find_last_not_of(" \t") - a + 1);
}
 
inline std::string lower_ascii(std::string s)
{
    for (char& c : s)
        if (c >= 'A' && c <= 'Z')
            c = (char)(c - 'A' + 'a');
    return s;
}
 
inline std::string capitalise_ascii(std::string s)
{
    if (!s.empty() && s[0] >= 'a' && s[0] <= 'z')
        s[0] = (char)(s[0] - 'a' + 'A');
    return s;
}
 
inline bool starts_with(const std::string& s, const char* prefix)
{
    return s.compare(0, std::strlen(prefix), prefix) == 0;
}
 
inline bool starts_with(const std::string& s, const std::string& prefix)
{
    return s.compare(0, prefix.size(), prefix) == 0;
}
 
inline bool ends_with(const std::string& s, const std::string& suffix)
{
    return s.size() >= suffix.size() && s.compare(s.size() - suffix.size(), suffix.size(), suffix) == 0;
}
 
inline std::vector<std::string> lines(const std::string& s)
{
    std::vector<std::string> out;
    for (size_t start = 0; start <= s.size();)
    {
        size_t end = s.find('\n', start);
        if (end == std::string::npos)
            end = s.size();
        out.push_back(s.substr(start, end - start));
        if (!out.back().empty() && out.back().back() == '\r')
            out.back().pop_back();
        start = end + 1;
    }
    return out;
}
 
inline std::string short_url(const std::string& url)
{
    const size_t scheme = url.find("://");
    return scheme == std::string::npos ? url : url.substr(scheme + 3);
}
 
inline std::string url_encode(const std::string& s)
{
    static const char HEX[] = "0123456789ABCDEF";
    std::string out;
    for (unsigned char c : s)
    {
        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '~')
        {
            out += (char)c;
        }
        else
        {
            out += '%';
            out += HEX[c >> 4];
            out += HEX[c & 0xF];
        }
    }
    return out;
}
 
inline std::string join(const std::vector<std::string>& parts, const std::string& sep)
{
    std::string out;
    for (size_t i = 0; i < parts.size(); i++)
    {
        if (i)
            out += sep;
        out += parts[i];
    }
    return out;
}
 
class ConsoleComments
{
  public:
    enum Step
    {
        Show, 
        Skip, 
        Break, 
        Directive, 
    };
 
    Step next(const std::string& t, std::string& inner)
    {
        if (block_ == Comment)
        {
            if (t.find("-->") != std::string::npos)
                block_ = Plain;
            return Skip;
        }
        if (block_ == Hide)
        {
            if (t == "<!-- /console -->")
                block_ = Plain;
            return Skip;
        }
        if (block_ == Only && t == "-->")
        {
            block_ = Plain;
            return Break;
        }
        if (block_ == Plain && starts_with(t, "<!--"))
        {
            const bool closed = t.size() >= 7 && t.compare(t.size() - 3, 3, "-->") == 0;
            if (t == "<!-- console:hide -->")
            {
                block_ = Hide;
            }
            else if (t == "<!-- console:only")
            {
                block_ = Only;
            }
            else if (closed && starts_with(t, "<!-- console:"))
            {
                inner = trim_space(t.substr(13, t.size() - 16));
                return Directive;
            }
            else if (!closed)
            {
                block_ = Comment;
            }
            return Break;
        }
        return Show;
    }
 
  private:
    enum
    {
        Plain,
        Comment,
        Hide,
        Only
    } block_
        = Plain;
};
 
} // namespace text