xmi 0.5.3 → 0.5.5

data/lib/xmi/ea_root/code_generation.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Xmi
+  class EaRoot
+    module CodeGeneration
+      # Build extension classes directly via Class.new + const_set.
+      def build_extension(xml_path)
+        xmi_doc = Nokogiri::XML(File.read(xml_path))
+        @module_name = get_module_name(xmi_doc)
+        @def_namespace = get_namespace_from_definition(xmi_doc)
+
+        # Resolve namespace class (returns class object)
+        ns_class = resolve_namespace_class
+
+        # Create the parent module Xmi::EaRoot::ModuleName
+        mod = Module.new
+        EaRoot.const_set(@module_name.to_sym, mod)
+
+        # Process abstract class
+        @abstract_klass_node = get_abstract_klass_node(xmi_doc)
+        @abstract_tags = []
+        abstract_klass = nil
+        if @abstract_klass_node
+          abstract_klass = build_abstract_class(mod, @abstract_klass_node)
+        end
+
+        # Process non-abstract stereotypes
+        nodes = xmi_doc.xpath(
+          "//UMLProfiles//Stereotypes//Stereotype[not(contains(@isAbstract, 'true'))]",
+        )
+
+        # Without baseStereotypes
+        nodes.select { |n| n.attributes["baseStereotypes"].nil? }.each do |node|
+          build_stereotype_class(mod, node, abstract_klass, ns_class)
+        end
+
+        # With baseStereotypes
+        nodes.reject { |n| n.attributes["baseStereotypes"].nil? }.each do |node|
+          base_name = node.attributes["baseStereotypes"].value
+          build_stereotype_class(mod, node, abstract_klass, ns_class,
+                                 parent_name: base_name)
+        end
+      end
+
+      private
+
+      def build_abstract_class(parent_mod, abstract_node)
+        klass_name = Lutaml::Model::Utils.classify(
+          get_klass_name_from_node(abstract_node),
+        )
+
+        klass = Class.new(Lutaml::Model::Serializable)
+
+        # Add tag attributes (NO xml mapping for abstract classes)
+        tags = abstract_node.search("Tag")
+        @abstract_tags = tags
+        tags.each do |tag|
+          tag_name = get_tag_name(tag)
+          attr_name = Lutaml::Model::Utils.snake_case(tag_name)
+          klass.attribute attr_name.to_sym, :string
+        end
+
+        parent_mod.const_set(klass_name.to_sym, klass)
+        klass
+      end
+
+      def build_stereotype_class(parent_mod, node, abstract_klass, ns_class,
+                                 parent_name: nil)
+        node_name = get_klass_name_from_node(node)
+        klass_name = Lutaml::Model::Utils.classify(node_name)
+
+        # Determine parent class
+        parent_klass = if parent_name
+                         parent_mod.const_get(Lutaml::Model::Utils.classify(parent_name).to_sym)
+                       elsif abstract_klass
+                         abstract_klass
+                       else
+                         Lutaml::Model::Serializable
+                       end
+
+        # Collect tags and apply types
+        tags = node.search("Tag")
+        apply_nodes = node.search("Apply")
+
+        # Build the class
+        klass = Class.new(parent_klass) do
+          define_singleton_method(:root_tag) { node_name }
+        end
+
+        # Add tag attributes
+        tags.each do |tag|
+          tag_name = get_tag_name(tag)
+          attr_name = Lutaml::Model::Utils.snake_case(tag_name)
+          klass.attribute attr_name.to_sym, :string
+        end
+
+        # Add apply type attributes
+        apply_nodes.each do |n|
+          apply_types = n.attribute_nodes.map(&:value)
+          apply_types.each do |apply_type|
+            attr_name = Lutaml::Model::Utils.snake_case("base_#{apply_type}")
+            klass.attribute attr_name.to_sym, :string
+          end
+        end
+
+        # Add XML mapping
+        # Pre-compute tag mapping pairs (xml block runs in Mapping context, not EaRoot)
+        all_tag_pairs = (@abstract_tags + tags).map do |tag|
+          tag_name = get_tag_name(tag)
+          [tag_name, Lutaml::Model::Utils.snake_case(tag_name).to_sym]
+        end
+
+        apply_pairs = []
+        apply_nodes.each do |n|
+          n.attribute_nodes.map(&:value).each do |apply_type|
+            apply_pairs << [
+              "base_#{apply_type}",
+              Lutaml::Model::Utils.snake_case("base_#{apply_type}").to_sym,
+            ]
+          end
+        end
+
+        klass.xml do
+          root node_name
+          namespace ns_class
+
+          all_tag_pairs.each do |xml_name, attr_sym|
+            map_attribute xml_name, to: attr_sym
+          end
+
+          apply_pairs.each do |xml_name, attr_sym|
+            map_attribute xml_name, to: attr_sym
+          end
+        end
+
+        parent_mod.const_set(klass_name.to_sym, klass)
+        klass
+      end
+    end
+  end
+end

data/lib/xmi/ea_root/extension_lifecycle.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Xmi
+  class EaRoot
+    module ExtensionLifecycle
+      def update_mappings(module_name)
+        new_klasses = all_new_klasses(module_name)
+        inject_model_attributes(new_klasses, module_name)
+        inject_model_xml_mappings(new_klasses, module_name)
+      end
+
+      private
+
+      def inject_model_attributes(new_klasses, module_name)
+        sparx_root = Xmi::Sparx::SparxRoot
+        new_klasses.each do |klass_name|
+          method_name = Lutaml::Model::Utils.snake_case(klass_name)
+          full_klass = EaRoot.const_get(module_name).const_get(klass_name)
+          sparx_root.attribute method_name.to_sym, full_klass, collection: true
+        end
+      end
+
+      def inject_model_xml_mappings(new_klasses, module_name)
+        map_entries = []
+        new_klasses.each do |klass_name|
+          klass = EaRoot.const_get(module_name).const_get(klass_name)
+          next unless klass.respond_to?(:root_tag)
+
+          method_name = Lutaml::Model::Utils.snake_case(klass_name)
+          map_entries << [klass.root_tag, method_name.to_sym]
+        end
+
+        return if map_entries.empty?
+
+        Xmi::Sparx::SparxRoot.class_eval do
+          xml do
+            map_entries.each do |element_name, method_sym|
+              map_element element_name, to: method_sym,
+                                        value_map: Xmi::VALUE_MAP
+            end
+          end
+        end
+      end
+
+      def all_new_klasses(module_name)
+        EaRoot.const_get(module_name).constants.select do |c|
+          EaRoot.const_get(module_name).const_get(c).is_a? Class
+        end
+      end
+    end
+  end
+end

data/lib/xmi/ea_root/namespace_handling.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Xmi
+  class EaRoot
+    module NamespaceHandling
+      # Resolve the namespace class for the current extension.
+      # Returns the class object (not a name string) for direct use with
+      # the xml DSL's +namespace+ directive.
+      def resolve_namespace_class
+        uri = @def_namespace[:uri]
+        prefix = @def_namespace[:name]
+
+        existing = NamespaceRegistry.resolve(uri)
+        return existing if existing
+
+        module_name = @module_name
+        ns_class_name = "Xmi::Namespace::Dynamic::#{module_name}"
+        return Object.const_get(ns_class_name) if Object.const_defined?(ns_class_name)
+
+        Namespace.ensure_dynamic_namespace_module_exists!
+        ns_class = Class.new(Lutaml::Xml::Namespace) do
+          define_singleton_method(:uri) { uri }
+          define_singleton_method(:prefix_default) { prefix }
+        end
+        Namespace::Dynamic.const_set(module_name, ns_class)
+
+        NamespaceRegistry.register(uri, ns_class)
+
+        ns_class
+      end
+
+      # Returns the namespace class _name_ as a string.
+      def find_or_create_namespace_class
+        klass = resolve_namespace_class
+        klass.is_a?(String) ? klass : klass.name
+      end
+    end
+  end
+end

data/lib/xmi/ea_root/xml_parsing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Xmi
+  class EaRoot
+    module XmlParsing
+      def get_abstract_klass_node(xmi_doc)
+        xmi_doc.at_xpath(
+          "//UMLProfiles//Stereotypes//Stereotype[@isAbstract='true']",
+        )
+      end
+
+      def get_klass_name_from_node(node)
+        return Lutaml::Model::Serializable.to_s unless node
+
+        node.attribute_nodes.find { |attr| attr.name == "name" }.value
+      end
+
+      def get_module_name(xmi_doc)
+        get_module_name_from_definition(xmi_doc).capitalize
+      end
+
+      def get_module_name_from_definition(xmi_doc)
+        node = xmi_doc.at_xpath("//UMLProfile/Documentation")
+        node.attribute_nodes.find { |attr| attr.name == "name" }&.value
+      end
+
+      def get_module_uri(xmi_doc)
+        node = xmi_doc.at_xpath("//UMLProfile/Documentation")
+        uri = node.attribute_nodes.find { |attr| attr.name == "URI" }&.value
+        return uri if uri
+
+        name = get_module_name_from_definition(xmi_doc)
+        ver = node.attribute_nodes.find { |attr| attr.name == "version" }&.value
+
+        "http://www.sparxsystems.com/profiles/#{name}/#{ver}"
+      end
+
+      def get_namespace_from_definition(xmi_doc)
+        namespace_key = get_module_name_from_definition(xmi_doc)
+        namespace_uri = get_module_uri(xmi_doc)
+
+        { name: namespace_key, uri: namespace_uri }
+      end
+
+      def get_tag_name(tag)
+        tag_name = tag.attribute_nodes.find { |attr| attr.name == "name" }.value
+        tag_name == "xmlns" ? "altered_xmlns" : tag_name
+      end
+    end
+  end
+end