1pub use json_event_parser::TextPosition;
2use json_event_parser::{JsonParseError, JsonSyntaxError};
3use std::fmt::Formatter;
4use std::ops::Range;
5use std::{fmt, io};
6
7#[derive(Debug, thiserror::Error)]
9pub enum JsonLdParseError {
10 #[error(transparent)]
12 Io(#[from] io::Error),
13 #[error(transparent)]
15 Syntax(#[from] JsonLdSyntaxError),
16}
17
18impl From<JsonLdParseError> for io::Error {
19 #[inline]
20 fn from(error: JsonLdParseError) -> Self {
21 match error {
22 JsonLdParseError::Io(error) => error,
23 JsonLdParseError::Syntax(error) => error.into(),
24 }
25 }
26}
27
28#[doc(hidden)]
29impl From<JsonParseError> for JsonLdParseError {
30 #[inline]
31 fn from(error: JsonParseError) -> Self {
32 match error {
33 JsonParseError::Io(error) => Self::Io(error),
34 JsonParseError::Syntax(error) => Self::Syntax(error.into()),
35 }
36 }
37}
38
39#[derive(Debug, thiserror::Error)]
41#[error(transparent)]
42pub struct JsonLdSyntaxError(#[from] SyntaxErrorKind);
43
44#[derive(Debug, thiserror::Error)]
45enum SyntaxErrorKind {
46 #[error(transparent)]
47 Json(#[from] JsonSyntaxError),
48 #[error("{msg}")]
49 Msg { msg: String, code: JsonLdErrorCode },
50}
51
52impl JsonLdSyntaxError {
53 pub fn code(&self) -> Option<JsonLdErrorCode> {
55 match &self.0 {
56 SyntaxErrorKind::Json(_) => None,
57 SyntaxErrorKind::Msg { code, .. } => Some(*code),
58 }
59 }
60
61 pub fn location(&self) -> Option<Range<TextPosition>> {
63 match &self.0 {
64 SyntaxErrorKind::Json(e) => Some(e.location()),
65 SyntaxErrorKind::Msg { .. } => None,
66 }
67 }
68
69 pub(crate) fn msg_and_code(msg: impl Into<String>, code: JsonLdErrorCode) -> Self {
71 Self(SyntaxErrorKind::Msg {
72 msg: msg.into(),
73 code,
74 })
75 }
76}
77
78impl From<JsonLdSyntaxError> for io::Error {
79 #[inline]
80 fn from(error: JsonLdSyntaxError) -> Self {
81 match error.0 {
82 SyntaxErrorKind::Json(error) => error.into(),
83 SyntaxErrorKind::Msg { msg, .. } => Self::new(io::ErrorKind::InvalidData, msg),
84 }
85 }
86}
87
88#[doc(hidden)]
89impl From<JsonSyntaxError> for JsonLdSyntaxError {
90 #[inline]
91 fn from(error: JsonSyntaxError) -> Self {
92 Self(SyntaxErrorKind::Json(error))
93 }
94}
95
96#[derive(Debug, Clone, Copy)]
98#[non_exhaustive]
99pub enum JsonLdErrorCode {
100 CollidingKeywords,
103 ConflictingIndexes,
105 ContextOverflow,
107 CyclicIriMapping,
109 InvalidIdValue,
111 InvalidImportValue,
113 InvalidIncludedValue,
115 InvalidIndexValue,
117 InvalidNestValue,
119 InvalidPrefixValue,
121 InvalidPropagateValue,
123 InvalidProtectedValue,
125 InvalidReverseValue,
127 InvalidVersionValue,
129 InvalidBaseDirection,
131 InvalidBaseIri,
133 InvalidContainerMapping,
136 InvalidContextEntry,
138 InvalidContextNullification,
140 InvalidDefaultLanguage,
142 InvalidIriMapping,
144 InvalidJsonLiteral,
146 InvalidKeywordAlias,
148 InvalidLanguageMapValue,
151 InvalidLanguageMapping,
154 InvalidLanguageTaggedString,
156 InvalidLanguageTaggedValue,
158 InvalidLocalContext,
160 InvalidRemoteContext,
162 InvalidReverseProperty,
164 InvalidReversePropertyMap,
167 InvalidReversePropertyValue,
170 InvalidScopedContext,
172 InvalidSetOrListObject,
174 InvalidStreamingKeyOrder,
176 InvalidTermDefinition,
178 InvalidTypeMapping,
180 InvalidTypeValue,
183 InvalidTypedValue,
185 InvalidValueObject,
187 InvalidValueObjectValue,
190 InvalidVocabMapping,
192 IriConfusedWithPrefix,
195 KeywordRedefinition,
197 LoadingDocumentFailed,
199 LoadingRemoteContextFailed,
201 ProcessingModeConflict,
203 ProtectedTermRedefinition,
205}
206
207impl fmt::Display for JsonLdErrorCode {
208 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
209 f.write_str(match self {
210 Self::CollidingKeywords => "colliding keywords",
211 Self::ConflictingIndexes => "conflicting indexes",
212 Self::ContextOverflow => "context overflow",
213 Self::CyclicIriMapping => "cyclic IRI mapping",
214 Self::InvalidIdValue => "invalid @id value",
215 Self::InvalidImportValue => "invalid @import value",
216 Self::InvalidIncludedValue => "invalid @included value",
217 Self::InvalidIndexValue => "invalid @index value",
218 Self::InvalidNestValue => "invalid @nest value",
219 Self::InvalidPrefixValue => "invalid @prefix value",
220 Self::InvalidPropagateValue => "invalid @propagate value",
221 Self::InvalidProtectedValue => "invalid @protected value",
222 Self::InvalidReverseValue => "invalid @reverse value",
223 Self::InvalidVersionValue => "invalid @version value",
224 Self::InvalidBaseDirection => "invalid base direction",
225 Self::InvalidBaseIri => "invalid base IRI",
226 Self::InvalidContainerMapping => "invalid container mapping",
227 Self::InvalidContextEntry => "invalid context entry",
228 Self::InvalidContextNullification => "invalid context nullification",
229 Self::InvalidDefaultLanguage => "invalid default language",
230 Self::InvalidIriMapping => "invalid IRI mapping",
231 Self::InvalidJsonLiteral => "invalid JSON literal",
232 Self::InvalidKeywordAlias => "invalid keyword alias",
233 Self::InvalidLanguageMapValue => "invalid language map value",
234 Self::InvalidLanguageMapping => "invalid language mapping",
235 Self::InvalidLanguageTaggedString => "invalid language-tagged string",
236 Self::InvalidLanguageTaggedValue => "invalid language-tagged value",
237 Self::InvalidLocalContext => "invalid local context",
238 Self::InvalidRemoteContext => "invalid remote context",
239 Self::InvalidReverseProperty => "invalid reverse property",
240 Self::InvalidReversePropertyMap => "invalid reverse property map",
241 Self::InvalidReversePropertyValue => "invalid reverse property value",
242 Self::InvalidScopedContext => "invalid scoped context",
243 Self::InvalidSetOrListObject => "invalid set or list object",
244 Self::InvalidStreamingKeyOrder => "invalid streaming key order",
245 Self::InvalidTermDefinition => "invalid term definition",
246 Self::InvalidTypeMapping => "invalid type mapping",
247 Self::InvalidTypeValue => "invalid type value",
248 Self::InvalidTypedValue => "invalid typed value",
249 Self::InvalidValueObject => "invalid value object",
250 Self::InvalidValueObjectValue => "invalid value object value",
251 Self::InvalidVocabMapping => "invalid vocab mapping",
252 Self::IriConfusedWithPrefix => "IRI confused with prefix",
253 Self::KeywordRedefinition => "keyword redefinition",
254 Self::LoadingDocumentFailed => "loading document failed",
255 Self::LoadingRemoteContextFailed => "loading remote context failed",
256 Self::ProcessingModeConflict => "processing mode conflict",
257 Self::ProtectedTermRedefinition => "protected term redefinition",
258 })
259 }
260}