Support printing SchemaFrame to standard output streams (#1574)

Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

src/core/jsonschema/frame.cc

@@ -393,6 +393,121 @@ auto SchemaFrame::to_json() const -> JSON {
   return root;
 }
 
+auto operator<<(std::ostream &stream, const SchemaFrame &frame)
+    -> std::ostream & {
+  if (frame.locations().empty()) {
+    return stream;
+  }
+
+  for (auto iterator = frame.locations().cbegin();
+       iterator != frame.locations().cend(); iterator++) {
+    const auto &location{*iterator};
+
+    switch (location.second.type) {
+      case SchemaFrame::LocationType::Resource:
+        stream << "(RESOURCE)";
+        break;
+      case SchemaFrame::LocationType::Anchor:
+        stream << "(ANCHOR)";
+        break;
+      case SchemaFrame::LocationType::Pointer:
+        stream << "(POINTER)";
+        break;
+      case SchemaFrame::LocationType::Subschema:
+        stream << "(SUBSCHEMA)";
+        break;
+      default:
+        assert(false);
+    }
+
+    stream << " URI: " << location.first.second << "\n";
+
+    if (location.first.first == SchemaReferenceType::Static) {
+      stream << "    Type              : Static\n";
+    } else {
+      stream << "    Type              : Dynamic\n";
+    }
+
+    stream << "    Root              : "
+           << location.second.root.value_or("<ANONYMOUS>") << "\n";
+
+    if (location.second.pointer.empty()) {
+      stream << "    Pointer           :\n";
+    } else {
+      stream << "    Pointer           : ";
+      sourcemeta::core::stringify(location.second.pointer, stream);
+      stream << "\n";
+    }
+
+    stream << "    Base              : " << location.second.base << "\n";
+
+    if (location.second.relative_pointer.empty()) {
+      stream << "    Relative Pointer  :\n";
+    } else {
+      stream << "    Relative Pointer  : ";
+      sourcemeta::core::stringify(location.second.relative_pointer, stream);
+      stream << "\n";
+    }
+
+    stream << "    Dialect           : " << location.second.dialect << "\n";
+    stream << "    Base Dialect      : " << location.second.base_dialect
+           << "\n";
+
+    if (location.second.parent.has_value()) {
+      if (location.second.parent.value().empty()) {
+        stream << "    Parent            :\n";
+      } else {
+        stream << "    Parent            : ";
+        sourcemeta::core::stringify(location.second.parent.value(), stream);
+        stream << "\n";
+      }
+    } else {
+      stream << "    Parent            : <NONE>\n";
+    }
+
+    const auto &instance_locations{frame.instance_locations(location.second)};
+    if (!instance_locations.empty()) {
+      for (const auto &instance_location : instance_locations) {
+        if (instance_location.empty()) {
+          stream << "    Instance Location :\n";
+        } else {
+          stream << "    Instance Location : ";
+          sourcemeta::core::stringify(instance_location, stream);
+          stream << "\n";
+        }
+      }
+    }
+
+    if (std::next(iterator) != frame.locations().cend()) {
+      stream << "\n";
+    }
+  }
+
+  for (auto iterator = frame.references().cbegin();
+       iterator != frame.references().cend(); iterator++) {
+    stream << "\n";
+    const auto &reference{*iterator};
+    stream << "(REFERENCE) ORIGIN: ";
+    sourcemeta::core::stringify(reference.first.second, stream);
+    stream << "\n";
+
+    if (reference.first.first == SchemaReferenceType::Static) {
+      stream << "    Type              : Static\n";
+    } else {
+      stream << "    Type              : Dynamic\n";
+    }
+
+    stream << "    Destination       : " << reference.second.destination
+           << "\n";
+    stream << "    - (w/o fragment)  : "
+           << reference.second.base.value_or("<NONE>") << "\n";
+    stream << "    - (fragment)      : "
+           << reference.second.fragment.value_or("<NONE>") << "\n";
+  }
+
+  return stream;
+}
+
 auto SchemaFrame::analyse(const JSON &schema, const SchemaWalker &walker,
                           const SchemaResolver &resolver,
                           const std::optional<std::string> &default_dialect,

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

@@ -16,6 +16,7 @@
 #include <functional>    // std::reference_wrapper
 #include <map>           // std::map
 #include <optional>      // std::optional
+#include <ostream>       // std::ostream
 #include <string>        // std::string
 #include <tuple>         // std::tuple
 #include <unordered_set> // std::set
@@ -240,6 +241,12 @@ class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaFrame {
 #endif
 };
 
+/// @ingroup jsonschema
+/// Pretty print the contents of a schema frame
+SOURCEMETA_CORE_JSONSCHEMA_EXPORT
+auto operator<<(std::ostream &stream, const SchemaFrame &frame)
+    -> std::ostream &;
+
 // TODO: Eventually generalize this to detecting cross-keyword dependencies as
 // part of framing