ea 0.6.140 → 0.6.142

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9db50e16de6c9f9faa698a872686600da15ba3eef0787de0b18b0ea56eca0394
-  data.tar.gz: b537f2b76e1fdb3a5a6dcfd1581db9f651279c5aff4e35882144da2ace23cf26
+  metadata.gz: b51e9399fd02dbf1d891731d7a6cdcf754b1778efdbd3e3946479a02aa0761a2
+  data.tar.gz: 96c4a49164b75a78ac1a165bdd24f4a1a13e9e8199f84e1577fd111b7498b332
 SHA512:
-  metadata.gz: 9a685c1155369f6800fbfd294feed39ea2b450f482245c30be940c18bb31098466be6dbb0f0e6ca28e90502798ceaf10c8a5bbac0f0739b619b1cc0cd69696cb
-  data.tar.gz: 570de8eaf44e482c0330cc96f17eb2ab89e26a75542c613617b53468040b45dfec9ce597b308cd50b068d0a78e20e415a9cda9e897622f1cc1b1ab2a4e110baa
+  metadata.gz: 19e20b995ba1bcad98fb01f30b8cad1eec339994c57782f543e9b0014fe08f8bf4e2176ce4f5bea790e07c08bbe26f5745ee5609ec36ac1f1669e02e40f27973
+  data.tar.gz: ee051963f75748a2b32fb6021078146c76687d539e3f76cb52fd76281ef7abf6adeb355bfe48d528aa39244c400f5ea2a80064519f166c19098c3b5ecfef5dac

data/config/themes/default.yml

@@ -4,6 +4,13 @@ font:
   family:
   size:
   unit: px
+# Unthemed diagrams draw connector labels in Cambria 7pt, like the
+# themed ones (test B58D1A53 native; 0 of 220 published SVGs carry the
+# former Yu Gothic UI 13px fallback).
+label_font:
+  family: Cambria
+  size: 7
+  unit: pt
 text:
   color: "#000000"
   weight_normal: 400

data/lib/ea/cli/app.rb

@@ -41,6 +41,8 @@ module Ea
            "Diagram operations: list FILE | extract NAME FILE"
       option :format, type: :string, default: "table"
       option :output, **OUTPUT_OPTION, desc: "Output path (extract only)"
+      option :frame, type: :boolean, default: false,
+                     desc: "Draw EA's diagram frame (border, tab, label); default is unframed"
       def diagrams(action, file = nil, name = nil)
         Command::Diagrams
           .new(action: action, file: file, name: name, **symbolize(options))
@@ -81,6 +83,8 @@ module Ea
              desc: "Path to SPA YAML config (overrides model metadata: title, description, etc.)"
       option :mode, type: :string, default: "single_file",
                     desc: "Output mode: single_file | sharded"
+      option :frame, type: :boolean, default: false,
+                     desc: "Draw EA's diagram frame (border, tab, label); default is unframed"
       def spa(file)
         Command::Spa.new(file: file, **symbolize(options)).call
       end
@@ -92,7 +96,10 @@ module Ea
                    desc: "Render every diagram in the source file (NAME ignored)"
       option :output_dir, type: :string,
                           desc: "Directory for --all output (default: <basename>.svgs/)"
+      option :frame, type: :boolean, default: false,
+                     desc: "Draw EA's diagram frame (border, tab, label); default is unframed"
       def svg(name = nil, file = nil)
+        name, file = nil, name if options[:all] && file.nil?
         Command::Svg.new(name: name, file: file, **symbolize(options)).call
       end
 
@@ -113,7 +120,10 @@ module Ea
                       desc: "Output format: svg | png | pdf"
       option :output_dir, type: :string,
                           desc: "Directory for --all output (default: <basename>.renders/)"
+      option :frame, type: :boolean, default: false,
+                     desc: "Draw EA's diagram frame (border, tab, label); default is unframed"
       def render(name = nil, file = nil)
+        name, file = nil, name if options[:all] && file.nil?
         Command::Render.new(name: name, file: file, **symbolize(options)).call
       end
 

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fileutils"
+
 module Ea
   module Cli
     module Command
@@ -51,7 +53,8 @@ module Ea
 
           svg = Ea::Svg::EaEmitter::Document.new(diagram,
                                                    model_index: document.index_by_id,
-                                                   document: document).render
+                                                   document: document,
+                                                   frame: options[:frame] ? true : false).render
           path = options[:output] || begin
             base = File.basename(file_path, ".*")
             dir = File.dirname(file_path)

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

@@ -22,6 +22,12 @@ module Ea
 
         private
 
+        # `--format` names the image format here (svg|png|pdf), not the
+        # table/json output formatter, so the result listing is a table.
+        def formatter
+          Ea::Cli::Output.instance_for(:table)
+        end
+
         def render_one
           diagram = find_diagram
           write_diagram(diagram, resolve_output_path(diagram))
@@ -57,7 +63,8 @@ module Ea
         def render_svg(diagram)
           emitter_for_mode.new(diagram,
                                model_index: document.index_by_id,
-                               document: document).render
+                               document: document,
+                               frame: options[:frame] ? true : false).render
         end
 
         def svg_to_png(svg)

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

@@ -22,7 +22,8 @@ module Ea
             document,
             output: output_path,
             mode: mode,
-            configuration: spa_configuration
+            configuration: spa_configuration,
+            frame: options[:frame] ? true : false
           ).generate
 
           formatter.render([[output_path]], columns: [:written_to])

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

@@ -26,9 +26,7 @@ module Ea
 
         def render_one
           diagram = find_diagram
-          svg = emitter_for_mode.new(diagram,
-                                       model_index: document.index_by_id,
-                                       document: document).render
+          svg = render_svg(diagram)
 
           output_path = resolve_output_path(diagram)
           FileUtils.mkdir_p(File.dirname(output_path))
@@ -41,9 +39,7 @@ module Ea
           out_dir = options[:output_dir] || default_output_dir
           FileUtils.mkdir_p(out_dir)
           paths = document.diagrams.map do |diagram|
-            svg = emitter_for_mode.new(diagram,
-                                         model_index: document.index_by_id,
-                                         document: document).render
+            svg = render_svg(diagram)
             path = File.join(out_dir, "#{diagram.id}.svg")
             File.write(path, svg)
             path
@@ -52,6 +48,13 @@ module Ea
           formatter.render(paths.map { |p| [p] }, columns: [:written_to])
         end
 
+        def render_svg(diagram)
+          emitter_for_mode.new(diagram,
+                               model_index: document.index_by_id,
+                               document: document,
+                               frame: options[:frame] ? true : false).render
+        end
+
         def default_output_dir
           base = File.basename(file_path, ".*")
           dir = File.dirname(file_path)

data/lib/ea/fonts/metrics.rb

@@ -105,6 +105,7 @@ module Ea
         # Source sizes 90 and 100 both export as 9pt but retain
         # distinct 12px and 13px logical heights. Apply that same
         # source-height delta to the existing compartment spacing.
+        logical_height = source_logical_height(logical_height)
         adjustment = if logical_height && unit == "pt" &&
                         GDI_HEIGHT_FAMILIES.include?(resolve_family(family))
                        logical_height - gdi_logical_height(size)
@@ -114,6 +115,13 @@ module Ea
         size + offset + adjustment
       end
 
+      # A source logical height of 0 or less (QEA floors tiny fontsz to
+      # 0) carries no information: treat it as absent.
+      def source_logical_height(height)
+        height = height.to_i
+        height if height.positive?
+      end
+
       def gdi_logical_height(size)
         (size.to_f * 10 / 7).round
       end
@@ -152,11 +160,17 @@ module Ea
       # textLength is the SUM of those per-glyph integers - corpus
       # fitted to 97-100% exact on 10k Carlito texts (bold 7pt
       # 1666/1671). The legacy sum-then-round model matched only 27%.
-      def text_length(text, size_pt, family: nil, weight: nil, style: nil, logical_height: nil)
+      #
+      # `legend_title` marks a diagram-legend title, the only context in
+      # which a bold Cambria CJK run takes regular-weight advances.
+      def text_length(text, size_pt, family: nil, weight: nil, style: nil, logical_height: nil,
+                      legend_title: false)
         return nil unless supported_family?(family)
         return nil if text.nil? || text.empty?
 
-        return cambria_text_length(text, size_pt, weight, style) if resolve_family(family) == "Cambria"
+        if resolve_family(family) == "Cambria"
+          return cambria_text_length(text, size_pt, weight, style, logical_height, legend_title: legend_title)
+        end
 
         advance_text_length(text, size_pt, family, weight, style, logical_height)
       end
@@ -164,7 +178,7 @@ module Ea
       def advance_text_length(text, size_pt, family, weight, style, logical_height)
         resolved = resolve_family(family)
         if GDI_HEIGHT_FAMILIES.include?(resolved)
-          height = logical_height || gdi_logical_height(size_pt)
+          height = source_logical_height(logical_height) || gdi_logical_height(size_pt)
           table = table_for(family, weight, style)
           fallback = cjk_fallback_widths(resolved, height, weight, style)
           measured_latin = measured_carlito_widths(resolved, height, weight, style)
@@ -206,8 +220,16 @@ module Ea
       end
       private_class_method :measured_carlito_widths
 
-      def cambria_text_length(text, size_pt, weight, style)
-        return cambria_cjk_only_length(text, size_pt, weight, style) unless size_pt.to_f.to_r == 7
+      # True for Cambria outside the 7pt tables, where a run is measured
+      # character by character when it is not wholly in the CJK table.
+      def piecewise_family?(family, size_pt)
+        resolve_family(family) == "Cambria" && size_pt.to_f.to_r != 7
+      end
+
+      def cambria_text_length(text, size_pt, weight, style, logical_height = nil, legend_title: false)
+        unless size_pt.to_f.to_r == 7
+          return cambria_cjk_only_length(text, size_pt, weight, style, logical_height, legend_title: legend_title)
+        end
         return nil unless ["", "0", "400", "normal", "700", "bold"].include?(weight.to_s)
         return nil unless ["", "normal", "italic"].include?(style.to_s)
 
@@ -223,17 +245,23 @@ module Ea
       private_class_method :cambria_text_length
 
       # Cambria has no Latin table outside 7pt, but a run made only of
-      # characters in the measured MS UI Gothic table is exact at any
-      # measured height. EMPIRICAL FIT (decision a): EA draws a bold
-      # Cambria CJK run at logical height >= 17 with the regular-weight
-      # advances (no synthetic-bold pixel), although the Windows table
-      # records one. Checked on the 116 native legend titles "凡例"
-      # (Cambria bold 12pt, H17): native textLength 34 = 2 x 17, where
-      # the 17:700 entry would give 36. Below H17 bold keeps the bold
-      # table (native 7pt bold "都市計画データ" = 70).
-      def cambria_cjk_only_length(text, size_pt, weight, style)
-        height = gdi_logical_height(size_pt)
-        bold = bold?(weight) && height < CAMBRIA_REGULAR_BOLD_MIN_HEIGHT
+      # characters in the measured MS UI Gothic table is exact at the
+      # measured height (the source logical height when it is positive,
+      # else the one derived from the point size). A run with any other
+      # character is nil here; TextRenderer.estimate_width then prices
+      # the characters one at a time.
+      #
+      # EMPIRICAL FIT (decision a), legend titles only: EA draws a bold
+      # Cambria legend title at logical height >= 17 with the
+      # regular-weight advances (no synthetic-bold pixel), although the
+      # Windows table records one. Checked on the 116 native legend
+      # titles "凡例" (Cambria bold 12pt, H17): native textLength 34 =
+      # 2 x 17, where the 17:700 entry would give 36. Every other bold
+      # run, and a title below H17, keeps the bold table (native 7pt
+      # bold "都市計画データ" = 70).
+      def cambria_cjk_only_length(text, size_pt, weight, style, logical_height = nil, legend_title: false)
+        height = source_logical_height(logical_height) || gdi_logical_height(size_pt)
+        bold = bold?(weight) && !(legend_title && height >= CAMBRIA_REGULAR_BOLD_MIN_HEIGHT)
         widths = cjk_fallback_widths("Cambria", height, bold ? 700 : 400, style)
         advances = text.each_char.map { |char| widths[char] }
         advances.sum unless advances.include?(nil)

data/lib/ea/model/diagram.rb

@@ -43,6 +43,12 @@ module Ea
         map "annotations", to: :annotations, render_empty: true
       end
 
+      # True for an object diagram. QEA stores "Object", the XMI adapter
+      # yields lowercase "object"; compare case-insensitively.
+      def object_diagram?
+        diagram_type.to_s.casecmp?("Object")
+      end
+
       # Parses style_ex into a Hash of flag => value. Returns empty
       # Hash when style_ex is nil/empty.
       #

data/lib/ea/qea/services/database_loader.rb

@@ -102,7 +102,6 @@ module Ea
         # @raise [Errno::ENOENT] if QEA file not found
         # @raise [SQLite3::Exception] if database access fails
         def load
-          # Connect but don't use with_connection - we need to keep it open
           @connection.connect unless @connection.connected?
           db = @connection.connection
 
@@ -117,6 +116,10 @@ module Ea
           end
 
           database.freeze
+        ensure
+          # All tables are in memory; nothing reads the connection after
+          # load, and an open handle locks the file on Windows.
+          @connection.close
         end
 
         # Load a single table

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

@@ -7,6 +7,10 @@ module Ea
         # Internal geometry for choosing the facing edges of stored routes.
         module Routing
           REVERSED_TREE_BUS_OFFSET = 50
+          # A leg may start beside its box only this far from it (the one native
+          # case, 5038EEE3 connector 212, is 9px away); any other leg that
+          # leaves the box's x-span would be detached, so the fit yields.
+          REVERSED_TREE_BESIDE_REACH = 10
 
           private
 
@@ -19,19 +23,26 @@ module Ea
             connector = database.find_connector(link_row.connectorid)
             return model unless connector && reversed_corner_link?(link_row, diagram_row, connector)
 
-            boxes = stored_ray_boxes(link_row, diagram_row)
+            origins, points = reversed_corner_points(stored_ray_boxes(link_row, diagram_row), geom,
+                                                     intermediate_waypoints(link_row).first)
+            return model unless points
+
+            model.waypoints = points.map { |point| Ea::Model::Waypoint.new(position: point) }
+            model.source_anchor, model.target_anchor = origins
+            model
+          end
+
+          # Shared by QEA and XMI: clip each leg of the single saved bend from
+          # its stored origin, retaining origins outside their box. Returns
+          # [origins, [start, bend, end]], or nil when a leg cannot be clipped.
+          def reversed_corner_points(boxes, geom, corner)
             origins = [stored_ray_origin(boxes[0], geom[:sx], geom[:sy]),
                        stored_ray_origin(boxes[1], geom[:ex], geom[:ey])]
-            x, y = intermediate_waypoints(link_row).first
-            bend = Ea::Model::Point.new(x: x, y: y)
+            bend = Ea::Model::Point.new(x: corner[0], y: corner[1])
             ends = origins.zip(boxes).map do |origin, box|
               inside_box?(origin, box) ? diagonal_corner_exit(origin, bend, box) : origin
             end
-            return model unless ends.all?
-
-            model.waypoints = [ends[0], bend, ends[1]].map { |point| Ea::Model::Waypoint.new(position: point) }
-            model.source_anchor, model.target_anchor = origins
-            model
+            [origins, [ends[0], bend, ends[1]]] if ends.all?
           end
 
           # EMPIRICAL FIT (decision a), not a source-backed rule. A width-0
@@ -48,22 +59,37 @@ module Ea
             return model if context || !reversed_tree_link?(model, link_row, diagram_row, geom)
 
             start, finish = stored_ray_boxes(link_row, diagram_row)
-            bus, start_edge, finish_edge = reversed_tree_levels(start, finish)
-            return model unless bus
+            route = reversed_tree_points(start, finish, geom, stored_bus_levels(link_row))
+            return model unless route
 
-            first = reversed_tree_leg(start, geom[:sx], geom[:sy], start_edge, finish)
-            last = reversed_tree_leg(finish, geom[:ex], geom[:ey], finish_edge, start)
-            model.waypoints = [first, [first[0], bus], [last[0], bus], last].map do |x, y|
+            points, beside = route
+            model.waypoints = points.map do |x, y|
               Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
             end
             model.source_anchor = model.source_port = model.waypoints.first.position
             model.target_anchor = model.target_port = model.waypoints.last.position
             # EMPIRICAL FIT: a leg that starts beside its box (5038EEE3
             # connector 212) seats its source labels like a leftward leg.
-            model.style = model.style.to_h.merge(left_seated_source: true) if first[1] != start_edge
+            model.style = model.style.to_h.merge(left_seated_source: true) if beside
             model
           end
 
+          # The reversed-tree route points and whether the Start leg starts
+          # beside its box, or nil when the fit does not apply: no usable bus
+          # level, a stored bus that is not the discarded one (see
+          # reversed_tree_levels), or a leg that cannot stay attached to its box.
+          def reversed_tree_points(start, finish, geom, stored_bus)
+            bus, start_edge, finish_edge = reversed_tree_levels(start, finish, stored_bus)
+            return unless bus
+
+            first = reversed_tree_leg(start, geom[:sx], geom[:sy], start_edge, finish)
+            last = reversed_tree_leg(finish, geom[:ex], geom[:ey], finish_edge, start)
+            return unless first && last
+
+            points = [first, [first[0], bus], [last[0], bus], last].chunk_while { |a, b| a == b }.map(&:first)
+            [points, first[1] != start_edge]
+          end
+
           # EMPIRICAL FIT (decision a). EA seats the source labels of a
           # vertical lateral tree ("LV") whose SOID/EOID name the ends in
           # reverse as if the source leg left to the left, whichever way the
@@ -92,25 +118,37 @@ module Ea
 
           def stored_bus_levels(link_row)
             bends = intermediate_waypoints(link_row)
-            bends.size == 2 && bends.first[1] == bends.last[1]
+            bends.first[1] if bends.size == 2 && bends.first[1] == bends.last[1]
           end
 
           # [bus height, Start facing edge, End facing edge] for vertically
           # separated boxes: the bus sits 50px past the End box's edge and
           # must stay inside the gap. Nil otherwise.
-          def reversed_tree_levels(start, finish)
+          #
+          # EMPIRICAL FIT (decision a): a stored bus is replaced only when it
+          # is a 50px tree bus off one of the two facing edges, as EA lays
+          # them out: 50px past the Start box (the Path follows SOID/EOID
+          # order; the QEA y670 = Start edge 720 - 50 of all five 5038EEE3
+          # links) or already 50px past the End box (the XMI Path of three
+          # of them, y568). A stored bus anywhere else is a real route.
+          def reversed_tree_levels(start, finish, stored_bus)
             if finish.y + finish.height < start.y
               bus = finish.y + finish.height + REVERSED_TREE_BUS_OFFSET
-              [bus, start.y, finish.y + finish.height] if bus < start.y
+              discarded = start.y - REVERSED_TREE_BUS_OFFSET
+              edges = [start.y, finish.y + finish.height]
+              [bus, *edges] if bus < start.y && [bus, discarded].include?(stored_bus)
             elsif start.y + start.height < finish.y
               bus = finish.y - REVERSED_TREE_BUS_OFFSET
-              [bus, start.y + start.height, finish.y] if bus > start.y + start.height
+              discarded = start.y + start.height + REVERSED_TREE_BUS_OFFSET
+              edges = [start.y + start.height, finish.y]
+              [bus, *edges] if bus > edges.first && [bus, discarded].include?(stored_bus)
             end
           end
 
           # A leg runs vertically at the stored origin's x. It starts on the
-          # facing edge, unless the origin lies beside the box (outside its
-          # x-span but level with it), where the origin itself is kept.
+          # facing edge, unless the origin lies beside the box (just outside its
+          # x-span but level with it), where the origin itself is kept. Nil
+          # for an origin that would leave the leg detached.
           #
           # EMPIRICAL FIT (decision a): the leg's x is pulled toward the box
           # centre by |offset_y| / (vertical centre distance to the other box).
@@ -124,8 +162,12 @@ module Ea
             pull = span.positive? ? 1 - [offset_y.to_i.abs / span, 1].min : 1
             pulled = (offset_x.to_i.abs * pull).ceil * (offset_x.to_i.negative? ? -1 : 1)
             origin = stored_ray_origin(box, pulled, offset_y)
-            beside = !origin.x.between?(box.x, box.x + box.width) && origin.y.between?(box.y, box.y + box.height)
-            [origin.x, beside ? origin.y : edge_y]
+            return [origin.x, edge_y] if origin.x.between?(box.x, box.x + box.width)
+
+            reach = REVERSED_TREE_BESIDE_REACH
+            beside = origin.y.between?(box.y, box.y + box.height) &&
+                     origin.x.between?(box.x - reach, box.x + box.width + reach)
+            [origin.x, origin.y] if beside
           end
 
           # Path follows SOID/EOID placement order, independently of the

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

@@ -202,7 +202,10 @@ module Ea
         end
 
         def build_connectors(diagram_row)
-          links = database.diagram_links_for(diagram_row.diagram_id) || []
+          # A link row whose connector no longer exists (EA leaves them
+          # behind when a connector is deleted) has nothing to draw.
+          links = (database.diagram_links_for(diagram_row.diagram_id) || [])
+                  .select { |link_row| database.find_connector(link_row.connectorid) }
           context = ContextDiagramSupport.context?(diagram_row)
           # EA regenerates context diagrams at draw time; their
           # Hidden link rows are stale and never render.

data/lib/ea/sources/xmi/adapter.rb

@@ -37,6 +37,7 @@ module Ea
           )
           mark_connector_proxies(doc)
           apply_tagged_values(doc)
+          apply_constraints(doc)
           apply_receptions(doc)
           apply_stereotypes(doc)
           resolve_type_names(doc)
@@ -93,6 +94,17 @@ module Ea
           end
         end
 
+        # Attach the extension's element constraints to their classifiers,
+        # as the QEA adapter does from t_objectconstraint.
+        def apply_constraints(doc)
+          grouped = ConstraintBuilder.new(xmi_path).grouped_by_element
+          return if grouped.empty?
+
+          doc.classifiers.each do |c|
+            c.constraints = grouped[c.id] if c.id && grouped[c.id]
+          end
+        end
+
         # Attach tagged values parsed from the <xmi:Extension><tags>
         # block to their owning classifiers and packages.
         def apply_tagged_values(doc)
@@ -130,6 +142,7 @@ module Ea
             (classifier.properties || []).each do |prop|
               prop.type_name = types.attribute_type(prop.id) ||
                                qualified_by_id[prop.type_ref] || prop.type_name
+              apply_attribute_stereotype(prop, types)
             end
             (classifier.operations || []).each do |op|
               resolve_operation_types(op, qualified_by_id, types)
@@ -137,6 +150,13 @@ module Ea
           end
         end
 
+        def apply_attribute_stereotype(prop, types)
+          stereotype = types.attribute_stereotype(prop.id)
+          return if stereotype.nil? || prop.stereotype_refs.to_a.any?
+
+          prop.stereotype_refs = [stereotype]
+        end
+
         def resolve_operation_types(operation, qualified_by_id, types)
           operation.return_type_name = types.return_type(operation.id) ||
                                        qualified_by_id[operation.return_type_name] ||

data/lib/ea/sources/xmi/connector_index.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Indexes the extension's `<connector>` nodes by `xmi:idref`. EA never
+      # repeats `<source>`, `<target>`, `<properties>` or `<xrefs>` inside one
+      # connector; if a hand-edited file does, the parse yields an Array where
+      # a single node is read, so the first occurrence is kept.
+      module ConnectorIndex
+        SINGLE_NODES = %i[source target properties xrefs].freeze
+
+        def self.build(root)
+          connectors = root.extension&.connectors&.connector || []
+          connectors.each_with_object({}) do |connector, index|
+            next unless connector.idref
+
+            SINGLE_NODES.each { |name| keep_first(connector, name) }
+            index[connector.idref] = connector
+          end
+        end
+
+        def self.keep_first(connector, name)
+          value = connector.public_send(name)
+          connector.public_send(:"#{name}=", value.first) if value.is_a?(Array)
+        end
+      end
+    end
+  end
+end

data/lib/ea/sources/xmi/constraint_builder.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      # Extracts element constraints from the `<xmi:Extension><elements>`
+      # block (`<element><constraints><constraint/></constraints>`), the
+      # XMI image of t_objectconstraint. The xmi gem does not expose them,
+      # so the file is streamed once and grouped by owning element id.
+      class ConstraintBuilder
+        attr_reader :xmi_path
+
+        def initialize(xmi_path)
+          @xmi_path = xmi_path
+        end
+
+        # Returns Hash{element_id => Array<Ea::Model::Constraint>}
+        def grouped_by_element
+          return {} if xmi_path.nil?
+
+          @grouped_by_element ||= scan
+        end
+
+        private
+
+        def scan
+          @path = []
+          @owner = nil
+          @grouped = {}
+          @seen_owners = {}
+          @blocks_seen = {}
+          @skip_block = false
+          File.open(xmi_path) { |io| Nokogiri::XML::Reader(io).each { |node| visit(node) } }
+          @grouped
+        end
+
+        def visit(node)
+          case node.node_type
+          when Nokogiri::XML::Reader::TYPE_END_ELEMENT
+            @owner = nil if @path.pop == "element"
+          when Nokogiri::XML::Reader::TYPE_ELEMENT
+            enter(node)
+            @path.push(node.local_name) unless node.self_closing?
+          end
+        end
+
+        def enter(node)
+          if node.local_name == "element" && @path.last == "elements" && !node.self_closing?
+            @owner = first_block_owner(node.attribute("xmi:idref"))
+          elsif node.local_name == "constraints" && @owner && @path.last == "element"
+            @skip_block = @blocks_seen.key?(@owner)
+            @blocks_seen[@owner] = true
+          elsif node.local_name == "constraint" && @owner && !@skip_block && @path.last(2) == %w[element constraints]
+            (@grouped[@owner] ||= []) << constraint(node)
+          end
+        end
+
+        # A repeated `<element xmi:idref="X">` or `<constraints>` block would
+        # append X's constraints again, so only the first of each is read.
+        def first_block_owner(idref)
+          return nil if @seen_owners.key?(idref)
+
+          @seen_owners[idref] = true
+          idref
+        end
+
+        def constraint(node)
+          Ea::Model::Constraint.new(
+            id: IdNormalizer.synthetic_id(@owner, "constraint", @grouped[@owner].to_a.size.to_s),
+            name: node.attribute("name").to_s,
+            kind: node.attribute("type").to_s,
+            body: node.attribute("description").to_s,
+            status: node.attribute("status").to_s
+          )
+        end
+      end
+    end
+  end
+end