ea 0.4.0 → 0.5.0

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

@@ -8,10 +8,11 @@ module Ea
       # ObjectClassifierMap for dispatch (OCP — new classifier
       # kinds need no edit here).
       class ClassifierBuilder
-        attr_reader :database
+        attr_reader :database, :mdg_registry
 
-        def initialize(database)
+        def initialize(database, mdg_registry: nil)
           @database = database
+          @mdg_registry = mdg_registry
         end
 
         def build_all
@@ -23,12 +24,53 @@ module Ea
         end
 
         def build_one(object)
-          klass = ObjectClassifierMap.class_for(object.object_type)
+          klass = classifier_class_for(object)
           args = common_args(object)
           args.merge!(enumeration_args(object)) if klass == Ea::Model::Enumeration
+          args.delete(:properties) if klass == Ea::Model::Enumeration
           klass.new(**args)
         end
 
+        # EA's `t_object.Object_Type` selects the concrete classifier
+        # subclass, but a Class with the "enumeration" stereotype is
+        # rendered as an Enumeration (literals compartment, no
+        # visibility marker). Promote the model class when the
+        # stereotype says so.
+        def classifier_class_for(object)
+          base = ObjectClassifierMap.class_for(object.object_type)
+          return base unless base == Ea::Model::Klass
+          return Ea::Model::Enumeration if enumeration_stereotype?(object)
+
+          base
+        end
+
+        def enumeration_stereotype?(object)
+          stereotype = object.stereotype.to_s
+          !stereotype.empty? && stereotype.downcase == "enumeration"
+        end
+
+        # Resolves the classifier's full attribute list. Combines:
+        #   1. Own properties from t_attribute
+        #   2. Inherited properties from MDG-defined ancestor classes,
+        #      when an mdg_registry is provided AND the classifier's
+        #      applied stereotype maps to an MDG class.
+        #
+        # Public so integration tests can drive the merge directly
+        # without stubbing the entire build_one pipeline.
+        #
+        # When no mdg_registry is wired in, this returns just the
+        # own properties — preserving prior behavior.
+        def properties_for(object)
+          own = PropertyBuilder.new(database).build_all_for(object)
+          return own unless mdg_registry
+
+          inherited = mdg_inherited_properties_for(object)
+          return own if inherited.empty?
+
+          own_names = own.to_set { |p| p.name.to_s }
+          own + inherited.reject { |p| own_names.include?(p.name.to_s) }
+        end
+
         private
 
         def each_classifier_object
@@ -49,18 +91,123 @@ module Ea
             id: IdNormalizer.from_guid(object.ea_guid),
             name: object.name,
             package_id: package_id_for(object),
+            package_name: package_name_for(object),
             qualified_name: qualified_name_for(object),
             is_abstract: abstract?(object),
             visibility: visibility_from_scope(object.scope),
-            properties: PropertyBuilder.new(database).build_all_for(object),
+            properties: properties_for(object),
             operations: OperationBuilder.new(database).build_all_for(object),
             stereotype_refs: stereotype_refs_for(object),
-            tagged_values: TaggedValueBuilder.new(database).for_object(object.ea_guid),
+            tagged_values: TaggedValueBuilder.new(database)
+                                              .for_object(object.ea_guid,
+                                                          ea_object_id: object.ea_object_id),
+            constraints: constraints_for(object),
             annotations: AnnotationBuilder.from_note(object.note, object.ea_guid,
                                                      kind: "documentation")
           }
         end
 
+        # Looks up the classifier's applied stereotype's MDG class
+        # via the registry and returns its inherited properties.
+        # Returns [] when no stereotype or no matching MDG class.
+        def mdg_inherited_properties_for(object)
+          stereotype = stereotype_target_name(object)
+          return [] if stereotype.nil? || stereotype.empty?
+
+          classifier = mdg_registry.find_classifier_by_name(stereotype)
+          return [] unless classifier
+
+          mdg_registry.inherited_properties_for(classifier.id).map do |entry|
+            build_property_from_mdg_entry(entry)
+          end
+        end
+
+        # EA's stereotype field can carry either the simple name
+        # ("Type") or the FQName ("GML::Type"). We extract the
+        # class name from either form for MDG lookup.
+        def stereotype_target_name(object)
+          raw = object.stereotype.to_s
+          return nil if raw.empty?
+
+          # FQName format: "MDGName::ClassName" — take the part
+          # after the last "::". EA stores the simple form more
+          # often than the FQName.
+          raw.split("::").last
+        end
+
+        # EA renders association SourceRole names as virtual
+        # "property" attributes on the SOURCE classifier. When a
+        # connector has SourceRole="lod1ImplicitRepresentation",
+        # EA shows "+lod1ImplicitRepresentation" inside the source
+        # element's attribute compartment with «property»
+        # stereotype.
+        def association_role_properties_for(object)
+          connectors = database.collections[:connectors] || []
+          connectors.filter_map do |conn|
+            next nil unless conn.start_object_id == object.ea_object_id
+
+            role = conn.sourcerole.to_s
+            next nil if role.empty?
+
+            build_assoc_property(conn, role, object)
+          end
+        end
+
+        def build_assoc_property(conn, role, owner_object)
+          target = database.find_object(conn.end_object_id) if conn.end_object_id&.to_i&.positive?
+          Ea::Model::Property.new(
+            id: IdNormalizer.from_guid(conn.ea_guid),
+            name: role,
+            owner_id: IdNormalizer.from_guid(owner_object.ea_guid),
+            type_name: target&.name,
+            qualified_name: "#{owner_object.name}::#{role}",
+            multiplicity_lower: parse_cardinality(conn.sourcecard, :lower),
+            multiplicity_upper: parse_cardinality(conn.sourcecard, :upper),
+            visibility: "public",
+            aggregation: "none",
+            stereotype_refs: ["property"],
+            tagged_values: [],
+            annotations: []
+          )
+        end
+
+        def parse_cardinality(card_str, bound)
+          return nil if card_str.nil? || card_str.to_s.empty?
+
+          s = card_str.to_s
+          parts = s.split("..")
+          val = bound == :lower ? parts.first : (parts.size > 1 ? parts.last : parts.first)
+          val = val.to_s.strip
+          return -1 if val == "*"
+
+          Integer(val)
+        rescue ArgumentError
+          nil
+        end
+
+        def build_property_from_mdg_entry(entry)
+          Ea::Model::Property.new(
+            id: "mdg:#{entry.name}",
+            name: entry.name,
+            visibility: entry.visibility || "public",
+            multiplicity_lower: entry.multiplicity_lower,
+            multiplicity_upper: entry.multiplicity_upper
+          )
+        end
+
+        def constraints_for(object)
+          rows = database.constraints_for_object(object.ea_object_id) || []
+          rows.map do |row|
+            Ea::Model::Constraint.new(
+              id: IdNormalizer.from_guid("{#{row.constraint_id}}"),
+              name: row.constraint.to_s,
+              kind: row.constraint_type.to_s,
+              body: row.notes.to_s,
+              status: row.status.to_s
+            )
+          end
+        end
+
         def enumeration_args(object)
           literals = enumeration_literals_for(object)
           { literals: literals }
@@ -89,10 +236,40 @@ module Ea
           IdNormalizer.from_guid(pkg.ea_guid)
         end
 
+        def package_name_for(object)
+          pkg = database.find_package(object.package_id)
+          pkg&.name
+        end
+
+        # EA renders classifier names with a qualifier prefix using
+        # "::" — package prefix for top-level classes, parent-class
+        # prefix for nested classes. The QEA t_object.Name may
+        # already include a ":" prefix (e.g. "gml:CodeType"); use
+        # it verbatim.
         def qualified_name_for(object)
+          name = object.name.to_s
+          return name if name.include?(":")
+          return name if name.empty?
+
+          parent_name = nested_parent_name(object)
+          return "#{parent_name}::#{name}" if parent_name
+
           pkg = database.find_package(object.package_id)
-          pkg_prefix = pkg&.xmlpath || pkg&.name
-          pkg_prefix ? "#{pkg_prefix}::#{object.name}" : object.name
+          pkg_name = pkg&.name
+          pkg_name ? "#{pkg_name}::#{name}" : name
+        end
+
+        # When t_object.ParentID points at a Class (not a Package),
+        # the object is a nested classifier. EA qualifies its name
+        # with the parent class's name, not the package name.
+        def nested_parent_name(object)
+          parent_id_value = object.parentid
+          return nil unless parent_id_value && parent_id_value.to_i.positive?
+
+          parent = database.find_object(parent_id_value.to_i)
+          return nil unless parent&.object_type == "Class"
+
+          parent.name.to_s
         end
 
         def abstract?(object)

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

@@ -26,6 +26,12 @@ module Ea
             package_id: package_id_for(diagram_row),
             diagram_type: diagram_row.diagram_type,
             bounds: bounds_for(diagram_row),
+            style: diagram_row.pdata,
+            style_ex: diagram_row.styleex,
+            show_package_contents: package_contents_enabled?(diagram_row),
+            hand_draw: hand_draw_enabled?(diagram_row),
+            show_notes: show_notes_enabled?(diagram_row),
+            show_parents: show_parents_enabled?(diagram_row),
             elements: build_elements(diagram_row),
             connectors: build_connectors(diagram_row),
             annotations: AnnotationBuilder.from_note(diagram_row.notes,
@@ -34,6 +40,42 @@ module Ea
           )
         end
 
+        # EA encodes "show package contents" as a non-zero integer in
+        # t_diagram.ShowPackageContents (1 in basic.qea, 255 in
+        # test.qea). When true, the package body lists its child
+        # classifiers/sub-packages as "+ Name" rows.
+        def package_contents_enabled?(diagram_row)
+          return false if diagram_row.showpackagecontents.nil?
+
+          diagram_row.showpackagecontents.to_i.nonzero?
+        end
+
+        # HandDraw=1 in t_diagram.StyleEx triggers EA's wavy
+        # hand-drawn border style for every element on the diagram.
+        def hand_draw_enabled?(diagram_row)
+          style_ex = diagram_row.styleex.to_s
+          match = style_ex.match(/HandDraw=(\d)/)
+          match && match[1] == "1"
+        end
+
+        # ShowNotes=1 in t_diagram.StyleEx renders the classifier's
+        # documentation note as wrapped text in the element body.
+        def show_notes_enabled?(diagram_row)
+          style_ex = diagram_row.styleex.to_s
+          match = style_ex.match(/ShowNotes=(\d)/)
+          match && match[1] == "1"
+        end
+
+        # HideParents=1 in t_diagram.PDATA suppresses EA's "off-canvas
+        # parent class" ghost line — the italic parent name that EA
+        # normally prepends to a placed element's header when its
+        # generalization parent is not placed on the diagram.
+        def show_parents_enabled?(diagram_row)
+          pdata = diagram_row.pdata.to_s
+          match = pdata.match(/HideParents=(\d)/)
+          match ? match[1] != "1" : true
+        end
+
         private
 
         def build_elements(diagram_row)
@@ -42,41 +84,245 @@ module Ea
         end
 
         def build_element(obj_row, diagram_row)
+          style_hash = DiagramStyleParser.parse(obj_row.objectstyle)
           Ea::Model::DiagramElement.new(
             id: IdNormalizer.synthetic("de", diagram_row.diagram_id,
                                        obj_row.instance_id),
             diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
             model_element_ref: ref_for_object(obj_row),
             bounds: bounds_from_rect(obj_row),
-            style: DiagramStyleParser.parse(obj_row.objectstyle)
+            style: style_hash,
+            font_family: style_hash[:font],
+            font_bold: truthy?(style_hash[:bold]),
+            font_italic: truthy?(style_hash[:italic]),
+            show_tagged_values: truthy?(style_hash[:tag])
           )
         end
 
+        def truthy?(raw)
+          raw == "1" || raw == "-1"
+        end
+
         def build_connectors(diagram_row)
           links = database.diagram_links_for(diagram_row.diagram_id) || []
-          links.map { |link_row| build_connector(link_row, diagram_row) }
+          explicit = links.map { |link_row| build_connector(link_row, diagram_row) }
+          phantom = phantom_connectors(diagram_row, explicit)
+          explicit + phantom
+        end
+
+        # EA renders PHANTOM CONNECTORS for associations that exist
+        # in t_connector between two elements BOTH placed on the
+        # current diagram, even when no t_diagramlinks entry exists
+        # for that connector on this diagram. The phantom connector
+        # renders as a straight line between the two element edges,
+        # with SourceRole labels and appropriate markers.
+        #
+        # Only Association and Aggregation types produce phantom
+        # connectors. Generalization, Dependency, and Package types
+        # do NOT get phantom rendering.
+        PHANTOM_CONNECTOR_TYPES = %w[Association Aggregation].freeze
+
+        def phantom_connectors(diagram_row, explicit_connectors)
+          placed_ids = placed_object_ids_on(diagram_row.diagram_id)
+          explicit_conn_ids = explicit_connectors.map(&:relationship_ref).compact.to_set
+
+          all_connectors = database.collections[:connectors] || []
+          all_connectors.filter_map.with_index do |conn, idx|
+            next nil unless PHANTOM_CONNECTOR_TYPES.include?(conn.connector_type)
+            next nil unless placed_ids.include?(conn.start_object_id.to_i)
+            next nil unless placed_ids.include?(conn.end_object_id.to_i)
+
+            ref = ref_for_raw_connector(conn)
+            next nil if explicit_conn_ids.include?(ref)
+
+            build_phantom_connector(conn, diagram_row, idx)
+          end
+        end
+
+        def ref_for_raw_connector(conn)
+          IdNormalizer.from_guid(conn.ea_guid)
+        end
+
+        # Default label geometry for phantom connectors. EA renders
+        # SourceRole + «property» + multiplicity at default offsets
+        # from the source endpoint when no explicit geometry exists.
+        DEFAULT_LABEL_BOXES = {
+          llb: { "ox" => 0, "oy" => 0 },
+          llt: { "ox" => 0, "oy" => 0 }
+        }.freeze
+
+        def build_phantom_connector(conn, diagram_row, idx)
+          source_placement = diagram_object_placement(diagram_row.diagram_id,
+                                                       conn.start_object_id)
+          target_placement = diagram_object_placement(diagram_row.diagram_id,
+                                                       conn.end_object_id)
+          return nil unless source_placement && target_placement
+
+          source_bounds = bounds_from_rect(source_placement)
+          target_bounds = bounds_from_rect(target_placement)
+          source_point = bounds_edge_point(source_bounds, target_bounds)
+          target_point = bounds_edge_point(target_bounds, source_bounds)
+
+          waypoints = [
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: source_point[0], y: source_point[1])),
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: target_point[0], y: target_point[1]))
+          ]
+
+          Ea::Model::DiagramConnector.new(
+            id: IdNormalizer.synthetic("pc", diagram_row.diagram_id, idx),
+            diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
+            relationship_ref: ref_for_raw_connector(conn),
+            connector_type: conn.connector_type,
+            direction: conn.direction,
+            waypoints: waypoints,
+            label_boxes: DEFAULT_LABEL_BOXES,
+            style: {},
+            hidden: false,
+            has_geometry_offsets: false
+          )
+        end
+
+        # Computes the edge attachment point on source bounds that
+        # faces the target bounds. Uses the center-to-center direction
+        # to pick the nearest edge intersection.
+        def bounds_edge_point(bounds, other_bounds)
+          cx = bounds.x + bounds.width / 2
+          cy = bounds.y + bounds.height / 2
+          ocx = other_bounds.x + other_bounds.width / 2
+          ocy = other_bounds.y + other_bounds.height / 2
+
+          dx = ocx - cx
+          dy = ocy - cy
+
+          if dx.abs * bounds.height > dy.abs * bounds.width
+            x = dx > 0 ? bounds.x + bounds.width : bounds.x
+            y = cy + dy * (x - cx).abs / dx.abs rescue cy
+            [x, y]
+          else
+            y = dy > 0 ? bounds.y + bounds.height : bounds.y
+            x = cx + dx * (y - cy).abs / dy.abs rescue cx
+            [x, y]
+          end
         end
 
         def build_connector(link_row, diagram_row)
+          connector = database.find_connector(link_row.connectorid)
+          geom = parse_geometry_fields(link_row.geometry)
           Ea::Model::DiagramConnector.new(
             id: IdNormalizer.synthetic("dc", diagram_row.diagram_id,
                                        link_row.instance_id),
             diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
             relationship_ref: ref_for_connector(link_row),
+            connector_type: connector&.connector_type,
+            direction: connector&.direction,
             waypoints: waypoints_for_link(link_row, diagram_row),
-            style: DiagramStyleParser.parse(link_row.style)
+            label_boxes: geom[:label_boxes] || {},
+            style: DiagramStyleParser.parse(link_row.style),
+            hidden: hidden?(link_row),
+            ghost_labels: ghost_labels_for(connector, diagram_row, link_row),
+            has_geometry_offsets: geometry_has_offsets?(link_row.geometry)
           )
         end
 
-        # EA's t_diagramlinks.Geometry field stores connector routing
-        # in a packed format. The leading "X1,Y1,X2,Y2" pair (when
-        # present) is in a coordinate frame that does NOT match the
-        # element rect frame (elements use RectTop < RectBottom with
-        # negative y; geometry uses positive y). Rather than trust
-        # the stored absolute coords, we compute the polyline from
-        # the actual placed-element bounds + the SX/SY/EX/EY delta
-        # fields, which describe the bend routing relative to the
-        # element edges.
+        # EA's t_diagramlinks.Geometry may carry explicit SX/SY/EX/EY
+        # offset fields (even zeros) OR omit them entirely. The
+        # presence of SX= gates the «import» package_anchor marker:
+        # basic.qea Package Imports has SX=0;SY=0 → marker renders;
+        # plateau Urban Planning ADE2 omits SX/SY → no marker.
+        def geometry_has_offsets?(geometry_str)
+          return false if geometry_str.nil? || geometry_str.empty?
+
+          geometry_str.to_s.include?("SX=")
+        end
+
+        # EA's t_diagramlinks.Hidden is 1 when the user has hidden
+        # the connector on this diagram (right-click → Hide). Hidden
+        # connectors are absent from the reference SVG output.
+        def hidden?(link_row)
+          link_row.hidden.to_i.nonzero?
+        end
+
+        # Builds GhostLabel entries for connector endpoints that
+        # reference objects NOT placed on the current diagram. EA
+        # renders the off-canvas classifier's name as italic text
+        # near the connector's on-canvas endpoint so the reader
+        # knows what the connector attaches to outside the diagram.
+        def ghost_labels_for(connector, diagram_row, link_row)
+          return [] unless connector
+
+          placed_ids = placed_object_ids_on(diagram_row.diagram_id)
+          ghosts = []
+          %i[source target].each do |end_kind|
+            ea_object_id = end_kind == :source ? connector.start_object_id : connector.end_object_id
+            next unless ea_object_id&.to_i&.positive?
+            next if placed_ids.include?(ea_object_id.to_i)
+
+            obj = database.find_object(ea_object_id.to_i)
+            next unless obj
+            next if obj.name.to_s.strip.empty?
+
+            anchor_point = ghost_anchor(end_kind, connector, link_row, diagram_row)
+            next unless anchor_point
+
+            ghosts << Ea::Model::GhostLabel.new(
+              id: IdNormalizer.synthetic("ghost", link_row.instance_id, ea_object_id.to_i),
+              name: obj.name.to_s,
+              end_kind: end_kind.to_s,
+              anchor_x: anchor_point[0],
+              anchor_y: anchor_point[1]
+            )
+          end
+          ghosts
+        end
+
+        # Returns the Array of EA object IDs that have a placement
+        # (t_diagramobjects row) on the given diagram.
+        def placed_object_ids_on(diagram_id)
+          objects = database.diagram_objects_for(diagram_id) || []
+          objects.map(&:ea_object_id)
+        end
+
+        # Ghost label anchors at the on-canvas end of the connector.
+        # When the source is off-canvas, anchor at the target's
+        # first waypoint; vice versa for target off-canvas.
+        def ghost_anchor(end_kind, connector, link_row, diagram_row)
+          placement = if end_kind == :source
+                        target_placement_for(connector, diagram_row)
+                      else
+                        source_placement_for(connector, diagram_row)
+                      end
+          return nil unless placement
+
+          # Use the on-canvas end's edge center as the anchor.
+          b = bounds_from_rect(placement)
+          # Offset to the right of the element so the label sits
+          # outside the on-canvas element. EA's actual offset is
+          # roughly +12px in x and -8px in y from the element's
+          # right-center edge.
+          [b.x + b.width + 4, b.y + (b.height / 2) - 8]
+        end
+
+        def source_placement_for(connector, diagram_row)
+          diagram_object_placement(diagram_row.diagram_id, connector.start_object_id)
+        end
+
+        def target_placement_for(connector, diagram_row)
+          diagram_object_placement(diagram_row.diagram_id, connector.end_object_id)
+        end
+
+        # EA stores connector routing in two places:
+        #
+        #   - t_diagramlinks.Path: explicit intermediate waypoints as
+        #     `x:y;x:y;...` in the element-rect coordinate frame.
+        #     Present when the user has manually routed the connector
+        #     or when EA's auto-router produced multi-bend paths.
+        #   - t_diagramlinks.Geometry SX/SY/EX/EY: delta fields that
+        #     describe the source-side and target-side bend offsets
+        #     relative to the edge attachment points.
+        #
+        # Path takes precedence when present — it's the authoritative
+        # routing. SX/SY/EX/EY are fallback for auto-routed direct
+        # connectors with at most one bend on each end.
         #
         # If we can't resolve the source or target element placement
         # for this diagram, we emit no waypoints (the connector will
@@ -96,21 +342,40 @@ module Ea
 
           source_point = element_edge_point(source_placement, :source, edge_out)
           target_point = element_edge_point(target_placement, :target, edge_out)
+
+          intermediate = intermediate_waypoints(link_row)
+          if intermediate.any?
+            points = [source_point, *intermediate, target_point]
+          else
+            points = sx_sy_ex_ey_waypoints(source_point, target_point, geom)
+          end
+
+          points.map do |x, y|
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+          end
+        end
+
+        # Parse t_diagramlinks.Path into [[x, y], ...] intermediate
+        # waypoints. Format: `x1:y1;x2:y2;...`. Empty string returns [].
+        def intermediate_waypoints(link_row)
+          raw = link_row.path.to_s
+          return [] if raw.empty?
+
+          raw.scan(/(-?\d+):(-?\d+)/).map { |x, y| [x.to_i, y.to_i] }
+        end
+
+        # Fallback when no explicit Path: compute source/target bend
+        # points from the SX/SY/EX/EY delta fields.
+        def sx_sy_ex_ey_waypoints(source_point, target_point, geom)
           points = [source_point]
-          # SX/SY: delta from source point to first bend.
           if geom[:sx] && geom[:sy] && (geom[:sx].nonzero? || geom[:sy].nonzero?)
             points << [source_point[0] + geom[:sx], source_point[1] + geom[:sy]]
           end
-          # EX/EY: delta from second bend to target point. Reverse
-          # to get from target back to the bend.
           if geom[:ex] && geom[:ey] && (geom[:ex].nonzero? || geom[:ey].nonzero?)
             points << [target_point[0] - geom[:ex], target_point[1] - geom[:ey]]
           end
           points << target_point
-
-          points.map do |x, y|
-            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
-          end
+          points
         end
 
         # Parse the SX, SY, EX, EY, EDGE key=value pairs out of the
@@ -126,7 +391,61 @@ module Ea
             sy: pick_int(s, /SY=(-?\d+)/),
             ex: pick_int(s, /EX=(-?\d+)/),
             ey: pick_int(s, /EY=(-?\d+)/),
-            edge: pick_int(s, /EDGE=(-?\d+)/)
+            edge: pick_int(s, /EDGE=(-?\d+)/),
+            label_boxes: parse_label_boxes(s)
+          }
+        end
+
+        # Parse EA's $LLB=, $LLT=, $LRB=, $LRT= label box geometry.
+        # Format: $LLB=CX=<int>:CY=<int>:OX=<int>:OY=<int>:HDN=0:BLD=0:
+        #         ITA=0:UND=0:CLR=-1:ALN=0:DIR=0:ROT=0;
+        # Only the FIRST segment carries the leading `$`; subsequent
+        # segments use bare `KEY=` after the semicolon separator.
+        #
+        # Returns Hash keyed by :llb, :llt, :lrt, :lrb (and optional
+        # :lmt, :lmb, :irhs, :ilhs). Each value is a Hash with:
+        #   - "ox", "oy"         — label offset from anchor (always set)
+        #   - "cx", "cy"         — cell size for label box
+        #   - "hidden"           — bool, label suppressed when true
+        #   - "bold", "italic", "underline" — bool font flags
+        #   - "color"            — signed int (VB OLE_COLOR; -1 = default)
+        #   - "alignment"        — 0=left, 1=center, 2=right
+        #   - "direction"        — text direction enum
+        #   - "rotation"         — degrees
+        def parse_label_boxes(geom_str)
+          boxes = {}
+          %i[llb llt lrt lrb lmt lmb irhs ilhs].each do |key|
+            match = geom_str.match(/(?:\$|;)\s*#{key.to_s.upcase}=([^;]*)/i)
+            next unless match && !match[1].empty?
+
+            parsed = parse_label_style(match[1])
+            next unless parsed
+
+            boxes[key] = parsed
+          end
+          boxes
+        end
+
+        # Parse one label box's colon-separated key=value body into
+        # a Hash with string keys. Returns nil if OX/OY are absent.
+        def parse_label_style(body)
+          ox = body.match(/OX=(-?\d+)/)
+          oy = body.match(/OY=(-?\d+)/)
+          return nil unless ox && oy
+
+          {
+            "ox" => ox[1].to_i,
+            "oy" => oy[1].to_i,
+            "cx" => pick_int(body, /CX=(-?\d+)/),
+            "cy" => pick_int(body, /CY=(-?\d+)/),
+            "hidden" => pick_int(body, /HDN=(\d+)/) == 1,
+            "bold" => pick_int(body, /BLD=(\d+)/) == 1,
+            "italic" => pick_int(body, /ITA=(\d+)/) == 1,
+            "underline" => pick_int(body, /UND=(\d+)/) == 1,
+            "color" => pick_int(body, /CLR=(-?\d+)/),
+            "alignment" => pick_int(body, /ALN=(\d+)/),
+            "direction" => pick_int(body, /DIR=(\d+)/),
+            "rotation" => pick_int(body, /ROT=(-?\d+)/)
           }
         end
 
@@ -186,12 +505,21 @@ module Ea
           )
         end
 
+        # EA's t_diagramobjects stores rect with the origin at the
+        # bottom-left (math convention) — recttop > rectbottom for
+        # valid bounds, and y values are often negative. Convert to
+        # screen-space (origin top-left) by taking min/max and using
+        # absolute width/height.
         def bounds_from_rect(obj_row)
+          left = obj_row.rectleft || 0
+          right = obj_row.rectright || 0
+          top = obj_row.recttop || 0
+          bottom = obj_row.rectbottom || 0
           Ea::Model::Bounds.new(
-            x: obj_row.rectleft || 0,
-            y: obj_row.recttop || 0,
-            width: (obj_row.rectright || 0) - (obj_row.rectleft || 0),
-            height: (obj_row.rectbottom || 0) - (obj_row.recttop || 0)
+            x: [left, right].min,
+            y: [top, bottom].min,
+            width: (right - left).abs,
+            height: (bottom - top).abs
           )
         end