Lexicon support (#140)

spruceid · May 15, 2023 · 0f6e93a · 0f6e93a
1 parent 0e06bf3
commit 0f6e93a
Show file tree

Hide file tree

Showing 71 changed files with 4,294 additions and 1,000 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,6 +11,7 @@ members = [
 	"modules/rust/macros",
 	"modules/rust/cli",
 	"modules/rust/prelude",
+	"modules/lexicon"
 ]
 
 [workspace.package]
@@ -28,6 +29,7 @@ treeldr-json-ld-context = { path = "modules/json-ld-context", version = "0.1.0"
 treeldr-rust-gen = { path = "modules/rust/gen", version = "0.1.0" }
 treeldr-rust-macros = { path = "modules/rust/macros", version = "0.1.0" }
 treeldr-rust-prelude = { path = "modules/rust/prelude", version = "0.1.0" }
+treeldr-lexicon = { path = "modules/lexicon", version = "0.1.0" }
 
 log = "0.4"
 iref = "2.2"
@@ -45,14 +47,15 @@ thiserror = "1.0.31"
 decoded-char = "0.1.1"
 contextual = "0.1.3"
 json-ld = "0.14.0"
-json-syntax = "0.9.1"
+json-syntax = "0.9.4"
+serde = "1.0"
 
 chrono = "0.4.19"
 quote = "1.0"
 proc-macro2 = "1.0"
 syn = "2.0.15"
 
-clap = "3.0"
+clap = "4.0"
 async-std = "1.12.0"
 nquads-syntax = "0.12.0"
 

diff --git a/build/src/error/node_type_invalid.rs b/build/src/error/node_type_invalid.rs
@@ -9,9 +9,20 @@ use super::NodeBindingTypeInvalid;
 
 #[derive(Debug)]
 pub struct NodeTypeInvalid<M> {
-	pub id: Id,
-	pub expected: Type,
-	pub found: PropertyValues<Type, M>
+	id: Id,
+	expected: Type,
+	found: PropertyValues<Type, M>
+}
+
+impl<M> NodeTypeInvalid<M> {
+	pub fn new(
+		id: Id,
+		expected: Type,
+		found: PropertyValues<Type, M>
+	) -> Self {
+		// panic!("invalid type");
+		Self { id, expected, found }
+	}
 }
 
 impl<M> NodeTypeInvalid<M> {

diff --git a/build/src/layout/primitive.rs b/build/src/layout/primitive.rs
@@ -104,6 +104,12 @@ impl<M: Clone + Merge> BuildPrimitive<M> for Primitive {
 			Primitive::Url => Ok(treeldr::layout::RestrictedPrimitive::Url(
 				restrictions.try_map(|r| r.build(id))?,
 			)),
+			Primitive::Bytes => Ok(treeldr::layout::RestrictedPrimitive::Bytes(
+				restrictions.try_map(|r| r.build(id))?,
+			)),
+			Primitive::Cid => Ok(treeldr::layout::RestrictedPrimitive::Cid(
+				restrictions.try_map(|r| r.build(id))?,
+			)),
 		}
 	}
 }
diff --git a/build/src/resource.rs b/build/src/resource.rs
@@ -311,11 +311,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, Type::Class(None)) {
 			Ok(self.as_type())
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: Type::Class(None).into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				Type::Class(None).into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -326,11 +326,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, Type::Class(None)) {
 			Ok(treeldr::TId::new(self.data.id))
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: Type::Class(None).into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				Type::Class(None).into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -341,11 +341,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, ty::SubClass::DataType) {
 			Ok(self.as_datatype())
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: ty::SubClass::DataType.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				ty::SubClass::DataType.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -356,11 +356,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, ty::SubClass::DataType) {
 			Ok(treeldr::TId::new(self.data.id))
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: ty::SubClass::DataType.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				ty::SubClass::DataType.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -371,11 +371,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, ty::SubClass::Restriction) {
 			Ok(self.as_restriction())
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: ty::SubClass::Restriction.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				ty::SubClass::Restriction.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -386,11 +386,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, Type::LayoutRestriction) {
 			Ok(treeldr::TId::new(self.data.id))
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: Type::LayoutRestriction.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				Type::LayoutRestriction.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -401,11 +401,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, Type::DatatypeRestriction) {
 			Ok(self.as_datatype_restriction())
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: Type::DatatypeRestriction.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				Type::DatatypeRestriction.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -416,11 +416,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, Type::DatatypeRestriction) {
 			Ok(treeldr::TId::new(self.data.id))
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: Type::DatatypeRestriction.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				Type::DatatypeRestriction.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -431,11 +431,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, Type::Property(None)) {
 			Ok(self.as_property())
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: Type::Property(None).into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				Type::Property(None).into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -446,11 +446,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, Type::Property(None)) {
 			Ok(treeldr::TId::new(self.data.id))
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: Type::Property(None).into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				Type::Property(None).into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -461,11 +461,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, component::Type::Layout) {
 			Ok(self.as_layout())
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: component::Type::Layout.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				component::Type::Layout.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -476,11 +476,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, component::Type::Layout) {
 			Ok(treeldr::TId::new(self.data.id))
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: component::Type::Layout.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				component::Type::Layout.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -491,11 +491,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, component::formatted::Type::LayoutField) {
 			Ok(self.as_layout_field())
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: component::formatted::Type::LayoutField.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				component::formatted::Type::LayoutField.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -506,11 +506,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, component::formatted::Type::LayoutField) {
 			Ok(treeldr::TId::new(self.data.id))
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: component::formatted::Type::LayoutField.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				component::formatted::Type::LayoutField.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -521,11 +521,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, component::formatted::Type::LayoutVariant) {
 			Ok(self.as_layout_variant())
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: component::formatted::Type::LayoutVariant.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				component::formatted::Type::LayoutVariant.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -536,11 +536,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, component::formatted::Type::LayoutVariant) {
 			Ok(treeldr::TId::new(self.data.id))
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: component::formatted::Type::LayoutVariant.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				component::formatted::Type::LayoutVariant.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -551,11 +551,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, Type::LayoutRestriction) {
 			Ok(self.as_layout_restriction())
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: Type::LayoutRestriction.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				Type::LayoutRestriction.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -566,11 +566,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, Type::LayoutRestriction) {
 			Ok(treeldr::TId::new(self.data.id))
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: Type::LayoutRestriction.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				Type::LayoutRestriction.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}
 
@@ -581,11 +581,11 @@ impl<M: Clone> Definition<M> {
 		if self.has_type(context, Type::List) {
 			Ok(self.as_list())
 		} else {
-			Err(NodeTypeInvalid {
-				id: self.data.id,
-				expected: Type::List.into(),
-				found: self.data.type_.clone(),
-			})
+			Err(NodeTypeInvalid::new(
+				self.data.id,
+				Type::List.into(),
+				self.data.type_.clone(),
+			))
 		}
 	}