update to latest oxrdf libs, remove rd-canon

Author: Porges

Cargo.lock

@@ -14,6 +14,6 @@ rust-version = "1.82.0"
 
 [workspace.dependencies]
 html2rdf = { path = "html2rdf" }
-oxiri = "^0.2.11"
-oxrdf = "^0.2.4"
-oxttl = "^0.1.8"
+oxiri = "0.2.11"
+oxrdf = "0.3.3"
+oxttl = "0.2.3"

Cargo.toml

@@ -18,13 +18,13 @@ itertools = "0.14.0"
 oxiri = { workspace = true }
 oxrdf = { workspace = true }
 oxsdatatypes = "0.2.2"
-rdf-canon = "0.15.1"
 rxml_validation = "0.11.0"
 scraper = "0.23.1"
 vec1 = "1.12.1"
 
 [dev-dependencies]
 insta = { version = "1.43.1", features = ["glob"] }
+oxrdf = { workspace = true, features = ["rdfc-10"] }
 oxttl = { workspace = true }
 pretty_assertions = "1.4.1"
 rstest = { version = "0.25.0", default-features = false, features = ["crate-name"] }

html2rdf/Cargo.toml

@@ -1,6 +1,5 @@
 use std::cell::RefCell;
 use std::collections::BTreeMap;
-use std::ops::Not;
 use std::rc::Rc;
 use std::{borrow::Cow, str::FromStr};
 
@@ -114,15 +113,15 @@ pub fn parse(
         let base_sel = scraper::selector::Selector::parse("html>head>base").unwrap();
 
         if let Some(base_el) = doc.select(&base_sel).next()
-            && let Some(base_href) = base_el.attr("href") {
-                base =
-                    Iri::parse(base_href.to_string()).map_err(|source| Error::IriParseError {
-                        source,
-                        iri: base_href.to_string(),
-                    })?;
-
-                trace!("<base> found: {base}");
-            }
+            && let Some(base_href) = base_el.attr("href")
+        {
+            base = Iri::parse(base_href.to_string()).map_err(|source| Error::IriParseError {
+                source,
+                iri: base_href.to_string(),
+            })?;
+
+            trace!("<base> found: {base}");
+        }
 
         let eval_context = EvaluationContext::new(base);
         proc.run(eval_context, doc)?;
@@ -815,7 +814,7 @@ impl HostLanguage for &HTMLHost {
 }
 
 fn emit_processor(pg: &mut Graph, pg_type: PGType, msg: &str) {
-    let warning_subj: oxrdf::Subject = oxrdf::BlankNode::default().into();
+    let warning_subj: oxrdf::NamedOrBlankNode = oxrdf::BlankNode::default().into();
     let pg_type: oxrdf::NamedNodeRef = pg_type.into();
     // new bnode is-a PGClass
     let node = TripleRef::new(&warning_subj, oxrdf::vocab::rdf::TYPE, pg_type);
@@ -970,9 +969,11 @@ impl<'o, 'p> RDFaProcessor<'o, 'p> {
             trace!(
                 "{}{}{} {attrs}",
                 ancestor_stack.join(">"),
-                if ancestor_stack
-                    .is_empty()
-                    .not() { ">" } else { Default::default() },
+                if ancestor_stack.is_empty() {
+                    Default::default()
+                } else {
+                    ">"
+                },
                 el.name()
             );
         }
@@ -1458,11 +1459,12 @@ impl<'o, 'p> RDFaProcessor<'o, 'p> {
         // “If in any of the previous steps a new subject
         //  was set to a non-null value different from the parent object;
         if let Some(ns) = &local.new_subject
-            && Some(ns) != eval_context.parent_object.as_ref() {
-                // “The list mapping taken from the evaluation context is set to a new, empty mapping.
-                trace!("- Setting new list mapping");
-                local.list_mappings = Default::default();
-            }
+            && Some(ns) != eval_context.parent_object.as_ref()
+        {
+            // “The list mapping taken from the evaluation context is set to a new, empty mapping.
+            trace!("- Setting new list mapping");
+            local.list_mappings = Default::default();
+        }
 
         // 9.
         // “If in any of the previous steps a current object resource was set to a non-null value,
@@ -1742,49 +1744,50 @@ impl<'o, 'p> RDFaProcessor<'o, 'p> {
         // “If the skip element flag is 'false', and new subject was set to a non-null value,
         //  then any incomplete triples within the current context should be completed:
         if !local.skip_element
-            && let Some(new_subject) = &local.new_subject {
-                // “The list of incomplete triples from the current evaluation context
-                //  (not the local list of incomplete triples) will contain zero or more predicate
-                //  IRIs. This list is iterated over and each of the predicates is used with parent
-                //  subject and new subject to generate a triple or add a new element to the local
-                //  list mapping. Note that at each level there are two lists of incomplete triples;
-                //  one for the current processing level (which is passed to each child element in
-                //  the previous step), and one that was received as part of the evaluation context.
-                //  It is the latter that is used in processing during this step.
-                for incomplete in eval_context.incomplete_triples.iter() {
-                    // “Note that each incomplete triple has a direction value that is used to determine
-                    //  what will become the subject, and what will become the object, of each generated triple:
-                    match incomplete {
-                        // “If direction is 'none',
-                        //  the new subject is added to the list from the iterated incomplete triple.
-                        IncompleteTriple::List(list) => list
-                            .borrow_mut()
-                            .push(Rc::new(new_subject.as_ref().clone().into())),
-                        // “If direction is 'forward' then the following triple is generated:
-                        IncompleteTriple::Forward(predicate) => {
-                            self.emit_output(TripleRef::new(
-                                // subject = parent subject
-                                eval_context.parent_subject.as_ref(),
-                                // predicate = the predicate from the iterated incomplete triple
-                                predicate.as_ref(),
-                                // object = new subject
-                                new_subject.as_ref(),
-                            ));
-                        }
-                        // “If direction is 'reverse' then this is the triple generated:
-                        IncompleteTriple::Reverse(predicate) => {
-                            self.emit_output(TripleRef::new(
-                                // subject = new subject
-                                new_subject.as_ref(),
-                                // predicate = the predicate from the iterated incomplete triple
-                                predicate.as_ref(),
-                                // object = parent subject
-                                eval_context.parent_subject.as_ref(),
-                            ));
-                        }
+            && let Some(new_subject) = &local.new_subject
+        {
+            // “The list of incomplete triples from the current evaluation context
+            //  (not the local list of incomplete triples) will contain zero or more predicate
+            //  IRIs. This list is iterated over and each of the predicates is used with parent
+            //  subject and new subject to generate a triple or add a new element to the local
+            //  list mapping. Note that at each level there are two lists of incomplete triples;
+            //  one for the current processing level (which is passed to each child element in
+            //  the previous step), and one that was received as part of the evaluation context.
+            //  It is the latter that is used in processing during this step.
+            for incomplete in eval_context.incomplete_triples.iter() {
+                // “Note that each incomplete triple has a direction value that is used to determine
+                //  what will become the subject, and what will become the object, of each generated triple:
+                match incomplete {
+                    // “If direction is 'none',
+                    //  the new subject is added to the list from the iterated incomplete triple.
+                    IncompleteTriple::List(list) => list
+                        .borrow_mut()
+                        .push(Rc::new(new_subject.as_ref().clone().into())),
+                    // “If direction is 'forward' then the following triple is generated:
+                    IncompleteTriple::Forward(predicate) => {
+                        self.emit_output(TripleRef::new(
+                            // subject = parent subject
+                            eval_context.parent_subject.as_ref(),
+                            // predicate = the predicate from the iterated incomplete triple
+                            predicate.as_ref(),
+                            // object = new subject
+                            new_subject.as_ref(),
+                        ));
+                    }
+                    // “If direction is 'reverse' then this is the triple generated:
+                    IncompleteTriple::Reverse(predicate) => {
+                        self.emit_output(TripleRef::new(
+                            // subject = new subject
+                            new_subject.as_ref(),
+                            // predicate = the predicate from the iterated incomplete triple
+                            predicate.as_ref(),
+                            // object = parent subject
+                            eval_context.parent_subject.as_ref(),
+                        ));
                     }
                 }
             }
+        }
 
         // 13.
         // “Next, all elements that are children of the current element are processed

html2rdf/src/lib.rs

@@ -188,13 +188,13 @@ struct EvaluationContext {
 
     // “The parent subject. The initial value will be the same as the initial value of base,
     //  but it will usually change during the course of processing.
-    parent_subject: Rc<oxrdf::Subject>,
+    parent_subject: Rc<oxrdf::NamedOrBlankNode>,
 
     // “The parent object. In some situations the object of a statement becomes the subject
     //  of any nested statements, and this member is used to convey this value. Note that this
     //  value may be a bnode, since in some situations a number of nested statements are grouped
     //  together on one bnode. This means that the bnode must be set in the containing statement and passed down.
-    parent_object: Option<Rc<oxrdf::Subject>>, // note that this is a subject, not an object, but the parent object cannot be a term
+    parent_object: Option<Rc<oxrdf::NamedOrBlankNode>>, // note that this is a subject, not an object, but the parent object cannot be a term
 
     // “A list of current, in-scope IRI mappings.
     iri_mappings: Rc<curie::PrefixMapping>,
@@ -237,11 +237,11 @@ struct LocalScope<'a> {
     skip_element: bool,
     // “A new subject value, which once calculated will set the parent subject in an evaluation context,
     //  as well as being used to complete any incomplete triples, as described in the next section.
-    new_subject: Option<Rc<oxrdf::Subject>>,
+    new_subject: Option<Rc<oxrdf::NamedOrBlankNode>>,
     // “A value for the current object resource, the resource to use when creating triples that have a resource object.
-    current_object_resource: Option<Rc<oxrdf::Subject>>,
+    current_object_resource: Option<Rc<oxrdf::NamedOrBlankNode>>,
     // “A value for the typed resource, the source for creating rdf:type relationships to types specified in @typeof.
-    typed_resource: Option<Rc<oxrdf::Subject>>,
+    typed_resource: Option<Rc<oxrdf::NamedOrBlankNode>>,
     // “The local term mappings, a list of terms and their associated IRIs.
     term_mappings: Rc<BTreeMap<String, oxrdf::NamedNode>>,
     // “The local list mapping, mapping IRIs to lists
@@ -704,7 +704,7 @@ impl HostLanguage for &HTMLHost {
 }
 
 fn emit_processor(pg: &mut Graph, pg_type: PGType, msg: &str) {
-    let warning_subj: oxrdf::Subject = oxrdf::BlankNode::default().into();
+    let warning_subj: oxrdf::NamedOrBlankNode = oxrdf::BlankNode::default().into();
     let pg_type: oxrdf::NamedNodeRef = pg_type.into();
     // new bnode is-a PGClass
     let node = TripleRef::new(&warning_subj, oxrdf::vocab::rdf::TYPE, pg_type);
@@ -743,7 +743,7 @@ impl<'o, 'p> RDFaProcessor<'o, 'p> {
     fn run(&mut self, eval_context: EvaluationContext, html: Html) -> Result<(), Error> {
         enum S<'a> {
             Child(ElementRef<'a>, Rc<EvaluationContext>),
-            OutputList(Rc<oxrdf::Subject>, Rc<RefCell<ListMapping>>),
+            OutputList(Rc<oxrdf::NamedOrBlankNode>, Rc<RefCell<ListMapping>>),
         }
 
         // TODO: we need a marker on the stack to emit list elements
@@ -1066,8 +1066,8 @@ impl<'o, 'p> RDFaProcessor<'o, 'p> {
         let inlist = el.attr("inlist").is_some();
 
         let has_about = el.attr("about").is_some();
-        let about: Option<Rc<oxrdf::Subject>> =
-            handle_safecurie_or_curie_or_iri(el.attr("about")).map(|x| Rc::new(x.into()));
+        let about: Option<Rc<oxrdf::NamedOrBlankNode>> =
+            handle_safecurie_or_curie_or_iri(el.attr("about")).map(Rc::new);
 
         let type_of = handle_term_or_curie_or_absiri_s(el.attr("typeof"));
 
@@ -1076,12 +1076,12 @@ impl<'o, 'p> RDFaProcessor<'o, 'p> {
         let src = handle_iri(el.attr("src"));
 
         // read from the "resource attributes"
-        let resource_iri: Option<Rc<oxrdf::Subject>> = resource
+        let resource_iri: Option<Rc<oxrdf::NamedOrBlankNode>> = resource
             .or_else(|| href.map(NamedOrBlankNode::from))
             .or_else(|| src.map(NamedOrBlankNode::from))
-            .map(|x| Rc::new(oxrdf::Subject::from(x)));
+            .map(Rc::new);
 
-        let _new_subject: Rc<oxrdf::Subject>;
+        let _new_subject: Rc<oxrdf::NamedOrBlankNode>;
 
         //5.
         // “If the current element contains no @rel or @rev attribute,