import_graph: rewrite imports on root; add depth/cycle tests

Author: gtfierro

lib/src/api.rs

@@ -2,7 +2,7 @@
 //! This includes loading, saving, updating, and querying the environment.
 
 use crate::config::Config;
-use crate::consts::{ONTOLOGY, TYPE};
+use crate::consts::IMPORTS;
 use crate::doctor::{
     ConflictingPrefixes, Doctor, DuplicateOntology, OntologyDeclaration, OntologyProblem,
 };
@@ -12,9 +12,7 @@ use crate::transform;
 use crate::ToUriString;
 use crate::{EnvironmentStatus, FailedImport};
 use chrono::prelude::*;
-use oxigraph::model::{
-    Dataset, Graph, NamedNode, NamedNodeRef, NamedOrBlankNodeRef, TermRef, TripleRef,
-};
+use oxigraph::model::{Dataset, Graph, NamedNode, NamedNodeRef, NamedOrBlankNodeRef, TripleRef};
 use oxigraph::store::Store;
 use petgraph::visit::EdgeRef;
 use std::io::{BufReader, Write};
@@ -1419,6 +1417,9 @@ impl OntoEnv {
         recursion_depth: i32,
         root: NamedNodeRef,
     ) -> Result<Graph> {
+        let imported = self.get_ontology(id)?;
+        let imported_imports = imported.imports.clone();
+
         let closure = self.get_closure(id, recursion_depth)?;
         let mut union = self.get_union_graph(&closure, Some(true), Some(true))?;
 
@@ -1431,8 +1432,32 @@ impl OntoEnv {
         // Flatten dataset into a single graph, ignoring named graph labels.
         let mut graph = Graph::new();
         for quad in union.dataset.iter() {
+            // Drop owl:imports on non-root subjects to prevent retaining inner edges in cycles.
+            if quad.predicate == IMPORTS && quad.subject != root_nb {
+                continue;
+            }
             graph.insert(TripleRef::new(quad.subject, quad.predicate, quad.object));
         }
+        // Re-attach imports of the imported ontology and its dependencies onto the root; skip self-imports and dedup.
+        let closure_names: std::collections::HashSet<NamedNodeRef> =
+            closure.iter().map(|id| id.name()).collect();
+        let mut seen = std::collections::HashSet::new();
+        let mut add_import = |target: NamedNodeRef, dep: NamedNodeRef| {
+            if target == dep {
+                return;
+            }
+            if seen.insert(dep.to_string()) {
+                graph.insert(TripleRef::new(target, IMPORTS, dep));
+            }
+        };
+        for dep in imported_imports {
+            if closure_names.contains(&dep.as_ref()) {
+                add_import(root, dep.as_ref());
+            }
+        }
+        for dep_id in closure.iter().skip(1) {
+            add_import(root, dep_id.name());
+        }
         Ok(graph)
     }
 

lib/tests/test_ontoenv.rs

@@ -1,9 +1,12 @@
 use anyhow::Result;
 use ontoenv::api::{OntoEnv, ResolveTarget};
 use ontoenv::config::Config;
+use ontoenv::consts::IMPORTS;
 use ontoenv::ontology::OntologyLocation;
 use ontoenv::options::{CacheMode, Overwrite, RefreshStrategy};
 use oxigraph::model::NamedNodeRef;
+use oxigraph::model::NamedOrBlankNodeRef;
+use oxigraph::model::TermRef;
 use std::fs;
 use std::path::PathBuf;
 use std::thread;
@@ -178,11 +181,20 @@ ex:b ex:p ex:o .
         "Merged graph missing B data"
     );
 
-    // No owl:imports should remain
-    assert_eq!(
-        merged.triples_for_predicate(IMPORTS).count(),
-        0,
-        "Merged graph should not contain owl:imports"
+    // owl:imports should be rewritten onto the root (base) ontology
+    let imports: Vec<_> = merged
+        .triples_for_predicate(IMPORTS)
+        .filter(|t| t.subject == NamedOrBlankNodeRef::NamedNode(a_id.name()))
+        .collect();
+    assert!(
+        !imports.is_empty(),
+        "Merged graph should contain rewritten imports on the root"
+    );
+    assert!(
+        imports
+            .iter()
+            .all(|t| t.subject == NamedOrBlankNodeRef::NamedNode(a_id.name())),
+        "All imports should be on the root ontology"
     );
 
     // Only one owl:Ontology declaration (root) should remain
@@ -199,6 +211,178 @@ ex:b ex:p ex:o .
     Ok(())
 }
 
+#[test]
+fn import_graph_handles_cycles() -> Result<()> {
+    use ontoenv::consts::{IMPORTS, ONTOLOGY, TYPE};
+
+    let dir = TempDir::new("ontoenv-import-cycle")?;
+
+    let a_path = dir.path().join("A.ttl");
+    let b_path = dir.path().join("B.ttl");
+    let a_iri = format!("file://{}", a_path.display());
+    let b_iri = format!("file://{}", b_path.display());
+
+    fs::write(
+        &a_path,
+        format!(
+            "@prefix owl: <http://www.w3.org/2002/07/owl#> .\n@prefix ex: <http://example.com/A#> .\n<{a}> a owl:Ontology ; owl:imports <{b}> .\nex:A a owl:Class .\n",
+            a = a_iri,
+            b = b_iri
+        ),
+    )?;
+    fs::write(
+        &b_path,
+        format!(
+            "@prefix owl: <http://www.w3.org/2002/07/owl#> .\n@prefix ex: <http://example.com/B#> .\n<{b}> a owl:Ontology ; owl:imports <{a}> .\nex:B a owl:Class .\n",
+            a = a_iri,
+            b = b_iri
+        ),
+    )?;
+
+    let cfg = default_config(&dir);
+    let mut env = OntoEnv::init(cfg, false)?;
+    env.add(
+        OntologyLocation::File(a_path),
+        Overwrite::Allow,
+        RefreshStrategy::UseCache,
+    )?;
+    env.add(
+        OntologyLocation::File(b_path),
+        Overwrite::Allow,
+        RefreshStrategy::UseCache,
+    )?;
+
+    let a_id = env
+        .resolve(ResolveTarget::Location(OntologyLocation::from_str(&a_iri)?))
+        .unwrap();
+    let merged = env.import_graph(&a_id, -1)?;
+
+    // Single root ontology
+    let ontology_decls = merged
+        .triples_for_object(ONTOLOGY)
+        .filter(|t| t.predicate == TYPE)
+        .count();
+    assert_eq!(ontology_decls, 1);
+
+    // Imports rewritten onto root with no self-loop
+    let imports: Vec<_> = merged
+        .triples_for_predicate(IMPORTS)
+        .filter(|t| t.subject == NamedOrBlankNodeRef::NamedNode(a_id.name()))
+        .collect();
+    assert_eq!(imports.len(), 1);
+    if let TermRef::NamedNode(obj) = imports[0].object {
+        assert_eq!(obj.as_str(), b_iri);
+    } else {
+        panic!("Import object was not a NamedNode");
+    }
+
+    // No imports hanging off B
+    assert_eq!(
+        merged
+            .triples_for_predicate(IMPORTS)
+            .filter(|t| {
+                t.subject == NamedOrBlankNodeRef::NamedNode(NamedNodeRef::new_unchecked(&b_iri))
+            })
+            .count(),
+        0
+    );
+
+    // Data from both ontologies present
+    assert!(merged
+        .iter()
+        .any(|t| format!("{:?}", t.subject).contains("#A")));
+    assert!(merged
+        .iter()
+        .any(|t| format!("{:?}", t.subject).contains("#B")));
+
+    teardown(dir);
+    Ok(())
+}
+
+#[test]
+fn import_graph_respects_recursion_depth() -> Result<()> {
+    let dir = TempDir::new("ontoenv-import-depth")?;
+
+    let a_path = dir.path().join("A.ttl");
+    let b_path = dir.path().join("B.ttl");
+    let c_path = dir.path().join("C.ttl");
+
+    let a_iri = format!("file://{}", a_path.display());
+    let b_iri = format!("file://{}", b_path.display());
+    let c_iri = format!("file://{}", c_path.display());
+
+    fs::write(
+        &a_path,
+        format!(
+            "@prefix owl: <http://www.w3.org/2002/07/owl#> .\n<{a}> a owl:Ontology ; owl:imports <{b}> .",
+            a = a_iri, b = b_iri
+        ),
+    )?;
+    fs::write(
+        &b_path,
+        format!(
+            "@prefix owl: <http://www.w3.org/2002/07/owl#> .\n<{b}> a owl:Ontology ; owl:imports <{c}> .",
+            b = b_iri, c = c_iri
+        ),
+    )?;
+    fs::write(
+        &c_path,
+        format!(
+            "@prefix owl: <http://www.w3.org/2002/07/owl#> .\n<{c}> a owl:Ontology .",
+            c = c_iri
+        ),
+    )?;
+
+    let cfg = default_config(&dir);
+    let mut env = OntoEnv::init(cfg, false)?;
+    env.add(
+        OntologyLocation::File(a_path),
+        Overwrite::Allow,
+        RefreshStrategy::UseCache,
+    )?;
+    env.add(
+        OntologyLocation::File(b_path),
+        Overwrite::Allow,
+        RefreshStrategy::UseCache,
+    )?;
+    env.add(
+        OntologyLocation::File(c_path),
+        Overwrite::Allow,
+        RefreshStrategy::UseCache,
+    )?;
+
+    let a_id = env
+        .resolve(ResolveTarget::Location(OntologyLocation::from_str(&a_iri)?))
+        .unwrap();
+
+    // depth 0: only A (no imports attached)
+    let g0 = env.import_graph(&a_id, 0)?;
+    let imports0 = g0
+        .triples_for_predicate(IMPORTS)
+        .filter(|t| t.subject == NamedOrBlankNodeRef::NamedNode(a_id.name()))
+        .count();
+    assert_eq!(imports0, 0, "depth 0 should not carry imports on root");
+
+    // depth 1: A imports B
+    let g1 = env.import_graph(&a_id, 1)?;
+    let imports_b: Vec<_> = g1
+        .triples_for_predicate(IMPORTS)
+        .filter(|t| t.subject == NamedOrBlankNodeRef::NamedNode(a_id.name()))
+        .collect();
+    assert_eq!(imports_b.len(), 1);
+
+    // depth -1: full closure, includes C
+    let gfull = env.import_graph(&a_id, -1)?;
+    let imports_full: Vec<_> = gfull
+        .triples_for_predicate(IMPORTS)
+        .filter(|t| t.subject == NamedOrBlankNodeRef::NamedNode(a_id.name()))
+        .collect();
+    assert_eq!(imports_full.len(), 2);
+
+    teardown(dir);
+    Ok(())
+}
+
 #[cfg(unix)]
 mod unix_permission_tests {
     use super::*;

python/src/lib.rs

@@ -521,6 +521,25 @@ impl OntoEnv {
         };
         let root_node = root_node_owned.as_ref();
 
+        // Remove owl:imports in the destination graph only for ontologies that will be rewritten.
+        let imports_uri = uriref_constructor.call1((IMPORTS.as_str(),))?;
+        let closure_set: std::collections::HashSet<String> =
+            closure.iter().map(|c| c.to_uri_string()).collect();
+        let triples_to_remove_imports = destination_graph.call_method(
+            "triples",
+            ((py.None(), imports_uri, py.None()),),
+            None,
+        )?;
+        for triple in triples_to_remove_imports.try_iter()? {
+            let t = triple?;
+            let obj: Bound<'_, PyAny> = t.get_item(2)?;
+            if let Ok(s) = obj.str() {
+                if closure_set.contains(s.to_str()?) {
+                    destination_graph.getattr("remove")?.call1((t,))?;
+                }
+            }
+        }
+
         // Remove any ontology declarations in the destination that are not the chosen root.
         let triples_to_remove = destination_graph.call_method(
             "triples",
@@ -559,6 +578,19 @@ impl OntoEnv {
             )?;
             destination_graph.getattr("add")?.call1((t,))?;
         }
+        // Re-attach imports from the original closure onto the root in the destination graph.
+        for dep in closure.iter().skip(1) {
+            let dep_uri = dep.to_uri_string();
+            let t = PyTuple::new(
+                py,
+                &[
+                    uriref_constructor.call1((root_node.as_str(),))?,
+                    uriref_constructor.call1((IMPORTS.as_str(),))?,
+                    uriref_constructor.call1((dep_uri.as_str(),))?,
+                ],
+            )?;
+            destination_graph.getattr("add")?.call1((t,))?;
+        }
         Ok(())
     }