ea 0.6.138 → 0.6.139

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c2231b8d009e8d99c841920776cbe8539e09b76d512beed109f073fb7904282
-  data.tar.gz: 3feade927368b299842047c9c0e31aa0cb8473e7dad6870e5626fb369e1503de
+  metadata.gz: 34c3f680cb51a88a683e57db2c059fcee8979e5b6b31cfaae4c3cbc3ac91ac86
+  data.tar.gz: a4cbd25958c54c24d6d1801bf4e4cc83f76f42d652f371cf9d491865160d7725
 SHA512:
-  metadata.gz: 025f36b456316a6fcd801318f17c27363d62d3ee7355cd303c1b7147081f44d3b70fdf711966ae4a5a7fc33e022dc097ba4d6f15f6c3ad03e237d59318b89fac
-  data.tar.gz: d2487edce57559735c9cdf42984dd16ad3597985fb5d2f01ddeb9289c893b423a986f8587b3788d0cd759aaca93661c8e0a86262a4939f503d21e9495e29db9f
+  metadata.gz: c87682bc64b73abb6502c0dfd71ca7b9209ab8bcd71b79762032d0c4008f80999e3785257b72f39d73a816247d1dbcc5580a70e64f526a8ee98ee1aab32b645a
+  data.tar.gz: ed3c4dd24e1ed8b1bd9c371545d56392cda07b2e0f3223f27d84761b728963c5df7df67fab8da905bdd586150fb94750a5cbe3f2bd1bec9fd11adfd3ec18b9c6

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

@@ -280,7 +280,9 @@ module Ea
 
           metadata = stored_ray_metadata(connector, placed, source, target)
           metadata.each { |name, value| connector.public_send("#{name}=", value) }
-          connector.style[:association_ray_outline] = true unless metadata.empty?
+          return if metadata.empty? || connector.connector_type == "Generalization"
+
+          connector.style[:association_ray_outline] = true
         end
 
         def stored_ray_metadata(connector, placed, source, target, stage: :ray_metadata)

data/lib/ea/sources/xmi/stored_route.rb

@@ -26,9 +26,12 @@ module Ea
           finish(points, link, connector, source, target, bends, ports, offsets, edge)
         end
 
-        # Direct custom-line associations and aggregations retain ray origins as
-        # well as their computed boundary ports, just as the QEA builder does.
+        # Saved rays retain origins and computed boundary ports, matching QEA.
         def ray_metadata(model, link:, bounds:, offsets:, edge:)
+          if model.connector_type == "Generalization"
+            return generalization_ray_metadata(model, link, bounds, offsets, edge)
+          end
+
           return {} unless direct_association_ray?(model, bounds, offsets)
 
           source, target = bounds.values_at(:source, :target)
@@ -169,6 +172,39 @@ module Ea
             bounds.values.all? && offsets.values.flatten.none?(&:nil?)
         end
 
+        # A direct Generalization clips its saved mathematical origins rather
+        # than treating boundary ports as the origins of the final drawn ray.
+        def generalization_ray_metadata(model, link, bounds, offsets, edge)
+          geom = ray_geometry(offsets, edge)
+          return {} unless generalization_ray_candidate?(model, link, bounds, offsets, geom)
+
+          source, target = bounds.values_at(:source, :target)
+          return {} unless stored_ray_gap?(source, target, model.style[:mode], edge)
+
+          points = ray_points(source, target, offsets, geom)
+          return {} if points.empty?
+
+          points.merge(style: generalization_ray_style(model, points, source, target))
+        end
+
+        def generalization_ray_candidate?(model, link, bounds, offsets, geom)
+          model.waypoints.size == 2 && stored_ray_style?(model.style, link) &&
+            bounds.values.all? && offsets.values.flatten.none?(&:nil?) &&
+            (!geom[:sy].zero? || !geom[:ey].zero?)
+        end
+
+        def generalization_ray_style(model, points, source, target)
+          candidate = Ea::Model::DiagramConnector.new(
+            connector_type: model.connector_type, style: model.style.to_h.dup,
+            source_anchor: points[:source_anchor], target_anchor: points[:target_anchor]
+          )
+          return model.style.to_h unless centered_origin_ray?(candidate, source, target)
+
+          flags = { centered_origin_ray: true }
+          flags[:stored_origin_ray] = true if stored_origin_ray?(candidate, source, target)
+          model.style.to_h.merge(flags)
+        end
+
         def ray_geometry(offsets, edge)
           { sx: offsets[:source][0], sy: offsets[:source][1],
             ex: offsets[:target][0], ey: offsets[:target][1], edge: edge }

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

@@ -9,6 +9,7 @@ module Ea
       # connector passes over a crossing.
       class ConnectorBridges
         RADIUS = 6
+        PHANTOM = :phantom
 
         def initialize(_diagram, routes)
           @routes = routes.map { |connector, points| [connector, points, priority_for(connector)] }
@@ -56,78 +57,75 @@ module Ea
 
         # nil or empty: no bridge decision for this connector.
         def priority_for(connector)
+          return PHANTOM if phantom?(connector)
+
           connector.paint_order if connector.paint_order&.any?
         end
 
-        def crossings_for(connector, priority, first, last)
-          axis = axis_for(first, last)
-          return [] unless axis
+        # A phantom (relationship without a link row) has no stored order; it
+        # is appended after every link in the export, so it passes over them.
+        def phantom?(connector)
+          connector.paint_order.nil?
+        end
 
+        def crossings_for(connector, priority, first, last)
           crossings = lower_routes(connector, priority).flat_map do |_partner, points, _order|
             points.each_cons(2).filter_map do |start, finish|
-              crossing(first, last, start, finish, axis)
+              crossing(first, last, start, finish)
             end
           end
-          separate_crossings(crossings, axis).sort_by { |point| (point[axis] - first[axis]).abs }
+          separate_crossings(crossings, first, last).sort_by { |point| distance(point, first) }
         end
 
         # The order key is only proven across different start placements, so
         # connectors leaving the same placement make no carrier decision.
         def lower_routes(connector, priority)
+          return keyed_routes(connector) if priority == PHANTOM
+
           @routes.select do |partner, _points, order|
-            !partner.equal?(connector) && order && order.size == priority.size &&
+            !partner.equal?(connector) && order.is_a?(Array) && order.size == priority.size &&
               !same_source?(connector, partner) && (order <=> priority).negative?
           end
         end
 
+        def keyed_routes(connector)
+          @routes.select { |partner, _points, order| !partner.equal?(connector) && order.is_a?(Array) }
+        end
+
         def same_source?(connector, partner)
           connector.source_element_ref && connector.source_element_ref == partner.source_element_ref
         end
 
-        # Suppress both overlapping spans, including coincident crossings,
-        # so route order cannot select one of several ambiguous arcs.
-        def separate_crossings(crossings, axis)
-          crossings.reject.with_index do |point, index|
-            crossings.each_with_index.any? do |other, other_index|
-              index != other_index && (point[axis] - other[axis]).abs < 2 * RADIUS
-            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 crossing(first, last, start, finish, axis)
-          return unless axis_for(start, finish) == 1 - axis
-
-          point = axis.zero? ? [start[0], first[1]] : [first[0], start[1]]
-          return unless segment_interior?(point, first, last, axis) &&
-                        segment_interior?(point, start, finish, 1 - axis)
-
-          point
-        end
-
-        def segment_interior?(point, first, last, axis)
-          interior?(point[axis], first[axis], last[axis])
+        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 interior?(value, first, last)
-          minimum, maximum = [first, last].minmax
-          value > minimum && value < maximum &&
-            value - minimum >= RADIUS && maximum - value >= RADIUS
+        def crossing(first, last, start, finish)
+          SegmentGeometry.crossing(first, last, start, finish, RADIUS)
         end
 
-        def axis_for(first, last)
-          return 0 if first[1] == last[1] && first[0] != last[0]
-          return 1 if first[0] == last[0] && first[1] != last[1]
-
-          nil
+        def distance(point, other)
+          SegmentGeometry.distance(point, other)
         end
 
         def arc_commands(first, last, crossing)
-          axis = axis_for(first, last)
-          direction = last[axis] > first[axis] ? 1 : -1
-          start = crossing.dup
-          finish = crossing.dup
-          start[axis] -= direction * RADIUS
-          finish[axis] += direction * RADIUS
+          start, finish = SegmentGeometry.chord(first, last, crossing, RADIUS)
           ["L #{coordinates(start)}", "A #{RADIUS} #{RADIUS} 180 0 0 #{coordinates(finish)}"]
         end
 

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Segment arithmetic for connector bridges: where two segments cross at
+      # any slope, and where the arc chord sits on the carrier segment.
+      module SegmentGeometry
+        EPSILON = 1e-9
+
+        module_function
+
+        def distance(point, other)
+          Math.hypot(point[0] - other[0], point[1] - other[1])
+        end
+
+        # 0 for a horizontal segment, 1 for a vertical one, nil otherwise.
+        def axis_for(first, last)
+          return 0 if first[1] == last[1] && first[0] != last[0]
+          return 1 if first[0] == last[0] && first[1] != last[1]
+
+          nil
+        end
+
+        # A proper crossing of two segments; parallel and collinear segments
+        # never cross. Each span must leave `radius` of room either side.
+        def crossing(first, last, start, finish, radius)
+          point = axis_crossing(first, last, start, finish) ||
+                  slanted_crossing(first, last, start, finish)
+          return unless point && room?(point, first, last, radius) && room?(point, start, finish, radius)
+          return unless chord_fits?(first, last, point, radius)
+
+          point
+        end
+
+        # The arc chord, one radius either side of the crossing along the
+        # carrier's dominant axis. A horizontal/vertical carrier keeps the
+        # exact crossing. On a slanted carrier EA seats the centre on the
+        # integer grid at floor(crossing) and offsets it by the half-chord
+        # (radius, truncated radius * slope), signed with the line direction.
+        def chord(first, last, crossing, radius)
+          major = dominant_axis(first, last)
+          step = last[major] > first[major] ? radius : -radius
+          return axis_chord(first, crossing, major, step) if first[1 - major] == last[1 - major]
+
+          slanted_chord(first, last, crossing, major, step)
+        end
+
+        def slanted_chord(first, last, crossing, major, step)
+          centre = crossing.map { |value| (value + EPSILON).floor }
+          half = half_chord(first, last, major, step)
+          [-1, 1].map { |sign| centre.zip(half).map { |c, h| c + sign * h } }
+        end
+
+        def half_chord(first, last, major, step)
+          minor = 1 - major
+          slope = (last[minor] - first[minor]).fdiv(last[major] - first[major])
+          major.zero? ? [step, (step * slope).truncate] : [(step * slope).truncate, step]
+        end
+
+        def axis_chord(first, crossing, major, step)
+          start = crossing.dup
+          finish = crossing.dup
+          start[1 - major] = finish[1 - major] = first[1 - major]
+          start[major] -= step
+          finish[major] += step
+          [start, finish]
+        end
+
+        # Integer seating must not extend the decorated carrier past an end.
+        def chord_fits?(first, last, point, radius)
+          chord(first, last, point, radius).all? do |seat|
+            [0, 1].all? { |axis| within?(seat[axis], first[axis], last[axis]) }
+          end
+        end
+
+        def dominant_axis(first, last)
+          (last[0] - first[0]).abs >= (last[1] - first[1]).abs ? 0 : 1
+        end
+
+        def axis_crossing(first, last, start, finish)
+          axis = axis_for(first, last)
+          return unless axis && axis_for(start, finish) == 1 - axis
+
+          axis.zero? ? [start[0], first[1]] : [first[0], start[1]]
+        end
+
+        def slanted_crossing(first, last, start, finish)
+          return if axis_for(first, last) && axis_for(start, finish)
+
+          direction = delta(first, last)
+          other = delta(start, finish)
+          denominator = cross(direction, other)
+          return if denominator.zero?
+
+          advance(first, direction, cross(delta(first, start), other).fdiv(denominator))
+        end
+
+        def advance(origin, direction, fraction)
+          [origin[0] + fraction * direction[0], origin[1] + fraction * direction[1]]
+        end
+
+        def delta(from, to)
+          [to[0] - from[0], to[1] - from[1]]
+        end
+
+        def cross(one, other)
+          one[0] * other[1] - one[1] * other[0]
+        end
+
+        def room?(point, first, last, radius)
+          distance(point, first) >= radius && distance(point, last) >= radius &&
+            [0, 1].all? { |axis| within?(point[axis], first[axis], last[axis]) }
+        end
+
+        def within?(value, from, to)
+          minimum, maximum = [from, to].minmax
+          value >= minimum - EPSILON && value <= maximum + EPSILON
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter.rb

@@ -33,6 +33,8 @@ module Ea
       autoload :Connectors, "ea/svg/ea_emitter/connectors"
       autoload :ConnectorBridges, "ea/svg/ea_emitter/connector_bridges"
       private_constant :ConnectorBridges
+      autoload :SegmentGeometry, "ea/svg/ea_emitter/segment_geometry"
+      private_constant :SegmentGeometry
       autoload :Markers, "ea/svg/ea_emitter/markers"
       autoload :Labels, "ea/svg/ea_emitter/labels"
       autoload :GhostLabels, "ea/svg/ea_emitter/ghost_labels"

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.138"
+  VERSION = "0.6.139"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.138
+  version: 0.6.139
 platform: ruby
 authors:
 - Ribose Inc.
@@ -977,6 +977,7 @@ files:
 - 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/segment_geometry.rb
 - lib/ea/svg/ea_emitter/style.rb
 - lib/ea/svg/ea_emitter/text_renderer.rb
 - lib/ea/svg/ea_emitter/visibility_symbol.rb