xmi 0.3.21 → 0.5.0

data/lib/xmi/sparx/mappings/base_mapping.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module SparxMappings
+      # Base XML mapping class for Sparx EA XMI documents.
+      #
+      # This reusable mapping class encapsulates all the XML element → attribute
+      # mappings for SparxRoot, eliminating the previous eval hack.
+      #
+      # @example Use in a model class
+      #   class SparxRoot < Root
+      #     xml SparxMappings::BaseMapping
+      #   end
+      #
+      # @example Extend with additional mappings
+      #   class ExtendedRoot < Root
+      #     xml SparxMappings::GmlMapping
+      #   end
+      class BaseMapping < Lutaml::Xml::Mapping
+        xml do
+          # Set the default namespace for element name resolution
+          namespace ::Xmi::Namespace::Omg::Xmi
+
+          namespace_scope [
+            ::Xmi::Namespace::Omg::Xmi,
+            ::Xmi::Namespace::Omg::Uml,
+            ::Xmi::Namespace::Omg::UmlDi,
+            ::Xmi::Namespace::Omg::UmlDc,
+            ::Xmi::Namespace::Sparx::Extension,
+            ::Xmi::Namespace::Sparx::SysPhS,
+            ::Xmi::Namespace::Sparx::Gml,
+            ::Xmi::Namespace::Sparx::EaUml,
+            ::Xmi::Namespace::Sparx::CustomProfile,
+            ::Xmi::Namespace::Sparx::CityGml,
+          ]
+
+          # Extension element containing Sparx EA-specific metadata
+          map_element "Extension", to: :extension
+
+          # Modelica parameter elements (SysPhS profile)
+          map_element "ModelicaParameter", to: :modelica_parameter
+
+          # UML import elements (EAUML profile)
+          map_element "import", to: :eauml_import,
+                                value_map: {
+                                  from: {
+                                    nil: :empty,
+                                    empty: :empty,
+                                    omitted: :empty,
+                                  },
+                                  to: {
+                                    nil: :empty,
+                                    empty: :empty,
+                                    omitted: :empty,
+                                  },
+                                }
+
+          # GML ApplicationSchema elements
+          map_element "ApplicationSchema", to: :gml_application_schema,
+                                           value_map: {
+                                             from: {
+                                               nil: :empty,
+                                               empty: :empty,
+                                               omitted: :empty,
+                                             },
+                                             to: {
+                                               nil: :empty,
+                                               empty: :empty,
+                                               omitted: :empty,
+                                             },
+                                           }
+
+          # GML CodeList elements
+          map_element "CodeList", to: :gml_code_list,
+                                  value_map: {
+                                    from: {
+                                      nil: :empty,
+                                      empty: :empty,
+                                      omitted: :empty,
+                                    },
+                                    to: {
+                                      nil: :empty,
+                                      empty: :empty,
+                                      omitted: :empty,
+                                    },
+                                  }
+
+          # GML DataType elements
+          map_element "DataType", to: :gml_data_type,
+                                  value_map: {
+                                    from: {
+                                      nil: :empty,
+                                      empty: :empty,
+                                      omitted: :empty,
+                                    },
+                                    to: {
+                                      nil: :empty,
+                                      empty: :empty,
+                                      omitted: :empty,
+                                    },
+                                  }
+
+          # GML Union elements
+          map_element "Union", to: :gml_union,
+                               value_map: {
+                                 from: {
+                                   nil: :empty,
+                                   empty: :empty,
+                                   omitted: :empty,
+                                 },
+                                 to: {
+                                   nil: :empty,
+                                   empty: :empty,
+                                   omitted: :empty,
+                                 },
+                               }
+
+          # GML Enumeration elements
+          map_element "Enumeration", to: :gml_enumeration,
+                                     value_map: {
+                                       from: {
+                                         nil: :empty,
+                                         empty: :empty,
+                                         omitted: :empty,
+                                       },
+                                       to: {
+                                         nil: :empty,
+                                         empty: :empty,
+                                         omitted: :empty,
+                                       },
+                                     }
+
+          # GML Type elements
+          map_element "Type", to: :gml_type,
+                              value_map: {
+                                from: {
+                                  nil: :empty,
+                                  empty: :empty,
+                                  omitted: :empty,
+                                },
+                                to: {
+                                  nil: :empty,
+                                  empty: :empty,
+                                  omitted: :empty,
+                                },
+                              }
+
+          # GML FeatureType elements
+          map_element "FeatureType", to: :gml_feature_type,
+                                     value_map: {
+                                       from: {
+                                         nil: :empty,
+                                         empty: :empty,
+                                         omitted: :empty,
+                                       },
+                                       to: {
+                                         nil: :empty,
+                                         empty: :empty,
+                                         omitted: :empty,
+                                       },
+                                     }
+
+          # GML property elements
+          map_element "property", to: :gml_property,
+                                  value_map: {
+                                    from: {
+                                      nil: :empty,
+                                      empty: :empty,
+                                      omitted: :empty,
+                                    },
+                                    to: {
+                                      nil: :empty,
+                                      empty: :empty,
+                                      omitted: :empty,
+                                    },
+                                  }
+        end
+      end
+    end
+  end
+end

data/lib/xmi/sparx/mappings.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module SparxMappings
+      # Reusable XML mapping classes for Sparx EA XMI documents.
+      autoload :BaseMapping, "xmi/sparx/mappings/base_mapping"
+    end
+  end
+end

data/lib/xmi/sparx/primitive_type.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    module PrimitiveType
+      class PrimitiveTypes < Lutaml::Model::Serializable
+        attribute :packaged_element, Uml::PackagedElement, collection: true
+
+        xml do
+          root "primitivetypes"
+
+          map_element "packagedElement", to: :packaged_element,
+                                         value_map: VALUE_MAP
+        end
+      end
+    end
+  end
+end

data/lib/xmi/sparx/root.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    class SparxRoot < Root
+      attribute :modelica_parameter, SysPhS
+
+      attribute :eauml_import, EaUml::Import, collection: true
+      attribute :gml_application_schema, Gml::ApplicationSchema,
+                collection: true
+      attribute :gml_code_list, Gml::CodeList, collection: true
+      attribute :gml_data_type, Gml::CodeList, collection: true
+      attribute :gml_union, Gml::CodeList, collection: true
+      attribute :gml_enumeration, Gml::CodeList, collection: true
+      attribute :gml_type, Gml::CodeList, collection: true
+      attribute :gml_feature_type, Gml::CodeList, collection: true
+      attribute :gml_property, Gml::Property, collection: true
+
+      attribute :extension, Extension
+      attribute :model, Uml::UmlModel
+
+      class << self
+        # Parse XMI content into Ruby objects.
+        #
+        # This method uses automatic version detection to handle different XMI
+        # namespace versions (e.g., XMI 20110701, 20131001, 20161101) and
+        # their corresponding UML versions.
+        #
+        # @param xml_content [String] The raw XMI XML content
+        # @return [SparxRoot] The parsed Ruby object
+        #
+        # @see Xmi.parse
+        def parse_xml(xml_content)
+          xml_content = fix_encoding(xml_content)
+          Xmi.init_versioning!
+          Xmi::VersionRegistry.parse_with_detected_version(xml_content, self)
+        end
+
+        # Fix invalid UTF-8 encoding in the XML content.
+        #
+        # Some EA-generated XMI files contain invalid UTF-8 byte sequences
+        # that would cause parsing failures. This method replaces invalid
+        # bytes with placeholder characters.
+        #
+        # @param xml_content [String] The raw XML content
+        # @return [String] The XML content with valid UTF-8 encoding
+        def fix_encoding(xml_content)
+          return xml_content if xml_content.valid_encoding?
+
+          xml_content
+            .encode("UTF-16be", invalid: :replace, replace: "?")
+            .encode("UTF-8")
+        end
+      end
+
+      # Use the reusable BaseMapping class instead of eval hack
+      xml SparxMappings::BaseMapping
+    end
+  end
+end

data/lib/xmi/sparx/sys_ph_s.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Xmi
+  module Sparx
+    class SysPhS < Lutaml::Model::Serializable
+      attribute :base_package, :string
+      attribute :name, :string
+
+      xml do
+        root "ModelicaParameter"
+        namespace ::Xmi::Namespace::Sparx::SysPhS
+
+        map_attribute "base_Package", to: :base_package
+        map_attribute "name", to: :name
+      end
+    end
+  end
+end