ea 0.6.101 → 0.6.102

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c722ef7c5b7c7968f5beb08538b31b8090a3ab1533b0418a9600752c2724ef3
-  data.tar.gz: 818694e4771383a00ae453f76a7b3f98e79b6b5a839d9459d415ec72129e4226
+  metadata.gz: c453170a8a782786ce0a1061623c8de93ed75536228bb99d9b6c1857163f58f3
+  data.tar.gz: 19c5dc1e01e47508e51dfc87add4cd24059b4035b83ed45c5aa98d46d4edcb8b
 SHA512:
-  metadata.gz: b00b8fddbd7701f724dc20bd6640dfc53b7a99903d7a075581be94c9f3674254a114fa976a2a895d5ba231ca3b0c93f7b8ce241c42ef4d5c9e106f82c7b660a6
-  data.tar.gz: c41701279192e06adba33b39063dac26a9355dedf1a46fd687079013c341c880f8f3d83278876593cf27733c527f41e22032140b901246b0b6e335cf29dcb308
+  metadata.gz: 26fbc91c4d39c834e0e9a19c443501953b487210ea88922be813bf167dfb56c6d2cc55cb3238441f58a08a6cd7511560e495f787a05a566466e9e7c5f45b06b0
+  data.tar.gz: 79f6d211068cf179e2fee6eea24e2e0ae60385be826db2254dcb6ce3d3aab345d68c743f529d430b242f8ea0cc3fdda7425e6cf880cf984abf1b7aeec145d74c

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

@@ -23,6 +23,16 @@ module Ea
             set_stored_ray_origins(model, source, target, geom)
           end
 
+          def mark_default_square_ray(model, link_row, geom, context)
+            style = model.style.to_h
+            return model if context || !link_row.path.to_s.empty? || model.waypoints.size != 2
+            return model unless style[:mode] == "3" && style[:tree] == "OS" && style[:lwidth] == "2"
+            return model unless geom[:sx].nil? && geom[:sy].nil? && [geom[:ex], geom[:ey]] == [0, 0]
+
+            model.style = style.merge(default_square_ray: true)
+            model
+          end
+
           # A Mode 2 Generalization whose stored Path is a horizontal jog
           # between vertically separated boxes that overlap in x is EA's
           # auto-route: one vertical ray at the overlap midpoint plus SX.
@@ -100,30 +110,39 @@ module Ea
             return model unless stored_ray_candidate?(model, link_row, geom)
 
             source, target = stored_ray_boxes(link_row, diagram_row)
-            return model unless stored_ray_gap?(source, target, model.style[:mode], geom[:edge])
+            allowed = if normalized_port_anchors?(model)
+                        normalized_level_ray?(model, source, target, geom)
+                      else
+                        stored_ray_gap?(source, target, model.style[:mode], geom[:edge])
+                      end
+            return model unless allowed
 
             set_stored_ray_origins(model, source, target, geom)
           end
 
-          # An empty-Path Mode 3 Association with explicit offsets on both
-          # ends is the straight line between the two stored ray origins.
-          # Origins outside their own box are not a stored ray.
+          # An empty-Path Mode 3 Association follows the line between its
+          # stored endpoint origins; an omitted offset defaults to the center.
+          # The target origin must lie inside its own stroked outline.
           def association_stored_ray(model, link_row, diagram_row, geom, context)
             return model if context
             return model unless association_ray_candidate?(model, link_row)
 
             source, target = stored_ray_boxes(link_row, diagram_row)
-            origins = association_ray_origins(source, target, geom, model.style.to_h[:lwidth])
+            width = association_outline_width(model, link_row, diagram_row)
+            origins = association_ray_origins(source, target, geom, width)
             return model unless origins
 
-            model.waypoints = port_waypoints(model)
+            model.waypoints = port_waypoints(model, origins)
             model.source_anchor, model.target_anchor = origins
             model.style = model.style.to_h.merge(stored_association_ray: true, association_ray_outline: true)
+            if geom[:edge] == 1 && !inside_box?(origins.first, grown_bounds(source, width == "2" ? 1 : 0))
+              model.style[:stored_top_dock] = true
+            end
             model
           end
 
-          def port_waypoints(model)
-            [model.source_port, model.target_port].map do |point|
+          def port_waypoints(model, origins)
+            [model.source_port || origins.first, model.target_port || origins.last].map do |point|
               Ea::Model::Waypoint.new(position: point)
             end
           end
@@ -135,12 +154,41 @@ module Ea
             origins = [stored_ray_origin(source, geom[:sx], geom[:sy]),
                        stored_ray_origin(target, geom[:ex], geom[:ey])]
             boxes = [source, target].map { |box| grown_bounds(box, outline) }
-            inside = origins.zip(boxes).all? { |o, b| inside_box?(o, b) }
-            return unless inside && origins.first != origins.last
+            return unless origins.first != origins.last && association_origin_pair?(origins, boxes, width, geom[:edge])
 
             origins if width == "2" || sub_pixel_safe_origins?(origins, [source, target] + boxes)
           end
 
+          # An external source origin is a virtual point on the saved ray.
+          # It is usable only when that segment actually crosses the source.
+          def association_origin_pair?(origins, boxes, width, edge)
+            return false unless inside_box?(origins.last, boxes.last)
+            return true if inside_box?(origins.first, boxes.first)
+
+            return segment_crosses_box?(origins.first, origins.last, boxes.first) if width == "2"
+            return false unless edge == 1
+
+            source = boxes.first
+            top = Ea::Model::Bounds.new(x: source.x, y: source.y, width: source.width, height: 0)
+            segment_crosses_box?(origins.first, origins.last, top)
+          end
+
+          def segment_crosses_box?(first, last, box)
+            interval = [0.0, 1.0]
+            axes = [[first.x, last.x, box.x, box.x + box.width],
+                    [first.y, last.y, box.y, box.y + box.height]]
+            axes.all? do |origin, finish, low, high|
+              if origin == finish
+                origin.between?(low, high)
+              else
+                times = [(low - origin).to_f / (finish - origin),
+                         (high - origin).to_f / (finish - origin)].minmax
+                interval = [[interval.first, times.first].max, [interval.last, times.last].min]
+                interval.first <= interval.last
+              end
+            end
+          end
+
           def grown_bounds(bounds, amount)
             Ea::Model::Bounds.new(x: bounds.x - amount, y: bounds.y - amount,
                                   width: bounds.width + 2 * amount,
@@ -149,8 +197,21 @@ module Ea
 
           def association_ray_candidate?(model, link_row)
             model.connector_type == "Association" && link_row.path.to_s.empty? &&
-              model.has_geometry_offsets && model.source_port && model.target_port &&
-              association_ray_style?(model.style.to_h)
+              model.source_anchor && model.target_anchor &&
+              (model.source_port || model.target_port) && association_ray_style?(model.style.to_h)
+          end
+
+          # A thin connector still meets the outer stroke of explicitly
+          # bordered elements. Ambiguous placements must agree on that border.
+          def association_outline_width(model, link_row, diagram_row)
+            width = model.style[:lwidth]
+            return width if width == "2"
+
+            connector = database.find_connector(link_row.connectorid)
+            ids = [connector.start_object_id, connector.end_object_id]
+            placements = database.diagram_objects_for(diagram_row.diagram_id)
+            borders = placements.select { |placement| ids.include?(placement.ea_object_id) }
+            borders.all? { |placement| DiagramStyleParser.parse(placement.objectstyle)[:lwth] == "2" } ? "2" : width
           end
 
           def association_ray_style?(style)
@@ -263,7 +324,21 @@ module Ea
           def stored_ray_candidate?(model, link_row, geom)
             %w[Generalization Aggregation].include?(model.connector_type) &&
               model.waypoints.size == 2 && stored_ray_style?(model.style, link_row) &&
-              stored_ray_geometry?(model, geom) && !normalized_port_anchors?(model)
+              stored_ray_geometry?(model, geom)
+          end
+
+          # Boundary-port rounding can move a computed jog off a level saved
+          # ray. Equal stored origin rows specify the line before clipping.
+          def normalized_level_ray?(model, source, target, geom)
+            style = model.style.to_h
+            return false unless style[:mode] == "3" && style[:lwidth] == "2" &&
+                                horizontal_ray_gap?(source, target)
+
+            origins = [stored_ray_origin(source, geom[:sx], geom[:sy]),
+                       stored_ray_origin(target, geom[:ex], geom[:ey])]
+            boxes = [source, target].map { |box| grown_bounds(box, 1) }
+            origins.first.y == origins.last.y &&
+              origins.zip(boxes).all? { |origin, box| inside_box?(origin, box) }
           end
 
           def stored_ray_style?(style, link_row)

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

@@ -436,7 +436,8 @@ module Ea
           model = mode2_overlap_ray(model, link_row, diagram_row, geom, context)
           model = association_stored_ray(model, link_row, diagram_row, geom, context)
           model = correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
-          overlap_ray_origins(model, link_row, diagram_row, geom, context)
+          model = overlap_ray_origins(model, link_row, diagram_row, geom, context)
+          mark_default_square_ray(model, link_row, geom, context)
         end
 
         # Ray origin for one connector end: the element's center

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

@@ -46,7 +46,8 @@ module Ea
           original = clipped_pairs(bounds, anchors)
           unless stroke_outline?(connector, bounds) || overlap_ray?(connector) ||
                  bordered_outline?(connector, diagram, [source_ref, target_ref], bounds)
-            return original
+            pairs = default_square_pairs(connector, points, source_bounds, target_bounds, original)
+            return stored_top_pairs(connector, source_bounds, pairs)
           end
 
           # EA docks these markers on the outer edge of the 2px box stroke.
@@ -55,9 +56,48 @@ module Ea
                                   width: box.width + 2, height: box.height + 2)
           end
           candidate = clipped_pairs(outline, anchors)
-          forward_route?(original, candidate) ? candidate : original
+          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)
         end
 
+        # 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)
+          return pairs unless connector.connector_type == "Association" &&
+                              connector.style.to_h[:stored_top_dock] == true
+
+          first = connector.source_anchor
+          last = connector.target_anchor
+          return pairs unless first && last && first.y != last.y
+
+          ratio = (source.y - first.y).to_f / (last.y - first.y)
+          x_position = first.x + ratio * (last.x - first.x)
+          return pairs unless ratio.between?(0, 1) &&
+                              x_position.between?(source.x, source.x + source.width)
+
+          proposed = [[x_position.floor, source.y], pairs.last]
+          forward_route?(pairs, proposed) ? proposed : pairs
+        end
+        private_class_method :stored_top_pairs
+
+        # A square ray with an omitted source offset keeps its chosen side
+        # edge and projects that end to the clipped target's horizontal row.
+        def default_square_pairs(connector, points, source, target, pairs)
+          return pairs unless connector.style.to_h[:default_square_ray] == true
+          return pairs unless points.first[1] == points.last[1] &&
+                              on_side_edge?(points.first, source) && on_side_edge?(pairs.last, target)
+
+          first = [points.first[0], pairs.last[1]]
+          return pairs unless on_side_edge?(first, source)
+
+          proposed = [first, pairs.last]
+          forward_route?(points, proposed) ? proposed : pairs
+        end
+        private_class_method :default_square_pairs
+
         # A horizontal lateral tree the QEA builder derived as one level
         # line (internal style flag) keeps it between the facing side edges.
         def flush_lateral_line?(connector, points, source, target)

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.101"
+  VERSION = "0.6.102"
 end

metadata

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