ea 0.5.0 → 0.5.1

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

data/lib/ea/ocl/evaluator.rb

@@ -38,7 +38,7 @@ module Ea
 
       def eval_exists(ast, context)
         collection = evaluate(ast.collection, context)
-        return false unless collection.respond_to?(:each)
+        return false unless collection.is_a?(Array)
 
         var_name = ast.var
         predicate = ast.predicate
@@ -49,7 +49,7 @@ module Ea
 
       def eval_for_all(ast, context)
         collection = evaluate(ast.collection, context)
-        return true unless collection.respond_to?(:each)
+        return true unless collection.is_a?(Array)
 
         var_name = ast.var
         predicate = ast.predicate

data/lib/ea/qea/models/ea_implement.rb

@@ -6,7 +6,7 @@ module Ea
       # UML-to-code mapping hint from t_implement.
       class EaImplement < BaseModel
         attribute :implement_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :language, :string
         attribute :code, :string
 
@@ -20,7 +20,7 @@ module Ea
 
         COLUMN_MAP = {
           "ImplementID" => :implement_id,
-          "Object_ID" => :object_id
+          "Object_ID" => :ea_object_id
         }.freeze
 
         def self.column_map

data/lib/ea/qea/models/ea_object_effort.rb

@@ -6,7 +6,7 @@ module Ea
       # Effort estimate from t_objecteffort.
       class EaObjectEffort < BaseModel
         attribute :object_effort_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :effort, :string
         attribute :effort_type, :string
         attribute :notes, :string
@@ -21,7 +21,7 @@ module Ea
 
         COLUMN_MAP = {
           "ObjectEffortID" => :object_effort_id,
-          "Object_ID" => :object_id,
+          "Object_ID" => :ea_object_id,
           "EffortType" => :effort_type
         }.freeze
 

data/lib/ea/qea/models/ea_object_problem.rb

@@ -6,7 +6,7 @@ module Ea
       # Object problem record from t_objectproblems.
       class EaObjectProblem < BaseModel
         attribute :object_problem_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :problem, :string
         attribute :problem_type, :string
         attribute :date_resolved, :string
@@ -23,7 +23,7 @@ module Ea
 
         COLUMN_MAP = {
           "ObjectProblemID" => :object_problem_id,
-          "Object_ID" => :object_id,
+          "Object_ID" => :ea_object_id,
           "ProblemType" => :problem_type,
           "DateResolved" => :date_resolved
         }.freeze

data/lib/ea/qea/models/ea_object_require.rb

@@ -6,7 +6,7 @@ module Ea
       # Requirement trace from t_objectrequires.
       class EaObjectRequire < BaseModel
         attribute :object_require_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :requirement, :string
         attribute :requirement_type, :string
         attribute :notes, :string
@@ -21,7 +21,7 @@ module Ea
 
         COLUMN_MAP = {
           "ObjectReqID" => :object_require_id,
-          "Object_ID" => :object_id,
+          "Object_ID" => :ea_object_id,
           "ReqType" => :requirement_type
         }.freeze
 

data/lib/ea/qea/models/ea_object_resource.rb

@@ -6,7 +6,7 @@ module Ea
       # Resource allocation from t_objectresource.
       class EaObjectResource < BaseModel
         attribute :object_resource_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :resource, :string
         attribute :role, :string
         attribute :time_allocated, :string
@@ -22,7 +22,7 @@ module Ea
 
         COLUMN_MAP = {
           "ObjectResourceID" => :object_resource_id,
-          "Object_ID" => :object_id
+          "Object_ID" => :ea_object_id
         }.freeze
 
         def self.column_map

data/lib/ea/qea/models/ea_object_risk.rb

@@ -6,7 +6,7 @@ module Ea
       # Risk register entry from t_objectrisks.
       class EaObjectRisk < BaseModel
         attribute :object_risk_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :risk, :string
         attribute :risk_type, :string
         attribute :notes, :string
@@ -21,7 +21,7 @@ module Ea
 
         COLUMN_MAP = {
           "ObjectRiskID" => :object_risk_id,
-          "Object_ID" => :object_id,
+          "Object_ID" => :ea_object_id,
           "RiskType" => :risk_type
         }.freeze
 

data/lib/ea/qea/models/ea_object_scenario.rb

@@ -6,7 +6,7 @@ module Ea
       # Use case scenario from t_objectscenarios.
       class EaObjectScenario < BaseModel
         attribute :object_scenario_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :scenario, :string
         attribute :scenario_type, :string
         attribute :notes, :string
@@ -21,7 +21,7 @@ module Ea
 
         COLUMN_MAP = {
           "ObjectScenarioID" => :object_scenario_id,
-          "Object_ID" => :object_id,
+          "Object_ID" => :ea_object_id,
           "ScenarioType" => :scenario_type
         }.freeze
 

data/lib/ea/qea/models/ea_object_test.rb

@@ -6,7 +6,7 @@ module Ea
       # Test case from t_objecttests.
       class EaObjectTest < BaseModel
         attribute :object_test_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :test, :string
         attribute :test_type, :string
         attribute :status, :string
@@ -22,7 +22,7 @@ module Ea
 
         COLUMN_MAP = {
           "ObjectTestID" => :object_test_id,
-          "Object_ID" => :object_id,
+          "Object_ID" => :ea_object_id,
           "TestType" => :test_type
         }.freeze
 

data/lib/ea/qea/models/ea_object_trx.rb

@@ -6,7 +6,7 @@ module Ea
       # Transaction record from t_objecttrx.
       class EaObjectTrx < BaseModel
         attribute :object_trx_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :trx, :string
         attribute :trx_type, :string
         attribute :notes, :string
@@ -21,7 +21,7 @@ module Ea
 
         COLUMN_MAP = {
           "ObjectTrxID" => :object_trx_id,
-          "Object_ID" => :object_id,
+          "Object_ID" => :ea_object_id,
           "TrxType" => :trx_type
         }.freeze
 

data/lib/ea/qea/models/ea_palette_item.rb

@@ -7,7 +7,7 @@ module Ea
       # entry to its visual icon and default toolbox slot.
       class EaPaletteItem < BaseModel
         attribute :palette_id, :string
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :name, :string
         attribute :alias, :string
         attribute :image_id, :integer
@@ -23,7 +23,7 @@ module Ea
 
         COLUMN_MAP = {
           "PaletteID" => :palette_id,
-          "Object_ID" => :object_id,
+          "Object_ID" => :ea_object_id,
           "Image_ID" => :image_id
         }.freeze
 

data/lib/ea/qea/models/ea_role_constraint.rb

@@ -6,7 +6,7 @@ module Ea
       # Role-based constraint from t_roleconstraint.
       class EaRoleConstraint < BaseModel
         attribute :roleconstraint_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :role, :string
         attribute :notes, :string
 
@@ -20,7 +20,7 @@ module Ea
 
         COLUMN_MAP = {
           "RoleConstraintID" => :roleconstraint_id,
-          "Object_ID" => :object_id
+          "Object_ID" => :ea_object_id
         }.freeze
 
         def self.column_map

data/lib/ea/qea/models/ea_secrypt.rb

@@ -7,7 +7,7 @@ module Ea
       # the QEA are encrypted and what algorithm was used.
       class EaSecrypt < BaseModel
         attribute :secrypt_id, :integer
-        attribute :object_id, :integer
+        attribute :ea_object_id, :integer
         attribute :encrypt, :string
         attribute :password_hash, :string
 
@@ -21,7 +21,7 @@ module Ea
 
         COLUMN_MAP = {
           "SecryptID" => :secrypt_id,
-          "Object_ID" => :object_id,
+          "Object_ID" => :ea_object_id,
           "PasswordHash" => :password_hash
         }.freeze