ea 0.6.3 → 0.6.5

data/frontend/src/types.ts

@@ -1,221 +1,218 @@
-export interface SpaCardinality {
-  min?: string
-  max?: string
+export interface SpaStatistics {
+  packages: number
+  classes: number
+  attributes: number
+  operations: number
+  associations: number
+  diagrams: number
 }
 
-export interface SpaAttribute {
-  id: string
-  name: string
-  type: string
-  visibility?: string
-  owner: string
-  ownerName: string
-  cardinality?: SpaCardinality
-  definition?: string
-  stereotypes: string[]
-  isStatic: boolean
-  isReadOnly: boolean
-  defaultValue?: string
+export interface SpaLogoVariant {
+  path?: string
+  url?: string
 }
 
-export interface SpaAssociationEnd {
-  class?: string
-  className?: string
-  role?: string
-  cardinality?: SpaCardinality
-  aggregation?: string
+export interface SpaLogoConfig {
+  light: SpaLogoVariant
+  dark: SpaLogoVariant
 }
 
-export interface SpaAssociation {
-  id: string
-  xmiId: string
-  name: string
-  type: string
-  definition?: string
-  source?: SpaAssociationEnd
-  target?: SpaAssociationEnd
+export interface SpaLogos {
+  square?: SpaLogoConfig
+  long?: SpaLogoConfig
 }
 
-export interface SpaOperation {
-  id: string
-  name: string
-  visibility?: string
-  returnType?: string
-  owner: string
-  ownerName: string
-  parameters: SpaParameter[]
-  isStatic: boolean
-  isAbstract: boolean
+export interface SpaAppearance {
+  logos?: SpaLogos
 }
 
-export interface SpaParameter {
-  name: string
-  type?: string
-  direction?: string
+export interface SpaMetadata {
+  id?: string
+  title?: string
+  description?: string
+  version?: string
+  generated?: string
+  generator?: string
+  createdDate?: string
+  modifiedDate?: string
+  sourceFormat?: string
+  sourceTool?: string
+  sourcePath?: string
+  appearance?: SpaAppearance
+  statistics?: SpaStatistics
 }
 
-export interface SpaLiteral {
+export interface SpaPackageTreeNode {
+  id: string
   name: string
-  definition?: string
-}
-
-export interface SpaInheritedAttribute {
-  attributeId: string
-  attribute: SpaAttribute
-  inheritedFrom: string
-  inheritedFromName: string
-  parentOrder: number
+  parentId?: string
+  childIds: string[]
+  classifierIds: string[]
+  diagramIds: string[]
 }
 
-export interface SpaInheritedAssociation {
-  associationId: string
-  inheritedFrom: string
-  inheritedFromName: string
-  parentOrder: number
-  localRole: string
+export interface SpaPackageTree {
+  rootIds: string[]
+  nodes: SpaPackageTreeNode[]
 }
 
-export interface SpaClass {
+export interface SpaSkeletonEntry {
   id: string
-  xmiId: string
   name: string
-  qualifiedName: string
-  type: string
-  package?: string
-  stereotypes: string[]
-  definition?: string
-  attributes: string[]
-  operations: string[]
-  associations: string[]
-  generalizations: string[]
-  specializations: string[]
-  isAbstract: boolean
-  literals: SpaLiteral[]
-  inheritedAttributes: SpaInheritedAttribute[]
-  inheritedAssociations: SpaInheritedAssociation[]
+  kind: string
+  packageId?: string
+  qualifiedName?: string
+  shardUrl: string
 }
 
-export interface SpaPackage {
+export interface SpaShard {
   id: string
-  xmiId: string
-  name: string
-  path: string
-  definition?: string
-  stereotypes: string[]
-  classes: string[]
-  subPackages: string[]
-  diagrams: string[]
-  parent?: string
+  kind: string
+  payload: any
 }
 
-export interface SpaTreeClassRef {
+export interface SpaSearchEntry {
   id: string
+  kind: string
   name: string
-  stereotypes: string[]
+  qualifiedName: string
+  package: string
+  content: string
+  boost?: number
 }
 
-export interface SpaPackageTreeNode {
+export interface SpaSearchIndex {
+  version: string
+  fields: string[]
+  entries: SpaSearchEntry[]
+}
+
+export interface SpaAnnotation {
   id: string
-  name: string
-  path: string
-  stereotypes: string[]
-  classCount: number
-  classes: SpaTreeClassRef[]
-  children: SpaPackageTreeNode[]
+  kind: string
+  body?: string
 }
 
-export interface SpaDiagram {
+export interface SpaPropertyPayload {
   id: string
-  xmiId: string
   name: string
-  type: string
-  package?: string
-  objectCount: number
-  linkCount: number
-  svg?: string
+  ownerId: string
+  typeName?: string
+  qualifiedName?: string
+  multiplicityLower?: number
+  multiplicityUpper?: number
+  isDerived: boolean
+  isReadonly: boolean
+  visibility?: string
+  stereotypeRefs: string[]
+  annotations: SpaAnnotation[]
 }
 
-export interface SpaStatistics {
-  packages: number
-  classes: number
-  associations: number
-  attributes: number
-  operations: number
+export interface SpaParameterPayload {
+  name?: string
+  direction?: string
+  typeName?: string
+  multiplicityLower?: number
+  multiplicityUpper?: number
+  defaultValue?: string
 }
 
-export interface SpaLogoVariant {
-  path?: string
-  url?: string
+export interface SpaOperationPayload {
+  id: string
+  name: string
+  ownerId: string
+  qualifiedName?: string
+  returnTypeName?: string
+  isStatic: boolean
+  isAbstract: boolean
+  visibility?: string
+  parameters: SpaParameterPayload[]
+  stereotypeRefs: string[]
+  annotations: SpaAnnotation[]
 }
 
-export interface SpaLogoConfig {
-  light: SpaLogoVariant
-  dark: SpaLogoVariant
+export interface SpaGeneralizationStub {
+  id: string
+  targetId: string
 }
 
-export interface SpaLogos {
-  square?: SpaLogoConfig
-  long?: SpaLogoConfig
+export interface SpaAssociationStub {
+  id: string
+  name?: string
+  sourceId: string
+  targetId: string
+  thisEndRoleName?: string
+  otherEndRoleName?: string
+  otherEndId: string
+  otherEndMultiplicity?: [number?, number?]
+  otherEndAggregation?: string
 }
 
-export interface SpaAppearance {
-  logos?: SpaLogos
+export interface SpaEnumerationLiteralPayload {
+  id: string
+  name: string
+  value?: string
+  ordinal?: number
 }
 
-export interface SpaMetadata {
-  title?: string
-  description?: string
-  generated: string
-  generator: string
-  version: string
-  homepage?: string
-  repository?: string
-  license?: string
-  authors?: string
-  tags?: string[]
-  appearance?: SpaAppearance
-  statistics: SpaStatistics
+export interface SpaClassifierPayload {
+  id: string
+  name: string
+  qualifiedName: string
+  packageId: string
+  packageName?: string
+  isAbstract: boolean
+  visibility?: string
+  modelKind: string
+  properties: SpaPropertyPayload[]
+  operations: SpaOperationPayload[]
+  stereotypeRefs: string[]
+  taggedValues: any[]
+  constraints: any[]
+  annotations: SpaAnnotation[]
+  literals?: SpaEnumerationLiteralPayload[]
+  generalizations?: SpaGeneralizationStub[]
+  specializations?: SpaGeneralizationStub[]
+  associations?: SpaAssociationStub[]
+}
+
+export interface SpaPackagePayload {
+  id: string
+  name: string
+  parentId?: string
+  subPackageIds: string[]
+  classifierIds: string[]
+  diagramIds: string[]
+  stereotypeRefs: string[]
+  taggedValues: any[]
+  annotations: SpaAnnotation[]
 }
 
-export interface SpaSearchEntry {
+export interface SpaDiagramPayload {
   id: string
-  type: string
-  entityType: string
-  entityId: string
   name: string
-  qualifiedName: string
-  package: string
-  content: string
-  boost: number
+  packageId?: string
+  diagramType?: string
+  elements: any[]
+  connectors: any[]
+  annotations: SpaAnnotation[]
+  svg?: string
 }
 
-export interface SpaSearchIndex {
-  version: string
-  fields: { name: string; boost: number }[]
-  ref: string
-  documentStore: SpaSearchEntry[]
-  pipeline: string[]
+export interface SpaViewExtras {
+  ui?: Record<string, any>
+  appearance?: SpaAppearance
+  diagrams?: { enabled?: boolean }
 }
 
-export interface SpaDocument {
+export interface SpaSkeleton {
   metadata: SpaMetadata
-  packageTree: SpaPackageTreeNode
-  packages: Record<string, SpaPackage>
-  classes: Record<string, SpaClass>
-  attributes: Record<string, SpaAttribute>
-  associations: Record<string, SpaAssociation>
-  operations: Record<string, SpaOperation>
-  diagrams: Record<string, SpaDiagram>
+  packageTree: SpaPackageTree
+  entries: SpaSkeletonEntry[]
+  viewExtras?: SpaViewExtras
 }
 
-export interface SpaData {
-  metadata: SpaMetadata
-  packageTree: SpaPackageTreeNode
-  packages: Record<string, SpaPackage>
-  classes: Record<string, SpaClass>
-  attributes: Record<string, SpaAttribute>
-  associations: Record<string, SpaAssociation>
-  operations: Record<string, SpaOperation>
-  diagrams: Record<string, SpaDiagram>
+export interface SpaData extends SpaSkeleton {
   searchIndex: SpaSearchIndex
+  shards: SpaShard[]
 }

data/lib/ea/model/diagram_connector.rb

@@ -33,6 +33,13 @@ module Ea
       # connectors (no SX/SY) get a plain solid line.
       attribute :has_geometry_offsets, :boolean, default: false
 
+      # Absolute connection points on the source/target element boxes,
+      # derived from the Geometry SX/SY and EX/EY edge offsets. EA
+      # docks the connector's visible endpoints at these ports; nil
+      # when the geometry string carries no offsets (auto-routed).
+      attribute :source_port, Ea::Model::Point
+      attribute :target_port, Ea::Model::Point
+
       json do
         map "id", to: :id
         map "diagramId", to: :diagram_id
@@ -43,6 +50,8 @@ module Ea
         map "targetDuid", to: :target_duid
         map "sourceEdge", to: :source_edge
         map "targetEdge", to: :target_edge
+        map "sourcePort", to: :source_port
+        map "targetPort", to: :target_port
         map "connectorType", to: :connector_type
         map "direction", to: :direction
         map "waypoints", to: :waypoints, render_empty: true

data/lib/ea/model/property.rb

@@ -12,7 +12,11 @@ module Ea
       attribute :type_name, :string             # name shown when type is external/primitive
       attribute :qualified_name, :string
       attribute :multiplicity_lower, :integer
-      attribute :multiplicity_upper, :integer   # -1 means "many"
+      attribute :multiplicity_upper, :integer
+      # Verbatim stored bound text (e.g. EA's literal "n") when the
+      # column value is non-numeric; rendered as-is by the SVG line
+      # builder while computed-unbounded uppers render as "*".
+      attribute :multiplicity_upper_raw, :string   # -1 means "many"
       attribute :default_value, :string
       attribute :is_derived, :boolean, default: false
       attribute :is_readonly, :boolean, default: false
@@ -33,6 +37,7 @@ module Ea
         map "typeName", to: :type_name
         map "qualifiedName", to: :qualified_name
         map "multiplicityLower", to: :multiplicity_lower
+        map "multiplicityUpperRaw", to: :multiplicity_upper_raw
         map "multiplicityUpper", to: :multiplicity_upper
         map "defaultValue", to: :default_value
         map "isDerived", to: :is_derived, render_default: true

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

@@ -155,8 +155,10 @@ module Ea
 
         def build_assoc_property(conn, role, owner_object)
           target = database.find_object(conn.end_object_id) if conn.end_object_id&.to_i&.positive?
+          guid = IdNormalizer.from_guid(conn.ea_guid)
           Ea::Model::Property.new(
-            id: IdNormalizer.from_guid(conn.ea_guid),
+            id: guid,
+            association_id: guid,
             name: role,
             owner_id: IdNormalizer.from_guid(owner_object.ea_guid),
             type_name: target&.name,

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

@@ -92,9 +92,11 @@ module Ea
             model_element_ref: ref_for_object(obj_row),
             bounds: bounds_from_rect(obj_row),
             style: style_hash,
-            font_family: style_hash[:font],
+            font_family: presence(style_hash[:font]),
+            font_size: font_size_from(style_hash),
             font_bold: truthy?(style_hash[:bold]),
             font_italic: truthy?(style_hash[:italic]),
+            font_underline: truthy?(style_hash[:ul]),
             show_tagged_values: truthy?(style_hash[:tag])
           )
         end
@@ -103,6 +105,28 @@ module Ea
           raw == "1" || raw == "-1"
         end
 
+        def presence(value)
+          value.nil? || value.to_s.empty? ? nil : value
+        end
+
+        # EA stores the element font size in tenths of a point in the
+        # objectstyle string. 0 means "use default", and 80/90 (8pt /
+        # 9pt) are EA's classic defaults the dialogs write back when
+        # the user never customized — verified against EA-published
+        # reference images, where such elements render at the theme
+        # size. Only genuinely custom sizes are surfaced as explicit
+        # element fonts.
+        USE_DEFAULT_FONTSZ = [0, 80, 90].freeze
+
+        def font_size_from(style_hash)
+          raw = style_hash[:fontsz]
+          return nil if raw.nil? || raw.to_s.empty?
+
+          return nil if USE_DEFAULT_FONTSZ.include?(raw.to_i)
+
+          (raw.to_f / 10).round
+        end
+
         def build_connectors(diagram_row)
           links = database.diagram_links_for(diagram_row.diagram_id) || []
           explicit = links.map { |link_row| build_connector(link_row, diagram_row) }
@@ -216,6 +240,8 @@ module Ea
             connector_type: connector&.connector_type,
             direction: connector&.direction,
             waypoints: waypoints_for_link(link_row, diagram_row),
+            source_port: connection_port(diagram_row, connector, :source, geom),
+            target_port: connection_port(diagram_row, connector, :target, geom),
             label_boxes: geom[:label_boxes] || {},
             style: DiagramStyleParser.parse(link_row.style),
             hidden: hidden?(link_row),
@@ -340,12 +366,22 @@ module Ea
           geom = parse_geometry_fields(link_row.geometry)
           edge_out = geom[:edge] || 0
 
-          source_point = element_edge_point(source_placement, :source, edge_out)
-          target_point = element_edge_point(target_placement, :target, edge_out)
+          source_port = connection_port(diagram_row, connector, :source, geom)
+          target_port = connection_port(diagram_row, connector, :target, geom)
+          # Waypoint points flow through this method as [x, y] arrays;
+          # keep the ports in the same shape.
+          source_point = source_port ? [source_port.x, source_port.y] :
+                         element_edge_point(source_placement, :source, edge_out)
+          target_point = target_port ? [target_port.x, target_port.y] :
+                         element_edge_point(target_placement, :target, edge_out)
 
           intermediate = intermediate_waypoints(link_row)
           if intermediate.any?
             points = [source_point, *intermediate, target_point]
+          elsif source_port || target_port
+            # Exact ports are known — the SX/SY bend heuristics in
+            # sx_sy_ex_ey_waypoints would double-apply the offsets.
+            points = [source_point, target_point]
           else
             points = sx_sy_ex_ey_waypoints(source_point, target_point, geom)
           end
@@ -355,13 +391,53 @@ module Ea
           end
         end
 
+        # Absolute connection point EA docks the connector's visible
+        # endpoint at, derived from the Geometry SX/SY (source) and
+        # EX/EY (target) offsets. The offsets are measured inward from
+        # the placed object's box edges — the X offset counts from the
+        # edge FACING the other end (source: right edge for positive
+        # values, left edge for negative; target mirrored), while the
+        # Y offset counts from the top edge for positive values and
+        # from the bottom edge for negative. Derived and verified
+        # against EA's own rendering on the PLATEAU models.
+        def connection_port(diagram_row, connector, end_kind, geom)
+          return nil unless connector
+
+          ea_object_id = end_kind == :source ? connector.start_object_id : connector.end_object_id
+          placement = ea_object_id &&
+                      diagram_object_placement(diagram_row.diagram_id, ea_object_id)
+          return nil unless placement
+
+          x_off = geom[end_kind == :source ? :sx : :ex]
+          y_off = geom[end_kind == :source ? :sy : :ey]
+          return nil if x_off.nil? || y_off.nil?
+
+          # EA's SX/SY and EX/EY are the offset of the docking line's
+          # direction from the element's CENTER (stored math coords,
+          # y up): the port is where the ray from the center through
+          # center+offset crosses the box border. Verified against
+          # EA-published reference SVGs. Bounds are already mirrored
+          # to screen-down space, so the offset's Y negates too.
+          b = bounds_from_rect(placement)
+          center_x = b.x + b.width / 2.0
+          center_y = b.y + b.height / 2.0
+          dx = x_off.to_f
+          dy = -y_off.to_f
+          return nil if dx.zero? && dy.zero?
+
+          tx = dx.zero? ? Float::INFINITY : (dx > 0 ? b.x + b.width - center_x : b.x - center_x) / dx
+          ty = dy.zero? ? Float::INFINITY : (dy > 0 ? b.y + b.height - center_y : b.y - center_y) / dy
+          t = [tx, ty].min
+          Ea::Model::Point.new(x: (center_x + t * dx).round, y: (center_y + t * dy).round)
+        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] }
+          raw.scan(/(-?\d+):(-?\d+)/).map { |x, y| [x.to_i, -y.to_i] }
         end
 
         # Fallback when no explicit Path: compute source/target bend
@@ -369,10 +445,10 @@ module Ea
         def sx_sy_ex_ey_waypoints(source_point, target_point, geom)
           points = [source_point]
           if geom[:sx] && geom[:sy] && (geom[:sx].nonzero? || geom[:sy].nonzero?)
-            points << [source_point[0] + geom[:sx], source_point[1] + geom[:sy]]
+            points << [source_point[0] + geom[:sx], source_point[1] - geom[:sy]]
           end
           if geom[:ex] && geom[:ey] && (geom[:ex].nonzero? || geom[:ey].nonzero?)
-            points << [target_point[0] - geom[:ex], target_point[1] - geom[:ey]]
+            points << [target_point[0] - geom[:ex], target_point[1] + geom[:ey]]
           end
           points << target_point
           points
@@ -427,6 +503,10 @@ module Ea
         end
         public :parse_label_boxes
 
+        # Pure helpers exposed for specs and consumers — no database
+        # access, safe to call in isolation.
+        public :font_size_from, :connection_port
+
         # 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)
@@ -509,8 +589,10 @@ module Ea
         # 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.
+        # screen-space (origin top-left, y increasing downward) by
+        # mirroring: EA's own SVG export draws the model mirrored, so
+        # the flipped top edge is -(max(top, bottom)); verified
+        # against EA-published reference images (dx=0, dy=-mirror).
         def bounds_from_rect(obj_row)
           left = obj_row.rectleft || 0
           right = obj_row.rectright || 0
@@ -518,7 +600,7 @@ module Ea
           bottom = obj_row.rectbottom || 0
           Ea::Model::Bounds.new(
             x: [left, right].min,
-            y: [top, bottom].min,
+            y: -[top, bottom].max,
             width: (right - left).abs,
             height: (bottom - top).abs
           )

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

@@ -27,6 +27,7 @@ module Ea
             type_name: row.type,
             qualified_name: "#{owner_object.name}::#{row.name}",
             multiplicity_lower: parse_lower(row),
+            multiplicity_upper_raw: raw_upper(row),
             multiplicity_upper: parse_upper(row),
             default_value: row.default,
             is_ordered: boolean(row.isordered),
@@ -42,6 +43,14 @@ module Ea
 
         private
 
+        # EA stores some bounds as literal text ("n"); those render
+        # verbatim in attribute lines while computed-unbounded bounds
+        # render as "*" (verified against EA-published SVGs).
+        def raw_upper(row)
+          raw = row.upperbound.to_s
+          raw.match?(/\A[nN]\z/) ? raw.downcase : nil
+        end
+
         def parse_lower(row)
           Integer(row.lowerbound || 1)
         rescue StandardError
@@ -49,10 +58,11 @@ module Ea
         end
 
         def parse_upper(row)
-          return -1 if row.upperbound.to_s == "*"
+          raw = row.upperbound.to_s
+          return -1 if raw.match?(/\A[*nN]\z/)
 
           begin
-            Integer(row.upperbound || 1)
+            Integer(raw.empty? ? 1 : raw)
           rescue StandardError
             1
           end

data/lib/ea/spa/output/single_file_strategy.rb

@@ -19,7 +19,7 @@ module Ea
           payload = {
             metadata: skeleton.metadata,
             packageTree: skeleton.package_tree,
-            skeletonEntries: skeleton.entries,
+            entries: skeleton.entries,
             searchIndex: projector.search_index,
             shards: projector.each_shard.to_a
           }