ea 0.6.104 → 0.6.106

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53866c904e4fef2b317cd5aeb9e0b142e3d970507b65e9d9f14d2c768a56f1e8
-  data.tar.gz: 40ad1c86acd5461a89fe8e6b23a9da1f65eb43ef9eba632583344d09ed54b932
+  metadata.gz: 944b29164fec6d17c5e89224547ae993a7ef4dfbee74ac1c15208eba6f88f0d5
+  data.tar.gz: e0d40f4203d9ef1bf8a1d6f0cf72349b7e3e052ed2c3c920f96f1ca655ff2741
 SHA512:
-  metadata.gz: f475a015d57fc2337ef3a19ea8e81fbd75e2f04532d79893e5fc01e1e9b344b07b973e4b833a4480dc49aed31f1ff4b45463950e53dc5e290f2b7304638be9e9
-  data.tar.gz: b8ca9731d6d2442f74778cbe4ad66550cada64399cbf33eb858a4e0ad59ad7e9488516732194d29ebaa7733c3beae401ae7e7856964b3d1c4fd0989abae0db6d
+  metadata.gz: 4087c56867c690c67f9c99011a3e8bd4c043fdcb4bb25880a6d7020d7bab5c6e9bed6adc5b25475e37d9dfe64034d6ce7a52fea44d163fb7a41df37998ce1186
+  data.tar.gz: 4ae9f0ff3fc328d2f4ceeec2a9e8b0acb51fc72326c9806b00471449dfc656d3b60029f002b4bd5e59269c32807144ed1a660dafb29bc9b4916731e5ba57e761

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

@@ -4,7 +4,7 @@ module Ea
   module Sources
     module Qea
       class DiagramBuilder
-        # Source-led routes for auto-routed associations with unequal end offsets.
+        # Stored mathematical docking for auto-routed associations.
         module AutoRouting
           private
 
@@ -22,6 +22,53 @@ module Ea
             model
           end
 
+          # When the shared row misses the target, retain the physical ports
+          # and let the emitter clip their ray before inserting the elbow.
+          def auto_port_elbow(model, link_row, diagram_row, geom, context)
+            return model if context || !auto_port_elbow_candidate?(model, link_row, geom)
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            origins = [stored_ray_origin(source, geom[:sx], geom[:sy]),
+                       stored_ray_origin(target, geom[:ex], geom[:ey])]
+            return model unless auto_port_elbow_origins?(source, target, origins, geom)
+
+            apply_auto_port_elbow(model, origins)
+          end
+
+          def apply_auto_port_elbow(model, origins)
+            model.source_anchor, model.target_anchor = origins
+            model.waypoints = origins.map { |point| Ea::Model::Waypoint.new(position: point) }
+            model.style = model.style.to_h.merge(association_ray_outline: true, auto_port_elbow: true)
+            model
+          end
+
+          def auto_port_elbow_candidate?(model, link_row, geom)
+            auto_port_elbow_model?(model) && link_row.path.to_s.empty? &&
+              source_row_style?(model.style.to_h) && uniform_overlap_offsets?(geom) && geom[:edge] == 4
+          end
+
+          def auto_port_elbow_model?(model)
+            model.connector_type == "Association" && model.has_geometry_offsets &&
+              model.source_anchor && model.target_anchor && model.waypoints.size == 2
+          end
+
+          def auto_port_elbow_origins?(source, target, origins, geom)
+            return false if overlap_origins(source, target, geom)
+            return false unless source_row_faces_target?(source, target, geom[:edge])
+            return false unless origins.first.x == source.x - 1
+            return false if within_height?(origins.first.y, target)
+            return false unless crosses_target_horizontal_edge?(origins, target)
+
+            [source, target].zip(origins).all? { |box, origin| inside_box?(origin, grown_bounds(box, 1)) }
+          end
+
+          def crosses_target_horizontal_edge?(origins, target)
+            outline = grown_bounds(target, 1)
+            edge = Ea::Model::Bounds.new(x: outline.x, width: outline.width, height: 0,
+                                         y: origins.first.y < outline.y ? outline.y : outline.y + outline.height)
+            segment_crosses_box?(*origins, edge)
+          end
+
           def source_row_origins(source, target, geom)
             return nil unless source_row_faces_target?(source, target, geom[:edge])
 

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

@@ -10,7 +10,16 @@ module Ea
           private
 
           def restore_stored_square_ports(model, link_row, diagram_row, geom, context)
-            return model if context || !stored_square_port_style?(model, link_row, geom)
+            return model if context
+
+            model = mark_orthogonal_origin_ray(model, link_row, diagram_row, geom)
+            return model if model.style.to_h[:orthogonal_origin_ray] == true
+
+            restore_global_square_ports(model, link_row, diagram_row, geom)
+          end
+
+          def restore_global_square_ports(model, link_row, diagram_row, geom)
+            return model unless stored_square_port_style?(model, link_row, geom)
 
             connector = database.find_connector(link_row.connectorid)
             points = stored_square_port_coordinates(connector)
@@ -25,6 +34,50 @@ module Ea
             model
           end
 
+          # A square route with no stored bends uses the original mathematical
+          # ray to choose its orthogonal dock axis at render time.
+          def mark_orthogonal_origin_ray(model, link_row, diagram_row, geom)
+            return model unless orthogonal_origin_style?(model, link_row, geom)
+
+            origins = orthogonal_math_origins(link_row, diagram_row, geom)
+            return model unless origins
+
+            model.source_anchor, model.target_anchor = origins
+            model.waypoints = origins.map { |point| Ea::Model::Waypoint.new(position: point) }
+            model.style = model.style.to_h.merge(orthogonal_origin_ray: true)
+            model
+          end
+
+          def orthogonal_math_origins(link_row, diagram_row, geom)
+            connector = database.find_connector(link_row.connectorid)
+            boxes = stored_square_port_boxes(connector, diagram_row)
+            return unless boxes && orthogonal_box_gap?(*boxes)
+
+            offsets = [[geom[:sx], geom[:sy]], [geom[:ex], geom[:ey]]]
+            origins = boxes.zip(offsets).map { |box, offset| stored_ray_origin(box, *offset) }
+            origins if orthogonal_origins_inside?(origins, boxes)
+          end
+
+          def orthogonal_origins_inside?(origins, boxes)
+            origins.zip(boxes).all? { |point, box| origin_inside_outline?(point, box) }
+          end
+
+          def orthogonal_origin_style?(model, link_row, geom)
+            %w[Association Generalization].include?(model.connector_type) && link_row.path.to_s.empty? &&
+              model.style.to_h.values_at(:mode, :tree, :lwidth) == %w[3 OS 2] &&
+              %i[sx sy ex ey].all? { |key| !geom[key].nil? }
+          end
+
+          def orthogonal_box_gap?(source, target)
+            [source, target].all? { |box| box.width.positive? && box.height.positive? } &&
+              (horizontal_ray_gap?(source, target) ^ vertical_ray_gap?(source, target))
+          end
+
+          def origin_inside_outline?(point, box)
+            point.x.between?(box.x - 1, box.x + box.width + 1) &&
+              point.y.between?(box.y - 1, box.y + box.height + 1)
+          end
+
           def stored_square_port_style?(model, link_row, geom)
             style = model.style.to_h
             model.connector_type == "Association" && link_row.path.to_s.empty? &&

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

@@ -443,6 +443,7 @@ module Ea
           model = correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
           model = source_row_association_ray(model, link_row, diagram_row, geom, context)
           model = overlap_ray_origins(model, link_row, diagram_row, geom, context)
+          model = auto_port_elbow(model, link_row, diagram_row, geom, context)
           model = mark_default_square_ray(model, link_row, geom, context)
           restore_stored_square_ports(model, link_row, diagram_row, geom, context)
         end

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

@@ -34,6 +34,9 @@ module Ea
           return nil unless source_bounds && target_bounds
           return nil if source_ref == target_ref
 
+          square = OrthogonalRay.pairs_for(connector, source_bounds, target_bounds)
+          return square if square
+
           if lateral
             target = lateral_target(points[1], target_bounds, connector.style[:tree])
             return target && [points[0], points[1], target]
@@ -56,13 +59,45 @@ module Ea
                                   width: box.width + 2, height: box.height + 2)
           end
           candidate = clipped_pairs(outline, anchors)
+          candidate[0] = external_source_point(connector, outline.first, anchors, candidate.first)
           expanded = forward_route?(original, candidate)
           pairs = expanded ? candidate : original
           target = expanded ? outline.last : target_bounds
           pairs = default_square_pairs(connector, points, source_bounds, target, pairs)
-          stored_top_pairs(connector, expanded ? outline.first : source_bounds, pairs)
+          source = expanded ? outline.first : source_bounds
+          pairs = stored_top_pairs(connector, source, pairs)
+          auto_port_elbow_pairs(connector, source, target, pairs)
         end
 
+        # Auto routing turns at the clipped target column when the source
+        # leaves a side edge and the target enters through its top or bottom.
+        def auto_port_elbow_pairs(connector, source, target, pairs)
+          return pairs unless connector.style.to_h[:auto_port_elbow] == true
+
+          first, last = pairs
+          return pairs unless on_side_edge?(first, source) &&
+                              [target.y, target.y + target.height].include?(last[1]) &&
+                              last[0].between?(target.x, target.x + target.width)
+          return pairs if first[0] == last[0] || first[1] == last[1]
+
+          [first, [last[0], first[1]], last]
+        end
+        private_class_method :auto_port_elbow_pairs
+
+        # An external saved ray can cross two source edges; retain its
+        # clockwise perimeter choice instead of the nearest crossing.
+        def external_source_point(connector, source, anchors, fallback)
+          style = connector.style.to_h
+          return fallback unless style[:stored_association_ray] == true && style[:lwidth] == "2"
+
+          first, last = anchors
+          return fallback if first.x.between?(source.x, source.x + source.width) &&
+                             first.y.between?(source.y, source.y + source.height)
+
+          anchor_exit(first, source, last, perimeter: true)
+        end
+        private_class_method :external_source_point
+
         # EDGE=1 explicitly seats an external source ray on the top edge;
         # its first contact can instead be the bottom when its origin is below.
         def stored_top_pairs(connector, source, pairs)
@@ -273,10 +308,9 @@ module Ea
         end
         private_class_method :forward_route?
 
-        # Exit point of the anchor-to-anchor segment through a box's
-        # outline: smallest positive t whose crossing lies on the
-        # rectangle perimeter.
-        def anchor_exit(anchor, bounds, other)
+        # Interior rays use the nearest forward exit. External saved sources
+        # can request the first intersecting edge in clockwise perimeter order.
+        def anchor_exit(anchor, bounds, other, perimeter: false)
           ax, ay = anchor.x.to_f, anchor.y.to_f
           ox, oy = other.x.to_f, other.y.to_f
           dx, dy = ox - ax, oy - ay
@@ -297,12 +331,25 @@ module Ea
             x >= bounds.x - 0.01 && x <= bounds.x + bounds.width + 0.01 &&
               y >= bounds.y - 0.01 && y <= bounds.y + bounds.height + 0.01
           end
-          best = on_perimeter.min_by(&:first)
+          best = if perimeter
+                   on_perimeter.min_by { |_t, x, y| perimeter_order(x, y, bounds) }
+                 else
+                   on_perimeter.min_by(&:first)
+                 end
           # EA floors the dock coordinates (F851A657: 297.75 -> 297,
           # 433.7 -> 433) - a rounded-up dock is a visible miss.
           best ? [best[1].floor, best[2].floor] : [ax.floor, ay.floor]
         end
 
+        def perimeter_order(point_x, point_y, bounds)
+          return 0 if point_y == bounds.y
+          return 1 if point_x == bounds.x + bounds.width
+          return 2 if point_y == bounds.y + bounds.height
+
+          3
+        end
+        private_class_method :perimeter_order
+
         # EA never docks a horizontal connector line at the header
         # divider: endpoints landing on (box side edge, divider_y)
         # move down one row slot to divider_y + 13 - the first

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Orthogonal docking from the nearer physical intersection of a stored ray.
+      module OrthogonalRay
+        module_function
+
+        def pairs_for(connector, source, target)
+          return unless eligible?(connector, source, target)
+
+          origins = [connector.source_anchor, connector.target_anchor]
+
+          boxes = [source, target]
+          physical = boxes.map { |box| outline(box) }
+          clipped = physical_intersections(origins, physical)
+          selected = nearer_origin(clipped, origins)
+          orthogonal_pairs(clipped, selected, boxes, physical, origins) unless selected.nil?
+        end
+
+        def eligible?(connector, source, target)
+          connector.style.to_h[:orthogonal_origin_ray] == true && source && target &&
+            connector.source_anchor && connector.target_anchor
+        end
+        private_class_method :eligible?
+
+        def physical_intersections(origins, physical)
+          origins.each_with_index.map do |origin, index|
+            ConnectorRedock.anchor_exit(origin, physical[index], origins[1 - index])
+          end
+        end
+        private_class_method :physical_intersections
+
+        def outline(box)
+          Ea::Model::Bounds.new(x: box.x - 1, y: box.y - 1,
+                                width: box.width + 2, height: box.height + 2)
+        end
+        private_class_method :outline
+
+        def nearer_origin(clipped, origins)
+          distances = clipped.zip(origins).map do |(x, y), origin|
+            (x - origin.x)**2 + (y - origin.y)**2
+          end
+          distances.each_with_index.min.last unless distances.first == distances.last
+        end
+        private_class_method :nearer_origin
+
+        def orthogonal_pairs(clipped, selected, boxes, physical, origins)
+          point = clipped[selected]
+          projected = project_opposite(point, physical[selected], boxes[1 - selected])
+          return unless projected && forward_projection?(point, projected, origins, selected)
+
+          selected.zero? ? [point, projected] : [projected, point]
+        end
+        private_class_method :orthogonal_pairs
+
+        def project_opposite(point, own, other)
+          case physical_edge_axis(point, own)
+          when :horizontal then horizontal_projection(point, other)
+          when :vertical then vertical_projection(point, other)
+          end
+        end
+        private_class_method :project_opposite
+
+        def physical_edge_axis(point, own)
+          horizontal = [own.y, own.y + own.height].include?(point[1])
+          vertical = [own.x, own.x + own.width].include?(point[0])
+          return unless horizontal ^ vertical
+
+          horizontal ? :horizontal : :vertical
+        end
+        private_class_method :physical_edge_axis
+
+        def horizontal_projection(point, other)
+          x, y = point
+          return unless x.between?(other.x, other.x + other.width)
+
+          edge = facing_edge(y, other.y, other.height)
+          [x, edge] if edge
+        end
+        private_class_method :horizontal_projection
+
+        def vertical_projection(point, other)
+          x, y = point
+          return unless y.between?(other.y, other.y + other.height)
+
+          edge = facing_edge(x, other.x, other.width)
+          [edge, y] if edge
+        end
+        private_class_method :vertical_projection
+
+        def facing_edge(coordinate, start, extent)
+          return start if coordinate < start
+          return start + extent if coordinate > start + extent
+
+          nil
+        end
+        private_class_method :facing_edge
+
+        def forward_projection?(point, projected, origins, selected)
+          first, last = origins.values_at(selected, 1 - selected)
+          x, y = point
+          target_x, target_y = projected
+          ((last.x - first.x) * (target_x - x) + (last.y - first.y) * (target_y - y)).positive?
+        end
+        private_class_method :forward_projection?
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter.rb

@@ -45,6 +45,9 @@ module Ea
       autoload :Document, "ea/svg/ea_emitter/document"
       autoload :Label, "ea/svg/ea_emitter/label"
       autoload :Compartment, "ea/svg/ea_emitter/compartment"
+      autoload :OrthogonalRay, "ea/svg/ea_emitter/orthogonal_ray"
+      private_constant :OrthogonalRay
+
       autoload :ConnectorRedock, "ea/svg/ea_emitter/connector_redock"
       autoload :RenderContext, "ea/svg/ea_emitter/render_context"
       autoload :VisibilitySymbol, "ea/svg/ea_emitter/visibility_symbol"

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.104"
+  VERSION = "0.6.106"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.104
+  version: 0.6.106
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-15 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -950,6 +950,7 @@ files:
 - lib/ea/svg/ea_emitter/marker/plus.rb
 - lib/ea/svg/ea_emitter/marker/registry.rb
 - lib/ea/svg/ea_emitter/markers.rb
+- lib/ea/svg/ea_emitter/orthogonal_ray.rb
 - lib/ea/svg/ea_emitter/render_context.rb
 - lib/ea/svg/ea_emitter/style.rb
 - lib/ea/svg/ea_emitter/text_renderer.rb