support recursive models and registering with sdf_version = nil

Author: Rezenders

lib/sdf/xml.rb

@@ -165,7 +165,8 @@ def self.gazebo_models(sdf_version = nil)
         #
         # @param [String] model_name the target name in the cache
         # @param [REXML::Document,REXML::Element,String] xml_doc the XML model representation
-        def self.register_in_memory_model(model_name, xml_doc, sdf_version: nil)
+        # @param [Hash,nil] metadata the pre-resolved include metadata
+        def self.register_in_memory_model(model_name, xml_doc, sdf_version: nil, metadata: nil)
             xml = case xml_doc
                   when REXML::Document
                       xml_doc
@@ -186,19 +187,24 @@ def self.register_in_memory_model(model_name, xml_doc, sdf_version: nil)
                 end
             end
 
+            virtual_path = "virtual://#{model_name}"
+            metadata ||= {}
+            metadata["includes"] ||= {}
+            metadata["path"]     ||= virtual_path
+
             @gazebo_models[sdf_version] ||= {}
             cache = (@gazebo_models[sdf_version][model_name] ||= ModelCacheEntry.new)
-            cache.path = "virtual://#{model_name}"
-            cache.xml = xml
-            cache.metadata = { "includes" => {}, "path" => cache.path }
+            cache.path     = metadata["path"]
+            cache.xml      = xml
+            cache.metadata = metadata
 
             # Also register under nil as a generic fallback
             if sdf_version
                 @gazebo_models[nil] ||= {}
                 cache_nil = (@gazebo_models[nil][model_name] ||= ModelCacheEntry.new)
-                cache_nil.path = "virtual://#{model_name}"
-                cache_nil.xml = xml
-                cache_nil.metadata = { "includes" => {}, "path" => cache_nil.path }
+                cache_nil.path     = cache.path
+                cache_nil.xml      = xml
+                cache_nil.metadata = metadata
             end
         end
 
@@ -231,6 +237,14 @@ def self.model_path_from_name(model_name, model_path: @model_path, sdf_version:
             cache = (@gazebo_models[sdf_version][model_name] ||= ModelCacheEntry.new)
             return cache.path if cache.path
 
+            # Fallback to the nil cache for virtual in-memory models
+            if sdf_version && (nil_cache = @gazebo_models.dig(nil, model_name)) && nil_cache.path && nil_cache.path.start_with?("virtual://")
+                cache.path = nil_cache.path
+                cache.xml = nil_cache.xml if nil_cache.xml
+                cache.metadata = nil_cache.metadata if nil_cache.metadata
+                return cache.path
+            end
+
             model_path.each do |p|
                 model_dir = File.join(p, model_name)
                 if File.file?(File.join(model_dir, "model.config"))
@@ -508,16 +522,23 @@ def self.sdf_version_of(sdf)
         # @raise [NotSDF] if the file is not a SDF file
         # @raise [InvalidXML] if the file is not a valid XML file
         # @return [REXML::Element]
-        def self.load_sdf(sdf_file, flatten: true, metadata: false)
-            sdf = load_sdf_raw(sdf_file)
+        # Processes an in-memory SDF XML tree, resolving its include tags and relative URIs
+        #
+        # @param [REXML::Document] sdf the XML tree
+        # @param [Boolean] flatten flattens the XML model or not
+        # @param [Boolean] metadata returns a metadata hash or not
+        # @param [String,nil] path the file path or virtual path representing the SDF
+        # @return [REXML::Element, [REXML::Element, Hash]]
+        def self.resolve_sdf_xml(sdf, flatten: true, metadata: false, path: nil)
             sdf_version = sdf_version_of(sdf)
+            base_path = path ? File.dirname(path) : nil
 
-            sdf_metadata = Hash["includes" => {}, "path" => sdf_file]
-            includes = add_include_tags(sdf.root, sdf_version, File.dirname(sdf_file))
+            sdf_metadata = Hash["includes" => {}, "path" => path]
+            includes = add_include_tags(sdf.root, sdf_version, base_path)
             sdf_metadata["includes"].merge!(includes) do |_, old, new|
                 old + new
             end
-            resolve_relative_uris(sdf.root, sdf_version, File.dirname(sdf_file))
+            resolve_relative_uris(sdf.root, sdf_version, base_path)
 
             sdf = deep_copy_xml(sdf)
             flatten_model_tree(sdf.root) if flatten
@@ -527,6 +548,15 @@ def self.load_sdf(sdf_file, flatten: true, metadata: false)
             else
                 sdf
             end
+        end
+
+        # Loads a SDF file and returns the XML representation
+        #
+        # Unlike {.load_sdf_raw}, this resolves the include tags in the XML representation
+        def self.load_sdf(sdf_file, flatten: true, metadata: false)
+            sdf = load_sdf_raw(sdf_file)
+            sdf = deep_copy_xml(sdf)
+            resolve_sdf_xml(sdf, flatten: flatten, metadata: metadata, path: sdf_file)
         rescue Exception => e
             raise e, "while loading #{sdf_file}: #{e.message}", e.backtrace
         end

test/test_xml.rb

@@ -440,7 +440,7 @@ def sdf_model_in_model_that_replaces_pose_in_include
                 SDF::XML.register_in_memory_model("virtual_model", doc)
 
                 assert SDF::XML.cached_model?("virtual_model")
-                assert_equal doc, SDF::XML.model_from_name("virtual_model", flatten: false)
+                assert_equal doc.to_s, SDF::XML.model_from_name("virtual_model", flatten: false).to_s
             end
 
             it "allows registering a model as a REXML::Element" do
@@ -452,7 +452,7 @@ def sdf_model_in_model_that_replaces_pose_in_include
 
                 assert SDF::XML.cached_model?("virtual_el")
                 loaded = SDF::XML.model_from_name("virtual_el", flatten: false)
-                assert_equal element, loaded.root
+                assert_equal element.to_s, loaded.root.to_s
             end
 
             it "allows registering a model as a raw XML String" do
@@ -471,6 +471,38 @@ def sdf_model_in_model_that_replaces_pose_in_include
                     SDF::XML.register_in_memory_model("invalid_model", 12_345)
                 end
             end
+
+            it "falls back to the nil version cache if the requested version is not registered" do
+                doc = REXML::Document.new("<model name='virtual_fallback'/>")
+                # Register exclusively under nil (unversioned) cache by passing nil explicitly
+                SDF::XML.register_in_memory_model("virtual_fallback", doc, sdf_version: nil)
+
+                # Requesting with specific version 160 should fall back and load successfully
+                loaded = SDF::XML.model_from_name("virtual_fallback", 160, flatten: false)
+                assert_equal "virtual_fallback", loaded.root.attributes["name"]
+            end
+
+            it "resolves nested inclusions within in-memory models at registration time" do
+                submodel_doc = REXML::Document.new("<sdf version='1.6'><model name='sub'><link name='sub_link'/></model></sdf>")
+                SDF::XML.register_in_memory_model("submodel", submodel_doc)
+
+                # Register a parent model containing an include to the submodel
+                parent_doc = REXML::Document.new(
+                    "<sdf version='1.6'>" \
+                    "  <model name='parent'>" \
+                    "    <include><uri>model://submodel</uri><name>included_sub</name></include>" \
+                    "  </model>" \
+                    "</sdf>"
+                )
+                resolved_doc, metadata = SDF::XML.resolve_sdf_xml(parent_doc, flatten: false, metadata: true, path: "virtual://parent_model")
+                SDF::XML.register_in_memory_model("parent_model", resolved_doc, metadata: metadata)
+
+                # Retrieve with flatten: true (which requires all inclusions to be resolved)
+                loaded = SDF::XML.model_from_name("parent_model", flatten: true)
+
+                # Verify that the submodel's links are present in the flattened parent tree
+                assert loaded.elements["//link[@name='included_sub::sub_link']"]
+            end
         end
         it "raises if the model cannot be found" do
             exception = assert_raises(SDF::XML::NoSuchModel) do