json_ld/processor/

remote_document.rs

use super::{
	compact_expanded_full, CompactError, CompactResult, CompareResult, ExpandError, ExpandResult,
	FlattenError, FlattenResult, JsonLdProcessor, Options,
};
use crate::context_processing::{self, Process};
use crate::expansion::{self, Expand};
use crate::IntoDocumentResult;
use crate::{Context, Flatten, Loader, RemoteDocument, RemoteDocumentReference};
use contextual::WithContext;
use json_ld_core::{Document, RemoteContextReference};
use rdf_types::{Generator, VocabularyMut};
use std::hash::Hash;

impl<I> JsonLdProcessor<I> for RemoteDocument<I> {
	async fn compare_full<N>(
		&self,
		other: &Self,
		vocabulary: &mut N,
		loader: &impl Loader,
		options: Options<I>,
		mut warnings: impl context_processing::WarningHandler<N> + expansion::WarningHandler<N>,
	) -> CompareResult
	where
		N: VocabularyMut<Iri = I>,
		I: Clone + Eq + Hash,
		N::BlankId: Clone + Eq + Hash,
	{
		if json_ld_syntax::Compare::compare(self.document(), other.document()) {
			let a = JsonLdProcessor::expand_full(
				self,
				vocabulary,
				loader,
				options.clone(),
				&mut warnings,
			)
			.await?;
			let b = JsonLdProcessor::expand_full(other, vocabulary, loader, options, &mut warnings)
				.await?;
			Ok(a == b)
		} else {
			Ok(false)
		}
	}

	async fn expand_full<N>(
		&self,
		vocabulary: &mut N,
		loader: &impl Loader,
		mut options: Options<I>,
		mut warnings: impl context_processing::WarningHandler<N> + expansion::WarningHandler<N>,
	) -> ExpandResult<I, N::BlankId>
	where
		N: VocabularyMut<Iri = I>,
		I: Clone + Eq + Hash,
		N::BlankId: Clone + Eq + Hash,
	{
		let mut active_context = Context::new(options.base.clone().or_else(|| self.url().cloned()));

		if let Some(expand_context) = options.expand_context.take() {
			active_context = expand_context
				.load_context_with(vocabulary, loader)
				.await
				.map_err(ExpandError::ContextLoading)?
				.into_document()
				.process_full(
					vocabulary,
					&active_context,
					loader,
					active_context.original_base_url().cloned(),
					options.context_processing_options(),
					&mut warnings,
				)
				.await
				.map_err(ExpandError::ContextProcessing)?
				.into_processed()
		};

		if let Some(context_url) = self.context_url() {
			active_context = RemoteDocumentReference::Iri(context_url.clone())
				.load_context_with(vocabulary, loader)
				.await
				.map_err(ExpandError::ContextLoading)?
				.into_document()
				.process_full(
					vocabulary,
					&active_context,
					loader,
					Some(context_url.clone()),
					options.context_processing_options(),
					&mut warnings,
				)
				.await
				.map_err(ExpandError::ContextProcessing)?
				.into_processed()
		}

		self.document()
			.expand_full(
				vocabulary,
				active_context,
				self.url().or(options.base.as_ref()),
				loader,
				options.expansion_options(),
				warnings,
			)
			.await
			.map_err(ExpandError::Expansion)
	}

	async fn into_document_full<'a, N>(
		self,
		vocabulary: &'a mut N,
		loader: &'a impl Loader,
		options: Options<I>,
		warnings: impl 'a + context_processing::WarningHandler<N> + expansion::WarningHandler<N>,
	) -> IntoDocumentResult<I, N::BlankId>
	where
		N: VocabularyMut<Iri = I>,
		I: 'a + Clone + Eq + Hash,
		N::BlankId: 'a + Clone + Eq + Hash,
	{
		let expanded =
			JsonLdProcessor::expand_full(&self, vocabulary, loader, options, warnings).await?;
		Ok(Document::new(self, expanded))
	}

	async fn compact_full<'a, N>(
		&'a self,
		vocabulary: &'a mut N,
		context: RemoteContextReference<I>,
		loader: &'a impl Loader,
		options: Options<I>,
		mut warnings: impl 'a + context_processing::WarningHandler<N> + expansion::WarningHandler<N>,
	) -> CompactResult
	where
		N: VocabularyMut<Iri = I>,
		I: Clone + Eq + Hash,
		N::BlankId: 'a + Clone + Eq + Hash,
	{
		let expanded_input = JsonLdProcessor::expand_full(
			self,
			vocabulary,
			loader,
			options.clone().unordered(),
			&mut warnings,
		)
		.await
		.map_err(CompactError::Expand)?;

		compact_expanded_full(
			&expanded_input,
			self.url(),
			vocabulary,
			context,
			loader,
			options,
			warnings,
		)
		.await
	}

	async fn flatten_full<'a, N>(
		&'a self,
		vocabulary: &'a mut N,
		generator: &'a mut impl Generator<N>,
		context: Option<RemoteContextReference<I>>,
		loader: &'a impl Loader,
		options: Options<I>,
		mut warnings: impl 'a + context_processing::WarningHandler<N> + expansion::WarningHandler<N>,
	) -> FlattenResult<I, N::BlankId>
	where
		N: VocabularyMut<Iri = I>,
		I: Clone + Eq + Hash,
		N::BlankId: 'a + Clone + Eq + Hash,
	{
		let expanded_input = JsonLdProcessor::expand_full(
			self,
			vocabulary,
			loader,
			options.clone().unordered(),
			&mut warnings,
		)
		.await
		.map_err(FlattenError::Expand)?;

		let flattened_output =
			Flatten::flatten_with(expanded_input, vocabulary, generator, options.ordered)
				.map_err(FlattenError::ConflictingIndexes)?;

		match context {
			Some(context) => compact_expanded_full(
				&flattened_output,
				self.url(),
				vocabulary,
				context,
				loader,
				options,
				warnings,
			)
			.await
			.map_err(FlattenError::Compact),
			None => Ok(json_ld_syntax::IntoJson::into_json(
				flattened_output.into_with(vocabulary),
			)),
		}
	}
}

impl<I> JsonLdProcessor<I> for RemoteDocumentReference<I, json_syntax::Value> {
	async fn compare_full<N>(
		&self,
		other: &Self,
		vocabulary: &mut N,
		loader: &impl Loader,
		options: Options<I>,
		warnings: impl context_processing::WarningHandler<N> + expansion::WarningHandler<N>,
	) -> CompareResult
	where
		N: VocabularyMut<Iri = I>,
		I: Clone + Eq + Hash,
		N::BlankId: Clone + Eq + Hash,
	{
		let a = self.loaded_with(vocabulary, loader).await?;
		let b = other.loaded_with(vocabulary, loader).await?;
		JsonLdProcessor::compare_full(
			a.as_ref(),
			b.as_ref(),
			vocabulary,
			loader,
			options,
			warnings,
		)
		.await
	}

	async fn expand_full<N>(
		&self,
		vocabulary: &mut N,
		loader: &impl Loader,
		options: Options<I>,
		warnings: impl context_processing::WarningHandler<N> + expansion::WarningHandler<N>,
	) -> ExpandResult<I, N::BlankId>
	where
		N: VocabularyMut<Iri = I>,
		I: Clone + Eq + Hash,
		N::BlankId: Clone + Eq + Hash,
	{
		let doc = self.loaded_with(vocabulary, loader).await?;
		JsonLdProcessor::expand_full(doc.as_ref(), vocabulary, loader, options, warnings).await
	}

	async fn into_document_full<'a, N>(
		self,
		vocabulary: &'a mut N,
		loader: &'a impl Loader,
		options: Options<I>,
		warnings: impl 'a + context_processing::WarningHandler<N> + expansion::WarningHandler<N>,
	) -> IntoDocumentResult<I, N::BlankId>
	where
		N: VocabularyMut<Iri = I>,
		I: 'a + Clone + Eq + Hash,
		N::BlankId: 'a + Clone + Eq + Hash,
	{
		let doc = self.load_with(vocabulary, loader).await?;
		JsonLdProcessor::into_document_full(doc, vocabulary, loader, options, warnings).await
	}

	async fn compact_full<'a, N>(
		&'a self,
		vocabulary: &'a mut N,
		context: RemoteContextReference<I>,
		loader: &'a impl Loader,
		options: Options<I>,
		warnings: impl 'a + context_processing::WarningHandler<N> + expansion::WarningHandler<N>,
	) -> CompactResult
	where
		N: VocabularyMut<Iri = I>,
		I: Clone + Eq + Hash,
		N::BlankId: 'a + Clone + Eq + Hash,
	{
		let doc = self.loaded_with(vocabulary, loader).await?;
		JsonLdProcessor::compact_full(doc.as_ref(), vocabulary, context, loader, options, warnings)
			.await
	}

	async fn flatten_full<'a, N>(
		&'a self,
		vocabulary: &'a mut N,
		generator: &'a mut impl Generator<N>,
		context: Option<RemoteContextReference<I>>,
		loader: &'a impl Loader,
		options: Options<I>,
		warnings: impl 'a + context_processing::WarningHandler<N> + expansion::WarningHandler<N>,
	) -> FlattenResult<I, N::BlankId>
	where
		N: VocabularyMut<Iri = I>,
		I: Clone + Eq + Hash,
		N::BlankId: 'a + Clone + Eq + Hash,
	{
		let doc = self.loaded_with(vocabulary, loader).await?;
		JsonLdProcessor::flatten_full(
			doc.as_ref(),
			vocabulary,
			generator,
			context,
			loader,
			options,
			warnings,
		)
		.await
	}
}