yaml_file_provider_impl.ipp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <map>
#include <sstream>
 
#include "yaml-cpp/yaml.h"
 
#include "porytiles2/domain/repos/tileset_artifact_key_provider.hpp"
#include "porytiles2/infra/config/config_provider.hpp"
#include "porytiles2/utilities/text/text_formatter.hpp"
 
// The anonymous namespace ensures internal linkage per translation unit
// This file is intentionally included only in yaml_file_provider.cpp
namespace {
 
using namespace porytiles2;
 
// Static caches shared across all YamlFileProvider instances
std::map<std::filesystem::path, YAML::Node> yaml_cache;
std::map<std::filesystem::path, std::vector<std::string>> file_lines_cache;
 
std::string get_line_content(const std::filesystem::path &path, std::size_t line_num)
{
    const auto it = file_lines_cache.find(path);
    if (it != file_lines_cache.end() && line_num < it->second.size()) {
        return it->second[line_num];
    }
    return "";
}
 
std::string make_source_string(const TextFormatter *format, const std::string &file_path, const YAML::Mark &mark)
{
    return format->format("{}:{}", FormatParam{file_path}, FormatParam{mark.line + 1});
}
 
std::vector<std::string> make_source_details(
    const TextFormatter *format, const std::string &file_path, const YAML::Mark &mark, std::size_t window_size = 7)
{
    std::vector<std::string> details;
 
    const std::filesystem::path path{file_path};
    const auto it = file_lines_cache.find(path);
    if (it == file_lines_cache.end()) {
        return details;
    }
 
    const auto &lines = it->second;
    const std::size_t line_num = mark.line; // 0-indexed
 
    if (lines.empty() || line_num >= lines.size()) {
        return details;
    }
 
    // Calculate window boundaries
    const std::size_t half_window = (window_size - 1) / 2;
    const std::size_t start = (line_num >= half_window) ? line_num - half_window : 0;
    const std::size_t end = std::min(line_num + half_window + 1, lines.size());
 
    // Build contextual view
    for (std::size_t i = start; i < end; ++i) {
        const auto formatted_arrow =
            format->format("{}", FormatParam{"-> ", Style::bold | Style::italic | Style::yellow});
        const std::string prefix = (i == line_num) ? formatted_arrow : "   ";
 
        if (i == line_num) {
            // TODO: the spaces after the line number ":" are hardcoded
            // If a user supplies a YAML file with 1000+ lines, it will mess up the formatting.
            const auto highlight_line =
                format->format("{}", FormatParam{lines[i], Style::bold | Style::italic | Style::yellow});
            details.push_back(prefix + std::to_string(i + 1) + ":   " + highlight_line);
        }
        else {
            details.push_back(prefix + std::to_string(i + 1) + ":   " + lines[i]);
        }
    }
 
    return details;
}
 
LayerValue<std::size_t>
parse_size_t(const TextFormatter *format, const YAML::Node &node, const std::string &key, const std::string &file_path)
{
    if (!node.IsDefined()) {
        return LayerValue<std::size_t>::not_provided();
    }
 
    try {
        const auto value = node.as<std::size_t>();
        const auto mark = node.Mark();
        const auto source = make_source_string(format, file_path, mark);
        const auto details = make_source_details(format, file_path, mark);
        return LayerValue<std::size_t>::valid(value, source, details);
    }
    catch (const YAML::Exception &e) {
        const auto mark = node.Mark();
        const auto error =
            format->format("failed to parse '{}' as std::size_t: {}", FormatParam{key, Style::bold}, e.what());
        const auto source = make_source_string(format, file_path, mark);
        const auto details = make_source_details(format, file_path, mark);
        return LayerValue<std::size_t>::invalid(error, source, details);
    }
}
 
LayerValue<bool>
parse_bool(const TextFormatter *format, const YAML::Node &node, const std::string &key, const std::string &file_path)
{
    if (!node.IsDefined()) {
        return LayerValue<bool>::not_provided();
    }
 
    try {
        const auto value = node.as<bool>();
        const auto mark = node.Mark();
        const auto source = make_source_string(format, file_path, mark);
        const auto details = make_source_details(format, file_path, mark);
        return LayerValue<bool>::valid(value, source, details);
    }
    catch (const YAML::Exception &e) {
        const auto mark = node.Mark();
        const auto error = format->format("failed to parse '{}' as bool: {}", FormatParam{key, Style::bold}, e.what());
        const auto source = make_source_string(format, file_path, mark);
        const auto details = make_source_details(format, file_path, mark);
        return LayerValue<bool>::invalid(error, source, details);
    }
}
 
LayerValue<Rgba32>
parse_rgba32(const TextFormatter *format, const YAML::Node &node, const std::string &key, const std::string &file_path)
{
    if (!node.IsDefined()) {
        return LayerValue<Rgba32>::not_provided();
    }
 
    try {
        const auto mark = node.Mark();
        const auto details = make_source_details(format, file_path, mark);
 
        if (!node.IsSequence()) {
            const auto error =
                format->format("'{}' must be a sequence [r, g, b] or [r, g, b, a]", FormatParam{key, Style::bold});
            const auto source = make_source_string(format, file_path, mark);
            return LayerValue<Rgba32>::invalid(error, source, details);
        }
 
        if (node.size() < 3 || node.size() > 4) {
            const auto error = format->format(
                "'{}' must have 3 or 4 elements [r, g, b] or [r, g, b, a], got {}",
                FormatParam{key, Style::bold},
                FormatParam{node.size(), Style::bold});
            const auto source = make_source_string(format, file_path, mark);
            return LayerValue<Rgba32>::invalid(error, source, details);
        }
 
        const auto r = node[0].as<std::uint8_t>();
        const auto g = node[1].as<std::uint8_t>();
        const auto b = node[2].as<std::uint8_t>();
        const auto a = (node.size() == 4) ? node[3].as<std::uint8_t>() : Rgba32::alpha_opaque;
 
        const Rgba32 color{r, g, b, a};
        const auto source = make_source_string(format, file_path, mark);
        return LayerValue<Rgba32>::valid(color, source, details);
    }
    catch (const YAML::Exception &e) {
        const auto mark = node.Mark();
        const auto error =
            format->format("failed to parse '{}' as Rgba32: {}", FormatParam{key, Style::bold}, e.what());
        const auto source = make_source_string(format, file_path, mark);
        const auto details = make_source_details(format, file_path, mark);
        return LayerValue<Rgba32>::invalid(error, source, details);
    }
}
 
LayerValue<TilesPalMode> parse_tiles_pal_mode(
    const TextFormatter *format, const YAML::Node &node, const std::string &key, const std::string &file_path)
{
    if (!node.IsDefined()) {
        return LayerValue<TilesPalMode>::not_provided();
    }
 
    try {
        const auto mark = node.Mark();
        const auto details = make_source_details(format, file_path, mark);
        const auto str = node.as<std::string>();
        const auto mode_opt = tiles_pal_mode_from_str(str);
 
        if (!mode_opt.has_value()) {
            const auto error = format->format(
                "'{}' has invalid value '{}', expected 'true-color' or 'greyscale'",
                FormatParam{key, Style::bold},
                FormatParam{str, Style::bold});
            const auto source = make_source_string(format, file_path, mark);
            return LayerValue<TilesPalMode>::invalid(error, source, details);
        }
 
        const auto source = make_source_string(format, file_path, mark);
        return LayerValue<TilesPalMode>::valid(mode_opt.value(), source, details);
    }
    catch (const YAML::Exception &e) {
        const auto mark = node.Mark();
        const auto error =
            format->format("failed to parse '{}' as TilesPalMode: {}", FormatParam{key, Style::bold}, e.what());
        const auto source = make_source_string(format, file_path, mark);
        const auto details = make_source_details(format, file_path, mark);
        return LayerValue<TilesPalMode>::invalid(error, source, details);
    }
}
 
std::optional<YAML::Node> load_yaml_file(const std::filesystem::path &path)
{
    // Check cache first
    const auto cache_it = yaml_cache.find(path);
    if (cache_it != yaml_cache.end()) {
        return cache_it->second;
    }
 
    // File doesn't exist, return nullopt
    if (!std::filesystem::exists(path)) {
        return std::nullopt;
    }
 
    // Try to load and cache the file
    try {
        auto node = YAML::LoadFile(path.string());
        yaml_cache[path] = node;
 
        // Also cache the file contents line-by-line for source info
        std::ifstream file{path};
        std::vector<std::string> lines;
        std::string line;
        while (std::getline(file, line)) {
            lines.push_back(line);
        }
        file_lines_cache[path] = std::move(lines);
 
        return node;
    }
    catch (const YAML::Exception &) {
        // Failed to parse YAML, return nullopt
        return std::nullopt;
    }
}
 
std::vector<std::filesystem::path> get_tileset_config_path_chain(
    const std::filesystem::path &project_root,
    const TilesetArtifactKeyProvider *key_provider,
    const std::string &tileset)
{
    /*
     * TODO: once we add layout support, we'll need a separate method to resolve the config path chain for layouts,
     * since layouts will have their own LayoutArtifactKeyProvider.
     */
 
    std::vector<std::filesystem::path> paths;
 
    // Get tileset-specific config paths using the key provider
    using enum TilesetArtifact::Type;
    const auto tileset_local_config_key = key_provider->key_for(tileset, TilesetArtifact{local_config});
    const auto tileset_config_key = key_provider->key_for(tileset, TilesetArtifact{config});
 
    // Priority order (highest to lowest):
    // 1. tileset_folder/porytiles.local.yaml
    paths.push_back(std::filesystem::path{tileset_local_config_key.key()});
 
    // 2. tileset_folder/porytiles.yaml
    paths.push_back(std::filesystem::path{tileset_config_key.key()});
 
    // 3. project_root/porytiles.local.yaml
    paths.push_back(project_root / "porytiles.local.yaml");
 
    // 4. project_root/porytiles.yaml
    paths.push_back(project_root / "porytiles.yaml");
 
    return paths;
}
 
template <typename T, typename LoadFunc, typename NodeExtractFunc, typename ParseFunc>
LayerValue<T> search_config_files(
    const TextFormatter *format,
    const std::vector<std::filesystem::path> &paths,
    LoadFunc load_func,
    NodeExtractFunc extract_node_func,
    ParseFunc parse_func,
    const std::string &key)
{
    for (const auto &path : paths) {
        const auto yaml_doc = load_func(path);
        if (!yaml_doc.has_value()) {
            // File doesn't exist or couldn't be loaded, try next file
            continue;
        }
 
        try {
            const auto node = extract_node_func(yaml_doc.value());
            const auto result = parse_func(format, node, key, path.string());
 
            // If we got a valid value or an error, return it immediately
            if (result.state == ValidationState::valid || result.state == ValidationState::invalid) {
                return result;
            }
 
            // If not_provided, continue to next file
        }
        catch (const YAML::Exception &) {
            // Node extraction or parsing threw an exception, treat as not_provided for this file
            // and continue to the next file
            continue;
        }
    }
 
    // Not found in any file
    return LayerValue<T>::not_provided();
}
 
} // namespace