Merge pull request #42 from rodonile/imports

Add Schema Import support

Author: rwestphal

examples/schema_imports.rs

@@ -0,0 +1,56 @@
+use yang3::context::{Context, ContextFlags};
+
+static SEARCH_DIR: &str = "./assets/yang/";
+static MODULE_NAME: &str = "ietf-isis";
+
+fn main() -> std::io::Result<()> {
+    // Initialize context
+    let mut ctx = Context::new(ContextFlags::NO_YANGLIBRARY)
+        .expect("Failed to create context");
+
+    // Set search directory
+    ctx.set_searchdir(SEARCH_DIR)
+        .expect("Failed to set YANG search directory");
+
+    // Load the module
+    let module = ctx
+        .load_module(MODULE_NAME, None, &[])
+        .expect("Failed to load module");
+
+    // Get imports for the loaded module
+    let imports: Vec<_> = module.imports().collect();
+
+    println!("Module '{}' imports:\n", module.name());
+
+    // Check methods
+    for import in &imports {
+        println!("  Import: {}", import.name());
+        println!("    Prefix: {}", import.prefix());
+
+        if let Some(description) = import.description() {
+            println!("    Description: {}", description);
+        }
+
+        if let Some(reference) = import.reference() {
+            let reference_oneline =
+                reference.replace('\n', " ").replace('\r', " ");
+            println!("    Reference: {}", reference_oneline);
+        }
+
+        // Check module() method
+        let imported_module = import.module();
+        println!("      Name: {}", imported_module.name());
+        println!("      Namespace: {}", imported_module.namespace());
+
+        if let Some(filepath) = imported_module.filepath() {
+            println!("      File path: {}", filepath);
+        }
+
+        if let Some(revision) = imported_module.revision() {
+            println!("      Revision: {}", revision);
+        }
+        println!()
+    }
+
+    Ok(())
+}

src/schema.rs

@@ -38,6 +38,13 @@ pub struct SchemaSubmodule<'a> {
     pub(crate) raw: *mut ffi::lysp_submodule,
 }
 
+/// Available YANG schema tree structures representing YANG import.
+#[derive(Clone, Debug)]
+pub struct SchemaImport<'a> {
+    pub(crate) context: &'a Context,
+    pub(crate) raw: *mut ffi::lysp_import,
+}
+
 /// Schema input formats accepted by libyang.
 #[allow(clippy::upper_case_acronyms)]
 #[repr(u32)]
@@ -443,6 +450,17 @@ impl<'a> SchemaModule<'a> {
             self.notifications().flat_map(|snode| snode.traverse());
         data.chain(rpcs).chain(notifications)
     }
+
+    /// Returns an iterator over the list of imports.
+    pub fn imports(&self) -> impl Iterator<Item = SchemaImport<'a>> {
+        let parsed = unsafe { (*self.raw).parsed };
+        if parsed.is_null() {
+            return Array::new(self.context, std::ptr::null_mut(), 0);
+        }
+        let array = unsafe { (*parsed).imports };
+        let ptr_size = mem::size_of::<ffi::lysp_import>();
+        Array::new(self.context, array as *mut _, ptr_size)
+    }
 }
 
 unsafe impl<'a> Binding<'a> for SchemaModule<'a> {
@@ -529,6 +547,51 @@ impl PartialEq for SchemaSubmodule<'_> {
 unsafe impl Send for SchemaSubmodule<'_> {}
 unsafe impl Sync for SchemaSubmodule<'_> {}
 
+// ===== impl SchemaImport =====
+
+impl<'a> SchemaImport<'a> {
+    /// Import Module.
+    pub fn module(&self) -> SchemaModule<'_> {
+        let module = unsafe { (*self.raw).module };
+        unsafe { SchemaModule::from_raw(self.context, module) }
+    }
+
+    /// Import module name.
+    pub fn name(&self) -> &str {
+        char_ptr_to_str(unsafe { (*self.raw).name })
+    }
+
+    /// Prefix used to reference definitions from the import module.
+    pub fn prefix(&self) -> &str {
+        char_ptr_to_str(unsafe { (*self.raw).prefix })
+    }
+
+    /// Description of the import.
+    pub fn description(&self) -> Option<&str> {
+        char_ptr_to_opt_str(unsafe { (*self.raw).dsc })
+    }
+
+    /// Cross-reference for the import.
+    pub fn reference(&self) -> Option<&str> {
+        char_ptr_to_opt_str(unsafe { (*self.raw).ref_ })
+    }
+}
+
+unsafe impl<'a> Binding<'a> for SchemaImport<'a> {
+    type CType = ffi::lysp_import;
+    type Container = Context;
+
+    unsafe fn from_raw(
+        context: &'a Context,
+        raw: *mut ffi::lysp_import,
+    ) -> SchemaImport<'a> {
+        SchemaImport { context, raw }
+    }
+}
+
+unsafe impl Send for SchemaImport<'_> {}
+unsafe impl Sync for SchemaImport<'_> {}
+
 // ===== impl SchemaNode =====
 
 impl<'a> SchemaNode<'a> {

tests/schema.rs

@@ -634,3 +634,37 @@ fn test_extensions_uncompiled_modules() {
     let extensions = module.extensions().collect::<Vec<_>>();
     assert_eq!(extensions.len(), 0);
 }
+
+#[test]
+fn schema_module_imports() {
+    let mut ctx = create_context();
+
+    // Test a module that has imports
+    let module = ctx.get_module_latest("ietf-interfaces").unwrap();
+    let imports: Vec<_> = module.imports().collect();
+
+    // ietf-interfaces imports only ietf-yang-types
+    assert_eq!(imports.len(), 1);
+
+    // Test the ietf-yang-types import
+    let yang_types_import = &imports[0];
+    assert_eq!(yang_types_import.name(), "ietf-yang-types");
+    assert_eq!(yang_types_import.prefix(), "yang");
+    assert_eq!(yang_types_import.reference(), None);
+
+    // Test imported module access
+    let imported_module = yang_types_import.module();
+    assert_eq!(imported_module.name(), "ietf-yang-types");
+    assert_eq!(
+        imported_module.namespace(),
+        "urn:ietf:params:xml:ns:yang:ietf-yang-types"
+    );
+    assert_eq!(imported_module.reference(), None);
+
+    // Test a module with no imports (like ietf-restconf)
+    let module = ctx
+        .load_module("ietf-restconf", None, &[])
+        .expect("Failed to load module");
+    let module_imports: Vec<_> = module.imports().collect();
+    assert_eq!(module_imports.len(), 0);
+}