ea 0.5.2 → 0.6.0

data/lib/ea/model/ghost_label.rb

@@ -1,4 +1,5 @@
-# frozen_string: true
+# frozen_string_literal: true
+
 
 module Ea
   module Model

data/lib/ea/ocl/evaluator.rb

@@ -32,6 +32,8 @@ module Ea
         return nil unless context
 
         context.public_send(name)
+      rescue NoMethodError
+        nil
       end
 
       def eval_string_matches(ast, context)
@@ -63,14 +65,14 @@ module Ea
 
       def eval_size(ast, context)
         collection = evaluate(ast.collection, context)
-        return 0 unless collection.respond_to?(:size)
+        return 0 unless collection.is_a?(Array)
 
         collection.size
       end
 
       def eval_is_empty(ast, context)
         collection = evaluate(ast.collection, context)
-        return true unless collection.respond_to?(:empty?)
+        return true unless collection.is_a?(Array)
 
         collection.empty?
       end

data/lib/ea/qea/database.rb

@@ -65,6 +65,51 @@ module Ea
         documents scripts
       ].freeze
 
+      # Maps EA SQL table names to collection accessor symbols.
+      # Centralised here (MECE) so validators and services don't
+      # each maintain their own case/when dispatch. Adding a new
+      # table = adding one hash entry.
+      TABLE_TO_COLLECTION = {
+        "t_package"           => :packages,
+        "t_object"            => :objects,
+        "t_attribute"         => :attributes,
+        "t_operation"         => :operations,
+        "t_operationparams"   => :operation_params,
+        "t_connector"         => :connectors,
+        "t_diagram"           => :diagrams,
+        "t_diagramobjects"    => :diagram_objects,
+        "t_diagramlinks"      => :diagram_links,
+        "t_objectconstraint"  => :object_constraints,
+        "t_objectproperties"  => :object_properties,
+        "t_taggedvalue"       => :tagged_values,
+        "t_attributetag"      => :attribute_tags,
+        "t_xref"              => :xrefs,
+        "t_stereotypes"       => :stereotypes,
+        "t_datatypes"         => :datatypes,
+        "t_constrainttypes"   => :constraint_types,
+        "t_connectortypes"    => :connector_types,
+        "t_diagramtypes"      => :diagram_types,
+        "t_objecttypes"       => :object_types,
+        "t_statustypes"       => :status_types,
+        "t_complexitytypes"   => :complexity_types,
+        "t_documents"         => :documents,
+        "t_scripts"           => :scripts,
+      }.freeze
+
+      # @param table_name [String] EA SQL table name (e.g., "t_object")
+      # @return [Array] the collection for that table, or [] if unknown
+      def collection_for_table(table_name)
+        name = TABLE_TO_COLLECTION[table_name]
+        return [] unless name
+
+        records = @collections[name]
+        return [] unless records
+
+        # t_object is wrapped in ObjectRepository — call .all to
+        # get the plain Array that validators expect.
+        records.is_a?(Repositories::ObjectRepository) ? records.all : records
+      end
+
       COLLECTION_ACCESSORS.each do |name|
         define_method(name) do
           @collections[name] || []
@@ -167,9 +212,19 @@ module Ea
         @diagram_links_by_id[id] || []
       end
 
-      # Find an object by ID
+      # Find an object by ID. Uses the repository's primary-key index
+      # rather than a scan: the parentid walk in QeaToXmi's
+      # `cyclic_ancestry?` calls this once per ancestor hop per object.
+      #
+      # Hash lookup matches on eql?, so it would miss a Float id that a
+      # scan's == would have caught. No caller here can do that:
+      # t_object.Object_ID is declared Type::Integer and the model
+      # coerces on construction, and every caller passes either such an
+      # attribute or an explicit to_i. Deliberately left unguarded — a
+      # scan fallback on miss would put every absent-parent lookup in
+      # the ancestry walk back on a linear scan.
       def find_object(id)
-        objects.find_by_key(:ea_object_id, id)
+        objects.find(id)
       end
 
       # Find object by ea_guid

data/lib/ea/qea/factory/reference_resolver.rb

@@ -91,7 +91,7 @@ module Ea
         def normalize_guid(guid)
           return guid if guid.nil?
 
-          guid.to_s.gsub(/[{}]/, "").upcase
+          Ea::GuidFormat.strip_braces(guid).upcase
         end
       end
     end

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

@@ -81,23 +81,7 @@ module Ea
           const == 1
         end
 
-        # Check if attribute is public
-        # @return [Boolean]
-        def public?
-          scope&.downcase == "public"
-        end
-
-        # Check if attribute is private
-        # @return [Boolean]
-        def private?
-          scope&.downcase == "private"
-        end
-
-        # Check if attribute is protected
-        # @return [Boolean]
-        def protected?
-          scope&.downcase == "protected"
-        end
+        include ScopePredicate
 
         # @return [Integer] pos for attribute ordering within parent
         def sort_position

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

@@ -119,10 +119,11 @@ module Ea
           connector_type == "Aggregation"
         end
 
-        # Check if connector is a realization
+        # Check if connector is a realization. EA writes both the US
+        # and UK spellings depending on version/edition.
         # @return [Boolean]
         def realization?
-          connector_type == "Realization"
+          %w[Realization Realisation].include?(connector_type)
         end
 
         # Check if source is aggregate

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

@@ -194,17 +194,22 @@ module Ea
         #   Note           — diagram note. Same situation as Text: rendering
         #                    hint, not a model element. Dropped.
         #
+        TRANSFORMER_TYPES = {
+          "Enumeration" => :enumeration,
+          "DataType" => :data_type,
+          "PrimitiveType" => :data_type,
+          "Class" => :class,
+          "Interface" => :class,
+          "Signal" => :signal,
+          "Object" => :instance,
+          "Association" => :association_element,
+        }.freeze
+
         # @return [Symbol, nil] Registry key or nil if not a UML model element
         def transformer_type
-          if enumeration? || stereotype_is?("enumeration")
-            :enumeration
-          elsif data_type?
-            :data_type
-          elsif uml_class? || interface?
-            :class
-          elsif instance?
-            :instance
-          end
+          return :enumeration if stereotype_is?("enumeration")
+
+          TRANSFORMER_TYPES[object_type]
         end
 
         def stereotype_is?(expected)

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

@@ -106,23 +106,7 @@ module Ea
           styleex&.include?("Reception=1")
         end
 
-        # Check if operation is public
-        # @return [Boolean]
-        def public?
-          scope&.downcase == "public"
-        end
-
-        # Check if operation is private
-        # @return [Boolean]
-        def private?
-          scope&.downcase == "private"
-        end
-
-        # Check if operation is protected
-        # @return [Boolean]
-        def protected?
-          scope&.downcase == "protected"
-        end
+        include ScopePredicate
 
         # @return [Integer] pos for operation ordering within parent
         def sort_position

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

@@ -10,6 +10,9 @@ module Ea
         attribute :xref_id, Lutaml::Model::Type::String
         attribute :name, Lutaml::Model::Type::String
         attribute :xref_type, Lutaml::Model::Type::String
+        attribute :visibility, Lutaml::Model::Type::String
+        attribute :behavior, Lutaml::Model::Type::String
+        attribute :partition, Lutaml::Model::Type::String
         attribute :client, Lutaml::Model::Type::String
         attribute :supplier, Lutaml::Model::Type::String
         attribute :description, Lutaml::Model::Type::String

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Models
+      # Mixin providing `public?`, `private?`, `protected?` scope
+      # predicates for any model that has a `scope` attribute
+      # (t_attribute.scope, t_operation.scope, t_object.scope).
+      #
+      # EA stores scope as a case-insensitive string ("Public",
+      # "Private", "Protected"). This module centralises the
+      # comparison so both EaAttribute and EaOperation share one
+      # implementation.
+      module ScopePredicate
+        def public?
+          scope&.downcase == "public"
+        end
+
+        def private?
+          scope&.downcase == "private"
+        end
+
+        def protected?
+          scope&.downcase == "protected"
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/models.rb

@@ -6,6 +6,7 @@ module Ea
   module Qea
     module Models
       autoload :BaseModel, "ea/qea/models/base_model"
+      autoload :ScopePredicate, "ea/qea/models/scope_predicate"
       autoload :EaAttribute, "ea/qea/models/ea_attribute"
       autoload :EaAttributeTag, "ea/qea/models/ea_attribute_tag"
       autoload :EaComplexityType, "ea/qea/models/ea_complexity_type"

data/lib/ea/qea/repositories/base_repository.rb

@@ -215,9 +215,12 @@ module Ea
 
         private
 
+        # First occurrence wins, matching what a scan would return —
+        # `find` and `find_by_key` must not disagree about which record
+        # answers for a duplicated key.
         def build_pk_index
           @pk_index = {}
-          @records.each { |r| @pk_index[r.primary_key] = r }
+          @records.each { |r| @pk_index[r.primary_key] ||= r }
         end
       end
     end

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

@@ -128,54 +128,9 @@ module Ea
         # Maps table names to their corresponding collections in Database
         #
         # @param table [String] Table name (e.g., "t_package", "t_object")
-        # @return [Array, nil] Collection array or nil if table not mapped
-        def get_collection_for_table(table) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
-          case table
-          when "t_package"
-            database.packages
-          when "t_object"
-            database.objects.all
-          when "t_attribute"
-            database.attributes
-          when "t_operation"
-            database.operations
-          when "t_operationparams"
-            database.operation_params
-          when "t_connector"
-            database.connectors
-          when "t_diagram"
-            database.diagrams
-          when "t_diagramobjects"
-            database.diagram_objects
-          when "t_diagramlinks"
-            database.diagram_links
-          when "t_objectconstraint"
-            database.object_constraints
-          when "t_objectproperties"
-            database.object_properties
-          when "t_taggedvalue"
-            database.tagged_values
-          when "t_attributetag"
-            database.attribute_tags
-          when "t_xref"
-            database.xrefs
-          when "t_stereotypes"
-            database.stereotypes
-          when "t_datatypes"
-            database.datatypes
-          when "t_constrainttypes"
-            database.constraint_types
-          when "t_connectortypes"
-            database.connector_types
-          when "t_diagramtypes"
-            database.diagram_types
-          when "t_objecttypes"
-            database.object_types
-          when "t_statustypes"
-            database.status_types
-          when "t_complexitytypes"
-            database.complexity_types
-          end
+        # @return [Array] Collection array or [] if table not mapped
+        def get_collection_for_table(table)
+          database.collection_for_table(table)
         end
 
         # Adds an error to the validation result

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

@@ -24,18 +24,30 @@ module Ea
           return unless ast
 
           if evaluate(ast, owner)
-            result.add(:info, "OCL constraint '#{constraint.constraint_type}' " \
-                              "passed for #{owner.name}",
-                       entity_name: owner.name)
+            result.add_info(
+              category: :ocl_constraint,
+              entity_type: :class,
+              entity_id: owner.ea_object_id.to_s,
+              entity_name: owner.name,
+              message: "OCL constraint '#{constraint.constraint_type}' passed",
+            )
           else
-            result.add(:warning, "OCL constraint '#{constraint.constraint_type}' " \
-                                 "failed for #{owner.name}: #{constraint.constraint}",
-                       entity_name: owner.name)
+            result.add_warning(
+              category: :ocl_constraint,
+              entity_type: :class,
+              entity_id: owner.ea_object_id.to_s,
+              entity_name: owner.name,
+              message: "OCL constraint '#{constraint.constraint_type}' failed: #{constraint.constraint}",
+            )
           end
         rescue Ea::Ocl::UnsupportedError => e
-          result.add(:info, "Skipping OCL constraint on #{owner&.name} " \
-                            "(unsupported syntax): #{e.message}",
-                     entity_name: owner&.name)
+          result.add_info(
+            category: :ocl_constraint,
+            entity_type: :class,
+            entity_id: owner&.ea_object_id.to_s,
+            entity_name: owner&.name,
+            message: "Skipping OCL constraint (unsupported syntax): #{e.message}",
+          )
         end
 
         # Parse the OCL body. Returns nil for empty / non-invariant
@@ -51,13 +63,11 @@ module Ea
         end
 
         def owner_for(constraint)
-          object_id = constraint.respond_to?(:ea_object_id) ?
-                       constraint.ea_object_id :
-                       constraint.object_id
+          object_id = constraint.ea_object_id
           return nil unless object_id
 
           (database.collections[:objects] || [])
-            .find { |o| o.object_id == object_id }
+            .find { |o| o.ea_object_id == object_id }
         end
       end
     end

data/lib/ea/shapescript/renderer.rb

@@ -36,9 +36,7 @@ module Ea
       end
 
       def escape(text)
-        text.to_s.gsub("&", "&")
-             .gsub("<", "&lt;")
-             .gsub(">", "&gt;")
+        XmlEscape.call(text)
       end
 
       def render_rect(p, fill, stroke)

data/lib/ea/sources/qea/diagram_builder.rb

@@ -425,6 +425,7 @@ module Ea
           end
           boxes
         end
+        public :parse_label_boxes
 
         # Parse one label box's colon-separated key=value body into
         # a Hash with string keys. Returns nil if OX/OY are absent.

data/lib/ea/sources/qea/id_normalizer.rb

@@ -17,7 +17,7 @@ module Ea
         def from_guid(ea_guid)
           return nil if ea_guid.nil? || ea_guid.empty?
 
-          ea_guid.to_s.gsub(/[{}]/, "")
+          Ea::GuidFormat.strip_braces(ea_guid)
         end
 
         # Convert a GUID to the EAID_ filename format used by EA's
@@ -26,7 +26,7 @@ module Ea
         def to_eaid(ea_guid)
           return nil if ea_guid.nil? || ea_guid.empty?
 
-          "EAID_" + ea_guid.to_s.gsub(/[{}]/, "").tr("-", "_")
+          Ea::GuidFormat.ea_guid_to_xmi_id(ea_guid, prefix: "EAID")
         end
 
         def synthetic(prefix, *parts)

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

@@ -1,4 +1,5 @@
-# frozen_string_string: true
+# frozen_string_literal: true
+
 
 module Ea
   module Svg

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

@@ -55,12 +55,7 @@ module Ea
           private
 
           def visibility_marker
-            case property.visibility
-            when "private"   then "-"
-            when "protected" then "#"
-            when "package"   then "~"
-            else "+"
-            end
+            VisibilitySymbol.for(property.visibility)
           end
 
           # Property name, prefixed with the declaring classifier's

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

@@ -55,12 +55,7 @@ module Ea
           end
 
           def self.visibility_prefix(operation)
-            case operation.visibility
-            when "private"   then "- "
-            when "protected" then "# "
-            when "package"   then "~ "
-            else "+ "
-            end
+            VisibilitySymbol.for(operation.visibility, with_space: true)
           end
           private_class_method :visibility_prefix
 
@@ -71,7 +66,7 @@ module Ea
 
             "#{text}: #{operation.return_type_name}"
           end
-          private_class_method :operation_text
+          public_class_method :operation_text
 
           def self.namespace_double_colon(type_name)
             return "" if type_name.nil? || type_name.empty?

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

@@ -185,9 +185,6 @@ module Ea
         # alphabetical "+ Name" rows in the body compartment, but
         # only when the diagram's t_diagram.ShowPackageContents flag
         # is non-zero. Returns [] when the diagram suppresses
-        # package contents or the model element isn't a Package.
-        # Each entry is a Struct(name:, kind:) so the renderer can
-        # pick the correct per-type icon (Enumeration vs default).
         def package_content_lines_for(model_element)
           return [] unless model_element.is_a?(Ea::Model::Package)
           return [] unless diagram.show_package_contents
@@ -199,6 +196,7 @@ module Ea
             PackageContentRow.new(name: c.name.to_s, kind: row_icon_kind(c))
           end
         end
+        public :package_content_lines_for
 
         def package_children(package)
           return [] unless model_index

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

@@ -1,4 +1,5 @@
-# frozen_string: true
+# frozen_string_literal: true
+
 
 module Ea
   module Svg

data/lib/ea/svg/ea_emitter/label/end_label.rb

@@ -236,12 +236,7 @@ module Ea
           end
 
           def visibility_prefix(property)
-            case property.visibility
-            when "private"   then "-"
-            when "protected" then "#"
-            when "package"   then "~"
-            else "+"
-            end
+            VisibilitySymbol.for(property.visibility)
           end
 
           def text_at(x, y, content)

data/lib/ea/svg/ea_emitter/marker/package_import.rb

@@ -1,4 +1,4 @@
-# frozen_string: true
+# frozen_string_literal: true
 
 module Ea
   module Svg

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

@@ -62,7 +62,7 @@ module Ea
         # Backwards-compatible API: count of marker bodies emitted.
         def count_for(connector)
           return 0 if connector.hidden
-          return 0 unless connector.waypoints&.any? { |w| w.position }
+          return 0 unless connector.waypoints&.any?(&:position)
 
           entries_for(connector).size
         end
@@ -85,15 +85,51 @@ module Ea
           end
         end
 
+        # OCP registries for marker shapes. Adding a new marker shape
+        # = adding one entry to SHAPE_REGISTRY, not editing 3 case/when
+        # branches. Each entry carries the style_key and a render
+        # lambda that knows how to draw the shape.
+        #
+        # Style keys (:diamond_filled, :triangle_open, :connector_line)
+        # map to CSS strings via STYLE_MAP below.
+        SHAPE_REGISTRY = {
+          diamond: {
+            style_key: :diamond_filled,
+            render: ->(m, anchor, base) { m.diamond_polygon(anchor, base) }
+          },
+          triangle: {
+            style_key: :triangle_open,
+            render: ->(m, anchor, base) { m.triangle_polygon(anchor, base) }
+          },
+          plus: {
+            style_key: :connector_line,
+            render: ->(m, anchor, _base) { m.plus_path(anchor) }
+          },
+          arrow: {
+            style_key: :connector_line,
+            render: ->(m, anchor, base) { m.arrow_path(anchor, base) }
+          },
+          package_anchor: {
+            style_key: :connector_line,
+            render: ->(m, anchor, base) { m.package_anchor_path(anchor, base) }
+          }
+        }.freeze
+
+        # Style key → (fill, opacity) pair. The common stroke prefix
+        # is shared, so only the fill and opacity vary.
+        STYLE_MAP = {
+          diamond_filled: { fill: "#000000", opacity: "1.00" },
+          triangle_open: { fill: "#FFFFFF", opacity: "1.00" },
+          connector_line: { fill: "#000000", opacity: "0.00" }
+        }.freeze
+
         def style_for(key)
-          case key
-          when :diamond_filled
-            "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
-          when :triangle_open
-            "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#FFFFFF;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
-          when :connector_line
-            "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
-          end
+          spec = STYLE_MAP[key]
+          return nil unless spec
+
+          "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; " \
+            "fill:#{spec[:fill]};fill-opacity:#{spec[:opacity]}; " \
+            "stroke:#000000; stroke-opacity:1.00"
         end
 
         def visible_connectors
@@ -210,13 +246,7 @@ module Ea
         end
 
         def style_key_for(spec)
-          case spec.shape
-          when :diamond  then :diamond_filled
-          when :triangle then :triangle_open
-          when :plus     then :connector_line # shares style with line <g>
-          when :arrow    then :connector_line # share with line <g>
-          when :package_anchor then :connector_line
-          end
+          SHAPE_REGISTRY.dig(spec.shape, :style_key)
         end
 
         # Rounded [x, y] of the marker's tip (anchor) in canvas
@@ -227,13 +257,10 @@ module Ea
         end
 
         def render_shape(spec)
-          case spec.shape
-          when :diamond  then diamond_polygon(spec.anchor, spec.base)
-          when :triangle then triangle_polygon(spec.anchor, spec.base)
-          when :plus     then plus_path(spec.anchor)
-          when :arrow    then arrow_path(spec.anchor, spec.base)
-          when :package_anchor then package_anchor_path(spec.anchor, spec.base)
-          end
+          entry = SHAPE_REGISTRY[spec.shape]
+          return nil unless entry
+
+          entry[:render].call(self, spec.anchor, spec.base)
         end
 
         # Plus marker: two crossed line segments at the anchor.
@@ -384,6 +411,8 @@ module Ea
 
           [dx / len, dy / len]
         end
+        public :diamond_polygon, :triangle_polygon, :plus_path,
+               :arrow_path, :package_anchor_path
 
         def translate_point(p)
           return p unless @canvas

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

@@ -81,10 +81,7 @@ module Ea
         end
 
         def escaped_content
-          content.gsub("&", "&")
-                 .gsub("<", "&lt;")
-                 .gsub(">", "&gt;")
-                 .gsub("\"", "&quot;")
+          XmlEscape.call(content)
         end
       end
     end