stgen3/markdown.cpp

#include "markdown.h"

using namespace mmd;

int instances = 0;

std::unordered_map<std::string, std::string> markdown_parser::get_all_metavalues(mmd_engine *engine) {
    char *key_cstr = mmd_engine_metadata_keys(engine);

    if (!key_cstr) {
        free(key_cstr);
        return {};
    }

    std::string_view key_str (key_cstr);
    std::istringstream keyss (key_cstr);

    std::unordered_map<std::string, std::string> keys;

    for (std::string key; std::getline(keyss, key); ) {
        char *value = mmd_engine_metavalue_for_key(engine, key.c_str());

        if (!value) {
            spdlog::error("get_all_metavalues(): MMD lib error");
        }

        keys.emplace(std::string(key), std::string(value));
    }

    free(key_cstr);
    return keys;
}

markdown_parser::markdown_parser() {
    if (instances++ == 0) 
    token_pool_init(); 
}
markdown_parser::markdown_parser(std::string text) {
    if (instances++ == 0) 
        token_pool_init(); 

    engine = mmd_engine_create_with_string(text.c_str(), extensions);
}
markdown_parser::markdown_parser(std::string text, unsigned long extensions) {
    if (instances++ == 0) 
        token_pool_init(); 

    engine = mmd_engine_create_with_string(text.c_str(), extensions);
}



markdown_parser::markdown_parser(unsigned long extensions) : extensions(extensions) {
    if (instances++ == 0) 
        token_pool_init(); 
}

markdown_parser::~markdown_parser() {
    if (--instances == 0) {
        token_pool_drain();
        token_pool_free();
    }
}

std::string markdown_parser::parse_to_html() {
    assert(engine);
    char *markdown = mmd_engine_convert(engine, FORMAT_HTML);
    std::string retval (markdown);

    free(markdown);
    return retval;
}


std::string markdown_parser::parse_to_html(std::string const &s) {
    char *markdown = mmd::mmd_string_convert(s.c_str(), extensions, FORMAT_HTML, language);
    std::string retval (markdown);

    free(markdown);
    return retval;
}


std::optional<std::string> markdown_parser::get_property(std::string const &file, std::string const &key) {
    mmd_engine *e = mmd_engine_create_with_string(file.c_str(), extensions);

    char *c_str_val = mmd_engine_metavalue_for_key(e, key.c_str());

    if (c_str_val) {
        std::string value {c_str_val};
        mmd_engine_free(e,true);
        return value;
    } else {
        mmd_engine_free(e,true);
        return {};

    }
}

std::unordered_map<std::string, std::string> markdown_parser::get_all_metavalues() {
    assert(engine);
    if (!engine) {
        spdlog::error("get_all_metavalues: No Engine");
        assert(engine);
        //exit(223);
    }
    return get_all_metavalues(engine);
}

std::unordered_map<std::string, std::string> markdown_parser::get_all_metavalues(std::string const &file_text) {
    mmd_engine *e = mmd_engine_create_with_string(file_text.c_str(), extensions);
    auto values = get_all_metavalues(e);
    mmd_engine_free(e,true);
    return values;
}


std::string markdown_parser::cut_frontmatter(std::string const &text) {
    auto newline = text.find("\n\n");
    auto endblock = text.find("---\n");
    auto endblock2 = text.find("---\n", endblock);
    std::string::size_type subst {};

    if (!get_property(text, "title")) {
        // doesnt have frontmatter
        return text;
    }

    if (endblock == std::string::npos) {
        if (newline != std::string::npos) 
            subst = newline;
        else 
            subst = 0;
    } else if (endblock != 0) {
        if (newline < endblock)
            subst = newline;
        else if (endblock < newline)
            subst = endblock;
    } else {
        if (endblock2 < newline) 
            subst = endblock2;
        else if (newline < endblock2) 
            subst = newline;
    }

    return text.substr(subst);
}