ea 0.6.95 → 0.6.96

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87aea8f508b2ef7e8f98038519122caff0f87c967f3e59132838885124d0db84
-  data.tar.gz: 381aa0a30e5c9c3c60f0885f4fd2ca737d909f8fc620e36725e787db909898ab
+  metadata.gz: 3b98c8ee8bf786f5160291763db47b38d8213a029ef4d647df1d73c386551dba
+  data.tar.gz: 3f0ee88fdb07d831f70e1ec51f634048140887a5231baa3dc0eea778a7f60d7a
 SHA512:
-  metadata.gz: adba2730ddbc449a79ce0063273cb6f75c4fc88d219899e12e13bc4226d2d88d5ef438c062384d908296e62938d1b937c56b926043e89dc55b4d43a1d53c63c8
-  data.tar.gz: b677683c53a71f27f68c2c80f7b150517288751bdbf586d78ad0fbe986b014931b57659235587e4ba61b8753656de72f6949363291fd6f1ab2d6e1a0a70aa5d1
+  metadata.gz: f0297306864b343dc4bdd5cae1c6cdaabeb7a5bb043cc592c76f11c5b42cfce4e7895bbfb3e92c51a263072203ca7e46b5eb3640633856474afbdc22798db2ba
+  data.tar.gz: de6096010a2802088ea9d8cee6fa9105c1b6622f4de8b89274668a5231645fd19727ad7633c74db66fbc6be04f70009f0d4d270f8ba4440189ff282f168d1313

data/config/themes/119.yml

@@ -10,6 +10,9 @@ font:
   weight_normal: 400
   weight_bold: 700
 
+label_font:
+  family: Cambria
+
 # Element-level font (distinct from diagram-level frame font).
 # EA renders classifier compartments at this size regardless of
 # the diagram-level font.size.

data/lib/ea/fonts/cambria_7_regular_widths.json

@@ -0,0 +1,77 @@
+{
+  " ": 2,
+  "(": 4,
+  ")": 4,
+  "*": 4,
+  "+": 6,
+  "-": 3,
+  ".": 2,
+  "0": 6,
+  "1": 6,
+  "2": 6,
+  "3": 6,
+  "4": 6,
+  "5": 6,
+  "6": 6,
+  "8": 6,
+  "9": 6,
+  ":": 3,
+  "<": 6,
+  "=": 6,
+  ">": 6,
+  "A": 6,
+  "B": 6,
+  "C": 6,
+  "D": 7,
+  "E": 6,
+  "F": 5,
+  "G": 6,
+  "H": 7,
+  "I": 3,
+  "K": 6,
+  "L": 5,
+  "M": 8,
+  "N": 7,
+  "O": 7,
+  "P": 6,
+  "Q": 7,
+  "R": 6,
+  "S": 5,
+  "T": 6,
+  "U": 6,
+  "V": 6,
+  "W": 9,
+  "X": 6,
+  "Y": 6,
+  "Z": 5,
+  "[": 4,
+  "]": 4,
+  "a": 5,
+  "b": 5,
+  "c": 4,
+  "d": 6,
+  "e": 5,
+  "f": 3,
+  "g": 5,
+  "h": 6,
+  "i": 3,
+  "j": 3,
+  "k": 5,
+  "l": 3,
+  "m": 8,
+  "n": 6,
+  "o": 5,
+  "p": 6,
+  "q": 5,
+  "r": 4,
+  "s": 4,
+  "t": 3,
+  "u": 6,
+  "v": 5,
+  "w": 8,
+  "x": 5,
+  "y": 5,
+  "z": 5,
+  "{": 4,
+  "}": 4
+}

data/lib/ea/fonts/metrics.rb

@@ -29,9 +29,18 @@ module Ea
         "calibri" => "Carlito",
         "carlito" => "Carlito",
         "arial" => "Arial",
-        "arial narrow" => "Arial Narrow"
+        "arial narrow" => "Arial Narrow",
+        "cambria" => "Cambria"
       }.freeze
 
+      # Cambria measurements are in SVG units at 7pt, not em advances.
+      # Unmeasured characters and other sizes/styles must use the fallback.
+      CAMBRIA_7_REGULAR_WIDTHS = JSON.parse(File.read(
+                                              File.expand_path("cambria_7_regular_widths.json", __dir__)
+                                            )).freeze
+      CAMBRIA_7_GUILLEMET_PAIR_WIDTH = 10
+      private_constant :CAMBRIA_7_REGULAR_WIDTHS, :CAMBRIA_7_GUILLEMET_PAIR_WIDTH
+
       # Advance used for codepoints missing from the tables.
       DEFAULT_ADVANCE = 0.25
 
@@ -64,6 +73,12 @@ module Ea
         return nil unless supported_family?(family)
         return nil if text.nil? || text.empty?
 
+        return cambria_text_length(text, size_pt, weight, style) if resolve_family(family) == "Cambria"
+
+        advance_text_length(text, size_pt, family, weight, style)
+      end
+
+      def advance_text_length(text, size_pt, family, weight, style)
         resolved = resolve_family(family)
         if GDI_HEIGHT_FAMILIES.include?(resolved)
           height = (size_pt.to_f * 10 / 7).round
@@ -86,6 +101,26 @@ module Ea
          cjk_count * CJK_ADVANCE * size_pt.to_f).round(3)
       end
 
+      private_class_method :advance_text_length
+
+      def cambria_text_length(text, size_pt, weight, style)
+        return nil unless size_pt.to_f.to_r == 7
+        return nil unless ["", "0", "400", "normal"].include?(weight.to_s)
+        return nil unless ["", "normal"].include?(style.to_s)
+
+        return cambria_ascii_length(text) unless text.start_with?("«") && text.end_with?("»")
+
+        inner_width = cambria_ascii_length(text[1...-1])
+        inner_width + CAMBRIA_7_GUILLEMET_PAIR_WIDTH if inner_width
+      end
+      private_class_method :cambria_text_length
+
+      def cambria_ascii_length(text)
+        widths = text.each_char.map { |char| CAMBRIA_7_REGULAR_WIDTHS[char] }
+        widths.sum unless widths.empty? || widths.include?(nil)
+      end
+      private_class_method :cambria_ascii_length
+
       # Families whose EA driver quantizes per-glyph advances
       # (fitted from published textLengths).
       GDI_HEIGHT_FAMILIES = %w[Carlito].freeze

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

@@ -8,6 +8,115 @@ module Ea
         module Routing
           private
 
+          # 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)
+            return nil unless stored_square_style?(link_row, connector)
+
+            corners = stored_square_corners(link_row)
+            square_corner_route(corners, source, target) if corners
+          end
+
+          def stored_square_style?(link_row, connector)
+            style = DiagramStyleParser.parse(link_row.style)
+            %w[Association Aggregation Generalization].include?(connector.connector_type) &&
+              style[:mode] == "3" && style[:tree] == "OS" && style[:lwidth] == "2"
+          end
+
+          def stored_square_corners(link_row)
+            return nil unless link_row.path.to_s.match?(/\A(?:-?\d+:-?\d+;)*-?\d+:-?\d+;?\z/)
+
+            corners = intermediate_waypoints(link_row)
+            corners if corners.each_cons(2).all? { |a, b| a[0] == b[0] || a[1] == b[1] }
+          end
+
+          def square_corner_route(corners, source, target)
+            first = square_corner_dock(corners.first, source)
+            last = square_corner_dock(corners.last, target)
+            return nil unless first && last
+
+            points = corners.dup
+            points.unshift(first) unless points.first == first
+            points.push(last) unless points.last == last
+            points if points.size >= 3
+          end
+
+          def square_corner_dock(corner, bounds)
+            x, y = corner
+            projected = [x.clamp(bounds.x, bounds.x + bounds.width),
+                         y.clamp(bounds.y, bounds.y + bounds.height)]
+            return nil if projected[0] != x && projected[1] != y
+
+            projected if rectangle_edge?(projected, bounds)
+          end
+
+          def rectangle_edge?(point, bounds)
+            [bounds.x, bounds.x + bounds.width].include?(point[0]) ||
+              [bounds.y, bounds.y + bounds.height].include?(point[1])
+          end
+
+          # 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)
+            return nil unless %w[Aggregation Association].include?(connector.connector_type)
+
+            style = DiagramStyleParser.parse(link_row.style)
+            return nil unless stored_lateral_style?(style)
+
+            corner = stored_lateral_corner(link_row)
+            return nil unless corner
+
+            if style[:tree] == "LH"
+              horizontal_corner_route(corner, source, target)
+            else
+              vertical_corner_route(corner, source, target)
+            end
+          end
+
+          def stored_lateral_corner(link_row)
+            return nil unless link_row.path.to_s.match?(/\A-?\d+:-?\d+;?\z/)
+
+            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])
+          end
+
+          def horizontal_corner?(corner, source, target)
+            within_horizontal_span?(corner, source) && within_height?(corner[1], target) &&
+              !within_height?(corner[1], source) && !within_horizontal_span?(corner, target)
+          end
+
+          def horizontal_corner_route(corner, source, target)
+            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
+            [[x, source_y], corner, [target_x, y]]
+          end
+
+          def vertical_corner?(corner, source, target)
+            within_height?(corner[1], source) && within_horizontal_span?(corner, target) &&
+              !within_horizontal_span?(corner, source) && !within_height?(corner[1], target)
+          end
+
+          def vertical_corner_route(corner, source, target)
+            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, y], corner, [x, target_y]]
+          end
+
+          def within_height?(height, bounds)
+            height.between?(bounds.y, bounds.y + bounds.height)
+          end
+
           # A lateral tree leaves the side edge before turning upward.
           # Keep that dock only when its first leg actually points outward.
           def lateral_source_exit?(points, link_row, bounds)

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

@@ -648,7 +648,9 @@ module Ea
           # EDGE=2 routes are excluded; they are already exact.
           src = bounds_from_rect(source_placement)
           tgt = bounds_from_rect(target_placement)
-          tree_route = horizontal_tree_route(points, link_row, connector, src, tgt)
+          tree_route = stored_square_route(link_row, connector, src, tgt) ||
+                       stored_lateral_route(link_row, connector, src, tgt) ||
+                       horizontal_tree_route(points, link_row, connector, src, tgt)
           if tree_route
             points = tree_route
           elsif %w[Association Aggregation].include?(connector.connector_type) &&

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

@@ -75,11 +75,8 @@ module Ea
               text_pos, mult_pos = tree_positions(end_kind, anchor, role,
                                                   text_pos, mult_pos)
             elsif mult_box && stored_offsets_zero?(mult_box)
-              # A stored mult box with OX=0:OY=0 means "EA default":
-              # the multiplicity sits 12px right of and 15px below the
-              # endpoint anchor, regardless of line direction
-              # (87-sample corpus fit: dy = +15 constant, dx = +12
-              # dominant with a +3 minority).
+              # Start at the legacy default; measured directional seats
+              # below replace it for default Cambria labels.
               mult_pos = [anchor[0] + 12, anchor[1] + 15]
             end
             # The end's stored stereotype renders verbatim («Type» on
@@ -89,8 +86,11 @@ 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 = role_seat(direction, anchor, text_box, role) || text_pos
-              mult_pos = mult_seat(direction, anchor, mult_box) || mult_pos
+              text_pos = 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
             end
 
             build_texts(role:, mult:, standalone:,
@@ -147,19 +147,22 @@ module Ea
           # right: the multiplicity 6px above it on an upward leg and
           # 15px below it on a rightward one, the role 7px above it on
           # a rightward one. Other sizes, headings, the target end,
-          # custom presentation keep their offsets; zero multiplicity boxes keep their default seat.
+          # custom presentation keep their offsets. Zero multiplicity boxes
+          # follow the direction for Cambria and keep the default otherwise.
           def leg_direction(end_kind, heading)
             return nil unless source_seat?(end_kind, heading)
 
             dx, dy = heading
             return :up if dx.zero? && dy.negative?
             return :right if dy.zero? && dx.positive?
+            return :left if dy.zero? && dx.negative?
+            return :down if dx.zero? && dy.positive?
 
             nil
           end
 
           # Role text on a rightward leg is left-aligned at the corner,
-          # 7px above it. Upward legs keep the plain role offset.
+          # 7px above it.
           def role_seat(direction, anchor, box, role)
             return nil unless direction == :right
             return nil if box.nil? || role_empty?(role)
@@ -169,8 +172,93 @@ module Ea
             [x + SEAT_X_INSET, y - 7]
           end
 
+          # Property-role clusters use a direction-specific right edge;
+          # alignment controls the stereotype line within that cluster.
+          def source_property_seat(connector, direction, anchor, box, role)
+            return nil unless %i[up left down].include?(direction) && property_role_box?(box, direction)
+            return nil unless source_property_font?(connector, direction)
+
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, box)
+            inset, baseline = property_role_offsets(direction)
+            [x - inset - width, y + baseline]
+          end
+
+          def plain_upward_seat(connector, direction, anchor, box, role)
+            return nil unless direction == :up && cambria_box?(box)
+            return nil unless [0, 1].include?(box["alignment"])
+            return nil unless connector_source_dest_stereotype(connector, :source).empty?
+            return nil unless plain_role_route?(connector.style.to_h)
+
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, box)
+            [x - SEAT_X_INSET - width, y - 6]
+          end
+
+          def plain_role_route?(style)
+            %w[1 3].include?(style[:mode]) && %w[0 2].include?(style[:lwidth]) &&
+              [nil, "V"].include?(style[:tree])
+          end
+
+          def property_role_box?(box, direction)
+            alignments = direction == :down ? [1] : [0, 1]
+            box && alignments.include?(box["alignment"]) && default_presentation?(box)
+          end
+
+          def property_role_offsets(direction)
+            case direction
+            when :up then [60, -6]
+            when :left then [60, -7]
+            else [65, 15]
+            end
+          end
+
+          def source_property_font?(connector, direction)
+            font_family.to_s.casecmp("Cambria").zero? &&
+              property_label?(connector, :source) &&
+              source_property_route?(connector.style.to_h, direction)
+          end
+
+          def source_property_route?(style, direction)
+            case direction
+            when :left then left_property_route?(style)
+            when :down then downward_property_route?(style)
+            else style[:lwidth] == "2" && style[:tree] != "OS"
+            end
+          end
+
+          def left_property_route?(style)
+            style[:mode] == "3" && %w[0 2].include?(style[:lwidth]) &&
+              [nil, "H", "LV"].include?(style[:tree])
+          end
+
+          def downward_property_route?(style)
+            %w[1 3].include?(style[:mode]) && style[:lwidth] == "2" && !style[:tree]
+          end
+
+          def directional_multiplicity(connector, direction, anchor, box, mult)
+            return nil unless cambria_box?(box)
+
+            x, y = seat_corner(anchor, box)
+            return [x + 8, y + 15] if direction == :down
+            return nil unless direction == :left && source_property_font?(connector, direction)
+
+            width = Ea::Fonts::Metrics.text_length(mult, font_size, family: font_family)
+            [x - width - 3, y + 15] if width
+          end
+
+          def cambria_box?(box)
+            box && default_presentation?(box) && font_family.to_s.casecmp("Cambria").zero?
+          end
+
           def mult_seat(direction, anchor, box)
-            return nil if box.nil? || stored_offsets_zero?(box)
+            return nil unless %i[up right].include?(direction)
+            return nil if box.nil?
+            return nil if stored_offsets_zero?(box) && !cambria_box?(box)
             return nil unless default_presentation?(box)
 
             x, y = seat_corner(anchor, box)

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

@@ -91,7 +91,7 @@ module Ea
           end_renderer.texts(text_box: src_tb, mult_box: src_mb,
                              anchor: source_pt, connector: connector,
                              end_kind: :source, tree: tree && tree[:source],
-                             heading: stored_src && leg_heading(points),
+                             heading: stored_src && source_heading(connector, points),
                              stored_labels: stored_labels).each { |t| texts << t }
           end_renderer.texts(text_box: tgt_tb,
                              mult_box: tgt_mb,
@@ -112,6 +112,19 @@ module Ea
           { source: true, target: true }
         end
 
+        # Clipping can slant a stored vertical leg. Keep its label direction
+        # while the label position follows the final emitted endpoint.
+        def source_heading(connector, points)
+          heading = leg_heading(points)
+          return heading unless points.size == 2 && heading[0].nonzero? && heading[1].negative?
+
+          stored = waypoint_pairs(connector)
+          return heading unless stored.size == 2
+
+          original = leg_heading(stored)
+          original[0].zero? && original[1].negative? ? original : heading
+        end
+
         def leg_heading(points)
           [points[1][0] - points[0][0], points[1][1] - points[0][1]]
         end
@@ -195,7 +208,7 @@ module Ea
         end
 
         def label_font_family
-          theme.font_family || DEFAULT_FAMILY
+          theme.label_font_family || DEFAULT_FAMILY
         end
 
         def label_font_size

data/lib/ea/theme/definition.rb

@@ -65,6 +65,7 @@ module Ea
                                     text_y_offset: 12, line_height: 13).freeze
 
       def initialize(id:, name: nil, font_family: nil, font_size: nil,
+                     label_font_family: nil,
                      font_size_unit: "pt", text_weight_normal: 400,
                      text_weight_bold: 700,
                      element_font_size: 9, element_font_unit: "pt",
@@ -81,6 +82,7 @@ module Ea
         @id = id.to_s
         @name = name
         @font_family = font_family
+        @label_font_family = label_font_family
         @font_size = font_size
         @font_size_unit = font_size_unit
         @text_weight_normal = text_weight_normal
@@ -119,7 +121,12 @@ module Ea
         fills[classifier.class.name]
       end
 
+      def label_font_family
+        @label_font_family || font_family
+      end
+
       def with(**overrides)
+        overrides[:label_font_family] = nil if overrides.key?(:font_family) && !overrides.key?(:label_font_family)
         Definition.new(**to_h.merge(overrides))
       end
 
@@ -151,6 +158,7 @@ module Ea
           id: id, name: name,
           font_family: font_family, font_size: font_size,
           font_size_unit: font_size_unit,
+          label_font_family: @label_font_family,
           text_weight_normal: text_weight_normal,
           text_weight_bold: text_weight_bold,
           element_font_size: element_font_size,

data/lib/ea/theme/loader.rb

@@ -10,6 +10,7 @@ module Ea
     #   name: EA White Theme
     #   font: { family: Carlito, size: 7, unit: pt, weight_normal: 400, ... }
     #   element_font: { size: 9, unit: pt }
+    #   label_font: { family: Cambria }
     #   colors: { text: "#000000", attribute_text: "#66413F", ... }
     #   strokes: { element_border: 2, connector_line: 2, ... }
     #   text_metrics: { width_factor: 0.65 }
@@ -38,6 +39,7 @@ module Ea
         def from_hash(data)
           font = data["font"] || {}
           elem_font = data["element_font"] || {}
+          label_font = data["label_font"] || {}
           colors = data["colors"] || {}
           strokes = data["strokes"] || {}
           text_metrics = data["text_metrics"] || {}
@@ -53,6 +55,7 @@ module Ea
             id: data["id"],
             name: data["name"],
             font_family: font["family"],
+            label_font_family: label_font["family"],
             font_size: font["size"],
             font_size_unit: font["unit"] || "pt",
             text_weight_normal: font["weight_normal"] || 400,

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.95"
+  VERSION = "0.6.96"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.95
+  version: 0.6.96
 platform: ruby
 authors:
 - Ribose Inc.
@@ -615,6 +615,7 @@ files:
 - lib/ea/export/xsd/generator.rb
 - lib/ea/export/xsd/namespace_registry.rb
 - lib/ea/fonts.rb
+- lib/ea/fonts/cambria_7_regular_widths.json
 - lib/ea/fonts/carlito_metrics.json
 - lib/ea/fonts/metrics.rb
 - lib/ea/guid_format.rb