ea 0.6.120 → 0.6.122

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

@@ -125,7 +125,7 @@ module Ea
         # Unknown faces retain the stored-upward fallback.
         def source_heading(connector, points)
           heading = leg_heading(points)
-          return heading unless points.size == 2 && heading.none?(&:zero?)
+          return heading unless heading.none?(&:zero?) && source_face_route?(connector, points)
 
           box = source_dock_bounds(connector)
           face = box && source_dock_heading(connector, points.first, box)
@@ -134,6 +134,15 @@ module Ea
           stored_upward_heading(connector, heading)
         end
 
+        # Explicit source boxes preserve the heading of a manual bend. An
+        # omitted source box uses the same dock seat as a straight route.
+        def source_face_route?(connector, points)
+          return true if points.size == 2
+
+          boxes = connector.label_boxes || {}
+          end_boxes(boxes, :llt, :llb).nil? && !end_boxes(boxes, :lrt, :lrb).nil?
+        end
+
         # A target dock that clips an axis-aligned stored leg into a slight
         # diagonal keeps the stored leg's direction.
         def target_heading(connector, points)
@@ -150,15 +159,24 @@ module Ea
         # A saved external ray enters the source through the face it first
         # meets, even when the clipped leg then runs back across the box.
         def face_leads_leg?(connector, face, heading, box)
-          anchor = connector.source_anchor
-          if face == [0, 1] && anchor && anchor.y > box.y + box.height &&
-             connector.style.to_h[:stored_association_ray] == true
-            return true
-          end
+          return true if saved_ray_beyond_face?(connector, face, box)
 
           face.zip(heading).any? { |axis, delta| (axis * delta).positive? }
         end
 
+        # A saved ray from beyond the bottom or right face meets that face
+        # first. The top face is excluded: its clipped leg keeps the anchor seat.
+        def saved_ray_beyond_face?(connector, face, box)
+          anchor = connector.source_anchor
+          return false unless anchor && connector.style.to_h[:stored_association_ray] == true
+
+          case face
+          when [0, 1] then anchor.y > box.y + box.height
+          when [1, 0] then anchor.x > box.x + box.width
+          else false
+          end
+        end
+
         def stored_upward_heading(connector, heading)
           return heading unless heading[1].negative?
 

data/lib/ea/svg/ea_emitter/marker/arrow_path.rb

@@ -4,7 +4,9 @@ module Ea
   module Svg
     module EaEmitter
       module Marker
-        # Navigability arrow at the target end of an association.
+        # Navigability arrow at the target end of an association, plus
+        # the diamond of an association whose end carries an aggregate
+        # flag (SourceIsAggregate/DestIsAggregate).
         # Rendered as a `<path>` (not polygon) sharing style with the
         # connector line. When both ends are navigable
         # (bidirectional association), EA renders a separate arrow at
@@ -16,6 +18,14 @@ module Ea
 
           def self.specs_for(connector, source, target, before_target,
                              after_source, relationship: nil)
+            Diamond.flagged_end_specs(relationship, source, target,
+                                      before_target, after_source) +
+              arrow_specs(connector, source, target, before_target,
+                          after_source)
+          end
+
+          def self.arrow_specs(connector, source, target, before_target,
+                               after_source)
             # EA draws the navigability arrow on directed
             # associations AND aggregations (333EFCCF: 6 aggregations
             # render diamond + path arrow); Direction
@@ -33,6 +43,7 @@ module Ea
             base = whole_end_at_source ? before_target : after_source
             [Registry::Spec.new(shape: :arrow, anchor: anchor, base: base)]
           end
+          private_class_method :arrow_specs
 
           # EA marks truly bidirectional associations with
           # direction="Bi-Directional" on t_connector. These get a

data/lib/ea/svg/ea_emitter/marker/diamond.rb

@@ -4,8 +4,9 @@ module Ea
   module Svg
     module EaEmitter
       module Marker
-        # EA endpoint fields select the diamond end; direction selects
-        # the arrow end for target-owned aggregations.
+        # EA endpoint fields select the diamond end and its fill (shared
+        # is hollow, composite is solid); direction selects the arrow end
+        # for target-owned aggregations.
         class Diamond < Kind
           def self.handles?(effective_type)
             %w[Aggregation Composition].include?(effective_type)
@@ -15,15 +16,51 @@ module Ea
             whole_at_target = whole_at_target?(connector, relationship)
             whole_anchor = whole_at_target ? target : source
             whole_base = whole_at_target ? before_target : after_source
-            specs = [Registry::Spec.new(shape: :diamond,
+            specs = [Registry::Spec.new(shape: diamond_shape(connector, relationship, whole_at_target),
                                         anchor: whole_anchor,
                                         base: whole_base)]
             return specs unless whole_at_target
+            return specs if arrow_on_target_diamond?(connector, relationship)
 
             specs.concat(direction_specs(connector, source, target,
                                          before_target, after_source))
           end
 
+          # Diamonds for the ends of a plain association that carry an
+          # aggregate flag.
+          def self.flagged_end_specs(relationship, source, target,
+                                     before_target, after_source)
+            return [] unless relationship
+
+            { target_aggregation: [target, before_target],
+              source_aggregation: [source, after_source] }.filter_map do |reader, (anchor, base)|
+              shape = flagged_shape(relationship.public_send(reader))
+              Registry::Spec.new(shape: shape, anchor: anchor, base: base) if shape
+            end
+          end
+
+          def self.flagged_shape(kind)
+            case kind.to_s
+            when "shared" then :diamond_hollow
+            when "composite" then :diamond
+            end
+          end
+          private_class_method :flagged_shape
+
+          def self.diamond_shape(connector, relationship, whole_at_target)
+            kind = if relationship
+                     whole_at_target ? relationship.target_aggregation : relationship.source_aggregation
+                   end
+            kind = type_default_kind(connector) if kind.to_s.empty? || kind.to_s == "none"
+            kind.to_s == "shared" ? :diamond_hollow : :diamond
+          end
+          private_class_method :diamond_shape
+
+          def self.type_default_kind(connector)
+            connector.connector_type == "Composition" ? "composite" : "shared"
+          end
+          private_class_method :type_default_kind
+
           def self.whole_at_target?(connector, relationship)
             return true if dest_flagged?(relationship)
             return false if source_flagged?(relationship)
@@ -31,6 +68,14 @@ module Ea
             !whole_end_at_source?(connector)
           end
 
+          # EA draws no arrow where a directed, dest-flagged aggregation
+          # would put it on its own target diamond.
+          def self.arrow_on_target_diamond?(connector, relationship)
+            connector.direction == "Source -> Destination" &&
+              dest_flagged?(relationship)
+          end
+          private_class_method :arrow_on_target_diamond?
+
           def self.dest_flagged?(relationship)
             relationship &&
               %w[shared composite].include?(relationship.target_aggregation.to_s)

data/lib/ea/svg/ea_emitter/marker/open_triangle.rb

@@ -15,7 +15,7 @@ module Ea
         class OpenTriangle < Kind
           def self.handles?(effective_type)
             %w[Generalization Realization Realisation Dependency
-               InformationFlow NoteLink].include?(effective_type)
+               InformationFlow].include?(effective_type)
           end
 
           def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)

data/lib/ea/svg/ea_emitter/marker/package_import.rb

@@ -5,30 +5,17 @@ module Ea
     module EaEmitter
       module Marker
         # PackageImport marker for «import» connectors between
-        # packages. EA draws a closed trapezoid silhouette at the
-        # source end (the importing package) and an open V-arrow at
-        # the target end (the imported package) — but ONLY when the
-        # connector's geometry string carries explicit SX/SY offset
-        # fields. Auto-routed connectors (no SX/SY) render as a
-        # plain solid line with no package_anchor marker.
-        #
-        # Verified against both QEAs (output by the same EA run):
-        #   - basic.qea Package Imports: SX=0;SY=0 present → marker
-        #   - plateau Urban Planning ADE2: SX/SY absent → no marker
+        # packages. EA draws the dependency-style open arrowhead at the
+        # target (imported) end, whether or not the diagram link
+        # carries explicit SX/SY offsets.
         class PackageImport < Kind
           def self.handles?(effective_type)
             effective_type == "Package"
           end
 
-          def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
-            return [] unless connector.has_geometry_offsets
-
-            [
-              Registry::Spec.new(shape: :package_anchor,
-                                 anchor: source, base: after_source),
-              Registry::Spec.new(shape: :arrow, anchor: target,
-                                 base: before_target)
-            ]
+          def self.specs_for(_connector, _source, target, before_target, _after_source, **)
+            [Registry::Spec.new(shape: :dependency_arrow,
+                                anchor: target, base: before_target)]
           end
         end
       end

data/lib/ea/svg/ea_emitter/marker/plus.rb

@@ -4,16 +4,12 @@ module Ea
   module Svg
     module EaEmitter
       module Marker
-        # Plus-symbol marker at the contained end of a Nesting
-        # connector. EA renders a "+" (16x16, two crossed lines)
-        # at the end pointing INTO the container.
+        # Circled-plus marker at the container end of a Nesting
+        # connector. EA draws a white circle of radius ARM_LENGTH just
+        # outside the container edge with a plus (two crossed arms)
+        # through its centre; the connector starts at the nested
+        # element and ends at the container.
         #
-        # Path encoding (two sub-paths in one <path>):
-        #
-        #   M cx cy-8 L cx cy+8    (vertical arm, 16 tall)
-        #   M cx+8 cy L cx-8 cy    (horizontal arm, 16 wide)
-        #
-        # cx, cy = plus center, anchored at the source-end waypoint.
         class Plus < Kind
           ARM_LENGTH = 8
 
@@ -22,14 +18,10 @@ module Ea
           end
 
           def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
-            # Plus is at the contained (child) end. EA's convention:
-            # source end is the child, target end is the parent.
-            # Default to source unless the connector direction
-            # reverses the ends.
-            whole_end_at_source = whole_end_at_source?(connector)
-            anchor = whole_end_at_source ? source : target
-            base = whole_end_at_source ? after_source : before_target
-            [Registry::Spec.new(shape: :plus, anchor: anchor, base: base)]
+            container_at_target = whole_end_at_source?(connector)
+            anchor = container_at_target ? target : source
+            base = container_at_target ? before_target : after_source
+            [Registry::Spec.new(shape: :nesting, anchor: anchor, base: base)]
           end
         end
       end

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

@@ -9,7 +9,9 @@ module Ea
       #
       # Layer style keys:
       #   - :diamond_filled  → 4-pt <polygon>, black fill
+      #   - :diamond_hollow  → 4-pt <polygon>, white fill
       #   - :triangle_open   → 3-pt <polygon>, white fill
+      #   - :nesting_circle  → <ellipse> + plus <path>, white fill
       #   - :arrow           → 3-pt <path>, no fill (shares style with
       #     connector lines — same stroke, no fill)
       #
@@ -20,7 +22,7 @@ module Ea
         DIAMOND_HALF_W = 5
         DIAMOND_HALF_H = 10
         TRI_HALF_BASE = 6
-        TRI_HEIGHT = 11
+        TRI_HEIGHT = 16
         # EA's path arrowheads are height 15 corpus-wide, with
         # distinct bases per connector kind: association
         # navigability arrows base 12, dependency arrows base 10
@@ -48,22 +50,19 @@ module Ea
 
         def layers
           entries = visible_connectors.flat_map { |c| entries_for(c) }
-          return [] if entries.empty?
 
           if grouped
-            entries.group_by(&:style_key).map do |key, grouped_entries|
+            entries.group_by { |e| [e.style_key, e.stroke_width] }.map do |(key, width), grouped_entries|
               # EA emits ONE marker per connector regardless of
               # anchor overlap. Verified against plateau Bridge
               # diagram: 9 generalizations fanning from the same
               # parent anchor produce 9 distinct triangle polygons
               # at the same coordinates. The earlier "dedup by
               # anchor" hypothesis is disproven by reference SVGs.
-              Layer.new(style_key: key,
-                        style: style_for(key),
-                        body: grouped_entries.map(&:body).join("\n  "))
+              marker_layer(key, width, grouped_entries.map(&:body).join("\n  "))
             end
           else
-            entries.map { |e| Layer.new(style_key: e.style_key, style: style_for(e.style_key), body: e.body) }
+            entries.map { |e| marker_layer(e.style_key, e.stroke_width, e.body) }
           end
         end
 
@@ -86,7 +85,7 @@ module Ea
         # for future use (e.g. overlap diagnostics) but no longer
         # drives dedup — EA emits one marker per connector.
         Entry = Struct.new(:style_key, :body, :anchor,
-                           :connector_waypoint_count,
+                           :connector_waypoint_count, :stroke_width,
                            keyword_init: true) do
           def hash
             anchor.hash
@@ -109,13 +108,17 @@ module Ea
             style_key: :diamond_filled,
             render: ->(m, anchor, base) { m.diamond_polygon(anchor, base) }
           },
+          diamond_hollow: {
+            style_key: :diamond_hollow,
+            render: ->(m, anchor, base) { m.diamond_polygon(anchor, base) }
+          },
           triangle: {
             style_key: :triangle_open,
             render: ->(m, anchor, base) { m.triangle_polygon(anchor, base) }
           },
-          plus: {
-            style_key: :connector_line,
-            render: ->(m, anchor, _base) { m.plus_path(anchor) }
+          nesting: {
+            style_key: :nesting_circle,
+            render: ->(m, anchor, base) { m.nesting_marker(anchor, base) }
           },
           arrow: {
             style_key: :connector_line,
@@ -124,10 +127,6 @@ module Ea
           dependency_arrow: {
             style_key: :connector_line,
             render: ->(m, anchor, base) { m.dependency_arrow_path(anchor, base) }
-          },
-          package_anchor: {
-            style_key: :connector_line,
-            render: ->(m, anchor, base) { m.package_anchor_path(anchor, base) }
           }
         }.freeze
 
@@ -135,15 +134,22 @@ module Ea
         # is shared, so only the fill and opacity vary.
         STYLE_MAP = {
           diamond_filled: { fill: "#000000", opacity: "1.00" },
+          diamond_hollow: { fill: "#FFFFFF", opacity: "1.00" },
           triangle_open: { fill: "#FFFFFF", opacity: "1.00" },
+          nesting_circle: { fill: "#FFFFFF", opacity: "1.00" },
           connector_line: { fill: "#000000", opacity: "0.00" }
         }.freeze
 
-        def style_for(key)
+        def marker_layer(key, width, body)
+          Layer.new(style_key: Connectors.layer_key(key, width, stroke_width),
+                    style: style_for(key, width), body: body)
+        end
+
+        def style_for(key, width = stroke_width)
           spec = STYLE_MAP[key]
           return nil unless spec
 
-          "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; " \
+          "stroke-width:#{width};stroke-linecap:round;stroke-linejoin:bevel; " \
             "fill:#{spec[:fill]};fill-opacity:#{spec[:opacity]}; " \
             "stroke:#000000; stroke-opacity:1.00"
         end
@@ -164,7 +170,8 @@ module Ea
             Entry.new(style_key: style_key_for(spec),
                       body: body,
                       anchor: anchor_for(spec),
-                      connector_waypoint_count: waypoint_count)
+                      connector_waypoint_count: waypoint_count,
+                      stroke_width: Connectors.stroke_width_for(connector, stroke_width))
           end
         end
 
@@ -279,22 +286,36 @@ module Ea
           entry[:render].call(self, spec.anchor, spec.base)
         end
 
-        # Plus marker: two crossed line segments at the anchor.
-        # EA encodes as one <path> with two sub-paths:
-        #   M cx cy-8 L cx cy+8    (vertical arm)
-        #   M cx+8 cy L cx-8 cy    (horizontal arm)
-        def plus_path(anchor)
-          cx, cy = translate_point(anchor)
-          cx_str = Canvas.coord(cx)
-          cy_str = Canvas.coord(cy)
-          up = Canvas.coord(cy - Marker::Plus::ARM_LENGTH)
-          down = Canvas.coord(cy + Marker::Plus::ARM_LENGTH)
-          left = Canvas.coord(cx - Marker::Plus::ARM_LENGTH)
-          right = Canvas.coord(cx + Marker::Plus::ARM_LENGTH)
-          d = "M #{cx_str} #{up} L #{cx_str} #{down} M #{right} #{cy_str} L #{left} #{cy_str}"
+        # Nesting marker: a white circle tangent to the container edge
+        # at the anchor, with a plus through its centre. The plus is an
+        # unfilled path, so it stays visible on the circle's fill.
+        def nesting_marker(tip, base)
+          tx, ty = translate_point(tip)
+          bx, by = translate_point(base)
+          ux, uy = unit_vector(tx, ty, bx, by)
+          return nil unless ux
+
+          radius = Marker::Plus::ARM_LENGTH
+          cx_val = tx - ux * radius
+          cy_val = ty - uy * radius
+          circle = %(<ellipse cx="#{fixed(cx_val)}" cy="#{fixed(cy_val)}" ) +
+                   %(rx="#{radius}.00" ry="#{radius}.00" shape-rendering="auto"  />)
+          [circle, plus_path(cx_val, cy_val)].join("\n  ")
+        end
+
+        def plus_path(center_x, center_y)
+          arm = Marker::Plus::ARM_LENGTH
+          d = "M #{Canvas.coord(center_x)} #{Canvas.coord(center_y - arm)} " \
+              "L #{Canvas.coord(center_x)} #{Canvas.coord(center_y + arm)} " \
+              "M #{Canvas.coord(center_x + arm)} #{Canvas.coord(center_y)} " \
+              "L #{Canvas.coord(center_x - arm)} #{Canvas.coord(center_y)}"
           %(<path d="#{d}" shape-rendering="auto"/>)
         end
 
+        def fixed(value)
+          format("%<value>.2f", value: value)
+        end
+
         def specs_for(connector)
           points = waypoint_pairs(connector)
           return [] if points.size < 2
@@ -343,10 +364,10 @@ module Ea
           left_x = tx - ux * DIAMOND_HALF_H - (-uy) * DIAMOND_HALF_W
           left_y = ty - uy * DIAMOND_HALF_H - ux * DIAMOND_HALF_W
           pts = [
-            Canvas.coord(tx), Canvas.coord(ty),
-            Canvas.coord(right_x), Canvas.coord(right_y),
-            Canvas.coord(back_x), Canvas.coord(back_y),
-            Canvas.coord(left_x), Canvas.coord(left_y)
+            Canvas.coord(tx.round), Canvas.coord(ty.round),
+            Canvas.coord(right_x.round), Canvas.coord(right_y.round),
+            Canvas.coord(back_x.round), Canvas.coord(back_y.round),
+            Canvas.coord(left_x.round), Canvas.coord(left_y.round)
           ].join(" ")
           %(<polygon points="#{pts}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
         end
@@ -364,9 +385,9 @@ module Ea
           w2_x = back_x - (-uy) * TRI_HALF_BASE
           w2_y = back_y - ux * TRI_HALF_BASE
           pts = [
-            Canvas.coord(tx), Canvas.coord(ty),
-            Canvas.coord(w1_x), Canvas.coord(w1_y),
-            Canvas.coord(w2_x), Canvas.coord(w2_y)
+            Canvas.coord(tx.round), Canvas.coord(ty.round),
+            Canvas.coord(w1_x.round), Canvas.coord(w1_y.round),
+            Canvas.coord(w2_x.round), Canvas.coord(w2_y.round)
           ].join(" ")
           %(<polygon points="#{pts}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
         end
@@ -383,39 +404,9 @@ module Ea
           w1_y = back_y + ux * ARROW_HALF_BASE
           w2_x = back_x - (-uy) * ARROW_HALF_BASE
           w2_y = back_y - ux * ARROW_HALF_BASE
-          d = "M #{Canvas.coord(w1_x)} #{Canvas.coord(w1_y)} L #{Canvas.coord(tx)} #{Canvas.coord(ty)} L #{Canvas.coord(w2_x)} #{Canvas.coord(w2_y)}"
-          %(<path d="#{d}" shape-rendering="auto"/>)
-        end
-
-        # «import» source-end marker: a small closed trapezoid that
-        # visually represents the imported package. Shape is a 4-point
-        # polygon: top edge shorter than bottom edge, centered on the
-        # anchor point.
-        PACKAGE_ANCHOR_W = 5
-        PACKAGE_ANCHOR_H_TOP = 3
-        PACKAGE_ANCHOR_H_BOTTOM = 4
-
-        def package_anchor_path(tip, base)
-          tx, ty = translate_point(tip)
-          bx, by = translate_point(base)
-          ux, uy = unit_vector(tx, ty, bx, by)
-          return nil unless ux
-
-          back_x = tx - ux * PACKAGE_ANCHOR_H_BOTTOM
-          back_y = ty - uy * PACKAGE_ANCHOR_H_BOTTOM
-          tl_x = tx - ux * PACKAGE_ANCHOR_H_TOP + (-uy) * PACKAGE_ANCHOR_W
-          tl_y = ty - uy * PACKAGE_ANCHOR_H_TOP + ux * PACKAGE_ANCHOR_W
-          tr_x = tx - ux * PACKAGE_ANCHOR_H_TOP - (-uy) * PACKAGE_ANCHOR_W
-          tr_y = ty - uy * PACKAGE_ANCHOR_H_TOP - ux * PACKAGE_ANCHOR_W
-          bl_x = back_x + (-uy) * (PACKAGE_ANCHOR_W + 1)
-          bl_y = back_y + ux * (PACKAGE_ANCHOR_W + 1)
-          br_x = back_x - (-uy) * (PACKAGE_ANCHOR_W + 1)
-          br_y = back_y - ux * (PACKAGE_ANCHOR_W + 1)
-          d = "M #{Canvas.coord(tl_x)} #{Canvas.coord(tl_y)} " \
-              "L #{Canvas.coord(tr_x)} #{Canvas.coord(tr_y)} " \
-              "L #{Canvas.coord(br_x)} #{Canvas.coord(br_y)} " \
-              "L #{Canvas.coord(bl_x)} #{Canvas.coord(bl_y)} " \
-              "L #{Canvas.coord(tl_x)} #{Canvas.coord(tl_y)} Z"
+          d = "M #{Canvas.coord(w1_x.round)} #{Canvas.coord(w1_y.round)} " \
+              "L #{Canvas.coord(tx.round)} #{Canvas.coord(ty.round)} " \
+              "L #{Canvas.coord(w2_x.round)} #{Canvas.coord(w2_y.round)}"
           %(<path d="#{d}" shape-rendering="auto"/>)
         end
 
@@ -449,8 +440,8 @@ module Ea
 
           [dx / len, dy / len]
         end
-        public :diamond_polygon, :triangle_polygon, :plus_path,
-               :arrow_path, :dependency_arrow_path, :package_anchor_path
+        public :diamond_polygon, :triangle_polygon, :nesting_marker,
+               :arrow_path, :dependency_arrow_path
 
         def translate_point(p)
           return p unless @canvas

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.6.120"
+  VERSION = "0.6.122"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.120
+  version: 0.6.122
 platform: ruby
 authors:
 - Ribose Inc.