ea 0.5.0 → 0.5.1

data/lib/ea/qea/validation/database/ocl_constraint_validator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Validation
+      # Evaluates OCL invariants stored in t_objectconstraint.
+      # For each constraint, parse its OCL expression via
+      # Ea::Ocl::Parser and evaluate it against the owning
+      # object's attribute values. Failures surface as :warning
+      # messages — OCL failures aren't structural errors.
+      class OclConstraintValidator < BaseValidator
+        def validate
+          constraints = database.collections[:object_constraints] || []
+          constraints.each { |c| check_constraint(c) }
+        end
+
+        private
+
+        def check_constraint(constraint)
+          owner = owner_for(constraint)
+          return unless owner
+
+          ast = parse(constraint.constraint)
+          return unless ast
+
+          if evaluate(ast, owner)
+            result.add(:info, "OCL constraint '#{constraint.constraint_type}' " \
+                              "passed for #{owner.name}",
+                       entity_name: owner.name)
+          else
+            result.add(:warning, "OCL constraint '#{constraint.constraint_type}' " \
+                                 "failed for #{owner.name}: #{constraint.constraint}",
+                       entity_name: owner.name)
+          end
+        rescue Ea::Ocl::UnsupportedError => e
+          result.add(:info, "Skipping OCL constraint on #{owner&.name} " \
+                            "(unsupported syntax): #{e.message}",
+                     entity_name: owner&.name)
+        end
+
+        # Parse the OCL body. Returns nil for empty / non-invariant
+        # constraints (we don't try to evaluate non-invariant forms).
+        def parse(body)
+          return nil if body.nil? || body.empty?
+
+          Ea::Ocl::Parser.parse(body)
+        end
+
+        def evaluate(ast, owner)
+          Ea::Ocl::Evaluator.evaluate(ast, owner)
+        end
+
+        def owner_for(constraint)
+          object_id = constraint.respond_to?(:ea_object_id) ?
+                       constraint.ea_object_id :
+                       constraint.object_id
+          return nil unless object_id
+
+          (database.collections[:objects] || [])
+            .find { |o| o.object_id == object_id }
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/validation/database.rb

@@ -10,6 +10,8 @@ module Ea
                  "ea/qea/validation/database/orphan_validator"
         autoload :ReferentialIntegrityValidator,
                  "ea/qea/validation/database/referential_integrity_validator"
+        autoload :OclConstraintValidator,
+                 "ea/qea/validation/database/ocl_constraint_validator"
       end
     end
   end

data/lib/ea/qea/validation/validation_engine.rb

@@ -83,6 +83,7 @@ module Ea
             orphan
             circular_reference
             package
+            ocl_constraint
           ]
 
           validator_names = if validators
@@ -213,6 +214,7 @@ module Ea
           @registry.register(:circular_reference,
                              CircularReferenceValidator)
           @registry.register(:package, PackageValidator)
+          @registry.register(:ocl_constraint, OclConstraintValidator)
 
           # Phase 2: UML Tree Structure Validators
           # DocumentStructureValidator lives in lutaml-uml and may not be

data/lib/ea/qea/validation.rb

@@ -20,6 +20,8 @@ module Ea
                "ea/qea/validation/database/orphan_validator"
       autoload :CircularReferenceValidator,
                "ea/qea/validation/database/circular_reference_validator"
+      autoload :OclConstraintValidator,
+               "ea/qea/validation/database/ocl_constraint_validator"
       autoload :Database, "ea/qea/validation/database"
       autoload :Formatters, "ea/qea/validation/formatters"
       autoload :ValidationEngine, "ea/qea/validation/validation_engine"

data/lib/ea/query/builder.rb

@@ -58,13 +58,15 @@ module Ea
         filter_by { |o| o.package_id == pkg.package_id }
       end
 
-      # Filter by applied stereotype name.
+      # Filter by applied stereotype name. Stereotype lookup walks
+      # t_xref for @STEREO blocks referencing the object's ea_guid.
       # @param name [String]
       # @return [Builder]
       def with_stereotype(name)
+        xrefs = model.collections[:xrefs] || []
         filter_by do |o|
-          refs = o.respond_to?(:stereotype_refs) ? o.stereotype_refs : nil
-          refs&.any? { |r| r == name }
+          applied = stereotype_names_for(o, xrefs)
+          applied.any? { |r| r == name }
         end
       end
 
@@ -90,6 +92,23 @@ module Ea
         Builder.new(model, filters: filters + [block], kind: @kind)
       end
 
+      # Extract stereotype names applied to an object via t_xref.
+      # Returns [] when no @STEREO block references the object's GUID.
+      # @param object [Ea::Qea::Models::EaObject]
+      # @param xrefs [Array<Ea::Qea::Models::EaXref>]
+      # @return [Array<String>]
+      def stereotype_names_for(object, xrefs)
+        return [] unless object.is_a?(Ea::Qea::Models::EaObject)
+        return [] unless object.ea_guid
+
+        xrefs.select do |xr|
+          xr.client == object.ea_guid && xr.description&.include?("@STEREO")
+        end.map do |xr|
+          xr.description.match(/Name=([^;]+)/)[1]
+        end.compact
+      end
+      private :stereotype_names_for
+
       # Materialize the filtered collection.
       # @return [Array]
       def call

data/lib/ea/svg/ea_emitter/compartment/stereotype_icon.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Stereotype decorator icon compartment. Emits the small
+        # symbolic polygon that EA renders inside an element's body
+        # when a stereotype provides a custom icon (FeatureType
+        # diamond, Type polygon, etc.). Delegates to
+        # Element::StereotypeIconRenderer.
+        #
+        # Rendered after the header so the icon sits inside the
+        # element body below the stereotype label.
+        module StereotypeIcon
+          module_function
+
+          def render(context)
+            return nil unless context.classifier
+
+            svg = Element::StereotypeIconRenderer.render(
+              classifier: context.classifier,
+              bounds: context.bounds,
+              canvas: context.canvas
+            )
+            svg.empty? ? nil : svg
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/compartment.rb

@@ -14,6 +14,7 @@ module Ea
         autoload :NoteBody, "ea/svg/ea_emitter/compartment/note_body"
         autoload :Header, "ea/svg/ea_emitter/compartment/header"
         autoload :HeaderDivider, "ea/svg/ea_emitter/compartment/header_divider"
+        autoload :StereotypeIcon, "ea/svg/ea_emitter/compartment/stereotype_icon"
         autoload :Attributes, "ea/svg/ea_emitter/compartment/attributes"
         autoload :Operations, "ea/svg/ea_emitter/compartment/operations"
         autoload :EnumLiterals, "ea/svg/ea_emitter/compartment/enum_literals"
@@ -32,6 +33,7 @@ module Ea
           NoteBody,
           Header,
           HeaderDivider,
+          StereotypeIcon,
           Attributes,
           Operations,
           EnumLiterals,

data/lib/ea/svg/ea_emitter/document.rb

@@ -26,9 +26,42 @@ module Ea
                                         document: document)
                                   .layers
                                   .reject { |s| s.nil? || s.empty? }
+          image_layer = emit_images
+          layers << image_layer if image_layer
 
           %(<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">\n\n<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="#{canvas.width_cm}" height="#{canvas.height_cm}" viewBox="#{canvas.view_box}">\n<title></title>\n<desc>Created with Enterprise Architect (Build: #{BUILD_ID}) 2</desc>\n#{layers.join("\n")}\n</svg>)
         end
+
+        # Walks t_image rows (when the document carries a Database
+        # with an :images collection) and invokes EmfRenderer on
+        # each. Emits an `<image>` element per successfully converted
+        # SVG, or returns nil when no images or all conversions fail.
+        #
+        # The emfsvg gem currently can't parse EA's specific EMF
+        # variant (see TODO.diagrams/87 + TODO.complete/56). Until
+        # upstream emfsvg supports it, this method returns nil
+        # gracefully. The wiring is correct infrastructure for when
+        # emfsvg catches up.
+        def emit_images
+          return nil unless document
+          return nil unless document.is_a?(Ea::Qea::Database)
+
+          images = document.collections[:images] || []
+          return nil if images.empty?
+
+          fragments = images.filter_map { |image| render_image(image) }
+          return nil if fragments.empty?
+
+          %(<g id="images">\n#{fragments.join("\n")}\n</g>)
+        end
+
+        def render_image(image)
+          svg = Ea::Image::EmfRenderer.render(image.bytes)
+          return nil unless svg
+
+          %(<g>#{svg}</g>)
+        end
+        private :render_image
       end
     end
   end

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/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.1"
 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.1
 platform: ruby
 authors:
 - Ribose Inc.
@@ -223,6 +223,19 @@ 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/STATUS.md
 - TODO.diagrams/01-svg-measurement-harness.md
 - TODO.diagrams/01-xmi-extension-elements-parsing.md
@@ -586,8 +599,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 +764,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 +874,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 +953,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