ea 0.6.97 → 0.6.99

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2ca3f0fd4381aec39af89849d601c85defa496b697f1fe625558c8a210aef64
-  data.tar.gz: adbc3773a202f06ad7327ace0fbea64daacea45a4719afb28959332673dafdcd
+  metadata.gz: 4b9e7581bab2de7d7c5766a5f141c99885bb59cbb7ad974c313c26e86bfb96a2
+  data.tar.gz: 8933e36fb2422953eddb1d60069664e39177547beaf2ec17ed17c5b9f3aa4eac
 SHA512:
-  metadata.gz: 99b878a17d58444e251964011cf2af59d46459223e657b8ffbf1a4602dc572af56e594bedd05c321cec0502d91e654cdd013d5b408277027d1c4f41c65885d3f
-  data.tar.gz: 73ef9107ec26ea7b60f7c9e5d00b7fa09b4d08b10842345c589a75dfd13a62b553287b95b0ad1b71e0c45fc032ab30ff1299fecb03e2a3abac69027a69180e97
+  metadata.gz: ab6882700d57207a5fd2c1b27fa0befe5f287bb61f13387e99dc8f4429dbede75320d9fb6124a126094455d38d4dff7a41dbfc258633609c6695c5dcd216b36d
+  data.tar.gz: 82cd636abfe8c20a03dc8f6c5410192c65e674093eaaabc081e8fc84b7ec6544a87f3c87ff255f90fcaa1bc0f7704fdf1b2e46f344cf9288cd51ec4a7e8cfa97

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

@@ -8,6 +8,41 @@ module Ea
         module Routing
           private
 
+          # An empty custom-line Path has no authored corner to preserve.
+          # Keep normalized port routes; replace only the computed EDGE2 jog.
+          def direct_empty_path_ray(model, link_row, diagram_row, geom, context)
+            return model if context
+            return model unless empty_path_ray_candidate?(model, link_row, geom)
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            return model unless empty_path_ray_gap?(source, target, geom)
+
+            model.waypoints = [model.source_port, model.target_port].map do |point|
+              Ea::Model::Waypoint.new(position: point)
+            end
+            set_stored_ray_origins(model, source, target, geom)
+          end
+
+          def empty_path_ray_gap?(source, target, geom)
+            return false unless source.x + source.width < target.x
+
+            [stored_ray_origin(source, geom[:sx], geom[:sy]),
+             stored_ray_origin(target, geom[:ex], geom[:ey])].all? do |origin|
+              within_height?(origin.y, source) && within_height?(origin.y, target)
+            end
+          end
+
+          def empty_path_ray_candidate?(model, link_row, geom)
+            %w[Generalization Aggregation].include?(model.connector_type) &&
+              model.waypoints.size == 3 && empty_path_ray_style?(model.style, link_row, geom) &&
+              model.has_geometry_offsets && model.source_port && model.target_port
+          end
+
+          def empty_path_ray_style?(style, link_row, geom)
+            style[:mode] == "3" && style[:lwidth] == "2" && !style[:tree] &&
+              geom[:edge] == 2 && link_row.path.to_s.empty?
+          end
+
           # Stored SY/EY use mathematical Y; ray origins use screen Y.
           # Computed-jog origins are already normalized to their derived ports.
           def correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
@@ -80,6 +115,85 @@ module Ea
                                  y: bounds.y + bounds.height / 2 - y_offset.to_i)
           end
 
+          # A vertical tree stores its trunk bend twice when the parent sits
+          # directly above; EA draws that as one bend.
+          def drop_zero_length_tree_segments(points, link_row)
+            return points unless points.size == 4 && points[1] == points[2] &&
+                                 DiagramStyleParser.parse(link_row.style)[:tree] == "V"
+
+            points.values_at(0, 1, 3)
+          end
+
+          # A stored vertical tree trunk docks both ends on the box edges that
+          # face its bends, at the adjacent bend's x: Aggregations without
+          # geometry offsets whose child sits below, and flush Associations
+          # whose parent sits above. Other shapes keep their stored docks.
+          def redock_vertical_tree_trunk(points, link_row, connector, source_placement, target_placement)
+            style = DiagramStyleParser.parse(link_row.style)
+            return unless points.size == 4 && style[:tree] == "V"
+
+            case connector.connector_type
+            when "Aggregation"
+              return if geometry_has_offsets?(link_row.geometry)
+
+              redock_child_below(points, bounds_from_rect(source_placement), bounds_from_rect(target_placement))
+            when "Association"
+              return unless style[:lwidth] == "0"
+
+              redock_parent_above(points, link_row, source_placement, target_placement, strict: true)
+            end
+          end
+
+          def redock_child_below(points, src_b, tgt_b)
+            first_bend, last_bend = points.values_at(1, -2)
+            source_y = src_b.y + src_b.height
+            return points unless source_y <= tgt_b.y && first_bend[1] > source_y && last_bend[1] < tgt_b.y
+
+            points[0] = [clamp_to_span(first_bend[0], src_b), source_y]
+            points[-1] = [clamp_to_span(last_bend[0], tgt_b), tgt_b.y]
+            points
+          end
+
+          def clamp_to_span(position, bounds)
+            position.clamp(bounds.x, bounds.x + bounds.width)
+          end
+
+          # A stored-Path Mode 3 width-2 end whose adjacent bend lies level
+          # with its box (inside the box's span on one axis, outside on the
+          # other) enters the box orthogonally on the outer outline at that
+          # bend's coordinate. Bends that are not level keep the port and
+          # every authored corner stays.
+          def level_entry_route(points, link_row, connector, src, tgt)
+            return points unless points.size >= 3 && level_entry_style?(link_row, connector)
+
+            route = points.dup
+            first = level_entry_point(route[1], src)
+            last = level_entry_point(route[-2], tgt)
+            route[0] = first if first
+            route[-1] = last if last
+            route
+          end
+
+          def level_entry_style?(link_row, connector)
+            style = DiagramStyleParser.parse(link_row.style)
+            %w[Generalization Aggregation].include?(connector.connector_type) &&
+              style[:mode] == "3" && style[:lwidth] == "2" && !style.key?(:tree)
+          end
+
+          def level_entry_point(bend, box)
+            level_y = bend[1] > box.y && bend[1] < box.y + box.height
+            level_x = bend[0] > box.x && bend[0] < box.x + box.width
+            if level_y && outside_span?(bend[0], box.x, box.width)
+              [bend[0] < box.x ? box.x - 1 : box.x + box.width + 1, bend[1]]
+            elsif level_x && outside_span?(bend[1], box.y, box.height)
+              [bend[0], bend[1] < box.y ? box.y - 1 : box.y + box.height + 1]
+            end
+          end
+
+          def outside_span?(value, start, length)
+            value < start || value > start + length
+          end
+
           # Square routing keeps the stored orthogonal trunk, even when a
           # shorter facing-edge route exists between the same boxes.
           def stored_square_route(link_row, connector, source, target)
@@ -129,19 +243,29 @@ module Ea
 
           # A valid lateral corner joins one vertical leg and one horizontal
           # leg. Keep it even when the boxes also admit a shorter direct route.
-          def stored_lateral_route(link_row, connector, source, target)
+          # ported: both ends carry explicit SX/SY and EX/EY offsets. An
+          # untyped corner without them may be an authored diagonal.
+          def stored_lateral_route(link_row, connector, source, target, ported: false)
             return nil unless %w[Aggregation Association].include?(connector.connector_type)
 
             style = DiagramStyleParser.parse(link_row.style)
-            return nil unless stored_lateral_style?(style)
+            return nil unless stored_lateral_style?(style, connector, ported)
 
             corner = stored_lateral_corner(link_row)
-            return nil unless corner
+            corner && lateral_corner_route(style, corner, source, target)
+          end
 
-            if style[:tree] == "LH"
-              horizontal_corner_route(corner, source, target)
+          # An untyped Mode 3 Association corner takes whichever leg
+          # orientation its position fits; width-2 docks sit on the 1px
+          # outer outline.
+          def lateral_corner_route(style, corner, source, target)
+            case style[:tree]
+            when "LH" then horizontal_corner_route(corner, source, target)
+            when "LV" then vertical_corner_route(corner, source, target)
             else
-              vertical_corner_route(corner, source, target)
+              outline = style[:lwidth] == "2" ? 1 : 0
+              horizontal_corner_route(corner, source, target, outline) ||
+                vertical_corner_route(corner, source, target, outline)
             end
           end
 
@@ -151,8 +275,11 @@ module Ea
             intermediate_waypoints(link_row).first
           end
 
-          def stored_lateral_style?(style)
-            style[:mode] == "3" && %w[0 2].include?(style[:lwidth]) && %w[LH LV].include?(style[:tree])
+          def stored_lateral_style?(style, connector, ported)
+            return false unless style[:mode] == "3" && %w[0 2].include?(style[:lwidth])
+
+            %w[LH LV].include?(style[:tree]) ||
+              (style[:tree].nil? && ported && connector.connector_type == "Association")
           end
 
           def horizontal_corner?(corner, source, target)
@@ -160,13 +287,13 @@ module Ea
               !within_height?(corner[1], source) && !within_horizontal_span?(corner, target)
           end
 
-          def horizontal_corner_route(corner, source, target)
+          def horizontal_corner_route(corner, source, target, outline = 0)
             return nil unless horizontal_corner?(corner, source, target)
 
             x, y = corner
 
-            source_y = y < source.y ? source.y : source.y + source.height
-            target_x = x < target.x ? target.x : target.x + target.width
+            source_y = y < source.y ? source.y - outline : source.y + source.height + outline
+            target_x = x < target.x ? target.x - outline : target.x + target.width + outline
             [[x, source_y], corner, [target_x, y]]
           end
 
@@ -175,13 +302,13 @@ module Ea
               !within_horizontal_span?(corner, source) && !within_height?(corner[1], target)
           end
 
-          def vertical_corner_route(corner, source, target)
+          def vertical_corner_route(corner, source, target, outline = 0)
             return nil unless vertical_corner?(corner, source, target)
 
             x, y = corner
 
-            source_x = x < source.x ? source.x : source.x + source.width
-            target_y = y < target.y ? target.y : target.y + target.height
+            source_x = x < source.x ? source.x - outline : source.x + source.width + outline
+            target_y = y < target.y ? target.y - outline : target.y + target.height + outline
             [[source_x, y], corner, [x, target_y]]
           end
 

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

@@ -16,16 +16,11 @@ module Ea
 
         attr_reader :database
 
-        # Generalizations whose EA CustomProperties carry
-        # isSubstitutable draw '{isSubstitutable=false}' at the label
-        # seat (t_xref 'connector property' rows keyed by connector
-        # guid; VALU 0/empty both mean false).
+        # This flag requests the false annotation, not the property's Boolean
+        # value. An explicit true (-1) must not request a false annotation.
         def substitutable_connector?(conn)
-          @substitutable_guids ||= database.collections[:xrefs]
-                                           .select do |x|
-            x.xref_type == "connector property" &&
-              x.name == "CustomProperties" &&
-              x.description.to_s.include?("isSubstitutable")
+          @substitutable_guids ||= database.collections[:xrefs].select do |xref|
+            false_substitutability_xref?(xref)
           end.map(&:client).to_set
           @substitutable_guids.include?(conn.ea_guid)
         end
@@ -99,6 +94,22 @@ module Ea
 
         private
 
+        def false_substitutability_xref?(xref)
+          return false unless xref.xref_type == "connector property" && xref.name == "CustomProperties"
+
+          description = xref.description.to_s
+          description.include?("isSubstitutable") && !true_substitutability_property?(description)
+        end
+
+        def true_substitutability_property?(description)
+          description.scan(/@PROP=(.*?)@ENDPROP;/m).any? do |match|
+            property = match.first
+            property.include?("@NAME=isSubstitutable@ENDNAME;") &&
+              property.include?("@TYPE=Boolean@ENDTYPE;") &&
+              property[/@VALU=(.*?)@ENDVALU;/m, 1] == "-1"
+          end
+        end
+
         def build_elements(diagram_row)
           objs = database.diagram_objects_for(diagram_row.diagram_id) || []
           objs.map { |obj_row| build_element(obj_row, diagram_row) }
@@ -410,6 +421,7 @@ module Ea
             has_geometry_offsets: geometry_has_offsets?(link_row.geometry),
             is_substitutable: substitutable_connector?(connector)
           ), link_row, diagram_row, geom)
+          model = direct_empty_path_ray(model, link_row, diagram_row, geom, context)
           correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
         end
 
@@ -650,7 +662,8 @@ module Ea
           src = bounds_from_rect(source_placement)
           tgt = bounds_from_rect(target_placement)
           tree_route = stored_square_route(link_row, connector, src, tgt) ||
-                       stored_lateral_route(link_row, connector, src, tgt) ||
+                       stored_lateral_route(link_row, connector, src, tgt,
+                                            ported: source_port && target_port) ||
                        horizontal_tree_route(points, link_row, connector, src, tgt)
           if tree_route
             points = tree_route
@@ -669,8 +682,15 @@ module Ea
               redock_parent_above(points, link_row, source_placement,
                                   target_placement, strict: true)
             end
+            if intermediate.any?
+              redock_vertical_tree_trunk(points, link_row, connector, source_placement, target_placement)
+            end
           end
 
+          if intermediate.any? && !tree_route
+            points = level_entry_route(points, link_row, connector, src, tgt)
+          end
+          points = drop_zero_length_tree_segments(points, link_row)
           points.map do |x, y|
             Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
           end

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

@@ -209,18 +209,46 @@ module Ea
                       divider_y_by_ref[target_ref]]
           return nil unless bounds.all? && dividers.all?
 
-          adjusted = row_slot_pairs(pairs, bounds, dividers)
+          preserve_source = explicit_horizontal_source_dock?(pairs, connector)
+          adjusted = row_slot_pairs(pairs, bounds, dividers, preserve_source: preserve_source)
           if stroke_outline?(connector, bounds) &&
              pairs == pairs_for(connector, diagram, model_index, bounds_map)
             original = clipped_pairs(bounds, [connector.source_anchor, connector.target_anchor])
-            original_final = row_slot_pairs(original, bounds, dividers)
+            original_final = row_slot_pairs(original, bounds, dividers, preserve_source: preserve_source)
             adjusted = original_final if original != pairs && !forward_route?(original_final, adjusted)
           end
           adjusted == pairs ? nil : adjusted
         end
 
-        def row_slot_pairs(pairs, bounds, dividers)
+        # A supplied horizontal port already specifies its row. Moving it
+        # to the next compartment row would discard that explicit coordinate.
+        def explicit_horizontal_source_dock?(pairs, connector)
+          return false unless explicit_horizontal_ray?(connector)
+
+          connector.source_anchor.y == connector.target_anchor.y &&
+            connector.source_port.y == connector.source_anchor.y &&
+            pairs.first[1] == connector.source_port.y
+        end
+        private_class_method :explicit_horizontal_source_dock?
+
+        def explicit_horizontal_ray?(connector)
+          explicit_horizontal_ray_style?(connector) && connector.has_geometry_offsets &&
+            connector.source_port && connector.target_port &&
+            connector.source_anchor && connector.target_anchor
+        end
+        private_class_method :explicit_horizontal_ray?
+
+        def explicit_horizontal_ray_style?(connector)
+          style = connector.style.to_h
+          %w[Generalization Aggregation].include?(connector.connector_type) &&
+            style[:mode] == "3" && !style[:tree] && !style[:direct] && !style[:regenerated]
+        end
+        private_class_method :explicit_horizontal_ray_style?
+
+        def row_slot_pairs(pairs, bounds, dividers, preserve_source: false)
           pairs.each_with_index.map do |(x, y), index|
+            next [x, y] if preserve_source && index.zero?
+
             row_slot?(x, y, bounds[index], dividers[index]) ? [x, y + ROW_SLOT_PITCH] : [x, y]
           end
         end

data/lib/ea/svg/ea_emitter/label/end_label.rb

@@ -22,6 +22,10 @@ module Ea
           SEAT_FONT_SIZE = 7
           SEAT_X_INSET = 3
           SEAT_STEREOTYPE_GAP = 12
+          # EA keeps an upward property seat's left edge at diagram x >= 3;
+          # the stereotype line moves with the role. Measured only for the
+          # default Cambria 7pt boxed cluster.
+          MIN_ROLE_X = 3
 
           attr_reader :canvas, :model_index, :document, :theme,
                       :font_family, :font_size, :font_unit
@@ -86,12 +90,15 @@ module Ea
             stereo = stereo.nil? || stereo.empty? ? nil : "«#{stereo}»"
             direction = leg_direction(end_kind, heading)
             if direction && !(tree && zero_offset?(text_box, mult_box))
-              text_pos = source_property_seat(connector, direction, anchor, text_box, role) ||
+              text_pos = plain_vertical_role(connector, direction, anchor, text_box, role) ||
+                         source_property_seat(connector, direction, anchor, text_box, role) ||
                          plain_upward_seat(connector, direction, anchor, text_box, role) ||
                          role_seat(direction, anchor, text_box, role) || text_pos
               mult_pos = directional_multiplicity(connector, direction, anchor, mult_box, mult) ||
                          mult_seat(direction, anchor, mult_box) || mult_pos
             elsif end_kind == :target && !(tree && zero_offset?(text_box, mult_box))
+              text_pos = target_vertical_role(connector, heading, anchor, text_box, role) ||
+                         target_rightward_role(heading, anchor, text_box, role) || text_pos
               mult_pos = target_multiplicity_seat(heading, anchor, mult_box) || mult_pos
             end
 
@@ -185,7 +192,9 @@ module Ea
 
             x, y = seat_corner(anchor, box)
             inset, baseline = property_role_offsets(direction)
-            [x - inset - width, y + baseline]
+            left = x - inset - width
+            left = [left, MIN_ROLE_X].max if direction == :up
+            [left, y + baseline]
           end
 
           def plain_upward_seat(connector, direction, anchor, box, role)
@@ -201,6 +210,61 @@ module Ea
             [x - SEAT_X_INSET - width, y - 6]
           end
 
+          def target_vertical_role(connector, heading, anchor, box, role)
+            return nil unless heading && heading[0].zero? && !heading[1].zero?
+
+            direction = heading[1].negative? ? :target_up : :target_down
+            plain_vertical_role(connector, direction, anchor, box, role)
+          end
+
+          # A target whose leg arrives from the right seats its role like a
+          # source whose leg leaves to the right.
+          def target_rightward_role(heading, anchor, box, role)
+            return nil unless heading && heading[1].zero? && heading[0].positive?
+            return nil unless seat_font? && cambria_box?(box) && !role_empty?(role)
+
+            x, y = seat_corner(anchor, box)
+            [x + SEAT_X_INSET, y - 7]
+          end
+
+          def plain_vertical_role(connector, direction, anchor, box, role)
+            return nil unless %i[down target_up target_down].include?(direction) &&
+                              plain_vertical_box?(box)
+
+            end_kind = direction == :down ? :source : :target
+            return nil unless plain_vertical_connector?(connector, end_kind, direction)
+
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, box)
+            [x - width - 8, y + (direction == :target_up ? -7 : 15)]
+          end
+
+          def plain_vertical_box?(box)
+            seat_font? && cambria_box?(box) && [0, 1].include?(box["alignment"])
+          end
+
+          # A target leg that runs down seats only on the "LV" tree route
+          # with line width 2; every other vertical seat needs the plain
+          # width-0 route.
+          def plain_vertical_connector?(connector, end_kind, direction)
+            return false unless connector.connector_type == "Association" &&
+                                connector_source_dest_stereotype(connector, end_kind).empty?
+
+            plain_vertical_style?(connector.style.to_h, direction)
+          end
+
+          def plain_vertical_style?(style, direction)
+            return false unless style[:mode] == "3"
+
+            if direction == :target_down
+              style[:lwidth] == "2" && style[:tree] == "LV"
+            else
+              style[:lwidth] == "0" && !style[:tree]
+            end
+          end
+
           def plain_role_route?(style)
             %w[1 3].include?(style[:mode]) && %w[0 2].include?(style[:lwidth]) &&
               [nil, "V"].include?(style[:tree])
@@ -229,7 +293,7 @@ module Ea
             case direction
             when :left then left_property_route?(style)
             when :down then downward_property_route?(style)
-            else style[:lwidth] == "2" && style[:tree] != "OS"
+            else %w[0 2].include?(style[:lwidth]) && style[:tree] != "OS"
             end
           end
 

data/lib/ea/svg/ea_emitter/label/midpoint_label.rb

@@ -96,6 +96,9 @@ module Ea
           LINE_PITCH = 13
 
           def label_position(connector, points)
+            name_seat = stored_name_position(connector, points)
+            return name_seat if name_seat
+
             return midpoint(points) unless default_substitutable_seat?(connector) &&
                                            upward_four_point_route?(points)
 
@@ -103,6 +106,40 @@ module Ea
             [source[0] + 3, ((source[1] + bend[1]) / 2).floor - 1]
           end
 
+          # At 7pt, a centered name's stored corner is 3px below its baseline.
+          def stored_name_position(connector, points)
+            box = stored_name_box(connector)
+            return nil unless box
+
+            width = Ea::Fonts::Metrics.text_length(midpoint_content(connector), font_size, family: font_family)
+            return nil unless width
+
+            x, y = midpoint(points)
+            offset_x, offset_y = box.values_at("ox", "oy").map(&:to_i)
+            [x + offset_x - (width / 2.0).floor, y + offset_y - 3]
+          end
+
+          def stored_name_box(connector)
+            return nil unless connector.is_a?(Ea::Model::DiagramConnector) && measured_name_font?
+            return nil if connector.is_substitutable || stereotype_label(connector)
+            return nil if midpoint_content(connector).include?(": ")
+
+            box = connector.label_boxes.to_h[:lmt]
+            box if default_name_box?(box)
+          end
+
+          def measured_name_font?
+            font_family.to_s.casecmp("Cambria").zero? && font_size == 7 && font_unit == "pt"
+          end
+
+          def default_name_box?(box)
+            return false unless box && box["alignment"] == 1
+            return false unless box.values_at("ox", "oy").all?
+            return false unless [nil, 0, 1].include?(box["direction"]) && [nil, -1].include?(box["color"])
+
+            box["rotation"].to_i.zero? && box.values_at("bold", "italic", "underline", "hidden").none?
+          end
+
           def default_substitutable_seat?(connector)
             connector.is_a?(Ea::Model::DiagramConnector) && connector.is_substitutable &&
               connector.connector_type == "Generalization" && font_size == 7 &&

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

@@ -97,7 +97,7 @@ module Ea
                              mult_box: tgt_mb,
                              anchor: target_pt, connector: connector,
                              end_kind: :target, tree: tree && tree[:target],
-                             heading: stored_tgt && leg_heading(points.reverse),
+                             heading: stored_tgt && target_heading(connector, points),
                              stored_labels: stored_labels).each { |t| texts << t }
           texts
         end
@@ -126,6 +126,19 @@ module Ea
           stored_upward_heading(connector, heading)
         end
 
+        # A target dock that clips an axis-aligned stored leg into a slight
+        # diagonal keeps the stored leg's direction.
+        def target_heading(connector, points)
+          heading = leg_heading(points.reverse)
+          return heading unless points.size == 2 && heading.none?(&:zero?)
+
+          stored = waypoint_pairs(connector)
+          return heading unless stored.size == 2
+
+          original = leg_heading(stored.reverse)
+          original.any?(&:zero?) ? original : heading
+        end
+
         def stored_upward_heading(connector, heading)
           return heading unless heading[1].negative?
 

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.97"
+  VERSION = "0.6.99"
 end

metadata

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