ea 0.6.105 → 0.6.106

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 430568b3607d439af39bac818b48ee27caa207875c7f2015e3a6f5689419680b
-  data.tar.gz: dfb835e2208d50a51caa01acb96a30e2561f5ccbdf6e83a6a1c55ec368c4b5b8
+  metadata.gz: 944b29164fec6d17c5e89224547ae993a7ef4dfbee74ac1c15208eba6f88f0d5
+  data.tar.gz: e0d40f4203d9ef1bf8a1d6f0cf72349b7e3e052ed2c3c920f96f1ca655ff2741
 SHA512:
-  metadata.gz: ce35bed8f6b13d1f799d8c99b550ad70d19453e2f2827888c1dce54b246dc9a938baa52cfe2d24f9fb9f093ecce1a86b52c4dbecbb60b397777c592cc61ea654
-  data.tar.gz: 22747dc14774fbfaa984efba1c88078619d8ab6bc74b4d06d5276074a93957dccc071963574aad3ff272377d043e51e613723708d0fa48318acf6558ec920de1
+  metadata.gz: 4087c56867c690c67f9c99011a3e8bd4c043fdcb4bb25880a6d7020d7bab5c6e9bed6adc5b25475e37d9dfe64034d6ce7a52fea44d163fb7a41df37998ce1186
+  data.tar.gz: 4ae9f0ff3fc328d2f4ceeec2a9e8b0acb51fc72326c9806b00471449dfc656d3b60029f002b4bd5e59269c32807144ed1a660dafb29bc9b4916731e5ba57e761

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/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,6 +59,7 @@ 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
@@ -80,6 +84,20 @@ module Ea
         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)
@@ -290,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
@@ -314,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.105"
+  VERSION = "0.6.106"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.105
+  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