ea 0.6.94 → 0.6.95

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2c872554c2534df450bc335593fb39ed9363f3fe20053ef001b1621c5cdec6b
-  data.tar.gz: 79cecbb5a25a07a38d5bac1df1aaf413ffbc471cdd39938cd64cdf8bca822ce7
+  metadata.gz: 87aea8f508b2ef7e8f98038519122caff0f87c967f3e59132838885124d0db84
+  data.tar.gz: 381aa0a30e5c9c3c60f0885f4fd2ca737d909f8fc620e36725e787db909898ab
 SHA512:
-  metadata.gz: d24168a33acbf362b4feff14508abb00562139e6602caed154c7f4b5e8bfa2b0f773b045fd27585f0610946f8fb2e4e9e6dbf2b8667ab785fc1bd71f18e9aa83
-  data.tar.gz: 1559678bc826ecdb82d710a72723709fa195907e8a11bb138eed728ba8b9804b30fcab7f75a024f27f8df34558ba52ec7f373e18bf1f46e6c7a89f07af8cf70b
+  metadata.gz: adba2730ddbc449a79ce0063273cb6f75c4fc88d219899e12e13bc4226d2d88d5ef438c062384d908296e62938d1b937c56b926043e89dc55b4d43a1d53c63c8
+  data.tar.gz: b677683c53a71f27f68c2c80f7b150517288751bdbf586d78ad0fbe986b014931b57659235587e4ba61b8753656de72f6949363291fd6f1ab2d6e1a0a70aa5d1

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

@@ -29,7 +29,9 @@ module Ea
             return false unless connector.connector_type == "Aggregation" && points.size == 4
 
             style = DiagramStyleParser.parse(link_row.style)
-            return false unless style[:tree] == "V" && style[:lwidth] == "2"
+            return false unless style[:lwidth] == "2" || flush_width_zero_tree?(link_row)
+            return false unless style[:tree] == "V" ||
+                                (style[:mode] == "3" && style[:tree].nil?)
 
             tree_bends_fit?(points[1], points[-2], src, tgt)
           end
@@ -78,6 +80,56 @@ module Ea
             end
           end
 
+          # A computed Mode 3 Generalization between horizontally disjoint
+          # boxes whose two explicit ports sit on the facing sides one pixel
+          # apart in y or less (edge-port integer rounding) is one horizontal line.
+          # Stored Path jogs and every other shape keep their route.
+          def collapse_computed_jog(model, link_row, diagram_row, geom)
+            return model unless computed_jog_candidate?(model, link_row, geom)
+
+            connection = database.find_connector(link_row.connectorid)
+            src, tgt = [connection.start_object_id, connection.end_object_id].map do |id|
+              placement = diagram_object_placement(diagram_row.diagram_id, id)
+              placement && bounds_from_rect(placement)
+            end
+            return model unless src && tgt && facing_jog_ports?(model.source_port, model.target_port, src, tgt)
+
+            ends = [[model.source_port.x, model.source_port.y],
+                    [model.target_port.x, model.source_port.y]].map do |x, y|
+              Ea::Model::Point.new(x: x, y: y)
+            end
+            model.waypoints = ends.map { |point| Ea::Model::Waypoint.new(position: point) }
+            model.source_anchor = model.source_port = ends.first
+            model.target_anchor = model.target_port = ends.last
+            model
+          end
+
+          def computed_jog_candidate?(model, link_row, geom)
+            style = model.style.to_h
+            model.connector_type == "Generalization" && geom[:edge] == 2 &&
+              link_row.path.to_s.empty? && style[:mode] == "3" && style[:lwidth] == "2" &&
+              !style.key?(:tree) && model.source_port && model.target_port &&
+              model.waypoints.size == 3
+          end
+
+          def facing_jog_ports?(from, to, src, tgt)
+            return false unless (from.y - to.y).abs <= 1 && from.y.between?(tgt.y, tgt.y + tgt.height)
+
+            if src.x + src.width < tgt.x
+              from.x == src.x + src.width && to.x == tgt.x
+            elsif tgt.x + tgt.width < src.x
+              from.x == src.x && to.x == tgt.x + tgt.width
+            else
+              false
+            end
+          end
+
+          # Width-0 vertical trees dock on the box edges themselves (no outline).
+          def flush_width_zero_tree?(link_row)
+            style = DiagramStyleParser.parse(link_row.style)
+            style[:mode] == "3" && style[:tree] == "V" && style[:lwidth] == "0"
+          end
+
           def tree_bends_fit?(first, last, source, target)
             first[0] != last[0] && first[1] == last[1] &&
               within_vertical_gap?(first[1], source, target) &&

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

@@ -385,7 +385,7 @@ module Ea
           geom = parse_geometry_fields(link_row.geometry)
           context = ContextDiagramSupport.package_context(diagram_row) ||
                     ContextDiagramSupport.element_regenerate?(diagram_row)
-          Ea::Model::DiagramConnector.new(
+          collapse_computed_jog(Ea::Model::DiagramConnector.new(
             id: IdNormalizer.synthetic("dc", diagram_row.diagram_id,
                                        link_row.instance_id),
             diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
@@ -409,7 +409,7 @@ module Ea
             ghost_labels: ghost_labels_for(connector, diagram_row, link_row),
             has_geometry_offsets: geometry_has_offsets?(link_row.geometry),
             is_substitutable: substitutable_connector?(connector)
-          )
+          ), link_row, diagram_row, geom)
         end
 
         # Ray origin for one connector end: the element's center
@@ -653,14 +653,16 @@ module Ea
             points = tree_route
           elsif %w[Association Aggregation].include?(connector.connector_type) &&
                 edge_out != 2
-            unless preserve_stored_tree?(points, link_row, connector, src, tgt)
+            stored_tree = preserve_stored_tree?(points, link_row, connector, src, tgt)
+            unless stored_tree
               points = facing_edge_route(points, src, tgt)
             end
             # A width-2 Aggregation that keeps its stored bends is
             # docked like a Generalization one.
             if connector.connector_type == "Aggregation" &&
                intermediate.any? && points.size >= 4 &&
-               generalization_outline_offset(link_row, points.size) == 1
+               (generalization_outline_offset(link_row, points.size) == 1 ||
+                (stored_tree && flush_width_zero_tree?(link_row)))
               redock_parent_above(points, link_row, source_placement,
                                   target_placement, strict: true)
             end

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

@@ -98,11 +98,30 @@ module Ea
 
         def stroke_outline?(connector, bounds)
           connector.style.to_h[:lwidth] == "2" &&
-            %w[Generalization Aggregation].include?(connector.connector_type) &&
-            bounds.all? { |box| box.width.positive? && box.height.positive? }
+            bounds.all? { |box| box.width.positive? && box.height.positive? } &&
+            outline_connector?(connector, bounds)
         end
         private_class_method :stroke_outline?
 
+        def outline_connector?(connector, bounds)
+          return true if %w[Generalization Aggregation].include?(connector.connector_type)
+
+          return false unless stored_association?(connector)
+
+          # Diagonal Association rounding and tree docks keep their existing rules.
+          pairs = clipped_pairs(bounds, [connector.source_anchor, connector.target_anchor])
+          pairs.first.zip(pairs.last).any? { |first, last| first == last }
+        end
+        private_class_method :outline_connector?
+
+        def stored_association?(connector)
+          style = connector.style.to_h
+          connector.connector_type == "Association" && connector.has_geometry_offsets &&
+            connector.source_port && connector.target_port &&
+            %w[1 3].include?(style[:mode]) && !style[:tree]
+        end
+        private_class_method :stored_association?
+
         def clipped_pairs(bounds, anchors)
           source, target = bounds
           source_anchor, target_anchor = anchors

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

@@ -22,15 +22,18 @@ module Ea
         DEFAULT_FAMILY = "Yu Gothic UI"
         DEFAULT_SIZE = 13
 
-        attr_reader :diagram, :canvas, :model_index, :theme, :document
+        attr_reader :diagram, :canvas, :model_index, :theme, :document,
+                    :drawn_bounds, :divider_y_by_ref
 
         def initialize(diagram, canvas: nil, model_index: nil, theme: nil,
-                       document: nil)
+                       document: nil, drawn_bounds: nil, divider_y_by_ref: nil)
           @diagram = diagram
           @canvas = canvas
           @model_index = model_index
           @theme = theme || Ea::Theme::Registry.default
           @document = document
+          @drawn_bounds = drawn_bounds
+          @divider_y_by_ref = divider_y_by_ref
         end
 
         def render
@@ -51,7 +54,7 @@ module Ea
           # in t_connector.Name but renders only inside the Note box.
           return [] if connector.connector_type.to_s.casecmp("NoteLink").zero?
 
-          points = waypoint_pairs(connector)
+          points = label_points(connector)
           return [] if points.size < 2
 
           texts = []
@@ -170,6 +173,19 @@ module Ea
           )
         end
 
+        # Two-point routes are clipped during emission, after their stored
+        # waypoints were parsed. End-label offsets follow the same final dock.
+        def label_points(connector)
+          points = waypoint_pairs(connector)
+          return points unless points.size == 2
+
+          points = ConnectorRedock.pairs_for(connector, diagram, model_index,
+                                             drawn_bounds) || points
+          ConnectorRedock.row_slot_adjust(points, connector, diagram,
+                                          model_index, drawn_bounds,
+                                          divider_y_by_ref) || points
+        end
+
         def waypoint_pairs(connector)
           (connector.waypoints || []).filter_map do |w|
             next unless w.position

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

@@ -83,7 +83,9 @@ module Ea
 
         def labels_layer
           Labels.new(diagram, canvas: canvas, model_index: model_index,
-                      theme: theme, document: document).render
+                              theme: theme, document: document,
+                              drawn_bounds: drawn_bounds,
+                              divider_y_by_ref: divider_y_by_ref).render
         end
 
         def ghost_labels_layer

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.94"
+  VERSION = "0.6.95"
 end

metadata

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