Functions
const nlohmann::json &	array_or_empty (const nlohmann::json &document, std::string_view field)
std::optional< std::string >	projection_identifier (const nlohmann::json &value, std::string_view field, std::string_view integer_namespace)
std::optional< std::string >	projection_identifier (const nlohmann::json &value, std::string_view integer_namespace)
std::string	identifier (const nlohmann::json &value, std::string_view integer_namespace={})
std::string	entity_label (const nlohmann::json &value, const std::string &fallback)
void	upsert_node (std::map< std::string, nlohmann::ordered_json, std::less<> > &nodes, nlohmann::ordered_json node)
std::string	edge_id (std::string_view from, std::string_view to, std::string_view type, std::string_view source_id)
void	append_human_edge (nlohmann::ordered_json &edges, std::string from, std::string to, std::string type, std::string assertion_id, std::string snapshot_id, const nlohmann::json &evidence=nlohmann::json::array())
std::string	read_file (const std::filesystem::path &path)
void	write_file (const std::filesystem::path &path, std::string_view content)
void	write_immutable_file (const std::filesystem::path &path, std::string_view content)
void	validate_site_root (const std::filesystem::path &root)

Function Documentation

◆ append_human_edge()

void arachne::ariadne::anonymous_namespace{viewer.cpp}::append_human_edge	(	nlohmann::ordered_json &	edges,
		std::string	from,
		std::string	to,
		std::string	type,
		std::string	assertion_id,
		std::string	snapshot_id,
		const nlohmann::json &	evidence = nlohmann::json::array() )

Definition at line 155 of file viewer.cpp.

      {
        nlohmann::ordered_json source_ids = nlohmann::ordered_json::array();
        nlohmann::ordered_json evidence_ids = nlohmann::ordered_json::array();
        std::set<std::string, std::less<>> unique_sources;
        std::set<std::string, std::less<>> unique_evidence;
        if (!assertion_id.empty()) {
            unique_sources.insert(assertion_id);
        }
        if (evidence.is_array()) {
            for (const auto& value : evidence) {
                if (const auto id = projection_identifier(value, "evidence")) {
                    unique_sources.insert(*id);
                    unique_evidence.insert(*id);
                }
            }
        }
        for (const auto& source : unique_sources) {
            source_ids.push_back(source);
        }
        for (const auto& evidence_id : unique_evidence) {
            evidence_ids.push_back(evidence_id);
        }
        nlohmann::ordered_json provenance {
            { "origin", "human_authored" },
            { "snapshot_id", std::move(snapshot_id) },
            { "source_ids", std::move(source_ids) },
            { "explanation",
              "Accepted human-authored research relation with "
              "assertion-specific evidence." },
        };
        edges.push_back(
            { { "edge_id", edge_id(from, to, type, assertion_id) },
              { "source", std::move(from) },
              { "target", std::move(to) },
              { "edge_type", std::move(type) },
              { "provenance", std::move(provenance) },
              { "attributes",
                { { "derived", false },
                  { "assertion_id", assertion_id },
                  { "evidence", std::move(evidence_ids) } } } }
        );
    }

◆ array_or_empty()

const nlohmann::json & arachne::ariadne::anonymous_namespace{viewer.cpp}::array_or_empty	(	const nlohmann::json &	document,
		std::string_view	field )

Definition at line 22 of file viewer.cpp.

                                                                       {
        static const nlohmann::json empty = nlohmann::json::array();
        if (!document.is_object() || !document.contains(field)) {
            return empty;
        }
        if (!document.at(field).is_array()) {
            throw std::invalid_argument(
                std::string(field) + " must be an array"
            );
        }
        return document.at(field);
    }

◆ edge_id()

std::string arachne::ariadne::anonymous_namespace{viewer.cpp}::edge_id	(	std::string_view	from,
		std::string_view	to,
		std::string_view	type,
		std::string_view	source_id )

Definition at line 143 of file viewer.cpp.

      {
        return "edge_"
            + crypto::sha256(
                  std::string(from) + "\n" + std::string(to) + "\n"
                  + std::string(type) + "\n" + std::string(source_id)
            )
                  .substr(0, 24);
    }

References arachne::crypto::sha256().

Here is the call graph for this function:

◆ entity_label()

std::string arachne::ariadne::anonymous_namespace{viewer.cpp}::entity_label	(	const nlohmann::json &	value,
		const std::string &	fallback )

Definition at line 103 of file viewer.cpp.

                                                                       {
        for (const auto* field : { "label", "name", "title", "value" }) {
            if (value.contains(field) && value.at(field).is_string()
                && !value.at(field).get_ref<const std::string&>().empty()) {
                return value.at(field).get<std::string>();
            }
        }
        return fallback;
    }

◆ identifier()

std::string arachne::ariadne::anonymous_namespace{viewer.cpp}::identifier	(	const nlohmann::json &	value,
		std::string_view	integer_namespace = {} )

Definition at line 89 of file viewer.cpp.

                                                                      {}
    ) {
        for (const auto* field :
             { "id", "entity_id", "candidate_id", "work_id" }) {
            if (const auto id
                = projection_identifier(value, field, integer_namespace)) {
                return *id;
            }
        }
        throw std::invalid_argument("viewer record has no stable identifier");
    }

◆ projection_identifier() [1/2]

std::optional< std::string > arachne::ariadne::anonymous_namespace{viewer.cpp}::projection_identifier	(	const nlohmann::json &	value,
		std::string_view	field,
		std::string_view	integer_namespace )

Definition at line 35 of file viewer.cpp.

      {
        const auto found = value.find(std::string(field));
        if (found == value.end() || found->is_null()) {
            return std::nullopt;
        }
        if (found->is_string()) {
            const auto id = found->get<std::string>();
            return id.empty() ? std::nullopt
                              : std::optional<std::string> { id };
        }
        if (found->is_number_integer() && !integer_namespace.empty()) {
            const auto id = found->get<std::int64_t>();
            if (id <= 0) {
                throw std::invalid_argument(
                    std::string(field)
                    + " must be a positive internal database identifier"
                );
            }
            return std::string(integer_namespace) + ":" + std::to_string(id);
        }
        throw std::invalid_argument(
            std::string(field)
            + " must be a string identifier or a namespaced integer"
        );
    }

◆ projection_identifier() [2/2]

std::optional< std::string > arachne::ariadne::anonymous_namespace{viewer.cpp}::projection_identifier	(	const nlohmann::json &	value,
		std::string_view	integer_namespace )

Definition at line 64 of file viewer.cpp.

      {
        if (value.is_null()) {
            return std::nullopt;
        }
        if (value.is_string()) {
            const auto id = value.get<std::string>();
            return id.empty() ? std::nullopt
                              : std::optional<std::string> { id };
        }
        if (value.is_number_integer() && !integer_namespace.empty()) {
            const auto id = value.get<std::int64_t>();
            if (id <= 0) {
                throw std::invalid_argument(
                    "internal database identifier must be positive"
                );
            }
            return std::string(integer_namespace) + ":" + std::to_string(id);
        }
        throw std::invalid_argument(
            "projection identifier must be a string or namespaced integer"
        );
    }

◆ read_file()

std::string arachne::ariadne::anonymous_namespace{viewer.cpp}::read_file ( const std::filesystem::path & path )

Definition at line 202 of file viewer.cpp.

                                                       {
        std::ifstream input(path, std::ios::binary);
        if (!input) {
            throw std::runtime_error(
                "cannot read viewer template: " + path.string()
            );
        }
        return { std::istreambuf_iterator<char>(input),
                 std::istreambuf_iterator<char>() };
    }

◆ upsert_node()

void arachne::ariadne::anonymous_namespace{viewer.cpp}::upsert_node	(	std::map< std::string, nlohmann::ordered_json, std::less<> > &	nodes,
		nlohmann::ordered_json	node )

Definition at line 113 of file viewer.cpp.

      {
        const auto id = node.at("node_id").get<std::string>();
        if (const auto found = nodes.find(id); found == nodes.end()) {
            nodes.emplace(id, std::move(node));
        } else {
            if (node.contains("attributes")
                && node.at("attributes").is_object()) {
                auto& attributes = found->second["attributes"];
                if (!attributes.is_object()) {
                    attributes = nlohmann::ordered_json::object();
                }
                for (auto iterator = node.at("attributes").begin();
                     iterator != node.at("attributes").end(); ++iterator) {
                    attributes[iterator.key()] = iterator.value();
                }
            }
            for (auto iterator = node.begin(); iterator != node.end();
                 ++iterator) {
                if (iterator.key() != "attributes"
                    && (!found->second.contains(iterator.key())
                        || found->second.at(iterator.key()).is_null())) {
                    found->second[iterator.key()] = iterator.value();
                }
            }
        }
    }

◆ validate_site_root()

void arachne::ariadne::anonymous_namespace{viewer.cpp}::validate_site_root ( const std::filesystem::path & root )

Definition at line 290 of file viewer.cpp.

                                                           {
        if (root.empty() || root == root.root_path()) {
            throw std::invalid_argument("site root must be a scoped directory");
        }
        for (const auto& component : root) {
            if (component == "..") {
                throw std::invalid_argument(
                    "site root must not contain parent traversal"
                );
            }
        }
    }

Referenced by arachne::ariadne::viewer_builder::build_site().

Here is the caller graph for this function:

◆ write_file()

void arachne::ariadne::anonymous_namespace{viewer.cpp}::write_file	(	const std::filesystem::path &	path,
		std::string_view	content )

Definition at line 214 of file viewer.cpp.

                                                                      {
        std::filesystem::create_directories(path.parent_path());
        const auto temporary = path.string() + ".part";
        {
            std::ofstream output(temporary, std::ios::binary | std::ios::trunc);
            if (!output) {
                throw std::runtime_error(
                    "cannot write viewer artifact: " + path.string()
                );
            }
            output.write(
                content.data(), static_cast<std::streamsize>(content.size())
            );
            if (!output) {
                throw std::runtime_error(
                    "cannot finish viewer artifact: " + path.string()
                );
            }
        }
        std::filesystem::rename(temporary, path);
    }

◆ write_immutable_file()

void arachne::ariadne::anonymous_namespace{viewer.cpp}::write_immutable_file	(	const std::filesystem::path &	path,
		std::string_view	content )

Definition at line 236 of file viewer.cpp.

      {
        if (path.empty() || path.filename().empty()) {
            throw std::invalid_argument(
                "viewer artifact destination must be a file"
            );
        }
        if (!path.parent_path().empty()) {
            std::filesystem::create_directories(path.parent_path());
        }
        if (std::filesystem::exists(path)) {
            if (!std::filesystem::is_regular_file(path)
                || std::filesystem::file_size(path) != content.size()
                || crypto::sha256_file(path) != crypto::sha256(content)) {
                throw std::runtime_error(
                    "viewer artifact destination already contains different "
                    "bytes"
                );
            }
            return;
        }
        auto staging = path;
        staging += ".part";
        if (std::filesystem::exists(staging)) {
            throw std::runtime_error(
                "viewer artifact staging file already exists"
            );
        }
        try {
            {
                std::ofstream output(
                    staging, std::ios::binary | std::ios::trunc
                );
                if (!output) {
                    throw std::runtime_error("cannot create viewer artifact");
                }
                output.write(
                    content.data(), static_cast<std::streamsize>(content.size())
                );
                output.close();
                if (!output) {
                    throw std::runtime_error("cannot finish viewer artifact");
                }
            }
            std::filesystem::create_hard_link(staging, path);
            std::filesystem::remove(staging);
        } catch (...) {
            std::error_code ignored;
            std::filesystem::remove(staging, ignored);
            throw;
        }
    }