ea 0.5.1 → 0.6.0

data/lib/ea/ocl/parser.rb

@@ -33,7 +33,7 @@ module Ea
       end
 
       # Parse one expression. Returns a single AST node.
-      def parse_expression(source)
+      def parse_expression(source) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
         s = source.strip
 
         # Strip outer parens
@@ -45,7 +45,14 @@ module Ea
                                     operand: parse_expression(s[4..]))
         end
 
-        # 'and' / 'or' at top level (find the operator not inside parens)
+        # 'and' / 'or' / comparison ops — comparison has higher
+        # precedence than logical, so check it first.
+        if (split = split_on_comparison_op(s))
+          op, left, right = split
+          return Nodes::Comparison.new(op: op,
+                                       left: parse_expression(left),
+                                       right: parse_expression(right))
+        end
         if (split = split_on_logical_op(s))
           op, left, right = split
           return Nodes::BinaryOp.new(op: op,
@@ -58,6 +65,16 @@ module Ea
           return collection_node(m[2].to_sym, m[1], m[3], m[4])
         end
 
+        # Collection ->size() — integer cardinality
+        if (m = s.match(/^(.+?)->size\(\)\z/))
+          return Nodes::CollectionSize.new(collection: parse_expression(m[1]))
+        end
+
+        # Collection ->isEmpty() — boolean
+        if (m = s.match(/^(.+?)->isEmpty\(\)\z/))
+          return Nodes::CollectionIsEmpty.new(collection: parse_expression(m[1]))
+        end
+
         # String.matches('regex')
         if (m = s.match(/^(.+?)\.matches\(\s*['"](.+?)['"]\s*\)\z/))
           return Nodes::StringMatches.new(string: parse_expression(m[1]),
@@ -99,7 +116,6 @@ module Ea
       # Find the topmost ` and ` or ` or ` outside of parens.
       # Returns [op, left_str, right_str] or nil.
       def split_on_logical_op(source)
-        depth = 0
         # Look for ' or ' first (lower precedence than 'and' in OCL?)
         # Actually OCL: 'or' < 'xor' < 'and' < 'implies'. We pick the
         # rightmost top-level operator (left-associative).
@@ -113,6 +129,45 @@ module Ea
         nil
       end
 
+      # Split on top-level comparison operator (>, <, >=, <=, =, ==, !=).
+      # Comparison has higher precedence than and/or, so we split here
+      # BEFORE calling split_on_logical_op.
+      def split_on_comparison_op(source)
+        %w[>= <= == != = > <].each do |op|
+          # Need to be careful with `>=` vs `>`: scan in order so
+          # multi-char operators are detected first.
+          idx = find_top_level_op(source, op)
+          next unless idx
+
+          return [op, source[0...idx], source[(idx + op.length)..]]
+        end
+        nil
+      end
+
+      def find_top_level_op(source, op) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        depth = 0
+        i = 0
+        while i < source.length
+          c = source[i]
+          depth += 1 if c == "("
+          depth -= 1 if c == ")"
+          if depth.zero? && source[i, op.length] == op
+            # Each `next` clause below MUST fall through to `i += 1`
+            # at the loop's tail — using `next` here would skip the
+            # increment and infinite-loop on the same matching char.
+            should_skip =
+              (op == ">" && source[i + 1, 1] == "=") || # >= matches as >
+              (op == "<" && source[i + 1, 1] == "=") || # <= matches as <
+              (op == "=" && source[i + 1, 1] == "=") || # == matches as =
+              (op == ">" && source[i - 1, 1] == "-") || # -> arrow
+              (op == "<" && source[i - 1, 1] == "-") # <- arrow
+            return i unless should_skip
+          end
+          i += 1
+        end
+        nil
+      end
+
       # Find substring at depth 0 (not inside parens).
       def find_top_level(source, substring)
         depth = 0
@@ -121,9 +176,8 @@ module Ea
           c = source[i]
           depth += 1 if c == "("
           depth -= 1 if c == ")"
-          if depth.zero? && source[i, substring.length] == substring
-            return i
-          end
+          return i if depth.zero? && source[i, substring.length] == substring
+
           i += 1
         end
         nil

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