configuration.h

#ifndef SOURCEMETA_BLAZE_CONFIGURATION_H_
#define SOURCEMETA_BLAZE_CONFIGURATION_H_

 
#ifndef SOURCEMETA_BLAZE_CONFIGURATION_EXPORT
#include <sourcemeta/blaze/configuration_export.h>
#endif
 
// NOLINTBEGIN(misc-include-cleaner)
#include <sourcemeta/blaze/configuration_error.h>
// NOLINTEND(misc-include-cleaner)
 
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/jsonschema.h>
#include <sourcemeta/core/uri.h>
 
#include <cstddef>       // std::size_t
#include <cstdint>       // std::uint8_t
#include <exception>     // std::exception_ptr
#include <filesystem>    // std::filesystem
#include <functional>    // std::function
#include <map>           // std::map
#include <optional>      // std::optional
#include <string>        // std::string
#include <string_view>   // std::string_view
#include <unordered_map> // std::unordered_map
// TODO(C++23): Consider std::flat_map/std::flat_set when available in libc++
#include <unordered_set> // std::unordered_set
#include <vector>        // std::vector
 
namespace sourcemeta::blaze {
 
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(disable : 4251 4275)
#endif

struct SOURCEMETA_BLAZE_CONFIGURATION_EXPORT Configuration {
  std::optional<sourcemeta::core::JSON::String> title;
  std::optional<sourcemeta::core::JSON::String> description;
  std::optional<sourcemeta::core::JSON::String> email;
  std::optional<sourcemeta::core::JSON::String> github;
  std::optional<sourcemeta::core::JSON::String> website;
  std::filesystem::path absolute_path;
  bool absolute_path_explicit{false};
  std::filesystem::path base_path;
  sourcemeta::core::JSON::String base;
  sourcemeta::core::URI base_uri;
  std::optional<sourcemeta::core::JSON::String> default_dialect;
  std::unordered_set<sourcemeta::core::JSON::String> extension{".json", ".yml",
                                                               ".yaml"};
  std::unordered_map<sourcemeta::core::JSON::String,
                     sourcemeta::core::JSON::String>
      resolve;
  // Ordered to guarantee deterministic iteration
  std::map<sourcemeta::core::JSON::String, std::filesystem::path> dependencies;
  std::vector<std::filesystem::path> ignore;
 
  struct Lint {
    struct Rule {
      std::filesystem::path path;
      bool top_level{false};
    };
 
    std::vector<Rule> rules;
    std::unordered_set<sourcemeta::core::JSON::String> exclude;
  };
 
  Lint lint;
  sourcemeta::core::JSON extra = sourcemeta::core::JSON::make_object();

  using ReadCallback =
      // TODO(C++23): Use std::move_only_function when available in libc++
      std::function<std::string(const std::filesystem::path &)>;

  class SOURCEMETA_BLAZE_CONFIGURATION_EXPORT Lock {
  public:
    struct Entry {
      std::filesystem::path path;
      // TODO: Separately store the server ETag for exploiting HTTP caching?
      sourcemeta::core::JSON::String hash;
      enum class HashAlgorithm : std::uint8_t { SHA256 };
      HashAlgorithm hash_algorithm;
      enum class Status : std::uint8_t {
        Untracked,
        FileMissing,
        Mismatched,
        PathMismatch,
        UpToDate
      };
    };
 
    using const_iterator =
        std::map<sourcemeta::core::JSON::String, Entry>::const_iterator;
 
    auto
    emplace(const sourcemeta::core::JSON::String &uri,
            const std::filesystem::path &path,
            const sourcemeta::core::JSON::String &hash,
            Entry::HashAlgorithm hash_algorithm = Entry::HashAlgorithm::SHA256)
        -> void;
    auto erase(const sourcemeta::core::JSON::String &uri) -> void;
 
    [[nodiscard]] auto size() const noexcept -> std::size_t;
    [[nodiscard]] auto at(const sourcemeta::core::JSON::String &uri) const
        -> std::optional<std::reference_wrapper<const Entry>>;
    [[nodiscard]] auto begin() const noexcept -> const_iterator;
    [[nodiscard]] auto end() const noexcept -> const_iterator;
 
    [[nodiscard]]
    auto check(const sourcemeta::core::JSON::String &uri,
               const std::filesystem::path &expected_path,
               const ReadCallback &reader) const -> Entry::Status;
    [[nodiscard]]
    static auto from_json(const sourcemeta::core::JSON &value,
                          const std::filesystem::path &lock_base_path) -> Lock;
    [[nodiscard]]
    auto to_json(const std::filesystem::path &lock_base_path) const
        -> sourcemeta::core::JSON;
 
  private:
    // Ordered to guarantee deterministic iteration
    std::map<sourcemeta::core::JSON::String, Entry> entries_;
  };

  struct FetchEvent {
    enum class Type : std::uint8_t {
      FetchStart,
      FetchEnd,
      BundleStart,
      BundleEnd,
      WriteStart,
      WriteEnd,
      VerifyStart,
      VerifyEnd,
      UpToDate,
      FileMissing,
      Orphaned,
      Mismatched,
      PathMismatch,
      Untracked,
      Error
    };
 
    Type type;
    std::string uri;
    std::filesystem::path path;
    std::size_t index;
    std::size_t total;
    std::string details;
    std::exception_ptr exception;
 
    using Callback = std::function<bool(const FetchEvent &)>;
  };

  using FetchCallback =
      std::function<sourcemeta::core::JSON(std::string_view uri)>;

  using WriteCallback = std::function<void(const std::filesystem::path &,
                                           const sourcemeta::core::JSON &)>;

  enum class FetchMode : std::uint8_t {
    Missing,
    All
  };

  auto fetch(Lock &lock, const FetchCallback &fetcher,
             const sourcemeta::core::SchemaResolver &resolver,
             const ReadCallback &reader, const WriteCallback &writer,
             const FetchEvent::Callback &on_event, FetchMode mode,
             // TODO: Make this work for real
             std::size_t concurrency = 1) const -> void;

  auto fetch(const Lock &lock, const FetchCallback &fetcher,
             const sourcemeta::core::SchemaResolver &resolver,
             const ReadCallback &reader, const WriteCallback &writer,
             const FetchEvent::Callback &on_event, bool dry_run = false,
             // TODO: Make this work for real
             std::size_t concurrency = 1) const -> void;

  auto add_dependency(const sourcemeta::core::URI &uri,
                      const std::filesystem::path &path) -> void;

  [[nodiscard]]
  auto applies_to(const std::filesystem::path &path) const -> bool;

  [[nodiscard]]
  static auto from_json(const sourcemeta::core::JSON &value,
                        const std::filesystem::path &base_path)
      -> Configuration;

  [[nodiscard]]
  auto to_json() const -> sourcemeta::core::JSON;

  [[nodiscard]]
  static auto read_json(const std::filesystem::path &path,
                        const ReadCallback &reader) -> Configuration;

  [[nodiscard]]
  static auto find(const std::filesystem::path &path)
      -> std::optional<std::filesystem::path>;
};
 
#if defined(_MSC_VER)
#pragma warning(default : 4251 4275)
#endif
 
} // namespace sourcemeta::blaze
 
#endif