fix: Repaired the way prefixmap qualification works so the informatio…

…n about nodes appears with qualified IRIs

prefixmap/src/prefixmap.rs

@@ -214,6 +214,36 @@ impl PrefixMap {
     /// # Ok::<(), PrefixMapError>(())
     /// ```
     pub fn qualify(&self, iri: &IriS) -> String {
+        if let Some(qualified) = self.qualify_optional(iri) {
+            qualified
+        } else {
+            format!("<{iri}>")
+        }
+    }
+
+    /// Qualifies an IRI against a prefix map
+    /// ```
+    /// # use std::collections::HashMap;
+    /// # use prefixmap::PrefixMap;
+    /// # use prefixmap::PrefixMapError;
+    /// # use iri_s::*;
+    /// # use std::str::FromStr;
+    /// let pm = PrefixMap::from_hashmap(
+    ///   &HashMap::from([
+    ///     ("", "http://example.org/"),
+    ///     ("schema", "http://schema.org/")])
+    /// )?;
+    /// let a = IriS::from_str("http://example.org/a")?;
+    /// assert_eq!(pm.qualify(&a), ":a");
+    ///
+    /// let knows = IriS::from_str("http://schema.org/knows")?;
+    /// assert_eq!(pm.qualify(&knows), "schema:knows");
+    ///
+    /// let other = IriS::from_str("http://other.org/foo")?;
+    /// assert_eq!(pm.qualify(&other), "<http://other.org/foo>");
+    /// # Ok::<(), PrefixMapError>(())
+    /// ```
+    pub fn qualify_optional(&self, iri: &IriS) -> Option<String> {
         let mut founds: Vec<_> = self
             .map
             .iter()
@@ -237,22 +267,21 @@ impl PrefixMap {
                 Some(color) => ":".color(color),
                 None => ColoredString::from(":"),
             };
-            format!("{}{}{}", prefix_colored, semicolon_colored, rest_colored)
+            Some(format!(
+                "{}{}{}",
+                prefix_colored, semicolon_colored, rest_colored
+            ))
         } else {
-            format!("<{iri}>")
+            None
         };
         if self.hyperlink {
-            format!(
-                "\u{1b}]8;;{}\u{1b}\\{}\u{1b}]8;;\u{1b}\\",
-                iri.as_str(),
-                str
-            )
+            str.map(|s| format!("\u{1b}]8;;{}\u{1b}\\{}\u{1b}]8;;\u{1b}\\", s.as_str(), s))
         } else {
             str
         }
     }
 
-    /// Qualifies an IRI against a prefix map
+    /// Qualifies an IRI against a prefix map returning the length of the qualified string
     /// ```
     /// # use std::collections::HashMap;
     /// # use prefixmap::PrefixMap;

rudof_cli/src/main.rs

@@ -1201,7 +1201,11 @@ where
 {
     for node in node_selector.iter_node(rdf) {
         let subject = node_to_subject(node, rdf)?;
-        writeln!(writer, "Information about node")?;
+        writeln!(
+            writer,
+            "Information about {}",
+            rdf.qualify_subject(&subject)
+        )?;
 
         // Show outgoing arcs
         match show_node_mode {

sparql_service/src/srdf_data/rdf_data.rs

@@ -368,7 +368,16 @@ impl SRDFBasic for RdfData {
 
     fn qualify_iri(&self, node: &Self::IRI) -> String {
         let iri = IriS::from_str(node.as_str()).unwrap();
-        self.prefixmap_in_memory().qualify(&iri)
+        if let Some(graph) = &self.graph {
+            graph.prefixmap().qualify(&iri)
+        } else {
+            for e in self.endpoints.iter() {
+                if let Some(qualified) = e.prefixmap().qualify_optional(&iri) {
+                    return qualified;
+                }
+            }
+            format!("<{node}>")
+        }
     }
 
     fn qualify_subject(&self, subj: &Self::Subject) -> String {
@@ -394,7 +403,7 @@ impl SRDFBasic for RdfData {
         &self,
         prefix: &str,
         local: &str,
-    ) -> Result<iri_s::IriS, prefixmap::PrefixMapError> {
+    ) -> Result<IriS, prefixmap::PrefixMapError> {
         if let Some(graph) = self.graph() {
             let iri = graph.prefixmap().resolve_prefix_local(prefix, local)?;
             Ok(iri.clone())

srdf/src/srdf_basic.rs

@@ -143,5 +143,7 @@ pub trait SRDFBasic {
     fn qualify_term(&self, term: &Self::Term) -> String;
 
     fn prefixmap(&self) -> Option<PrefixMap>;
+
+    /// Resolves a a prefix and a local name and obtains the corresponding full `IriS`
     fn resolve_prefix_local(&self, prefix: &str, local: &str) -> Result<IriS, PrefixMapError>;
 }