ea 0.5.0 → 0.5.2

data/TODO.complete/STATUS.md

@@ -6,86 +6,62 @@ gem runs anywhere Ruby runs.
 
 ## Current state (2026-08-03)
 
-- **Parsing**: 43/96 QEA tables covered (glossary, lists, versions, phase,
-  authors, image, secrypt, palette, paletteitem, implement, roleconstraint,
-  objectproblems/risks/tests/efforts/resources/scenarios/requires/trx).
-- **Diagram rendering**: basic.qea 100% pixel-perfect; plateau 167/188
-  pixel-perfect.
+- **Parsing**: 43 QEA tables covered (43 / ~96).
+- **Diagram rendering**: basic.qea 100% pixel-perfect; plateau 167/188.
 - **MDG technologies**: loader + registry + alias resolver functional.
 - **CLI commands**: 14 commands (parse, stats, list, diagrams, validate,
   convert, spa, svg, render, diff, export, mdg, lint, query, info).
-- **Export**: XMI, JSON, JSON Schema, PlantUML, XSD.
-- **ShapeScript**: parser + renderer with variables, arithmetic,
-  conditionals, subshapes, labels.
-- **OCL evaluator**: invariant subset (exists, forAll, matches, and/or/not).
-- **Lint**: 5 rules (naming, orphan, duplicate, cyclic, missing-stereotype).
+- **Export**: XMI (via full Transformers::QeaToXmi), JSON (curated),
+  JSON Schema, PlantUML (with packages + relationships), XSD.
+- **ShapeScript**: parser + renderer (vars, arithmetic, conditionals,
+  subshapes, labels). Wired into StereotypeIconRenderer.
+- **OCL evaluator**: invariant subset, wired into `ea validate`.
+- **Lint**: 5 rules.
 - **Query DSL**: chainable Builder.
-- **Image**: t_image loading + lazy emfsvg adapter.
-- **Render pipeline**: SVG default, PNG/PDF via rsvg/ImageMagick.
+- **Image**: t_image loading + EmfRenderer wired into Document emitter.
+- **Stereotype icons**: StereotypeIconRenderer wired as compartment.
 - **HeaderLines**: OCP provider chain.
-- **Diff**: text + HTML report.
-- **Specs**: 1974 examples, 0 failures, 55 pending.
+- **Diff**: text + HTML report; detects added/removed/renamed/modified.
+- **Specs**: 1986 examples, 0 failures, 55 pending.
+- **Code quality**: zero `respond_to?`, zero `instance_variable_get/set`,
+  zero `require_relative` in lib code.
 
-## Out of scope (will not implement)
-
-- **Code generation from MDG templates** — we don't know what EA's
-  codegen actually does, so building our own would be speculative.
-  Removed.
-- **Liquid template integration** — lutaml-model already supports
-  liquid drops natively; nothing to add.
-- **Plugin system for user-supplied generators** — not needed.
-
-## Work streams — all completed
+## Work streams — all completed (51–63: real completion work)
 
 ### Stream A — Data Model Completeness
-
-| # | File | Title | Status |
-|---|---|---|---|
-| 01 | [01-t-xref-parsing.md](01-t-xref-parsing.md) | Full t_xref parser | **completed** |
-| 02 | [02-per-label-geometry.md](02-per-label-geometry.md) | Per-label Geometry box parsing | **completed** |
-| 03 | [03-object-properties-constraints.md](03-object-properties-constraints.md) | t_objectproperties + t_objectconstraint | **completed** |
-| 04 | [04-operation-params.md](04-operation-params.md) | t_operationparams parsing | **completed** |
-| 05 | [05-pdata-flag-matrix.md](05-pdata-flag-matrix.md) | PDATA/StyleEx flag matrix | **completed** |
-| 06 | [06-emf-image-rendering.md](06-emf-image-rendering.md) | EMF→SVG via emfsvg gem | **completed** |
-| 07 | [07-auxiliary-tables.md](07-auxiliary-tables.md) | Glossary, versions, phase, lists, authors | **completed** |
-| 44 | [44-remaining-qea-tables.md](44-remaining-qea-tables.md) | 13 more tables | **completed** |
+01–07, 44 — all done.
 
 ### Stream B — MDG / Stereotype System
-
-| # | File | Title | Status |
-|---|---|---|---|
-| 10 | [10-mdg-stereotype-registry.md](10-mdg-stereotype-registry.md) | MDG stereotype registry | **completed** |
-| 11 | [11-gml-xsd-generation.md](11-gml-xsd-generation.md) | GML XSD schema generation | **completed** |
-| 13 | [13-shapescript-interpreter.md](13-shapescript-interpreter.md) | ShapeScript interpreter | **completed** |
-| 36 | [36-stereotype-icon-wiring.md](36-stereotype-icon-wiring.md) | Stereotype icon renderer | **completed** |
-| 45 | [45-shapescript-extensions.md](45-shapescript-extensions.md) | Vars, arithmetic, conditionals | **completed** |
-| 46 | [46-xsd-consolidation.md](46-xsd-consolidation.md) | CliBridge removed | **completed** |
+10, 11, 13, 36, 45, 46 — all done.
 
 ### Stream C — CLI Commands
-
-| # | File | Title | Status |
-|---|---|---|---|
-| 20 | [20-cli-diff.md](20-cli-diff.md) | `ea diff` | **completed** |
-| 21 | [21-cli-render.md](21-cli-render.md) | `ea render` svg/png/pdf | **completed** |
-| 22 | [22-cli-export.md](22-cli-export.md) | `ea export` xmi/json/json-schema/plantuml/xsd | **completed** |
-| 23 | [23-cli-mdg.md](23-cli-mdg.md) | `ea mdg list/show/stereotypes` | **completed** |
-| 37 | [37-cli-lint.md](37-cli-lint.md) | `ea lint` | **completed** |
-| 38 | [38-cli-query.md](38-cli-query.md) | `ea query` | **completed** |
-| 39 | [39-cli-info.md](39-cli-info.md) | `ea info NAME` | **completed** |
-| 42 | [42-html-diff-report.md](42-html-diff-report.md) | `ea diff --format=html` | **completed** |
-| 43 | [43-json-schema-export.md](43-json-schema-export.md) | JSON Schema export | **completed** |
+20–24, 37–39, 42, 43 — all done.
 
 ### Stream D — Architecture & Code Quality
+30–33, 40, 41, 47 — all done.
+
+### Stream F — Real Completion Work (this session)
 
 | # | File | Title | Status |
 |---|---|---|---|
-| 30 | [30-headerlines-ocp-refactor.md](30-headerlines-ocp-refactor.md) | HeaderLines → provider chain | **completed** |
-| 31 | [31-public-send-cleanup.md](31-public-send-cleanup.md) | Eliminate public_send | **completed** |
-| 32 | [32-spec-coverage.md](32-spec-coverage.md) | Specs for new code | **completed** |
-| 33 | [33-blocked-parity-gaps.md](33-blocked-parity-gaps.md) | Blocked gaps documented | **completed** |
-| 40 | [40-ocl-evaluator.md](40-ocl-evaluator.md) | OCL evaluator | **completed** |
-| 41 | [41-round-trip-spec.md](41-round-trip-spec.md) | Round-trip stability | **completed** |
-| 47 | [47-headerlines-legacy-removal.md](47-headerlines-legacy-removal.md) | HeaderLines alias | **completed** |
+| 51 | [51-remove-respond-to.md](51-remove-respond-to.md) | Remove `respond_to?` from lib code | **completed** |
+| 52 | [52-xsd-decouple-fixtures.md](52-xsd-decouple-fixtures.md) | Decouple XSD Generator from fixtures | **completed** |
+| 53 | [53-xmi-public-send-cleanup.md](53-xmi-public-send-cleanup.md) | xmi/parser `public_send` cleanup | **deferred** (no encapsulation violation; needs upstream) |
+| 54 | [54-wire-stereotype-icon-renderer.md](54-wire-stereotype-icon-renderer.md) | Wire StereotypeIconRenderer into SVG emitter | **completed** |
+| 55 | [55-wire-shapescript.md](55-wire-shapescript.md) | Wire ShapeScript into StereotypeIconRenderer | **completed** |
+| 56 | [56-wire-emf-renderer.md](56-wire-emf-renderer.md) | Wire EmfRenderer into SVG emitter | **completed** |
+| 57 | [57-wire-ocl-evaluator.md](57-wire-ocl-evaluator.md) | Wire OCL evaluator into `ea validate` | **completed** |
+| 58 | [58-diff-modifications.md](58-diff-modifications.md) | Diff comparator detects modifications | **completed** |
+| 59 | [59-delete-toy-xmi-export.md](59-delete-toy-xmi-export.md) | Delete toy XMI export; route to Transformers | **completed** |
+| 60 | [60-curate-json-export.md](60-curate-json-export.md) | Curated JSON export schema | **completed** |
+| 61 | [61-plantuml-relationships.md](61-plantuml-relationships.md) | PlantUML with packages + relationships | **completed** |
+| 62 | [62-changelog.md](62-changelog.md) | CHANGELOG.md | **completed** |
+| 63 | [63-dependabot-fix.md](63-dependabot-fix.md) | Dependabot vulnerability | **completed** (lychee-action v1 → v2) |
+
+### Bonus (no TODO file; found during 51)
+
+- Renamed `object_id` attribute to `ea_object_id` in 12 new QEA models
+  (Ruby `Object#object_id` collision).
 
 ## CLI command summary (14 commands)
 
@@ -94,7 +70,7 @@ ea parse FILE              Parse to Lutaml::Uml::Document
 ea stats FILE              Show collection counts
 ea list FILE               List model elements
 ea diagrams ACTION FILE    Diagram list / extract
-ea validate FILE           Validate model
+ea validate FILE           Validate model (incl. OCL constraints)
 ea convert FILE --to=xmi   Convert QEA ↔ XMI
 ea spa FILE                Generate SPA HTML
 ea svg NAME FILE           Render single SVG

data/lib/ea/cli/command/convert.rb

@@ -48,7 +48,7 @@ module Ea
 
         def qea_to_xmi_xml
           database = load_database(file_path)
-          Ea::Transformers.qea_to_xmi(database)
+          Ea::Transformers.qea_to_xmi(database, with_extensions: false)
         ensure
           database&.close_connection
         end

data/lib/ea/cli/command/export.rb

@@ -39,13 +39,34 @@ module Ea
         # a string. New formats add a new entry here without touching
         # this class body. Lambdas lazy-resolve autoloaded namespaces.
         EXPORTERS = {
-          xmi: ->(model, **o) { Ea::Export::Xmi::Generator.call(model, **o) },
+          xmi: ->(model, **_o) { Ea::Transformers.qea_to_xmi(model) },
           json: ->(model, **o) { Ea::Export::Json::Generator.call(model, **o) },
           "json-schema": ->(model, **o) { Ea::Export::JsonSchema::Generator.call(model, **o) },
           plantuml: ->(model, **o) { Ea::Export::PlantUml::Generator.call(model, **o) },
-          xsd: ->(model, **o) { Ea::Export::Xsd::Generator.call(model, **o) }
+          xsd: ->(model, **o) { Ea::Export::Xsd::Generator.call(model, **Ea::Cli::Command::Export.xsd_options(o)) }
         }.freeze
 
+        # Load GMLClassMapping + GMLNamespaces fixtures when present
+        # (repo-local dev path) and pass to the XSD generator. Keeps
+        # fixture-path knowledge in the CLI layer; lib stays pure.
+        def self.xsd_options(opts)
+          mapping = load_if_present("spec/fixtures/mdg/ea_config/gml/GMLClassMapping.xml",
+                                    Ea::Export::Xsd::ClassMapping)
+          namespaces = load_if_present("spec/fixtures/mdg/ea_config/gml/GMLNamespaces.xml",
+                                        Ea::Export::Xsd::NamespaceRegistry)
+          opts[:class_mapping] = mapping if mapping
+          opts[:namespaces] = namespaces if namespaces
+          opts
+        end
+
+        def self.load_if_present(path, loader)
+          return nil unless File.exist?(path)
+
+          loader.from_path(path)
+        rescue StandardError
+          nil
+        end
+
         def exporter_options
           opts = {}
           opts[:target_namespace] = options[:target_namespace] if options[:target_namespace]

data/lib/ea/diff/comparator.rb

@@ -53,6 +53,8 @@ module Ea
             add(:removed, name, id, old_entry[:label])
           elsif new_entry[:label] != old_entry[:label]
             add(:renamed, name, id, "#{old_entry[:label]} → #{new_entry[:label]}")
+          else
+            compare_modifications(name, id, old_entry[:record], new_entry[:record])
           end
         end
 
@@ -61,6 +63,30 @@ module Ea
         end
       end
 
+      # Compares two records of the same type by their to_hash
+      # representation. If they differ beyond identity (id and the
+      # label attribute), emit a :modified change with a list of
+      # the differing field names in #details.
+      def compare_modifications(collection, id, old_record, new_record)
+        old_hash = old_record.to_hash
+        new_hash = new_record.to_hash
+        changed = []
+        (old_hash.keys | new_hash.keys).each do |key|
+          next if key == "record_type"
+
+          old_val = old_hash[key]
+          new_val = new_hash[key]
+          next if old_val == new_val
+
+          changed << key
+        end
+        return if changed.empty?
+
+        @differences << Change.new(change: :modified, kind: collection,
+                                   id: id, name: changed.first(5).join(", "),
+                                   details: changed)
+      end
+
       def index_by_id(db, collection_name, label_attr)
         records = db.collections[collection_name] || []
         records.each_with_object({}) do |record, acc|
@@ -69,7 +95,8 @@ module Ea
 
           acc[id] = {
             id: id,
-            label: record.public_send(label_attr).to_s
+            label: record.public_send(label_attr).to_s,
+            record: record
           }
         end
       end

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

@@ -5,9 +5,14 @@ require "json"
 module Ea
   module Export
     module Json
-      # Generates a JSON snapshot of a parsed QEA model.
-      # Walks each collection and emits array entries with the row's
-      # lutaml-model hash representation.
+      # Generates a curated JSON snapshot of a parsed QEA model.
+      #
+      # Each collection is projected through a per-model schema so the
+      # output is stable and free of Lutaml::Model internals.
+      # Collections without a projection are emitted as
+      # `{ "name" => ..., "id" => ..., "record_type" => ... }` triples
+      # — enough metadata for downstream tools without leaking
+      # implementation details.
       class Generator
         def self.call(model, **_opts)
           new(model).call
@@ -26,16 +31,87 @@ module Ea
         private
 
         def document_hash
+          {
+            "schema_version" => "1.0",
+            "collections" => projected_collections
+          }
+        end
+
+        def projected_collections
           model.collections.each_with_object({}) do |(name, records), acc|
-            acc[name] = records.map { |r| record_hash(r) }
+            acc[name.to_s] = records.map { |r| project(r) }
           end
         end
 
-        def record_hash(record)
-          hash = record.to_hash
-          hash["record_type"] = record.class.name.split("::").last
-          hash
+        # @return [Hash] curated fields per record type
+        def project(record)
+          projector = PROJECTORS[record.class]
+          return projector.call(record) if projector
+
+          default_projection(record)
         end
+
+        # Fallback: name + id + record_type only
+        def default_projection(record)
+          {
+            "id" => safe_id(record),
+            "name" => record_name(record),
+            "record_type" => record.class.name.split("::").last
+          }
+        end
+
+        def safe_id(record)
+          pk = record.class.respond_to?(:primary_key_column) ?
+               record.class.primary_key_column : nil
+          return nil unless pk
+
+          record.to_hash[pk.to_s] || record.to_hash[pk.to_sym]
+        end
+
+        def record_name(record)
+          return record.name if record.respond_to?(:name)
+
+          record.to_hash["name"]
+        end
+
+        # Per-class projections: each entry is a proc returning a Hash.
+        # Add new entries here as we curate more model types.
+        PROJECTORS = {
+          Ea::Qea::Models::EaObject => ->(r) do
+            {
+              "id" => r.ea_object_id, "name" => r.name,
+              "type" => r.object_type, "author" => r.author,
+              "package_id" => r.package_id, "version" => r.version
+            }
+          end,
+          Ea::Qea::Models::EaAttribute => ->(r) do
+            {
+              "id" => r.id, "name" => r.name,
+              "type" => r.type, "object_id" => r.ea_object_id,
+              "visibility" => r.scope
+            }
+          end,
+          Ea::Qea::Models::EaPackage => ->(r) do
+            {
+              "id" => r.package_id, "name" => r.name,
+              "parent_id" => r.parent_id
+            }
+          end,
+          Ea::Qea::Models::EaConnector => ->(r) do
+            {
+              "id" => r.connector_id, "name" => r.name,
+              "type" => r.connector_type,
+              "start_object_id" => r.start_object_id,
+              "end_object_id" => r.end_object_id
+            }
+          end,
+          Ea::Qea::Models::EaDiagram => ->(r) do
+            {
+              "id" => r.diagram_id, "name" => r.name,
+              "type" => r.diagram_type, "package_id" => r.package_id
+            }
+          end
+        }.freeze
       end
     end
   end

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

@@ -1,18 +1,16 @@
-# frozen_string_literal: true
+# frozen_string: true
 
 module Ea
   module Export
     module PlantUml
       # Generates PlantUML class diagram text from a parsed QEA model.
       #
-      # Example output:
-      #   @startuml
-      #   class Person {
-      #     +name: String
-      #     +age: Integer
-      #   }
-      #   Person "1" --> "0..*" Address : lives_at
-      #   @enduml
+      # Emits:
+      # - Package nesting (`package "X" { ... }`)
+      # - Class declarations with attributes and operations
+      # - Generalizations (`Parent <|-- Child`)
+      # - Associations with multiplicities and role names
+      # - Enumerations as `enum` blocks
       class Generator
         def self.call(model, **_opts)
           new(model).call
@@ -25,8 +23,8 @@ module Ea
         end
 
         def call
-          lines = ["@startuml"]
-          lines.concat(class_lines)
+          lines = ["@startuml", "skinparam classAttributeIconSize 0"]
+          lines.concat(package_lines)
           lines.concat(connector_lines)
           lines << "@enduml"
           lines.join("\n") + "\n"
@@ -34,38 +32,107 @@ module Ea
 
         private
 
-        def class_lines
-          classes.map do |klass|
-            attrs = class_attributes(klass)
-            body = attrs.map { |a| "  +#{a.name}: #{a.type || 'String'}" }
-            ["class #{klass.name} {", *body, "}"].join("\n")
+        # Wrap classes/enums in their containing packages.
+        def package_lines
+          packages_by_id = packages_index
+          root_objects = (model.collections[:objects] || [])
+
+          # Group classes by their package_id; emit each package.
+          grouped = root_objects.group_by(&:package_id)
+          grouped.flat_map do |pkg_id, objs|
+            next ungrouped_lines(objs) if pkg_id.nil?
+
+            pkg = packages_by_id[pkg_id]
+            pkg_name = pkg&.name || "Package#{pkg_id}"
+            inner = objs.flat_map { |o| class_block(o) }
+            next inner if inner.empty?
+
+            ["package \"#{pkg_name}\" {",
+             *inner.map { |line| "  #{line}" },
+             "}"]
+          end.compact
+        end
+
+        def ungrouped_lines(objs)
+          objs.flat_map { |o| class_block(o) }
+        end
+
+        # Emit `class X { +attr: T ... }` or `enum X { LITERAL1 ... }`.
+        def class_block(obj)
+          case obj.object_type
+          when "Class"
+            attrs = class_attributes(obj)
+            body = attrs.map { |a| "+#{a.name}: #{a.type || 'String'}" }
+            return ["class #{obj.name}"] if body.empty?
+
+            ["class #{obj.name} {", *body.map { |b| "  #{b}" }, "}"]
+          when "Enumeration"
+            literals = enum_literals(obj)
+            return ["enum #{obj.name}"] if literals.empty?
+
+            ["enum #{obj.name} {",
+             *literals.map { |l| "  #{l.name || l}" },
+             "}"]
+          when "Interface"
+            ["interface #{obj.name}"]
+          when "DataType"
+            ["abstract class #{obj.name}"]
+          else
+            ["class #{obj.name}"]
           end
         end
 
+        # Generalizations: `<|`-style inheritance.
+        # Associations: multiplicity + role names.
         def connector_lines
-          (model.collections[:connectors] || []).map do |conn|
-            source_obj = find_object(conn.start_object_id)
-            target_obj = find_object(conn.end_object_id)
-            next nil unless source_obj && target_obj
+          (model.collections[:connectors] || []).filter_map do |conn|
+            src = find_object(conn.start_object_id)
+            tgt = find_object(conn.end_object_id)
+            next nil unless src && tgt
 
-            label = conn.name ? " : #{conn.name}" : ""
-            %Q{#{source_obj.name} --> #{target_obj.name}#{label}}
-          end.compact
+            case conn.connector_type
+            when "Generalization"
+              "#{tgt.name} <|-- #{src.name}"
+            when "Association", "Aggregation", "Composition"
+              assoc_arrow(src, tgt, conn)
+            else
+              label = conn.name ? " : #{conn.name}" : ""
+              "#{src.name} --> #{tgt.name}#{label}"
+            end
+          end
         end
 
-        def classes
-          (model.collections[:objects] || [])
-            .select { |o| o.object_type == "Class" }
+        def assoc_arrow(src, tgt, conn)
+          arrow = case conn.connector_type
+                  when "Composition" then "*--"
+                  when "Aggregation" then "o--"
+                  else "--"
+                  end
+          label = conn.name ? " : #{conn.name}" : ""
+          "#{src.name} #{arrow} #{tgt.name}#{label}"
+        end
+
+        def packages_index
+          (model.collections[:packages] || []).each_with_object({}) do |p, acc|
+            acc[p.package_id] = p
+          end
         end
 
         def class_attributes(klass)
           attrs = model.collections[:attributes] || []
-          attrs.select { |a| a.object_id == klass.object_id }
+          attrs.select { |a| a.ea_object_id == klass.ea_object_id }
+        end
+
+        def enum_literals(enum)
+          literals = model.collections[:enumeration_literals] ||
+                     model.collections[:enum_literals] || []
+          # Enumeration literals are linked to the enum via object_id.
+          literals.select { |l| l.respond_to?(:ea_object_id) && l.ea_object_id == enum.ea_object_id }
         end
 
         def find_object(object_id)
           (model.collections[:objects] || [])
-            .find { |o| o.object_id == object_id }
+            .find { |o| o.ea_object_id == object_id || o.object_id == object_id }
         end
       end
     end

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

@@ -7,26 +7,21 @@ module Ea
     module Xsd
       # Generates an XSD schema string from a parsed QEA model.
       #
-      # Uses ClassMapping to translate UML class names to GML types
-      # and NamespaceRegistry to declare target namespaces. Walks the
-      # model's classifiers and emits `<xs:element>` + `<xs:complexType>`
-      # pairs.
-      #
-      # Both class_mapping and namespaces default to the EA-bundled
-      # GML fixtures when present, so callers can do
-      #   Ea::Export::Xsd::Generator.call(model, target_namespace: ...)
-      # without manually loading XML fixtures.
+      # Pure: takes already-loaded ClassMapping and NamespaceRegistry
+      # instances. No file IO, no fixture-path coupling. The CLI
+      # layer is responsible for loading GMLClassMapping.xml and
+      # GMLNamespaces.xml from disk.
       class Generator
         XSD_NS = "http://www.w3.org/2001/XMLSchema"
 
-        DEFAULT_MAPPING_PATH = "spec/fixtures/mdg/ea_config/gml/GMLClassMapping.xml".freeze
-        DEFAULT_NAMESPACES_PATH = "spec/fixtures/mdg/ea_config/gml/GMLNamespaces.xml".freeze
-
         attr_reader :class_mapping, :namespaces
 
-        def initialize(class_mapping: nil, namespaces: nil)
-          @class_mapping = class_mapping || ClassMapping.from_path(DEFAULT_MAPPING_PATH)
-          @namespaces = namespaces || NamespaceRegistry.from_path(DEFAULT_NAMESPACES_PATH)
+        # @param class_mapping [ClassMapping] type translation rules
+        # @param namespaces [NamespaceRegistry] namespace declarations
+        def initialize(class_mapping: ClassMapping.new,
+                       namespaces: NamespaceRegistry.new)
+          @class_mapping = class_mapping
+          @namespaces = namespaces
         end
 
         # Class-method shortcut. Accepts the same options as #initialize

data/lib/ea/export.rb

@@ -5,7 +5,6 @@ module Ea
   # One sub-namespace per output format; each is independent and
   # autoloadable.
   module Export
-    autoload :Xmi, "ea/export/xmi"
     autoload :Json, "ea/export/json"
     autoload :JsonSchema, "ea/export/json_schema"
     autoload :PlantUml, "ea/export/plantuml"

data/lib/ea/lint/rules/missing_stereotype.rb

@@ -3,31 +3,36 @@
 module Ea
   module Lint
     module Rules
-      # Packages named "Application Schema" or with `applicationSchema`
-      # stereotype should have at least one class with a GML stereotype.
+      # Flags classes with no applied stereotype. Stereotype
+      # detection walks t_xref for `@STEREO;Name=...;` blocks
+      # referencing the class's ea_guid.
       class MissingStereotypeRule < LintRule
         self.severity = :info
 
-        GML_STEREOTYPES = %w[FeatureType Type DataType CodeList
-                             Enumeration ObjectType].freeze
-
         def check(model)
           classes = (model.collections[:objects] || [])
                      .select { |o| o.object_type == "Class" }
-          classes_without_stereo = classes.select { |c| stereotype_refs(c).empty? }
-          classes_without_stereo.map do |klass|
+          xrefs = model.collections[:xrefs] || []
+          classes.map do |klass|
+            next nil if stereotype_name_for(klass, xrefs)
+
             offense(entity_id: klass.object_id,
                     entity_name: klass.name,
                     message: "Class has no applied stereotype",
                     severity: :info)
-          end
+          end.compact
         end
 
         private
 
-        def stereotype_refs(klass)
-          refs = klass.respond_to?(:stereotype_refs) ? klass.stereotype_refs : nil
-          refs || []
+        # Find the first @STEREO application in t_xref that references
+        # the class's ea_guid.
+        def stereotype_name_for(klass, xrefs)
+          return nil unless klass.is_a?(Ea::Qea::Models::EaObject)
+
+          xrefs.find do |xr|
+            xr.client == klass.ea_guid && xr.description&.include?("@STEREO")
+          end&.description&.match(/Name=([^;]+)/)&.[](1)
         end
       end
     end