ea 0.5.0 → 0.5.2

data/lib/ea/svg/ea_emitter/element/stereotype_icon_renderer.rb

@@ -28,22 +28,63 @@ module Ea
           OFFSET_X = 0
           OFFSET_Y = 0
 
-          attr_reader :classifier, :bounds, :canvas
+          attr_reader :classifier, :bounds, :canvas, :mdg_registry
 
-          def initialize(classifier:, bounds:, canvas: nil)
+          # @param mdg_registry [Ea::Mdg::Registry, nil] optional
+          #   registry to look up MDG-provided ShapeScript for the
+          #   classifier's stereotype. When provided and the matching
+          #   stereotype has a ShapeScript body, it's parsed and
+          #   rendered. Otherwise falls back to FALLBACK_ICONS.
+          def initialize(classifier:, bounds:, canvas: nil, mdg_registry: nil)
             @classifier = classifier
             @bounds = bounds
             @canvas = canvas
+            @mdg_registry = mdg_registry
           end
 
-          def self.render(classifier:, bounds:, canvas: nil, **_)
-            new(classifier: classifier, bounds: bounds, canvas: canvas).to_svg
+          def self.render(classifier:, bounds:, canvas: nil, **opts)
+            new(classifier: classifier, bounds: bounds, canvas: canvas, **opts).to_svg
           end
 
-          # @return [String] SVG polygon fragment, or "" if no icon applies
+          # @return [String] SVG fragment, or "" if no icon applies
           def to_svg
             return "" unless classifier && bounds
+            return "" unless stereotype_name
 
+            shapescript_svg || fallback_svg
+          end
+
+          private
+
+          # Try MDG-provided ShapeScript first.
+          # @return [String, nil] SVG fragment from parsed ShapeScript
+          def shapescript_svg
+            return nil unless mdg_registry
+
+            body = lookup_shapescript(stereotype_name)
+            return nil unless body
+
+            shapes = Ea::Shapescript::Parser.parse(body)
+            return nil if shapes.empty?
+
+            Ea::Shapescript::Renderer.render(shapes, fill: "#FAF1EC",
+                                             stroke: "#69738C")
+          end
+
+          # @return [String, nil] ShapeScript source for the stereotype, if any
+          def lookup_shapescript(name)
+            mdg_registry.documents.each do |doc|
+              stereo = (doc.stereotypes || []).find { |s| s.name == name }
+              next unless stereo
+
+              notes = stereo.notes
+              return notes if notes && notes.include?("shape")
+            end
+            nil
+          end
+
+          # @return [String] hardcoded fallback polygon, or "" if none
+          def fallback_svg
             spec = FALLBACK_ICONS[stereotype_name]
             return "" unless spec
 
@@ -55,15 +96,11 @@ module Ea
             %(<polygon points="#{pts_str}" fill="#{fill}" stroke="#{stroke}" stroke-width="1"/>)
           end
 
-          private
-
           def stereotype_name
-            refs = classifier.respond_to?(:stereotype_refs) ? classifier.stereotype_refs : nil
-            return refs.first if refs&.any?
+            return nil unless classifier.is_a?(Ea::Model::Classifier)
 
-            # Walk xref description as a fallback when classifier has no
-            # explicit stereotype_refs slot (e.g. raw Ea::Qea::Models::EaObject).
-            nil
+            refs = classifier.stereotype_refs
+            refs&.first
           end
 
           def translate_point(x, y)

data/lib/ea/transformers/qea_to_xmi/transformer.rb

@@ -70,8 +70,144 @@ module Ea
         # nil-valued attributes are skipped at the source. No
         # post-processing pass is needed — the prior XmlSanitizer
         # workaround (TODO 21 §1) has been removed.
-        def serialize
-          build_root.to_xml(use_prefix: true)
+        # Serialize to XMI XML.
+        #
+        # Default produces model tree only (parseable by the xmi gem's
+        # Sparx parser for round-trip). Pass `with_extensions: true` to
+        # also emit EA-specific `<connectors>` and `<diagrams>` sections
+        # inside `<xmi:Extension>`. Those use post-processing string
+        # injection that the xmi gem's parser doesn't model, so the
+        # output is NOT round-trippable when extensions are included.
+        #
+        # @param with_extensions [Boolean]
+        # @return [String] XMI XML
+        def serialize(with_extensions: true)
+          xml = build_root.to_xml(use_prefix: true)
+          with_extensions ? inject_extension_content(xml) : xml
+        end
+
+        # Injects EA-specific extension content (connectors, diagrams)
+        # into the serialized XMI. The xmi gem's Extension type is
+        # modeled but doesn't declare `connectors` / `diagrams`
+        # children. We post-process the serialized XML to insert
+        # them inside the existing `<xmi:Extension>` element.
+        def inject_extension_content(xml)
+          content = extension_inner_xml
+          return xml if content.empty?
+
+          # Replace the empty `<xmi:Extension .../>` or the
+          # closing `</xmi:Extension>` with the populated version.
+          if xml.include?("<xmi:Extension")
+            xml.sub(%r{<xmi:Extension ([^>]+)>\s*</xmi:Extension>},
+                   "<xmi:Extension \\1>\n#{content}\n\t</xmi:Extension>")
+               .sub(/<xmi:Extension ([^>]+)\/>/,
+                    "<xmi:Extension \\1>\n#{content}\n\t</xmi:Extension>")
+          else
+            xml
+          end
+        end
+
+        # @return [String] XML for the inner content of <xmi:Extension>:
+        #   <elements>...</elements>, <connectors>...</connectors>,
+        #   <diagrams>...</diagrams>. Empty when none apply.
+        def extension_inner_xml
+          parts = []
+          connectors_xml = build_connectors_extension
+          parts << connectors_xml unless connectors_xml.empty?
+          diagrams_xml = build_diagrams_extension
+          parts << diagrams_xml unless diagrams_xml.empty?
+          parts.join("\n")
+        end
+
+        def build_connectors_extension
+          connectors = @database.collections[:connectors] || []
+          return "" if connectors.empty?
+
+          inner = connectors.map { |conn| connector_xml(conn) }.compact.join("\n")
+          return "" if inner.empty?
+
+          "\t\t<connectors>\n#{inner}\n\t\t</connectors>"
+        end
+
+        def build_diagrams_extension
+          diagrams = @database.collections[:diagrams] || []
+          return "" if diagrams.empty?
+
+          inner = diagrams.map { |dgm| diagram_xml(dgm) }.compact.join("\n")
+          return "" if inner.empty?
+
+          "\t\t<diagrams>\n#{inner}\n\t\t</diagrams>"
+        end
+
+        # Per-connector XML with xmi:idref to the model-level
+        # association (when present) plus source/target references.
+        def connector_xml(conn)
+          return nil unless conn.ea_guid
+
+          connector_id = "EAID_#{guid_to_xmi_id(conn.ea_guid)}"
+          source_obj = @database.collections[:objects]&.find { |o| o.ea_object_id == conn.start_object_id }
+          target_obj = @database.collections[:objects]&.find { |o| o.ea_object_id == conn.end_object_id }
+          return nil unless source_obj && target_obj
+
+          name_attr = conn.name ? %( name="#{escape(conn.name)}") : ""
+          inner = source_end_xml(conn, source_obj) + target_end_xml(conn, target_obj)
+          %(<connector xmi:idref="#{connector_id}"#{name_attr}>\n#{inner}\t\t</connector>)
+        end
+
+        def source_end_xml(conn, source_obj)
+          end_xml(source_obj, "source")
+        end
+
+        def target_end_xml(conn, target_obj)
+          end_xml(target_obj, "target")
+        end
+
+        def end_xml(obj, kind)
+          xmi_id = "EAID_#{guid_to_xmi_id(obj.ea_guid)}"
+          lines = [
+            "\t\t\t<#{kind} xmi:idref=\"#{xmi_id}\">",
+            "\t\t\t\t<model ea_localid=\"#{obj.ea_object_id}\" " \
+              "type=\"#{obj.object_type}\" name=\"#{escape(obj.name.to_s)}\"/>",
+            "\t\t\t\t<role visibility=\"Public\" targetScope=\"instance\"/>",
+            "\t\t\t</#{kind}>"
+          ]
+          lines.join("\n") + "\n"
+        end
+
+        def diagram_xml(dgm)
+          return nil unless dgm.ea_guid
+
+          diagram_id = "EAID_#{guid_to_xmi_id(dgm.ea_guid)}"
+          pkg_guid = package_guid_for(dgm)
+          pkg_ref = pkg_guid ? "EAPK_#{guid_to_xmi_id(pkg_guid)}" : ""
+          lines = [
+            "<diagram xmi:id=\"#{diagram_id}\">",
+            "\t\t\t<model package=\"#{pkg_ref}\" localID=\"#{dgm.diagram_id}\" owner=\"#{pkg_ref}\"/>",
+            "\t\t\t<properties name=\"#{escape(dgm.name.to_s)}\" type=\"#{escape(dgm.diagram_type.to_s)}\"/>",
+            "\t\t</diagram>"
+          ]
+          lines.join("\n")
+        end
+
+        def package_guid_for(dgm)
+          pkg = (@database.collections[:packages] || []).find { |p| p.package_id == dgm.package_id }
+          pkg&.ea_guid || dgm.ea_guid
+        end
+
+        def guid_to_xmi_id(guid)
+          return "" unless guid
+
+          guid.to_s.gsub(/[{}]/, "")
+                  .tr("-", "_")
+                  .prepend("EA") # truncated below
+                  .sub(/\AEA/, "")
+        end
+
+        def escape(text)
+          text.to_s.gsub("&", "&amp;")
+               .gsub("<", "&lt;")
+               .gsub(">", "&gt;")
+               .gsub('"', "&quot;")
         end
 
         private

data/lib/ea/transformers.rb

@@ -25,9 +25,10 @@ module Ea
       # Sparx-specific concepts (stereotypes, tagged values, multiplicities,
       # diagrams, xrefs).
       # @param database [Ea::Qea::Database]
+      # @param with_extensions [Boolean] emit EA-specific connectors+diagrams
       # @return [String] XMI XML
-      def qea_to_xmi(database)
-        QeaToXmi::Transformer.new(database).serialize
+      def qea_to_xmi(database, with_extensions: true)
+        QeaToXmi::Transformer.new(database).serialize(with_extensions: with_extensions)
       end
     end
   end

data/lib/ea/validation/xmi_parity.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Ea
+  module Validation
+    # Compares Ea::Transformers.qea_to_xmi output against EA's
+    # reference XMI export (`examples/exports/*/model.xml`).
+    #
+    # Reports per-element-type counts (packagedElement, ownedAttribute,
+    # ownedEnd, memberEnd, generalization, connector, diagram, style,
+    # tags, documentation, xmi:Extension) so gaps surface clearly.
+    #
+    # Used by the parity regression spec to track XMI export fidelity
+    # over time. Improvements to QeaToXmi should shrink the gaps.
+    class XmiParity
+      ELEMENT_TYPES = %w[
+        packagedElement
+        ownedAttribute
+        ownedOperation
+        ownedEnd
+        memberEnd
+        generalization
+        connector
+        diagram
+        taggedValue
+        xmi:Extension
+        style
+        tags
+        documentation
+      ].freeze
+
+      # Per-element counts for one XMI document.
+      Counts = Struct.new(:total, :by_type, keyword_init: true) do
+        def initialize(*)
+          super
+          self.by_type ||= {}
+        end
+
+        def delta(other)
+          result = { total: total - other.total }
+          ELEMENT_TYPES.each do |t|
+            result[t] = (by_type[t] || 0) - (other.by_type[t] || 0)
+          end
+          result
+        end
+      end
+
+      # @param qea_path [String] path to the QEA file
+      # @param reference_xmi_path [String] path to EA's reference XMI
+      # @return [Hash] {:ours, :reference, :delta} each a Counts
+      def self.compare(qea_path, reference_xmi_path)
+        database = Ea::Qea.load(qea_path)
+        ours_xml = Ea::Transformers.qea_to_xmi(database)
+        ref_xml = File.read(reference_xmi_path)
+
+        {
+          qea: qea_path,
+          reference: reference_xmi_path,
+          ours: count(ours_xml),
+          reference_counts: count(ref_xml),
+          delta: count(ours_xml).delta(count(ref_xml))
+        }
+      end
+
+      # @param xml [String] XMI markup (any encoding)
+      # @return [Counts]
+      def self.count(xml)
+        # EA exports use windows-1252; force UTF-8 for safe regex.
+        safe = xml.to_s.encode("UTF-8", invalid: :replace, undef: :replace,
+                                replace: "?")
+        by_type = ELEMENT_TYPES.each_with_object({}) do |tag, acc|
+          # Match `<tag>` followed by space, `/`, or `>` (covers
+          # `<tag/>`, `<tag foo=...>`, `<tag>`). Using %r{} to avoid
+          # `/` regex-delimiter conflict with the `/` in the class.
+          acc[tag] = safe.scan(%r{<#{tag}[\s/>]}).size
+        end
+        Counts.new(total: by_type.values.sum, by_type: by_type)
+      end
+    end
+  end
+end

data/lib/ea/validation.rb

@@ -0,0 +1,12 @@
+# frozen_string: true
+
+module Ea
+  # Top-level validation namespace. Hosts cross-cutting validators
+  # that span multiple subsystems (QEA + XMI, lint rules, OCL).
+  #
+  # Distinct from Ea::Qea::Validation which is specific to QEA
+  # database + UML document structural validation.
+  module Validation
+    autoload :XmiParity, "ea/validation/xmi_parity"
+  end
+end

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.5.0"
+  VERSION = "0.5.2"
 end

data/lib/ea.rb

@@ -29,6 +29,7 @@ module Ea
   autoload :Lint, "ea/lint"
   autoload :Query, "ea/query"
   autoload :Ocl, "ea/ocl"
+  autoload :Validation, "ea/validation"
 
   class << self
     # Parse an EA file into its native representation.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Ribose Inc.
@@ -223,6 +223,25 @@ files:
 - TODO.complete/45-shapescript-extensions.md
 - TODO.complete/46-xsd-consolidation.md
 - TODO.complete/47-headerlines-legacy-removal.md
+- TODO.complete/51-remove-respond-to.md
+- TODO.complete/52-xsd-decouple-fixtures.md
+- TODO.complete/53-xmi-public-send-cleanup.md
+- TODO.complete/54-wire-stereotype-icon-renderer.md
+- TODO.complete/55-wire-shapescript.md
+- TODO.complete/56-wire-emf-renderer.md
+- TODO.complete/57-wire-ocl-evaluator.md
+- TODO.complete/58-diff-modifications.md
+- TODO.complete/59-delete-toy-xmi-export.md
+- TODO.complete/60-curate-json-export.md
+- TODO.complete/61-plantuml-relationships.md
+- TODO.complete/62-changelog.md
+- TODO.complete/63-dependabot-fix.md
+- TODO.complete/64-qeatoxmi-connectors.md
+- TODO.complete/65-qeatoxmi-diagrams.md
+- TODO.complete/66-qeatoxmi-style-tags-docs.md
+- TODO.complete/67-ocl-collection-ops.md
+- TODO.complete/68-ocl-comparison-ops.md
+- TODO.complete/69-spec-new-models.md
 - TODO.complete/STATUS.md
 - TODO.diagrams/01-svg-measurement-harness.md
 - TODO.diagrams/01-xmi-extension-elements-parsing.md
@@ -586,8 +605,6 @@ files:
 - lib/ea/export/json_schema/generator.rb
 - lib/ea/export/plantuml.rb
 - lib/ea/export/plantuml/generator.rb
-- lib/ea/export/xmi.rb
-- lib/ea/export/xmi/generator.rb
 - lib/ea/export/xsd.rb
 - lib/ea/export/xsd/class_mapping.rb
 - lib/ea/export/xsd/generator.rb
@@ -753,6 +770,7 @@ files:
 - lib/ea/qea/validation/class_validator.rb
 - lib/ea/qea/validation/database.rb
 - lib/ea/qea/validation/database/circular_reference_validator.rb
+- lib/ea/qea/validation/database/ocl_constraint_validator.rb
 - lib/ea/qea/validation/database/orphan_validator.rb
 - lib/ea/qea/validation/database/referential_integrity_validator.rb
 - lib/ea/qea/validation/diagram_validator.rb
@@ -862,6 +880,7 @@ files:
 - lib/ea/svg/ea_emitter/compartment/package_contents.rb
 - lib/ea/svg/ea_emitter/compartment/package_from_parent.rb
 - lib/ea/svg/ea_emitter/compartment/shape.rb
+- lib/ea/svg/ea_emitter/compartment/stereotype_icon.rb
 - lib/ea/svg/ea_emitter/compartment/tagged_values.rb
 - lib/ea/svg/ea_emitter/connectors.rb
 - lib/ea/svg/ea_emitter/diagram_frame.rb
@@ -940,6 +959,8 @@ files:
 - lib/ea/transformers/uml_to_xmi/id_generator.rb
 - lib/ea/transformers/uml_to_xmi/transformer.rb
 - lib/ea/transformers/uml_to_xmi/writer.rb
+- lib/ea/validation.rb
+- lib/ea/validation/xmi_parity.rb
 - lib/ea/version.rb
 - lib/ea/xmi.rb
 - lib/ea/xmi/liquid_drops/association_drop.rb

data/lib/ea/export/xmi/generator.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require "nokogiri"
-
-module Ea
-  module Export
-    module Xmi
-      # Generates Sparx-flavored XMI 2.1 from a parsed QEA model.
-      #
-      # Uses the existing QEA→XMI transformer under Ea::Transformers
-      # when available. Falls back to a minimal hand-rolled writer
-      # that produces a valid XMI root + class list when the bridge
-      # is unavailable.
-      class Generator
-        def self.call(model, **_opts)
-          new(model).call
-        end
-
-        attr_reader :model
-
-        # @param model [#collections] Ea::Qea::Database or compatible
-        def initialize(model)
-          @model = model
-        end
-
-        def call
-          builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
-            xml.xmi("XMI" => "2.1",
-                    "xmlns:UML" => "http://schema.omg.org/spec/UML/2.1",
-                    "xmlns:xmi" => "http://schema.omg.org/spec/XMI/2.1") do
-              xml.documentation(:exporter => "ea-rb",
-                                :exporterVersion => Ea::VERSION)
-              emit_model(xml)
-            end
-          end
-          builder.to_xml
-        end
-
-        private
-
-        def emit_model(xml)
-          classes = (model.collections[:objects] || [])
-                     .select { |o| o.object_type == "Class" }
-
-          xml.tag!("uml:Model", "xmi:id" => "model-root",
-                              "name" => "model") do
-            classes.each do |klass|
-              emit_class(xml, klass)
-            end
-          end
-        end
-
-        def emit_class(xml, klass)
-          attrs = class_attributes(klass)
-          xml.tag!("ownedMember",
-                  "xmi:type" => "uml:Class",
-                  "xmi:id" => klass.ea_guid || klass.object_id.to_s,
-                  "name" => klass.name || "Anonymous") do
-            attrs.each { |attr| emit_attribute(xml, attr) }
-          end
-        end
-
-        def emit_attribute(xml, attr)
-          xml.tag!("ownedAttribute",
-                  "xmi:type" => "uml:Property",
-                  "xmi:id" => attr.ea_guid || attr.property_id.to_s,
-                  "name" => attr.name)
-        end
-
-        def class_attributes(klass)
-          attrs = model.collections[:attributes] || []
-          attrs.select { |a| a.object_id == klass.object_id }
-        end
-      end
-    end
-  end
-end

data/lib/ea/export/xmi.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Ea
-  module Export
-    # XMI export namespace. Generates Sparx-flavored XMI from a
-    # parsed model.
-    module Xmi
-      autoload :Generator, "ea/export/xmi/generator"
-    end
-  end
-end