chore: run cargo fmt

lib/oxrdf/src/blank_node.rs

@@ -1,7 +1,7 @@
+use crate::{Term, TermCastError, TermCastErrorKind};
 use rand::random;
 use std::io::Write;
 use std::{fmt, str};
-use crate::{TermCastError, TermCastErrorKind, Term};
 
 /// An owned RDF [blank node](https://www.w3.org/TR/rdf11-concepts/#dfn-blank-node).
 ///
@@ -111,11 +111,10 @@ impl TryFrom<Term> for BlankNode {
         if let Term::BlankNode(node) = term {
             Ok(node)
         } else {
-            Err(TermCastErrorKind::Msg(format!(
+            Err(
-                "Cannot convert term to a blank node: {}",
+                TermCastErrorKind::Msg(format!("Cannot convert term to a blank node: {}", term))
-                term
+                    .into(),
-            ))
+            )
-            .into())
         }
     }
 }
@@ -382,13 +381,16 @@ mod tests {
 
     #[test]
     fn casting() {
-        let bnode: Result<BlankNode, TermCastError> = Term::BlankNode(BlankNode::new_from_unique_id(0x42)).try_into();
+        let bnode: Result<BlankNode, TermCastError> =
+            Term::BlankNode(BlankNode::new_from_unique_id(0x42)).try_into();
         assert_eq!(bnode.unwrap(), BlankNode::new_from_unique_id(0x42));
 
-        let literal: Result<BlankNode, TermCastError> = Term::Literal(Literal::new_simple_literal("Hello World!")).try_into();
+        let literal: Result<BlankNode, TermCastError> =
+            Term::Literal(Literal::new_simple_literal("Hello World!")).try_into();
         assert_eq!(literal.is_err(), true);
 
-        let named_node: Result<BlankNode, TermCastError> = Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()).try_into();
+        let named_node: Result<BlankNode, TermCastError> =
+            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()).try_into();
         assert_eq!(named_node.is_err(), true);
     }
 

lib/oxrdf/src/lib.rs

@@ -5,6 +5,7 @@
 #![doc(html_logo_url = "https://raw.githubusercontent.com/oxigraph/oxigraph/main/logo.svg")]
 
 mod blank_node;
+mod cast_error;
 pub mod dataset;
 pub mod graph;
 mod interning;
@@ -13,10 +14,10 @@ mod named_node;
 mod parser;
 mod triple;
 mod variable;
-mod cast_error;
 pub mod vocab;
 
 pub use crate::blank_node::{BlankNode, BlankNodeIdParseError, BlankNodeRef};
+pub use crate::cast_error::{TermCastError, TermCastErrorKind};
 pub use crate::dataset::Dataset;
 pub use crate::graph::Graph;
 pub use crate::literal::{Literal, LiteralRef};
@@ -27,6 +28,5 @@ pub use crate::triple::{
     SubjectRef, Term, TermRef, Triple, TripleRef,
 };
 pub use crate::variable::{Variable, VariableNameParseError, VariableRef};
-pub use crate::cast_error::{TermCastError, TermCastErrorKind};
 pub use oxilangtag::LanguageTagParseError;
 pub use oxiri::IriParseError;

lib/oxrdf/src/literal.rs

@@ -169,11 +169,10 @@ impl TryFrom<Term> for Literal {
         if let Term::Literal(node) = term {
             Ok(node)
         } else {
-            Err(TermCastErrorKind::Msg(format!(
+            Err(
-                "Cannot convert term to a literal: {}",
+                TermCastErrorKind::Msg(format!("Cannot convert term to a literal: {}", term))
-                term
+                    .into(),
-            ))
+            )
-            .into())
         }
     }
 }
@@ -677,16 +676,21 @@ mod tests {
         );
     }
 
-
     #[test]
     fn casting() {
-        let literal: Result<Literal, TermCastError> = Term::Literal(Literal::new_simple_literal("Hello World!")).try_into();
+        let literal: Result<Literal, TermCastError> =
-        assert_eq!(literal.unwrap(), Literal::new_simple_literal("Hello World!"));
+            Term::Literal(Literal::new_simple_literal("Hello World!")).try_into();
+        assert_eq!(
+            literal.unwrap(),
+            Literal::new_simple_literal("Hello World!")
+        );
 
-        let bnode: Result<Literal, TermCastError> = Term::BlankNode(BlankNode::new_from_unique_id(0x42)).try_into();
+        let bnode: Result<Literal, TermCastError> =
+            Term::BlankNode(BlankNode::new_from_unique_id(0x42)).try_into();
         assert_eq!(bnode.is_err(), true);
 
-        let named_node: Result<Literal, TermCastError> = Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()).try_into();
+        let named_node: Result<Literal, TermCastError> =
+            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()).try_into();
         assert_eq!(named_node.is_err(), true);
     }
 

lib/oxrdf/src/named_node.rs

@@ -1,7 +1,7 @@
+use crate::{Term, TermCastError, TermCastErrorKind};
 use oxiri::{Iri, IriParseError};
 use std::cmp::Ordering;
 use std::fmt;
-use crate::{TermCastErrorKind, Term, TermCastError};
 
 /// An owned RDF [IRI](https://www.w3.org/TR/rdf11-concepts/#dfn-iri).
 ///
@@ -226,11 +226,10 @@ impl TryFrom<Term> for NamedNode {
         if let Term::NamedNode(node) = term {
             Ok(node)
         } else {
-            Err(TermCastErrorKind::Msg(format!(
+            Err(
-                "Cannot convert term to a named node: {}",
+                TermCastErrorKind::Msg(format!("Cannot convert term to a named node: {}", term))
-                term
+                    .into(),
-            ))
+            )
-            .into())
         }
     }
 }
@@ -257,19 +256,25 @@ impl<'a> From<Iri<&'a str>> for NamedNodeRef<'a> {
 mod tests {
     #![allow(clippy::panic_in_result_fn)]
 
-    use crate::{Literal, BlankNode};
+    use crate::{BlankNode, Literal};
 
     use super::*;
 
     #[test]
     fn casting() {
-        let named_node: Result<NamedNode, TermCastError> = Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()).try_into();
+        let named_node: Result<NamedNode, TermCastError> =
-        assert_eq!(named_node.unwrap(), NamedNode::new("http://example.org/test").unwrap());
+            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()).try_into();
-        
+        assert_eq!(
-        let literal: Result<NamedNode, TermCastError> = Term::Literal(Literal::new_simple_literal("Hello World!")).try_into();
+            named_node.unwrap(),
+            NamedNode::new("http://example.org/test").unwrap()
+        );
+
+        let literal: Result<NamedNode, TermCastError> =
+            Term::Literal(Literal::new_simple_literal("Hello World!")).try_into();
         assert_eq!(literal.is_err(), true);
 
-        let bnode: Result<NamedNode, TermCastError> = Term::BlankNode(BlankNode::new_from_unique_id(0x42)).try_into();
+        let bnode: Result<NamedNode, TermCastError> =
+            Term::BlankNode(BlankNode::new_from_unique_id(0x42)).try_into();
         assert_eq!(bnode.is_err(), true);
     }
 }

lib/oxrdf/src/triple.rs

@@ -809,11 +809,7 @@ impl TryFrom<Term> for Box<Triple> {
         if let Term::Triple(node) = term {
             Ok(node)
         } else {
-            Err(TermCastErrorKind::Msg(format!(
+            Err(TermCastErrorKind::Msg(format!("Cannot convert term to a triple: {}", term)).into())
-                "Cannot convert term to a triple: {}",
-                term
-            ))
-            .into())
         }
     }
 }
@@ -1296,13 +1292,16 @@ mod tests {
         let t: Result<Box<Triple>, TermCastError> = Term::Triple(triple_box.clone()).try_into();
         assert_eq!(t.unwrap(), triple_box.clone());
 
-        let literal: Result<Box<Triple>, TermCastError> = Term::Literal(Literal::new_simple_literal("Hello World!")).try_into();
+        let literal: Result<Box<Triple>, TermCastError> =
+            Term::Literal(Literal::new_simple_literal("Hello World!")).try_into();
         assert_eq!(literal.is_err(), true);
 
-        let bnode: Result<Box<Triple>, TermCastError> = Term::BlankNode(BlankNode::new_from_unique_id(0x42)).try_into();
+        let bnode: Result<Box<Triple>, TermCastError> =
+            Term::BlankNode(BlankNode::new_from_unique_id(0x42)).try_into();
         assert_eq!(bnode.is_err(), true);
 
-        let named_node: Result<Box<Triple>, TermCastError> = Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()).try_into();
+        let named_node: Result<Box<Triple>, TermCastError> =
+            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()).try_into();
         assert_eq!(named_node.is_err(), true);
     }
 
@@ -1313,37 +1312,37 @@ mod tests {
         let optional_triple = Triple::new_from_terms(
             Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()),
             Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()),
-            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap())
+            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()),
         );
 
         let optional_triple_2 = Triple::new_from_terms(
             NamedNode::new("http://example.org/test").unwrap(),
             NamedNode::new("http://example.org/test").unwrap(),
-            NamedNode::new("http://example.org/test").unwrap()
+            NamedNode::new("http://example.org/test").unwrap(),
         );
 
         let bad_triple = Triple::new_from_terms(
             Term::BlankNode(BlankNode::new("abc123").unwrap()),
             Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()),
-            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap())
+            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()),
         );
 
         let bad_triple_2 = Triple::new_from_terms(
             BlankNode::new("abc123").unwrap(),
             NamedNode::new("http://example.org/test").unwrap(),
-            NamedNode::new("http://example.org/test").unwrap()
+            NamedNode::new("http://example.org/test").unwrap(),
         );
 
         let triple: Triple = Triple::new(
             Subject::NamedNode(NamedNode::new("http://example.org/test").unwrap()),
             NamedNode::new("http://example.org/test").unwrap(),
-            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap())
+            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()),
         );
 
         let triple_2: Triple = Triple::new(
             NamedNode::new("http://example.org/test").unwrap(),
             NamedNode::new("http://example.org/test").unwrap(),
-            NamedNode::new("http://example.org/test").unwrap()
+            NamedNode::new("http://example.org/test").unwrap(),
         );
 
         let unwrapped = optional_triple.unwrap();
@@ -1367,13 +1366,22 @@ mod tests {
         let t: Result<Subject, TermCastError> = Term::Triple(triple_box.clone()).try_into();
         assert_eq!(t.unwrap(), Subject::Triple(triple_box.clone()));
 
-        let literal: Result<Subject, TermCastError> = Term::Literal(Literal::new_simple_literal("Hello World!")).try_into();
+        let literal: Result<Subject, TermCastError> =
+            Term::Literal(Literal::new_simple_literal("Hello World!")).try_into();
         assert_eq!(literal.is_err(), true);
 
-        let bnode: Result<Subject, TermCastError> = Term::BlankNode(BlankNode::new_from_unique_id(0x42)).try_into();
+        let bnode: Result<Subject, TermCastError> =
-        assert_eq!(bnode.unwrap(), Subject::BlankNode(BlankNode::new_from_unique_id(0x42)));
+            Term::BlankNode(BlankNode::new_from_unique_id(0x42)).try_into();
+        assert_eq!(
+            bnode.unwrap(),
+            Subject::BlankNode(BlankNode::new_from_unique_id(0x42))
+        );
 
-        let named_node: Result<Subject, TermCastError> = Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()).try_into();
+        let named_node: Result<Subject, TermCastError> =
-        assert_eq!(named_node.unwrap(), Subject::NamedNode(NamedNode::new("http://example.org/test").unwrap()));
+            Term::NamedNode(NamedNode::new("http://example.org/test").unwrap()).try_into();
+        assert_eq!(
+            named_node.unwrap(),
+            Subject::NamedNode(NamedNode::new("http://example.org/test").unwrap())
+        );
     }
 }