tileset_command_setup.hpp

Go to the documentation of this file.

#pragma once
 
#include <filesystem>
#include <memory>
#include <string>
#include <unistd.h>
#include <utility>
#include <vector>
 
#include "CLI/CLI.hpp"
#include "fruit/fruit.h"
#include "gsl/pointers"
 
#include "porytiles/domain/repos/tileset_repo.hpp"
#include "porytiles/domain/services/palette_printer.hpp"
#include "porytiles/domain/services/tile_printer.hpp"
#include "porytiles/domain/services/tileset_compiler.hpp"
#include "porytiles/infra/cli/cli_option_storage.hpp"
#include "porytiles/infra/config/cli_option_provider.hpp"
#include "porytiles/infra/config/default_provider.hpp"
#include "porytiles/infra/config/header_define_provider.hpp"
#include "porytiles/infra/config/lazy_layered_config.hpp"
#include "porytiles/infra/config/yaml_file_provider.hpp"
#include "porytiles/infra/repos/project_artifact_checksum_provider.hpp"
#include "porytiles/infra/repos/project_tileset_artifact_key_provider.hpp"
#include "porytiles/infra/repos/project_tileset_artifact_reader.hpp"
#include "porytiles/infra/repos/project_tileset_artifact_writer.hpp"
#include "porytiles/infra/services/anim_code_generator.hpp"
#include "porytiles/infra/services/anim_code_parser.hpp"
#include "porytiles/infra/services/anim_json_parser.hpp"
#include "porytiles/infra/services/ascii_tile_printer.hpp"
#include "porytiles/infra/services/attributes_csv_loader.hpp"
#include "porytiles/infra/services/color_palette_printer.hpp"
#include "porytiles/infra/services/header_enum_map_provider.hpp"
#include "porytiles/infra/services/incbin_declaration_appender.hpp"
#include "porytiles/infra/services/jasc_palette_loader.hpp"
#include "porytiles/infra/services/jasc_palette_saver.hpp"
#include "porytiles/infra/services/metatile_attribute_schema_resolver.hpp"
#include "porytiles/infra/services/png_indexed_image_loader.hpp"
#include "porytiles/infra/services/png_indexed_image_saver.hpp"
#include "porytiles/infra/services/png_rgba_image_loader.hpp"
#include "porytiles/infra/services/png_rgba_image_saver.hpp"
#include "porytiles/infra/services/project_layout_metadata_provider.hpp"
#include "porytiles/infra/services/project_porytiles_tileset_manager.hpp"
#include "porytiles/infra/services/project_tileset_anims_modifier.hpp"
#include "porytiles/infra/services/project_tileset_metadata_provider.hpp"
#include "porytiles/infra/services/project_tileset_metadata_writer.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
#include "porytiles/utilities/text/terminal_width.hpp"
#include "porytiles/xcut/config/config_scope_type.hpp"
#include "porytiles/xcut/di/components.hpp"
#include "porytiles/xcut/diagnostics/diagnostic_tag_filter.hpp"
#include "porytiles/xcut/diagnostics/filtered_user_diagnostics.hpp"
#include "porytiles/xcut/diagnostics/stderr_styled_user_diagnostics.hpp"
#include "porytiles/xcut/diagnostics/user_diagnostics.hpp"
 
namespace porytiles {
 
class TilesetCommandEnv {
  private:
    struct ProviderChain {
        std::vector<std::unique_ptr<ConfigProvider>> providers;
        gsl::not_null<YamlFileProvider *> yaml_provider;
    };
 
    [[nodiscard]] static ProviderChain make_provider_chain(
        const std::filesystem::path &project_root,
        const CliOptionStorage &cli_storage,
        TextFormatter *text_formatter,
        StderrStyledUserDiagnostics *stderr_diag)
    {
        // Layered configuration, highest priority first: CLI options, YAML files, base-game header defines,
        // defaults. Every provider reads stated values only; the derivation that used to live in a provider now
        // happens in the schema resolver's reconciliation, downstream of the chain.
        //
        // TODO: YamlFileProvider holds the raw stderr sink, so its warnings bypass the user's diagnostic filters in
        // every command. The filters are themselves config values, so the chain has to exist before the filters can
        // (a bootstrap circularity). Fix by late-binding the provider's diagnostics sink to the filtered one after
        // initialize() succeeds.
        std::vector<std::unique_ptr<ConfigProvider>> providers{};
        providers.push_back(std::make_unique<CliOptionProvider>(cli_storage));
        providers.push_back(std::make_unique<YamlFileProvider>(text_formatter, stderr_diag, project_root));
        // Take the handle from the owning slot so its provenance is the list itself, not a moved-from local.
        auto *yaml_provider = static_cast<YamlFileProvider *>(providers.back().get());
        providers.push_back(
            std::make_unique<HeaderDefineProvider>(
                project_root, std::filesystem::path{"include/fieldmap.h"}, text_formatter));
        providers.push_back(std::make_unique<DefaultProvider>());
        return {std::move(providers), yaml_provider};
    }
 
  public:
    TilesetCommandEnv(std::filesystem::path root, const CliOptionStorage &cli_storage)
        : project_root{std::move(root)}, injector{di::get_formatter_component, !isatty(STDERR_FILENO)},
          text_formatter{injector.get<TextFormatter *>()},
          stderr_diag{text_formatter, resolve_terminal_width(STDERR_FILENO)},
          provider_chain{make_provider_chain(project_root, cli_storage, text_formatter, &stderr_diag)},
          yaml_provider{provider_chain.yaml_provider}, config{text_formatter, std::move(provider_chain.providers)}
    {
    }
 
    [[nodiscard]] ChainableResult<void> initialize(const std::string &tileset_name)
    {
        // Eagerly validate all YAML config files for unknown keys
        if (yaml_provider->preload_and_validate(ConfigScopeType::tileset, tileset_name)) {
            return FormattableError{
                "Configuration validation failed for tileset '{}'.", FormatParam{tileset_name, Style::bold}};
        }
 
        // Build diagnostic filters from config values
        PT_TRY_ASSIGN_PASS_ERR(
            warnings_exclude, config.diagnostic_warnings_exclude(ConfigScopeType::tileset, tileset_name), void);
        PT_TRY_ASSIGN_PASS_ERR(
            warnings_include, config.diagnostic_warnings_include(ConfigScopeType::tileset, tileset_name), void);
        PT_TRY_ASSIGN_PASS_ERR(
            remarks_exclude, config.diagnostic_remarks_exclude(ConfigScopeType::tileset, tileset_name), void);
        PT_TRY_ASSIGN_PASS_ERR(
            remarks_include, config.diagnostic_remarks_include(ConfigScopeType::tileset, tileset_name), void);
 
        DiagnosticTagFilter warning_filter{std::move(warnings_exclude).value(), std::move(warnings_include).value()};
        DiagnosticTagFilter remark_filter{std::move(remarks_exclude).value(), std::move(remarks_include).value()};
 
        // Wrap with filter decorator for all subsequent operations
        // TODO: YamlFileProvider keeps emitting through the raw stderr sink even after this point (see
        // make_provider_chain). Once it supports a late-bound diagnostics sink, rebind it to the filtered one here.
        diag = std::make_unique<FilteredUserDiagnostics>(
            text_formatter, &stderr_diag, std::move(warning_filter), std::move(remark_filter));
        return {};
    }
 
    TilesetCommandEnv(const TilesetCommandEnv &) = delete;
    TilesetCommandEnv &operator=(const TilesetCommandEnv &) = delete;
    TilesetCommandEnv(TilesetCommandEnv &&) = delete;
    TilesetCommandEnv &operator=(TilesetCommandEnv &&) = delete;
 
    std::filesystem::path project_root;
    fruit::Injector<TextFormatter> injector;
    TextFormatter *text_formatter;
    StderrStyledUserDiagnostics stderr_diag;
 
  private:
    // Bridges make_provider_chain's single return value across the member initializers: the handles copy out,
    // config takes ownership of the vector. After construction the providers vector is moved-from and empty.
    ProviderChain provider_chain;
 
  public:
    // Typed handle to the YamlFileProvider owned by config's provider list, needed for eager YAML validation.
    gsl::not_null<YamlFileProvider *> yaml_provider;
    LazyLayeredConfig config;
    std::unique_ptr<FilteredUserDiagnostics> diag;
};
 
struct ResolvedAttributeContext {
    LoadedMetatileAttributeSchema resolved;
    ProviderMap provider_map;
};
 
[[nodiscard]] inline ChainableResult<ResolvedAttributeContext>
resolve_attribute_context(TilesetCommandEnv &env, const std::string &tileset_name)
{
    MetatileAttributeSchemaResolver resolver{env.project_root, &env.config, env.text_formatter, env.diag.get()};
    PT_TRY_ASSIGN_PASS_ERR(resolved, resolver.resolve(tileset_name), ResolvedAttributeContext);
    ProviderMap provider_map =
        build_provider_map(env.project_root, resolved.schema, env.text_formatter, env.diag.get());
    return ResolvedAttributeContext{std::move(resolved), std::move(provider_map)};
}
 
class TilesetCommandServices {
  public:
    TilesetCommandServices(TilesetCommandEnv &env, ResolvedAttributeContext context)
        : tile_printer{std::make_unique<AsciiTilePrinter>(env.text_formatter)},
          palette_printer{std::make_unique<ColorPalettePrinter>(env.text_formatter)}, jasc_loader{env.text_formatter},
          jasc_saver{env.text_formatter}, anim_json_parser{env.text_formatter},
          anim_code_parser{env.text_formatter, env.diag.get()},
          metadata_provider{env.project_root, env.text_formatter, env.diag.get()},
          layout_metadata_provider{env.project_root, env.text_formatter, env.diag.get()},
          metadata_writer{env.project_root, env.text_formatter}, incbin_appender{env.project_root, env.text_formatter},
          tileset_anims_modifier{env.project_root, &env.config, env.diag.get()}, resolved{std::move(context.resolved)},
          provider_map{std::move(context.provider_map)},
          tileset_manager{
              env.project_root,
              &metadata_provider,
              &metadata_writer,
              &env.config,
              resolved.declaration_bytes,
              env.diag.get(),
              &incbin_appender,
              &tileset_anims_modifier},
          attributes_csv_loader{env.text_formatter, &env.config, env.diag.get()},
          key_provider{env.project_root, &env.config, &metadata_provider, env.text_formatter, env.diag.get()},
          artifact_reader{
              env.project_root,
              &resolved.schema,
              &provider_map,
              &png_rgba_loader,
              &png_indexed_loader,
              &jasc_loader,
              &attributes_csv_loader,
              &anim_json_parser,
              &anim_code_parser,
              &metadata_provider},
          artifact_writer{
              &env.config,
              &env.config,
              env.project_root,
              &resolved.schema,
              &provider_map,
              env.text_formatter,
              env.diag.get(),
              &png_rgba_saver,
              &png_indexed_saver,
              &jasc_saver,
              &anim_json_parser,
              &anim_code_generator},
          checksum_provider{env.project_root},
          repo{
              &checksum_provider,
              &metadata_provider,
              &key_provider,
              &artifact_reader,
              &artifact_writer,
              env.diag.get()},
          compiler{
              &env.config,
              &resolved.schema,
              env.text_formatter,
              env.diag.get(),
              tile_printer.get(),
              palette_printer.get()}
    {
    }
 
    TilesetCommandServices(const TilesetCommandServices &) = delete;
    TilesetCommandServices &operator=(const TilesetCommandServices &) = delete;
    TilesetCommandServices(TilesetCommandServices &&) = delete;
    TilesetCommandServices &operator=(TilesetCommandServices &&) = delete;
 
    std::unique_ptr<TilePrinter> tile_printer;
    std::unique_ptr<PalettePrinter> palette_printer;
    PngRgbaImageLoader png_rgba_loader{};
    PngIndexedImageLoader png_indexed_loader{};
    PngRgbaImageSaver png_rgba_saver{};
    PngIndexedImageSaver png_indexed_saver{};
    JascPaletteLoader jasc_loader;
    JascPaletteSaver jasc_saver;
    AnimJsonParser anim_json_parser;
    AnimCodeParser anim_code_parser;
    AnimCodeGenerator anim_code_generator{};
    ProjectTilesetMetadataProvider metadata_provider;
    ProjectLayoutMetadataProvider layout_metadata_provider;
    ProjectTilesetMetadataWriter metadata_writer;
    IncbinDeclarationAppender incbin_appender;
    ProjectTilesetAnimsModifier tileset_anims_modifier;
    // The invocation's resolved schema and its provider map, moved in from the pre-resolved context and shared by
    // every consumer below.
    LoadedMetatileAttributeSchema resolved;
    ProviderMap provider_map;
    ProjectPorytilesTilesetManager tileset_manager;
    AttributesCsvLoader attributes_csv_loader;
    ProjectTilesetArtifactKeyProvider key_provider;
    ProjectTilesetArtifactReader artifact_reader;
    ProjectTilesetArtifactWriter artifact_writer;
    ProjectArtifactChecksumProvider checksum_provider;
    TilesetRepo repo;
    TilesetCompiler compiler;
};
 
} // namespace porytiles