ea 0.6.139 → 0.6.140

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

@@ -10,6 +10,9 @@ module Ea
       class ConnectorBridges
         RADIUS = 6
         PHANTOM = :phantom
+        COINCIDENT_LEFTOVER = 3
+        NEAR_COINCIDENT = 2
+        Bridge = Struct.new(:start, :finish, :leftover)
 
         def initialize(_diagram, routes)
           @routes = routes.map { |connector, points| [connector, points, priority_for(connector)] }
@@ -39,9 +42,16 @@ module Ea
           end
         end
 
+        # EA also draws NoteLink, Package and two-point Dependency lines
+        # target-first with the repeat (9DA6C553 NoteLink; 2A5E0832 and
+        # DFBB1072 Package; 6481E2CC and DFBB1072 Dependency), the opposite
+        # of the stored source-to-target waypoint order.
+        TARGET_FIRST_TYPES = %w[NoteLink Package Dependency].freeze
+
         def direct?(connector)
           style = connector.style || {}
-          style.key?(:direct) || style.key?("direct")
+          style.key?(:direct) || style.key?("direct") ||
+            TARGET_FIRST_TYPES.include?(connector.connector_type)
         end
 
         def serialize(points, segments)
@@ -74,7 +84,7 @@ module Ea
               crossing(first, last, start, finish)
             end
           end
-          separate_crossings(crossings, first, last).sort_by { |point| distance(point, first) }
+          BridgeSpans.new(crossings, first, last).to_a.sort_by { |bridge| distance(bridge.start, first) }
         end
 
         # The order key is only proven across different start placements, so
@@ -96,26 +106,6 @@ module Ea
           connector.source_element_ref && connector.source_element_ref == partner.source_element_ref
         end
 
-        # Partners crossing at one point share a single arc (0BE81AC5 draws one
-        # arc for three coincident verticals). Distinct crossings whose spans
-        # overlap are all suppressed so route order cannot select one of
-        # several ambiguous arcs.
-        def separate_crossings(crossings, first, last)
-          crossings = crossings.uniq { |point| point.map { |value| value.round(6) } }
-          axis = SegmentGeometry.dominant_axis(first, last)
-          spans = crossings.map do |point|
-            SegmentGeometry.chord(first, last, point, RADIUS).map { |seat| seat[axis] }.minmax
-          end
-          crossings.reject.with_index { |_point, index| overlapping_span?(spans, index) }
-        end
-
-        def overlapping_span?(spans, index)
-          minimum, maximum = spans[index]
-          spans.each_with_index.any? do |(other_minimum, other_maximum), other_index|
-            index != other_index && minimum < other_maximum && other_minimum < maximum
-          end
-        end
-
         def crossing(first, last, start, finish)
           SegmentGeometry.crossing(first, last, start, finish, RADIUS)
         end
@@ -124,15 +114,99 @@ module Ea
           SegmentGeometry.distance(point, other)
         end
 
-        def arc_commands(first, last, crossing)
-          start, finish = SegmentGeometry.chord(first, last, crossing, RADIUS)
-          ["L #{coordinates(start)}", "A #{RADIUS} #{RADIUS} 180 0 0 #{coordinates(finish)}"]
+        def arc_commands(first, last, bridge)
+          arc = "A #{radii(first, last, bridge)} 180 0 0 #{coordinates(bridge.finish)}"
+          commands = ["L #{coordinates(bridge.start)}", arc]
+          return commands unless bridge.leftover
+
+          commands + ["L #{coordinates(bridge.finish)}", "A #{RADIUS} #{RADIUS} 0 1 0 #{coordinates(bridge.finish)}"]
+        end
+
+        # An axis-aligned arc has half its chord length as the radius along
+        # the carrier and RADIUS across it; slanted chords keep the circle.
+        def radii(first, last, bridge)
+          axis = SegmentGeometry.axis_for(first, last)
+          return "#{RADIUS} #{RADIUS}" unless axis
+
+          half = Canvas.coord(SegmentGeometry.distance(bridge.start, bridge.finish) / 2.0)
+          axis.zero? ? "#{half} #{RADIUS}" : "#{RADIUS} #{half}"
         end
 
         def coordinates(point)
           point.map { |value| Canvas.coord(value) }.join(" ")
         end
       end
+
+      # The arc chords decorating one carrier segment, from its crossings.
+      #
+      # Partners crossing at one point share a single arc (0BE81AC5 draws one
+      # arc for three coincident verticals).
+      #
+      # Axis-aligned carrier: crossings within NEAR_COINCIDENT pixels merge
+      # into one arc spanning the outer chord ends (30D62231 draws one
+      # 14-long arc over three horizontals one pixel apart; wider overlaps
+      # have no corpus case and stay suppressed).
+      #
+      # Slanted carrier: distinct crossings whose spans overlap are all
+      # suppressed so route order cannot select one of several ambiguous
+      # arcs. Empirical fit, 0BE81AC5 (the only slanted carrier with three
+      # coincident partners in the corpus): EA also writes one zero-length
+      # arc after the chord. Fewer coincident partners are not evidenced.
+      class BridgeSpans
+        def initialize(crossings, first, last)
+          @first = first
+          @axis = SegmentGeometry.dominant_axis(first, last)
+          @aligned = !SegmentGeometry.axis_for(first, last).nil?
+          groups = crossings.group_by { |point| point.map { |value| value.round(6) } }.values
+          @bridges = groups.map { |group| bridge_at(group, last) }
+        end
+
+        def to_a
+          @aligned ? merged : @bridges.reject.with_index { |_bridge, index| overlapping?(index) }
+        end
+
+        private
+
+        def bridge_at(group, last)
+          start, finish = SegmentGeometry.chord(@first, last, group.first, ConnectorBridges::RADIUS)
+          leftover = !@aligned && group.size >= ConnectorBridges::COINCIDENT_LEFTOVER
+          ConnectorBridges::Bridge.new(start, finish, leftover)
+        end
+
+        def merged
+          ordered = @bridges.sort_by { |bridge| distance(bridge.start) }
+          components = ordered.slice_when { |one, other| !overlap?(one, other) }
+          components.filter_map { |component| component.one? ? component.first : merge(component) }
+        end
+
+        def merge(component)
+          return if spread(component) > ConnectorBridges::NEAR_COINCIDENT
+
+          finish = component.map(&:finish).max_by { |point| distance(point) }
+          ConnectorBridges::Bridge.new(component.first.start, finish, false)
+        end
+
+        def spread(component)
+          centres = component.map { |bridge| bridge.start[@axis] + bridge.finish[@axis] }
+          (centres.max - centres.min) / 2.0
+        end
+
+        def overlapping?(index)
+          @bridges.each_with_index.any? do |other, other_index|
+            index != other_index && overlap?(@bridges[index], other)
+          end
+        end
+
+        def overlap?(one, other)
+          minimum, maximum = [one.start[@axis], one.finish[@axis]].minmax
+          other_minimum, other_maximum = [other.start[@axis], other.finish[@axis]].minmax
+          minimum < other_maximum && other_minimum < maximum
+        end
+
+        def distance(point)
+          SegmentGeometry.distance(point, @first)
+        end
+      end
     end
   end
 end

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

@@ -34,36 +34,70 @@ module Ea
         # EA draws each connector (and its markers) with the pen width
         # stored in the diagram link style (`LWidth`); links without
         # the field keep the diagram default.
+        #
+        # A link saved with `LWidth=0` defers to the connector's own saved
+        # pen (`t_connector.IsBold`, XMI `<appearance linewidth>`), which
+        # DiagramConnector#line_width carries. Checked on connector 438 in
+        # 9400D9BC and FEBE5726 (IsBold=2, native stroke-width 2); the 314
+        # LWidth=0 links with IsBold=0 stay one pixel.
         def self.stroke_width_for(connector, default)
           style = connector.style || {}
           raw = style[:lwidth] || style["lwidth"]
           return default if raw.to_s.strip.empty?
+          return connector.line_width if raw.to_i.zero? && connector.line_width.to_i.positive?
 
           [raw.to_i, 1].max
         end
 
+        DEFAULT_STROKE = "#000000"
+
+        # EA strokes a connector and its markers in the colour stored in
+        # the diagram link style (`Color`, a BGR integer; -1 = default).
+        # Checked on the #69738C links of 5DA1E7A7, 73025C5A, C31C1314
+        # and E7AABA98.
+        def self.stroke_color_for(connector)
+          raw = connector.line_color
+          raw = (connector.style || {})[:color] if raw.nil?
+          return DEFAULT_STROKE if raw.nil? || raw.to_s.strip.empty?
+
+          Element::BColDecoder.to_hex(raw.to_i) || DEFAULT_STROKE
+        end
+
         # Layer key for a style group: the plain key at the default
-        # width, suffixed with the width otherwise so layers of
-        # different widths never merge.
-        def self.layer_key(key, width, default)
-          width == default ? key : :"#{key}_w#{width}"
+        # width and colour, suffixed otherwise so layers of different
+        # widths or colours never merge.
+        def self.layer_key(key, width, default, color = DEFAULT_STROKE)
+          key = :"#{key}_w#{width}" unless width == default
+          color == DEFAULT_STROKE ? key : :"#{key}_c#{color.delete("#")}"
         end
 
         def layers
-          styles = paths_with_styles
+          styles = paths_with_styles.map { |_connector, style, path| [style, path] }
 
           if grouped
-            styles.group_by(&:first).map do |(width, dashed), entries|
-              line_layer(width, dashed, entries.map(&:last).join("\n  "))
+            styles.group_by(&:first).map do |(width, dash, color), entries|
+              line_layer(width, dash, color, entries.map(&:last).join("\n  "))
             end
           else
-            styles.map { |(width, dashed), path| line_layer(width, dashed, path) }
+            styles.map { |(width, dash, color), path| line_layer(width, dash, color, path) }
+          end
+        end
+
+        # One `[connector, Layer]` pair per drawn connector, in
+        # diagram link order: EA paints each connector (line, then its
+        # heads) in turn, so the sequencer interleaves these with the
+        # marker layers instead of bucketing every line first.
+        def connector_layers
+          paths_with_styles.map do |connector, (width, dash, color), path|
+            [connector, line_layer(width, dash, color, path)]
           end
         end
 
-        def line_style(width = stroke_width)
-          "stroke-width:#{width};stroke-linecap:round;stroke-linejoin:bevel; " \
-            "fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
+        # EA draws dashed lines with square caps and round joins.
+        def line_style(width = stroke_width, color = DEFAULT_STROKE, dashed: false)
+          cap_join = dashed ? "square;stroke-linejoin:round" : "round;stroke-linejoin:bevel"
+          "stroke-width:#{width};stroke-linecap:#{cap_join}; " \
+            "fill:#000000;fill-opacity:0.00; stroke:#{color}; stroke-opacity:1.00"
         end
 
         # Backwards-compatible render — joins all layers' `<g>`.
@@ -80,19 +114,35 @@ module Ea
           end
           bridges = ConnectorBridges.new(diagram, routes)
           routes.map do |connector, points|
-            [[self.class.stroke_width_for(connector, stroke_width), dashed?(connector)],
+            [connector,
+             [self.class.stroke_width_for(connector, stroke_width), dash_for(connector),
+              self.class.stroke_color_for(connector)],
              path_for(connector, points, bridges)]
           end
         end
 
-        def line_layer(width, dashed, body)
-          key = dashed ? :connector_line_dashed : LINE_STYLE_KEY
-          style = line_style(width)
-          style += ";stroke-dasharray:6,3" if dashed
-          Layer.new(style_key: self.class.layer_key(key, width, stroke_width),
+        def line_layer(width, dash, color, body)
+          key = dash ? :"connector_line_dash_#{dash.tr(",", "_")}" : LINE_STYLE_KEY
+          style = line_style(width, color, dashed: !dash.nil?)
+          style += ";stroke-dasharray:#{dash}" if dash
+          Layer.new(style_key: self.class.layer_key(key, width, stroke_width, color),
                     style: style, body: body)
         end
 
+        # Dash pattern as "dash,gap", nil when solid. A NoteLink is
+        # dashed at width + 2 (empirical fit, EA native: 4,4 at width 2 in
+        # 676B9C9A and 926AFE38, 3,3 at width 1 in 9DA6C553; no source
+        # field found); every other dashed connector uses 6,3 (23 native
+        # cases at width 1).
+        def dash_for(connector)
+          if connector.connector_type == "NoteLink"
+            n = self.class.stroke_width_for(connector, stroke_width) + 2
+            "#{n},#{n}"
+          elsif dashed?(connector)
+            "6,3"
+          end
+        end
+
         def dashed?(connector)
           return true if connector.style.to_h[:association_class_ref]
           return true if connector.connector_type == "Dependency"

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Measures the extent of emitted SVG content: the points EA draws
+      # shapes through (rect, path M/L/C/A end points, polygon, ellipse)
+      # and the box of every text run (left edge, top = baseline - font
+      # height, right = left + textLength). EA anchors an unframed
+      # export's canvas on this extent.
+      class ContentExtent
+        NUMBER = /-?\d*\.?\d+(?:[eE][-+]?\d+)?/
+        ELEMENT = /<(rect|path|polygon|polyline|ellipse|text)\b([^>]*)>/
+        ATTRIBUTE = /\b([\w:-]+)="([^"]*)"/
+        PATH_COMMAND = /([MLACHVZ])([^MLACHVZ]*)/
+        PX_PER_PT = 96 / 72.0
+
+        # Each box is [min_x, min_y, max_x, max_y] or nil when the
+        # content has no shape (or no text).
+        attr_reader :shapes, :texts
+
+        def self.measure(svg_fragments)
+          shape_points = []
+          text_boxes = []
+          svg_fragments.each do |svg|
+            svg.to_s.scan(ELEMENT) do |kind, attrs|
+              attributes = attrs.scan(ATTRIBUTE).to_h
+              next text_boxes << text_box(attributes) if kind == "text"
+
+              shape_points.concat(points(kind, attributes))
+            end
+          end
+          new(shape_points, text_boxes)
+        end
+
+        def self.points(kind, attrs)
+          case kind
+          when "rect" then rect_points(attrs)
+          when "path" then path_points(attrs["d"].to_s)
+          when "polygon", "polyline" then pairs(attrs["points"].to_s)
+          else ellipse_points(attrs)
+          end
+        end
+
+        def self.rect_points(attrs)
+          left, top, wide, high = %w[x y width height].map { |k| attrs[k].to_f }
+          [[left, top], [left + wide, top + high]]
+        end
+
+        def self.ellipse_points(attrs)
+          cx, cy, rx, ry = %w[cx cy rx ry].map { |k| attrs[k].to_f }
+          [[cx - rx, cy - ry], [cx + rx, cy + ry]]
+        end
+
+        def self.pairs(body)
+          body.scan(NUMBER).map(&:to_f).each_slice(2).select { |pair| pair.size == 2 }
+        end
+
+        def self.path_points(path_data)
+          path_data.scan(PATH_COMMAND).flat_map do |command, body|
+            numbers = body.scan(NUMBER).map(&:to_f)
+            case command
+            when "M", "L", "C" then numbers.each_slice(2).select { |pair| pair.size == 2 }
+            when "A" then numbers.each_slice(7).map { |a| a.last(2) }
+            else []
+            end
+          end
+        end
+
+        def self.text_box(attrs)
+          style = attrs["style"].to_s
+          size = style[/font-size:([\d.]+)/, 1].to_f
+          size *= PX_PER_PT if style[/font-size:[\d.]+(pt|px)/, 1] == "pt"
+          left = attrs["x"].to_f
+          base = attrs["y"].to_f
+          [left, base - size.ceil, left + attrs["textLength"].to_f, base]
+        end
+
+        def initialize(shape_points, text_boxes)
+          @shapes = box(shape_points.map(&:first), shape_points.map(&:last))
+          @texts = box(text_boxes.map(&:first) + text_boxes.map { |b| b[2] },
+                       text_boxes.map { |b| b[1] } + text_boxes.map { |b| b[3] })
+        end
+
+        private
+
+        def box(columns, rows)
+          return nil if columns.empty?
+
+          [columns.min, rows.min, columns.max, rows.max]
+        end
+      end
+    end
+  end
+end

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

@@ -10,35 +10,23 @@ module Ea
       class Document
         BUILD_ID = "1624"
 
-        attr_reader :diagram, :model_index, :frame, :document
+        attr_reader :diagram, :model_index, :frame, :document, :content_anchor
 
-        def initialize(diagram, model_index:, frame: nil, document: nil, **_options)
+        # No frame by default, like EA's own export; `frame: true` opts
+        # in. `content_anchor` (unframed only, on by default) sizes and
+        # origins the canvas on the drawn content like EA's native
+        # unframed export; off, it keeps the framed 35/40 content origin.
+        def initialize(diagram, model_index:, frame: false, document: nil,
+                       content_anchor: true, **_options)
           @diagram = diagram
           @model_index = model_index
-          @frame = frame.nil? ? !empty_diagram?(diagram) : frame
+          @frame = frame
           @document = document
+          @content_anchor = content_anchor && !@frame
         end
 
         def render
-          canvas = Canvas.from(diagram, model_index: model_index)
-          seq = LayerSequencer.new(diagram, model_index: model_index,
-                                   canvas: canvas, frame: frame,
-                                   document: document)
-          seq.layers
-          # Second pass over the DRAWN extents: grown classifiers and
-          # autosized packages can exceed the stored-rect canvas EA
-          # sizes from drawn extents. Skip when the first pass already
-          # covers the drawn extents (the common case).
-          grown = seq.drawn_bounds
-          if grown && grown.values.any? &&
-             exceeds?(canvas, grown.values)
-            canvas = Canvas.from_drawn(diagram, grown,
-                                       model_index: model_index)
-            seq = LayerSequencer.new(diagram, model_index: model_index,
-                                     canvas: canvas, frame: frame,
-                                     document: document)
-            seq.layers
-          end
+          canvas, seq = lay_out
           layers = seq.layers.reject { |s| s.nil? || s.empty? }
           image_layer = emit_images
           layers << image_layer if image_layer
@@ -46,6 +34,52 @@ module Ea
           %(<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">\n\n<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="#{canvas.width_cm}" height="#{canvas.height_cm}" viewBox="#{canvas.view_box}">\n<title></title>\n<desc>Created with Enterprise Architect (Build: #{BUILD_ID}) 2</desc>\n#{layers.join("\n")}\n</svg>)
         end
 
+        # First pass over the stored rects, then a second pass over the
+        # DRAWN extents: grown classifiers and autosized packages can
+        # exceed the stored-rect canvas EA sizes from drawn extents.
+        # Skipped when the first pass already covers them (the common
+        # case). An unframed export is finally anchored on the content.
+        def lay_out
+          canvas = Canvas.from(diagram, model_index: model_index,
+                             content_anchor: content_anchor)
+          seq = sequence(canvas)
+          canvas, seq = redo_on_drawn(canvas, seq)
+          content_anchor ? anchor_on_content(canvas, seq) : [canvas, seq]
+        end
+        private :lay_out
+
+        def redo_on_drawn(canvas, seq)
+          grown = seq.drawn_bounds
+          return [canvas, seq] unless grown&.values&.any? &&
+                                      exceeds?(canvas, grown.values)
+
+          canvas = Canvas.from_drawn(diagram, grown, model_index: model_index,
+                                                     content_anchor: content_anchor)
+          [canvas, sequence(canvas)]
+        end
+        private :redo_on_drawn
+
+        def sequence(canvas)
+          seq = LayerSequencer.new(diagram, model_index: model_index,
+                                            canvas: canvas, frame: frame,
+                                            document: document)
+          seq.layers
+          seq
+        end
+        private :sequence
+
+        # Re-renders at the canvas anchored on the measured drawn
+        # content when that differs from the stored-rect canvas.
+        def anchor_on_content(canvas, seq)
+          anchored = CanvasAnchor.reanchor(canvas, seq.layers.drop(1),
+                                           seq.label_reach,
+                                           bottom: BottomMargin.for(diagram, model_index))
+          return [canvas, seq] if CanvasAnchor.same_canvas?(canvas, anchored)
+
+          [anchored, sequence(anchored)]
+        end
+        private :anchor_on_content
+
         # Walks t_image rows (when the document carries a Database
         # with an :images collection) and invokes EmfRenderer on
         # each. Emits an `<image>` element per successfully converted
@@ -86,11 +120,6 @@ module Ea
           %(<g>#{svg}</g>)
         end
         private :render_image
-
-        def empty_diagram?(source_diagram)
-          source_diagram.elements.empty? && source_diagram.connectors.empty?
-        end
-        private :empty_diagram?
       end
     end
   end

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

@@ -31,16 +31,24 @@ module Ea
           ICON_LABEL_GAP = 22
           LABEL_BASELINE_FROM_ICON_TOP = 12
           DEFAULT_ITEM_FONT_SIZE = 9
+          # The legend pen is not set explicitly: the panel inherits the pen
+          # left by the previous drawing (round/bevel), or EA's initial pen
+          # (square/miter) when the legend is the first thing painted. Held
+          # across the corpus: 11 of 11 legends painted first are square, 105
+          # of 105 painted later are round.
+          INHERITED_STROKE = "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel;"
+          INITIAL_STROKE = "stroke-width:1;stroke-linecap:square;stroke-linejoin:miter;"
 
-          def self.render(bounds, legend:, family:, canvas: nil, item_font: {})
-            new(bounds, legend, family, canvas, item_font).to_svg
+          def self.render(bounds, legend:, family:, canvas: nil, item_font: {}, first_painted: false)
+            new(bounds, legend, family, canvas, item_font, first_painted: first_painted).to_svg
           end
 
-          def initialize(bounds, legend, family, canvas, item_font = {})
+          def initialize(bounds, legend, family, canvas, item_font = {}, first_painted: false)
             @bounds = bounds
             @legend = legend
             @family = family
             @canvas = canvas
+            @pen = first_painted ? INITIAL_STROKE : INHERITED_STROKE
             @item_font = item_font[:size]&.nonzero? ? item_font : {}
           end
 
@@ -82,19 +90,19 @@ module Ea
           end
 
           def container_style
-            "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
+            "#{@pen} " \
               "fill:#{container_fill};fill-opacity:1.00; " \
               "stroke:#{container_stroke}; stroke-opacity:1.00"
           end
 
           def icon_style(item)
-            "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
+            "#{@pen} " \
               "fill:#{icon_fill(item)};fill-opacity:1.00; " \
               "stroke:#000000; stroke-opacity:1.00"
           end
 
           def label_style
-            "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
+            "#{@pen} " \
               "fill:#{label_fill};fill-opacity:1.00; " \
               "stroke:#000000; stroke-opacity:0.00"
           end