Remove SchemaFlatFileResolver (#1689)

Signed-off-by: Juan Cruz Viotti <[email protected]>

Author: jviotti

src/core/jsonschema/include/sourcemeta/core/jsonschema_resolver.h

@@ -8,7 +8,6 @@
 #include <sourcemeta/core/json.h>
 #include <sourcemeta/core/jsonschema_types.h>
 
-#include <filesystem>  // std::filesystem
 #include <functional>  // std::function
 #include <map>         // std::map
 #include <optional>    // std::optional
@@ -74,85 +73,6 @@ class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaMapResolver {
 #endif
 };
 
-/// @ingroup jsonschema
-/// A convenient dynamic schema resolver capable of storing a high number of
-/// schemas by deferencing them from disk on-demand. It is called a flat
-/// resolver as it only looks at the top-level identifier of every schema. For
-/// example:
-///
-/// ```cpp
-/// #include <sourcemeta/core/jsonschema.h>
-/// #include <cassert>
-///
-/// // (1) Create a flat file resolver that falls back to the official resolver
-/// sourcemeta::core::SchemaFlatFileResolver
-///   resolver{sourcemeta::core::schema_official_resolver};
-///
-/// // (2) Register a schema by path
-/// resolver.add("path/to/example.schema.json");
-///
-/// assert(resolver("https://www.example.com").has_value());
-/// ```
-class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaFlatFileResolver {
-public:
-  /// Construct an empty resolver. If you don't add schemas to it, it will
-  /// always resolve to nothing
-  SchemaFlatFileResolver();
-
-  /// Construct an empty resolver that has another schema resolver as a fallback
-  SchemaFlatFileResolver(const SchemaResolver &resolver);
-
-  /// Determines how to access the registered file entry, letting you hook
-  /// into how schemas are read to support other file formats, like YAML
-  using Reader = std::function<JSON(const std::filesystem::path &)>;
-
-  /// Register a schema to the flat file resolver, returning the detected
-  /// identifier for the schema
-  auto add(
-      const std::filesystem::path &path,
-      const std::optional<std::string> &default_dialect = std::nullopt,
-      const std::optional<std::string> &default_id = std::nullopt,
-      const Reader &reader =
-          [](const std::filesystem::path &path) { return read_json(path); },
-      SchemaVisitorReference &&reference_visitor = nullptr)
-      -> const std::string &;
-
-  // Change the identifier of a registered schema
-  auto reidentify(const std::string &schema, const std::string &new_identifier)
-      -> void;
-
-  /// Attempt to resolve a schema
-  auto operator()(std::string_view identifier) const -> std::optional<JSON>;
-
-  /// Traverse the registered schemas using iterators
-  inline auto begin() const -> auto { return this->schemas.begin(); }
-
-  /// Traverse the registered schemas using iterators
-  inline auto end() const -> auto { return this->schemas.end(); }
-
-  /// Represent an entry in the resolver
-  struct Entry {
-    std::filesystem::path path;
-    std::optional<std::string> default_dialect;
-    std::string original_identifier;
-    Reader reader;
-    SchemaVisitorReference reference_visitor;
-  };
-
-private:
-// 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)
-#endif
-  std::map<std::string, Entry> schemas;
-  SchemaResolver default_resolver = nullptr;
-#if defined(_MSC_VER)
-#pragma warning(default : 4251)
-#endif
-};
-
 } // namespace sourcemeta::core
 
 #endif

src/core/jsonschema/resolver.cc

@@ -1,9 +1,7 @@
 #include <sourcemeta/core/jsonschema.h>
 
-#include <algorithm> // std::transform
-#include <cassert>   // assert
-#include <cctype>    // std::tolower
-#include <sstream>   // std::ostringstream
+#include <cassert> // assert
+#include <sstream> // std::ostringstream
 
 namespace sourcemeta::core {
 
@@ -84,98 +82,4 @@ auto SchemaMapResolver::operator()(std::string_view identifier) const
   return std::nullopt;
 }
 
-SchemaFlatFileResolver::SchemaFlatFileResolver() {}
-
-SchemaFlatFileResolver::SchemaFlatFileResolver(const SchemaResolver &resolver)
-    : default_resolver{resolver} {}
-
-static auto to_lowercase(const std::string_view input) -> std::string {
-  std::string result{input};
-  std::transform(result.cbegin(), result.cend(), result.begin(),
-                 [](const auto character) {
-                   return static_cast<char>(std::tolower(character));
-                 });
-  return result;
-}
-
-auto SchemaFlatFileResolver::add(
-    const std::filesystem::path &path,
-    const std::optional<std::string> &default_dialect,
-    const std::optional<std::string> &default_id, const Reader &reader,
-    SchemaVisitorReference &&reference_visitor) -> const std::string & {
-  const auto canonical{std::filesystem::weakly_canonical(path)};
-  const auto schema{reader(canonical)};
-  assert(sourcemeta::core::is_schema(schema));
-  const auto identifier{sourcemeta::core::identify(
-      schema, *this, SchemaIdentificationStrategy::Loose, default_dialect,
-      default_id)};
-  if (!identifier.has_value() && !default_id.has_value()) {
-    std::ostringstream error;
-    error << "Cannot identify schema: " << canonical.string();
-    throw SchemaError(error.str());
-  }
-
-  // Filesystems behave differently with regards to casing. To unify
-  // them, assume they are case-insensitive.
-  const auto effective_identifier{to_lowercase(
-      default_id.has_value() ? identifier.value_or(default_id.value())
-                             : identifier.value())};
-
-  const auto result{this->schemas.emplace(
-      effective_identifier,
-      Entry{canonical, default_dialect, effective_identifier, reader,
-            reference_visitor ? std::move(reference_visitor)
-                              : reference_visitor_relativize})};
-  if (!result.second && result.first->second.path != canonical) {
-    std::ostringstream error;
-    error << "Cannot register the same identifier twice: "
-          << effective_identifier;
-    throw SchemaError(error.str());
-  }
-
-  return result.first->first;
-}
-
-auto SchemaFlatFileResolver::reidentify(const std::string &schema,
-                                        const std::string &new_identifier)
-    -> void {
-  const auto result{this->schemas.find(to_lowercase(schema))};
-  assert(result != this->schemas.cend());
-  this->schemas.insert_or_assign(to_lowercase(new_identifier),
-                                 std::move(result->second));
-  this->schemas.erase(result);
-}
-
-auto SchemaFlatFileResolver::operator()(std::string_view identifier) const
-    -> std::optional<JSON> {
-  const std::string string_identifier{to_lowercase(identifier)};
-  const auto result{this->schemas.find(string_identifier)};
-  if (result != this->schemas.cend()) {
-    auto schema{result->second.reader(result->second.path)};
-    assert(sourcemeta::core::is_schema(schema));
-    if (schema.is_object() && !schema.defines("$schema") &&
-        result->second.default_dialect.has_value()) {
-      schema.assign("$schema", JSON{result->second.default_dialect.value()});
-    }
-
-    sourcemeta::core::reidentify(schema, result->second.original_identifier,
-                                 *this, result->second.default_dialect);
-    // Because we allow re-identification, we can get into issues unless we
-    // always try to relativize references
-    sourcemeta::core::reference_visit(
-        schema, schema_official_walker, *this, result->second.reference_visitor,
-        result->second.default_dialect, result->second.original_identifier);
-    sourcemeta::core::reidentify(schema, result->first, *this,
-                                 result->second.default_dialect);
-
-    return schema;
-  }
-
-  if (this->default_resolver) {
-    return this->default_resolver(identifier);
-  }
-
-  return std::nullopt;
-}
-
 } // namespace sourcemeta::core

test/jsonschema/CMakeLists.txt

@@ -82,7 +82,6 @@ sourcemeta_googletest(NAMESPACE sourcemeta PROJECT core NAME jsonschema
     jsonschema_official_resolver_test.cc
     jsonschema_relativize_test.cc
     jsonschema_map_resolver_test.cc
-    jsonschema_flat_file_resolver_test.cc
     jsonschema_format_test.cc
     jsonschema_wrap_test.cc)
 
@@ -94,8 +93,6 @@ target_link_libraries(sourcemeta_core_jsonschema_unit
   PRIVATE sourcemeta::core::jsonschema)
 target_link_libraries(sourcemeta_core_jsonschema_unit
   PRIVATE sourcemeta::core::uri)
-target_compile_definitions(sourcemeta_core_jsonschema_unit
-  PRIVATE SCHEMAS_PATH="${CMAKE_CURRENT_SOURCE_DIR}/schemas")
 
 # JSON Schema Referencing Suite
 # See https://github.com/python-jsonschema/referencing-suite