xmi 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa4e27e664d57a10744a5226b3aef8dfd3458e55aa95e83654bc0898b2426f18
-  data.tar.gz: f54767772c17fda9edaad58d8b899f9f0dac4f735a60cddbefe75ed6c3171092
+  metadata.gz: a6e11e8807b6e645ac8d6a3316ad055e34214aaa747925ee134ed6b5fd3a1cae
+  data.tar.gz: 0515d55369b0d206204e957d0cf0f835784d527fb8d658cdb06a1a43b66c2f8f
 SHA512:
-  metadata.gz: a65fc0ccd4efb06fc11cd74294a11dd00ab458a70feaa13d619af7c962aea887cac053e70b59fcaacc4b98b9688f719f4013aafa56e4dcfed05e0d6e791e2b69
-  data.tar.gz: f4e1bba099780038cac95ee69096b8fa052d2a53533c74d2894c36b8cc3419a99fe0ec302e161ff94259543f16b94641dcaf62dc2a2347a0ecb7794ad58ea514
+  metadata.gz: 5aa1d6b95aecb8e28587b8072268ad3b058bb3db819ec5fd3fe9d1d05a74affe81ddd1dfe7be9314a5e275f4e21db7006a2980c1687284a437ccaaf9d3e1c62a
+  data.tar.gz: d423ab53b4a06d9de7728a4c301d4861b218c1c512ab6745b51a2e3ecc0f18ac0335f8ee4ad157412576d28245188d69c1c87e590b47317de8207b54023a2602

data/.github/workflows/rake.yml

@@ -0,0 +1,14 @@
+name: rake
+
+on:
+  push:
+    branches: [ master, main ]
+    tags: [ v* ]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  rake:
+    uses: metanorma/ci/.github/workflows/graphviz-rake.yml@main
+    secrets:
+      pat_token: ${{ secrets.METANORMA_CI_PAT_TOKEN }}

data/.github/workflows/release.yml

@@ -0,0 +1,22 @@
+name: release
+
+on:
+  workflow_dispatch:
+    inputs:
+      next_version:
+        description: |
+          Next release version. Possible values: x.y.z, major, minor, patch or pre|rc|etc
+        required: true
+        default: 'skip'
+  push:
+    tags: [ v* ]
+
+jobs:
+  release:
+    uses: metanorma/ci/.github/workflows/rubygems-release.yml@main
+    with:
+      next_version: ${{ github.event.inputs.next_version }}
+    secrets:
+      rubygems-api-key: ${{ secrets.LUTAML_CI_RUBYGEMS_API_KEY }}
+      pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }}
+

data/.rubocop.yml

@@ -1,8 +1,14 @@
 AllCops:
   TargetRubyVersion: 3.0
+  Exclude:
+    - "lib/xmi/uml13/**/*.rb"
+    - "vendor/bundle/**/*"
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
+
+Documentation:
+  Enabled: false

data/README.adoc

@@ -1,5 +1,90 @@
-= XMI: OMG XMI parser
+= XMI
 
 == Purpose
 
-This parser provides a Ruby interface to OMG XMI (2.5.2) files.
+This Ruby object mapper is a module designed to convert XMI (XML Metadata Interchange) files into Ruby objects.  It can also leverage the `nokogiri` gem for XML parsing and provides methods to dynamically generate Ruby classes and modules based on the XML structure, particularly those related to EA (Enterprise Architect) MDG (Model Driven Generation) extensions.
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem "xmi"
+----
+
+And then execute:
+
+[source,shell]
+----
+$ bundle install
+----
+
+Or install it yourself as:
+
+[source,shell]
+----
+$ gem install xmi
+----
+
+== Usage
+
+=== Convert XMI file into Ruby objects
+
+To convert XMI file into Ruby objects, run:
+
+[source,ruby]
+----
+xml = "path/to/your/file.xmi"
+xml_content = File.read(xml)
+xmi_root_model = Xmi::Sparx::SparxRoot2013.from_xml(xml_content)
+----
+
+This method takes the path to an XMI file and generate the Ruby objects.
+
+=== Loading MDG Extensions and Generate Ruby Classes and Modules Dynamically
+
+To load an MDG extension from an XML file, use the `load_mdg_extension` method:
+
+[source,ruby]
+----
+Xmi::EaRoot.load_mdg_extension("path/to/your/mdg_extension.xml")
+
+xml = "path/to/your/file.xmi"
+xml_content = File.read(xml)
+xmi_root_model = Xmi::Sparx::SparxRoot2013.from_xml(xml_content)
+----
+
+`Xmi::EaRoot.load_mdg_extension` takes the path to an XML file and generate the
+Ruby classes and modules defined in XML file dynamically.
+Then, you can generate Ruby objects by `Xmi::Sparx::SparxRoot2013.from_xml`.
+
+=== Output Classes and Modules Generated from Extension into Ruby Files
+
+You can also generate Ruby files directly from the XMI content:
+
+[source,ruby]
+----
+Xmi::EaRoot.load_extension(
+  input_xml_path: 'path/to/your/custom_extension.xml',
+  module_name: 'CustomModule'
+)
+Xmi::EaRoot.output_rb_file('path/to/output_file.rb')
+----
+
+This approach allows you to save the dynamically generated Ruby code to a file for further use.
+
+== Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+
+== Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/xmi. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/xmi/blob/master/CODE_OF_CONDUCT.md).
+
+== Code of Conduct
+
+Everyone interacting in the Xmi project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/xmi/blob/master/CODE_OF_CONDUCT.md).

data/lib/xmi/documentation.rb

@@ -25,14 +25,14 @@ module Xmi
 
     xml do
       root "Documentation"
-      namespace "http://www.omg.org/spec/XMI/20131001", "xmlns"
+      namespace "http://www.omg.org/spec/XMI/20131001", "xmi"
 
-      map_attribute "id", to: :id, prefix: "xmlns", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "label", to: :label, prefix: "xmlns", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "uuid", to: :uuid, prefix: "xmlns", namespace: "http://www.omg.org/spec/XMI/20131001"
+      map_attribute "id", to: :id
+      map_attribute "label", to: :label
+      map_attribute "uuid", to: :uuid
       map_attribute "href", to: :href
-      map_attribute "idref", to: :idref, prefix: "xmlns", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "type", to: :type, prefix: "xmlns", namespace: "http://www.omg.org/spec/XMI/20131001"
+      map_attribute "idref", to: :idref
+      map_attribute "type", to: :type
       map_attribute "exporter", to: :exporter
       map_attribute "exporterVersion", to: :exporter_version
       map_attribute "exporterID", to: :exporter_id

data/lib/xmi/ea_root.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Xmi
+  class EaRoot # rubocop:disable Metrics/ClassLength
+    MODULE_TEMPLATE = <<~TEXT
+      module Xmi
+        class EaRoot
+          module #MODULE_NAME#
+      #KLASSES#
+          end
+        end
+      end
+    TEXT
+
+    KLASS_TEMPLATE = <<~TEXT
+            class #KLASS_NAME# < #FROM_KLASS#
+              #ROOT_TAG_LINE#
+
+      #ATTRIBUTES##XML_MAPPING#
+            end
+    TEXT
+
+    XML_MAPPING = <<~TEXT
+              xml do
+                root "#ROOT_TAG#"
+      #MAP_ATTRIBUTES#
+              end
+    TEXT
+
+    ATTRIBUTE_LINE = <<~TEXT
+      attribute :#TAG_NAME#, #ATTRIBUTE_TYPE#
+    TEXT
+
+    MAP_ATTRIBUTES = <<~TEXT
+      map_attribute "#ATTRIBUTE_NAME#", to: :#ATTRIBUTE_METHOD#
+    TEXT
+
+    MAP_ELEMENT = <<~TEXT
+      map_element "#ELEMENT_NAME#",
+                  to: :#ELEMENT_METHOD#,
+                  namespace: "#NAMESPACE#",
+                  prefix: "#PREFIX#"
+    TEXT
+
+    class << self
+      def load_mdg_extension(xml_path)
+        options = {}
+        options[:input_xml_path] = xml_path
+        options[:module_name] = "Mdg"
+        load_extension(options)
+        update_mdg_mappings
+      end
+
+      def load_extension(options)
+        @content = gen_content(options)
+        Object.class_eval @content
+      end
+
+      def output_rb_file(output_rb_path)
+        File.open(output_rb_path, "w") { |file| file.write(@content) }
+      end
+
+      private
+
+      def update_mdg_mappings
+        mdg_klasses = all_mdg_klasses
+        map_elements = construct_shale_xml_mappings(mdg_klasses)
+        sparx_roots.each do |sparx_root|
+          update_shale_attributes(mdg_klasses, sparx_root)
+          update_shale_xml_mappings(map_elements, sparx_root)
+        end
+      end
+
+      def construct_shale_xml_mappings(mdg_klasses)
+        map_elements = []
+        mdg_klasses.each do |klass|
+          next unless Xmi::EaRoot::Mdg.const_get(klass).respond_to? :root_tag
+
+          map_elements << MAP_ELEMENT
+                          .gsub("#ELEMENT_NAME#", Xmi::EaRoot::Mdg.const_get(klass).root_tag)
+                          .gsub("#ELEMENT_METHOD#", Shale::Utils.snake_case(klass.to_s))
+                          .gsub("#NAMESPACE#", @mdg_namespace[:uri])
+                          .gsub("#PREFIX#", @mdg_namespace[:name])
+        end
+
+        map_elements
+      end
+
+      def update_shale_attributes(mdg_klasses, sparx_root)
+        mdg_klasses.each do |klass|
+          method_name = Shale::Utils.snake_case(klass)
+          full_klass_name = "Xmi::EaRoot::Mdg::#{klass}"
+
+          attr_line = "#{ATTRIBUTE_LINE.rstrip}, collection: true"
+          attr_line = attr_line
+                      .gsub("#TAG_NAME#", method_name)
+                      .gsub("#ATTRIBUTE_TYPE#", full_klass_name)
+
+          sparx_root.class_eval(attr_line)
+        end
+      end
+
+      def update_shale_xml_mappings(map_elements, sparx_root)
+        new_mapping = sparx_root.class_variable_get("@@default_mapping")
+        new_mapping += map_elements.join("\n")
+        sparx_root.class_variable_set("@@mapping", new_mapping) # rubocop:disable Style/ClassVars
+
+        new_mapping_block = proc do
+          eval sparx_root.class_variable_get("@@mapping") # rubocop:disable Security/Eval
+        end
+        new_mapping = proc { xml(&new_mapping_block) }
+        sparx_root.class_eval(&new_mapping)
+      end
+
+      def sparx_roots
+        [Xmi::Sparx::SparxRoot, Xmi::Sparx::SparxRoot2013]
+      end
+
+      def all_mdg_klasses
+        Xmi::EaRoot::Mdg.constants.select do |c|
+          Xmi::EaRoot::Mdg.const_get(c).is_a? Class
+        end
+      end
+
+      def get_abstract_klass_node(xmi_doc)
+        xmi_doc.at_xpath(
+          "//UMLProfiles//Stereotypes//Stereotype[@isAbstract='true']"
+        )
+      end
+
+      def get_klass_name_from_node(node)
+        node.attribute_nodes.find { |attr| attr.name == "name" }.value
+      end
+
+      def gen_map_attribute_line(attr_name, attr_method)
+        space_before = " " * 10
+        method_name = Shale::Utils.snake_case(attr_method)
+
+        map_attributes = MAP_ATTRIBUTES
+                         .gsub("#ATTRIBUTE_NAME#", attr_name)
+                         .gsub("#ATTRIBUTE_METHOD#", method_name)
+
+        "#{space_before}#{map_attributes}"
+      end
+
+      def gen_attribute_line(tag_name, attribute_type = "Shale::Type::String")
+        tag_name = Shale::Utils.snake_case(tag_name)
+        space_before = " " * 8
+
+        attribute_line = ATTRIBUTE_LINE
+                         .gsub("#TAG_NAME#", tag_name)
+                         .gsub("#ATTRIBUTE_TYPE#", attribute_type)
+
+        "#{space_before}#{attribute_line}"
+      end
+
+      def get_tag_name(tag)
+        tag.attribute_nodes.find { |attr| attr.name == "name" }.value
+      end
+
+      def gen_tags(node)
+        tags = node.search("Tag")
+        attributes_lines = ""
+
+        tags.each do |tag|
+          tag_name = get_tag_name(tag)
+          attributes_lines += gen_attribute_line(tag_name)
+        end
+
+        [attributes_lines, tags]
+      end
+
+      def gen_abstract_klass
+        attributes_lines = ""
+        tags_lines, @abstract_tags = gen_tags(@abstract_klass_node)
+        attributes_lines += tags_lines
+        klass_name = get_klass_name_from_node(@abstract_klass_node)
+
+        KLASS_TEMPLATE
+          .gsub("#KLASS_NAME#", Shale::Utils.classify(klass_name))
+          .gsub("#FROM_KLASS#", "Shale::Mapper")
+          .gsub("#ATTRIBUTES#", attributes_lines.rstrip)
+          .gsub("#XML_MAPPING#", "")
+          .gsub("#ROOT_TAG_LINE#", "")
+      end
+
+      def gen_apply_types(node)
+        apply_types_lines = ""
+        apply_types_nodes = node.search("Apply")
+        apply_types_nodes.each do |n|
+          apply_types = n.attribute_nodes.map(&:value)
+          apply_types.each do |apply_type|
+            tag_name = "base_#{apply_type}"
+            apply_types_lines += gen_attribute_line(tag_name)
+          end
+        end
+
+        [apply_types_lines, apply_types_nodes]
+      end
+
+      def gen_generic_klass(node)
+        node_name = get_klass_name_from_node(node)
+        attributes_lines, map_attributes_lines = gen_klass_tags(node)
+        apply_types_lines, apply_types_nodes = gen_apply_types(node)
+        attributes_lines, map_attributes_lines = gen_klass_apply_types(
+          attributes_lines, map_attributes_lines,
+          apply_types_lines, apply_types_nodes
+        )
+
+        xml_mapping = replace_xml_mapping(node_name, map_attributes_lines)
+
+        replace_klass_template(node_name, attributes_lines, xml_mapping)
+      end
+
+      def gen_klass_apply_types(attributes_lines, map_attributes_lines, apply_types_lines, apply_types_nodes)
+        unless apply_types_nodes.empty?
+          attributes_lines += apply_types_lines
+          apply_types_nodes.each do |n|
+            apply_types = n.attribute_nodes.map(&:value)
+            apply_types.each do |apply_type|
+              map_attributes_lines += gen_map_attribute_line("base_#{apply_type}", "base_#{apply_type}")
+            end
+          end
+        end
+
+        [attributes_lines, map_attributes_lines]
+      end
+
+      def gen_klass_tags(node)
+        attributes_lines = ""
+        map_attributes_lines = ""
+
+        tags_lines, tags = gen_tags(node)
+        attributes_lines += tags_lines
+        (@abstract_tags + tags).each do |tag|
+          tag_name = get_tag_name(tag)
+          map_attributes_lines += gen_map_attribute_line(tag_name, tag_name)
+        end
+
+        [attributes_lines, map_attributes_lines]
+      end
+
+      def replace_xml_mapping(node_name, map_attributes_lines)
+        XML_MAPPING
+          .gsub("#ROOT_TAG#", node_name)
+          .gsub("#MAP_ATTRIBUTES#", "\n#{map_attributes_lines.rstrip}")
+          .rstrip
+      end
+
+      def replace_klass_template(node_name, attributes_lines, xml_mapping)
+        abstract_klass_name = get_klass_name_from_node(@abstract_klass_node)
+        root_tag_line = "def self.root_tag; \"#{node_name}\"; end"
+
+        KLASS_TEMPLATE
+          .gsub("#KLASS_NAME#", Shale::Utils.classify(node_name))
+          .gsub("#FROM_KLASS#", Shale::Utils.classify(abstract_klass_name))
+          .gsub("#ROOT_TAG_LINE#", root_tag_line)
+          .gsub("#ATTRIBUTES#", attributes_lines.rstrip)
+          .gsub("#XML_MAPPING#", "\n\n#{xml_mapping}")
+      end
+
+      def gen_generic_klasses(xmi_doc)
+        nodes = xmi_doc.xpath("//UMLProfiles//Stereotypes//Stereotype[not(contains(@isAbstract, 'true'))]")
+        klasses_lines = ""
+
+        nodes.each do |node|
+          # check baseStereotypes is abstract class
+          base_stereotypes = node.attribute_nodes.find do |attr|
+            attr.name == "baseStereotypes" && attr.value == get_klass_name_from_node(@abstract_klass_node)
+          end
+          next if base_stereotypes.nil?
+
+          klasses_lines += "#{gen_generic_klass(node)}\n"
+        end
+
+        klasses_lines
+      end
+
+      def gen_klasses(xmi_doc)
+        @abstract_klass_node = get_abstract_klass_node(xmi_doc)
+        klasses_lines = ""
+        klasses_lines += "#{gen_abstract_klass}\n"
+        klasses_lines += gen_generic_klasses(xmi_doc).rstrip
+        klasses_lines
+      end
+
+      def gen_module(xmi_doc, module_name)
+        MODULE_TEMPLATE
+          .gsub("#MODULE_NAME#", module_name)
+          .gsub("#KLASSES#", gen_klasses(xmi_doc))
+      end
+
+      def get_mdg_namespace(xmi_doc)
+        node = xmi_doc.at_xpath("//UMLProfile/Documentation")
+        namespace_key = node.attribute_nodes.find do |attr|
+          attr.name == "name"
+        end.value
+        namespace_uri = node.attribute_nodes.find do |attr|
+          attr.name == "URI"
+        end.value
+
+        { name: namespace_key, uri: namespace_uri }
+      end
+
+      def gen_content(options)
+        xml = options[:input_xml_path]
+        module_name = options[:module_name].capitalize
+        xmi_doc = Nokogiri::XML(File.open(xml).read)
+        @mdg_namespace = get_mdg_namespace(xmi_doc)
+        gen_module(xmi_doc, module_name)
+      end
+    end
+  end
+end

data/lib/xmi/extension.rb

@@ -17,12 +17,12 @@ module Xmi
       root "Extension"
       namespace "http://www.omg.org/spec/XMI/20131001", "xmi"
 
-      map_attribute "id", to: :id, prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "label", to: :label, prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "uuid", to: :uuid, prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
+      map_attribute "id", to: :id
+      map_attribute "label", to: :label
+      map_attribute "uuid", to: :uuid
       map_attribute "href", to: :href
-      map_attribute "idref", to: :idref, prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "type", to: :type, prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
+      map_attribute "idref", to: :idref
+      map_attribute "type", to: :type
       map_attribute "extender", to: :extender
       map_attribute "extenderID", to: :extender_id
     end

data/lib/xmi/root.rb

@@ -5,38 +5,61 @@ require_relative "documentation"
 require_relative "uml"
 
 module Xmi
+  module RootAttributes
+    def self.included(klass)
+      klass.class_eval do
+        attribute :id, Shale::Type::String
+        attribute :label, Shale::Type::String
+        attribute :uuid, Shale::Type::String
+        attribute :href, Shale::Type::String
+        attribute :idref, Shale::Type::String
+        attribute :type, Shale::Type::String
+        attribute :documentation, Documentation
+      end
+    end
+  end
+
   class Root < Shale::Mapper
-    attribute :id, Shale::Type::String
-    attribute :label, Shale::Type::String
-    attribute :uuid, Shale::Type::String
-    attribute :href, Shale::Type::String
-    attribute :idref, Shale::Type::String
-    attribute :type, Shale::Type::String
-    attribute :documentation, Documentation
+    include RootAttributes
     attribute :model, Uml::UmlModel
-    attribute :extension, Extension
 
     xml do
       root "XMI"
       namespace "http://www.omg.org/spec/XMI/20131001", "xmi"
 
-      map_attribute "id", to: :id, prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "label", to: :label, prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "uuid", to: :uuid, prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "href", to: :href
-      map_attribute "idref", to: :idref, prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
-      map_attribute "type", to: :type, prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
-
-      map_element "Documentation", to: :documentation,
-                                   prefix: "xmi", namespace: "http://www.omg.org/spec/XMI/20131001"
+      map_attribute "id", to: :id
+      map_attribute "label", to: :label
+      map_attribute "uuid", to: :uuid
+      map_attribute "href", to: :href, namespace: nil, prefix: nil
+      map_attribute "idref", to: :idref
+      map_attribute "type", to: :type
 
+      map_element "Documentation", to: :documentation
       map_element "Model", to: :model,
                            namespace: "http://www.omg.org/spec/UML/20161101",
                            prefix: "uml"
+    end
+  end
+
+  class Root2013 < Shale::Mapper
+    include RootAttributes
+    attribute :model, Uml::UmlModel2013
 
-      map_element "Extension", to: :extension,
-                               namespace: "http://www.omg.org/spec/XMI/20131001",
-                               prefix: "xmi"
+    xml do
+      root "XMI"
+      namespace "http://www.omg.org/spec/XMI/20131001", "xmi"
+
+      map_attribute "id", to: :id
+      map_attribute "label", to: :label
+      map_attribute "uuid", to: :uuid
+      map_attribute "href", to: :href, namespace: nil, prefix: nil
+      map_attribute "idref", to: :idref
+      map_attribute "type", to: :type
+
+      map_element "Documentation", to: :documentation
+      map_element "Model", to: :model,
+                           namespace: "http://www.omg.org/spec/UML/20131001",
+                           prefix: "uml"
     end
   end
 end

data/lib/xmi/root13.rb

@@ -3,7 +3,6 @@
 require "shale"
 
 module Xmi
-
   # OMG 1.3
   class EaXmiHeaderDocumentation < Shale::Mapper
     attribute :exporter, Shale::Type::String