ea 0.6.112 → 0.6.114

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6014a00e5fa8c483688ab06cc70027d3b3a8adcd65afbe98ef6782ea6a5473a3
-  data.tar.gz: bd75f6912efc6bb4bc1a963c21ef53056ac421de33af7960bc8e94ee00d8e1c1
+  metadata.gz: 251161fffac3b07a12851b0abd26a046998a61b19a9418da8c6d6ceea1cbb09f
+  data.tar.gz: 549486eec86fb19c6275db6ab7dafdcb7987c1a22b12df2740140e60c7bb2690
 SHA512:
-  metadata.gz: ca1099b7bbc4e22f6e874953b49c29afdc4d8bfc11aef61d7f6f55b3d4c6a2062d064f65e7812fb060c0946ebc47edd04d9a86a45e872584f0a40587f6454750
-  data.tar.gz: 5b56489efbaaf470115c56e180e0e78d8f9f8e46d0c4b21c030ab0443a7bf07bc41317125b16331ec76fef1aa3fae29b2731e35fb38b110743a60a18d0e88183
+  metadata.gz: c5cccbc615740b54619be7e36e4c6edb6382768d97b8a120841aca69018b73e693d9dadb8480e78c9e1e0a18ccfc09122668caf9680571496d99b44372c593cd
+  data.tar.gz: 87a9b79c59a7102d10aaf4968c052f5a63c1e707ef4daf2376d1278ca79b1317e2fc7d47988d57cb09c5abe88d57aeb12b611ba7066e421a1820ce07ac7ff581

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

@@ -126,6 +126,8 @@ module Ea
           @current_obj_row = obj_row
           style_hash = DiagramStyleParser.parse(obj_row.objectstyle)
           style_hash[:stored_attribute_order] = true
+          fqname = stereotype_fqname_for(obj_row)
+          style_hash[:stereotype_fqname] = fqname if fqname
           font_style = effective_font_style(obj_row, style_hash)
           Ea::Model::DiagramElement.new(
             id: IdNormalizer.synthetic("de", diagram_row.diagram_id,
@@ -150,6 +152,19 @@ module Ea
           raw == "1" || raw == "-1"
         end
 
+        def stereotype_fqname_for(placement)
+          object = database.find_object(placement.ea_object_id)
+          return nil unless object
+
+          database.xrefs_for_client(object.ea_guid).each do |xref|
+            application = Xref::Parser.parse(xref.description).stereotype
+            next unless application && application.name == object.stereotype
+
+            return application.fqname
+          end
+          nil
+        end
+
         def build_connectors(diagram_row)
           links = database.diagram_links_for(diagram_row.diagram_id) || []
           context = ContextDiagramSupport.context?(diagram_row)

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

@@ -389,6 +389,7 @@ module Ea
           dividers = [divider_y_by_ref[source_ref],
                       divider_y_by_ref[target_ref]]
           return nil unless bounds.all? && dividers.all?
+          return nil if flush_lateral_line?(connector, pairs, *bounds)
 
           preserve_source = explicit_horizontal_source_dock?(pairs, connector)
           adjusted = row_slot_pairs(pairs, bounds, dividers, preserve_source: preserve_source)

data/lib/ea/svg/ea_emitter/element/header_line_pipeline.rb

@@ -23,6 +23,7 @@ module Ea
                                :off_canvas_parent_name,
                                :foreign_package_name,
                                :suppress_stereotypes,
+                               :stereotype_fqname,
                                keyword_init: true)
 
           PROVIDERS = [

data/lib/ea/svg/ea_emitter/element/header_line_provider/stereotype_label.rb

@@ -22,7 +22,7 @@ module Ea
               # render zero «...» lines, classes included).
               return [] if context.suppress_stereotypes
 
-              labels = label_for(classifier, context.umldi_keyword)
+              labels = label_for(classifier, context.umldi_keyword, context.stereotype_fqname)
               return [] if labels.empty?
 
               labels.map { |l| [l, :normal] }
@@ -30,10 +30,10 @@ module Ea
 
             # @return [Array<String>] «name» labels (EA renders one
             # line per applied stereotype)
-            def self.label_for(classifier, umldi_keyword)
+            def self.label_for(classifier, umldi_keyword, stereotype_fqname = nil)
               return ["«#{umldi_keyword}»"] if umldi_keyword && !umldi_keyword.empty?
 
-              explicit = explicit_stereotype(classifier)
+              explicit = explicit_stereotype(classifier, stereotype_fqname)
               return explicit if explicit
 
               case classifier
@@ -45,21 +45,21 @@ module Ea
               end
             end
 
-            def self.explicit_stereotype(classifier)
+            def self.explicit_stereotype(classifier, stereotype_fqname = nil)
               return nil unless classifier.is_a?(Ea::Model::Classifier) ||
                                  classifier.is_a?(Ea::Model::Package)
 
               refs = classifier.stereotype_refs
               return nil unless refs&.any?
 
-              refs.map { |ref| "«#{canonical(ref)}»" }
+              refs.map { |ref| "«#{canonical(ref, stereotype_fqname)}»" }
             end
 
-            # EA renders the stereotype string exactly as stored in
-            # t_object.Stereotype — corpus-verified: 3,284 placements
-            # render verbatim ('CodeList', 'codeList', 'codelist',
-            # 'featureType' …), zero case-canonicalized.
-            def self.canonical(ref)
+            # EA's standard Class stereotype displays as «type» while
+            # its semantic name remains Type. Custom profiles retain case.
+            def self.canonical(ref, stereotype_fqname = nil)
+              return "type" if ref == "Type" && stereotype_fqname == "StandardProfileL2::Type"
+
               ref
             end
 

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

@@ -166,10 +166,12 @@ module Ea
               )
             end
           end
+          stereotype_fqname = element.style&.fetch(:stereotype_fqname, nil)
           header_lines = classifier ? Element::HeaderLines.for(classifier,
                                                                 diagram_package_id: diagram.package_id,
                                                                 visually_nested: visually_nested?(element),
                                                                 umldi_keyword: element.umldi_keyword,
+                                                                stereotype_fqname: stereotype_fqname,
                                                                 bounds_width: bounds.width,
                                                                 font_size: size, logical_height: logical_height,
                                                                 family: family,
@@ -452,7 +454,7 @@ module Ea
         def tagged_values_for(classifier)
           return [] unless classifier.is_a?(Ea::Model::Classifier)
 
-          classifier.tagged_values || []
+          (classifier.tagged_values || []).reject { |tag| tag.value.nil? || tag.value.empty? }
         end
 
         # Real OCL constraints render trailing, after the content

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

@@ -10,7 +10,7 @@ module Ea
       #   2. theme.font_family / theme.font_size (when theme is themed)
       #   3. diagram-level default (most common non-nil value across
       #      the diagram's elements)
-      #   4. locale fallback (Calibri 10)
+      #   4. unthemed fallback (Cambria)
       #
       # Lives outside the Elements emitter so the resolution rule is
       # defined once (MECE) and reusable by Labels and any future
@@ -83,14 +83,8 @@ module Ea
           theme.element_font_family || theme.font_family
         end
 
-        # EA's app-default font depends on the system locale:
-        # Japanese Windows → "Yu Gothic UI" 13, English Windows →
-        # "Calibri" 10. We can't query EA's runtime, so we infer
-        # from the diagram:
-        #
-        # - If ANY element specifies font=, use the most common.
-        # - If NO element specifies font= (all are "use default"),
-        #   assume the EA English-locale default: Calibri 10.
+        # Unthemed diagrams without a saved family use Cambria.
+        # Saved families still supply the diagram default.
         def diagram_default_family
           families = element_families
           return FALLBACK_DEFAULT_FAMILY if families.empty?
@@ -98,7 +92,7 @@ module Ea
           most_common(families)
         end
 
-        FALLBACK_DEFAULT_FAMILY = "Calibri"
+        FALLBACK_DEFAULT_FAMILY = "Cambria"
 
         def most_common(values)
           return nil if values.empty?

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

@@ -100,12 +100,18 @@ module Ea
                          mult_seat(direction, anchor, mult_box) || mult_pos
             elsif end_kind == :target && !(tree && zero_offset?(text_box, mult_box))
               text_pos = target_property_role(connector, heading, anchor, text_box, role) ||
+                         target_diagonal_property_role(connector, heading, anchor, text_box, role) ||
                          target_vertical_role(connector, heading, anchor, text_box, role) ||
                          target_rightward_role(heading, anchor, text_box, role) || text_pos
               mult_pos = target_multiplicity_seat(connector, heading, anchor, mult_box) ||
                          target_horizontal_multiplicity(heading, anchor, mult_box, mult) || mult_pos
             end
 
+            if end_kind == :source
+              text_pos = source_top_property_role(connector, heading, anchor, text_box, role) ||
+                         source_bottom_property_role(connector, heading, anchor, text_box, role) || text_pos
+            end
+
             build_texts(role:, mult:, standalone:,
                         text_pos:, mult_pos:, stereo:, text_box:)
           end
@@ -185,10 +191,10 @@ module Ea
             [x + SEAT_X_INSET, y - 7]
           end
 
-          # Property-role clusters use a direction-specific right edge;
+          # Property-role clusters use a direction-specific horizontal seat;
           # 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 %i[up left right 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)
@@ -196,11 +202,62 @@ module Ea
 
             x, y = seat_corner(anchor, box)
             inset, baseline = property_role_offsets(direction)
-            left = x - inset - width
+            left = property_role_x(direction, x, inset + width)
             left = [left, MIN_ROLE_X].max if direction == :up
             [left, y + baseline]
           end
 
+          def property_role_x(direction, origin, offset)
+            direction == :right ? origin + offset : origin - offset
+          end
+
+          # EDGE=1 certifies the top dock independently of the clipped ray's
+          # heading. An absent source box uses the upward Property seat.
+          def source_top_property_role(connector, heading, anchor, box, role)
+            return nil unless source_seat?(:source, heading) && heading[0].negative? && heading[1].positive?
+            return nil unless zero_source_property_box?(box)
+
+            return nil unless source_top_property_route?(connector.style.to_h)
+
+            source_property_seat(connector, :up, anchor, box, role)
+          end
+
+          def zero_source_property_box?(box)
+            box && box["alignment"]&.zero? && stored_offsets_zero?(box)
+          end
+
+          def source_top_property_route?(style)
+            style[:stored_top_dock] == true && style.values_at(:mode, :lwidth, :tree) == ["3", "2", nil]
+          end
+
+          # A saved external ray that first meets the source's bottom face
+          # seats an absent source Property role like the downward Property
+          # seat. The caller reports that face as a downward heading.
+          def source_bottom_property_role(connector, heading, anchor, box, role)
+            return nil unless source_bottom_dock?(connector, heading, box)
+
+            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(:down)
+            [x - inset - width, y + baseline]
+          end
+
+          def source_bottom_dock?(connector, heading, box)
+            source_seat?(:source, heading) && heading[0].zero? && heading[1].positive? &&
+              zero_source_property_box?(box) && default_presentation?(box) &&
+              source_bottom_property_route?(connector.style.to_h) && source_property_cambria?(connector)
+          end
+
+          # A downward leg on the horizontal lateral tree seats an absent
+          # box like the up leg already does on the same route.
+          def source_bottom_property_route?(style)
+            return false unless style.values_at(:mode, :lwidth) == %w[3 2]
+
+            style[:tree] == "LH" || (style[:stored_association_ray] == true && style[:tree].nil?)
+          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"])
@@ -233,6 +290,31 @@ module Ea
               property_label?(connector, :target) && downward_property_route?(connector.style.to_h)
           end
 
+          # Zero-offset diagonal labels use the dominant leg's Property
+          # right edge. Moved boxes keep their explicit placement.
+          def target_diagonal_property_role(connector, heading, anchor, box, role)
+            return nil unless diagonal_property_box?(connector, box)
+
+            inset = diagonal_property_inset(heading)
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family) if inset
+            [anchor[0] - inset - width, anchor[1] - 7] if width
+          end
+
+          def diagonal_property_box?(connector, box)
+            plain_vertical_box?(box) && box["alignment"] == 1 && stored_offsets_zero?(box) &&
+              property_label?(connector, :target) &&
+              connector.style.to_h.values_at(:mode, :lwidth, :tree) == ["3", "0", nil]
+          end
+
+          def diagonal_property_inset(heading)
+            return nil unless heading && !heading.include?(0)
+
+            dx, dy = heading
+            return property_role_offsets(:left).first if dx.negative? && dx.abs > dy.abs
+
+            property_role_offsets(:down).first if dy.negative? && dy.abs > dx.abs
+          end
+
           def target_vertical_role(connector, heading, anchor, box, role)
             return nil unless heading && heading[0].zero? && !heading[1].zero?
 
@@ -301,28 +383,33 @@ module Ea
           def property_role_offsets(direction)
             case direction
             when :up then [60, -6]
-            when :left then [60, -7]
+            when :left, :right 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_cambria?(connector) &&
               source_property_route?(connector.style.to_h, direction)
           end
 
+          def source_property_cambria?(connector)
+            font_family.to_s.casecmp("Cambria").zero? && property_label?(connector, :source)
+          end
+
           def source_property_route?(style, direction)
             case direction
             when :left then left_property_route?(style)
+            when :right then style.values_at(:mode, :lwidth, :tree) == %w[3 2 H]
             when :down then downward_property_route?(style)
             else %w[0 2].include?(style[:lwidth]) && 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])
+            downward_property_route?(style) ||
+              (style[:mode] == "3" && %w[0 2].include?(style[:lwidth]) &&
+                [nil, "H", "LV"].include?(style[:tree]))
           end
 
           def downward_property_route?(style)

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

@@ -96,8 +96,8 @@ module Ea
           LINE_PITCH = 13
 
           def label_position(connector, points)
-            name_seat = stored_name_position(connector, points)
-            return name_seat if name_seat
+            stored_seat = stored_stereotype_position(connector, points) || stored_name_position(connector, points)
+            return stored_seat if stored_seat
 
             return midpoint(points) unless default_substitutable_seat?(connector) &&
                                            upward_four_point_route?(points)
@@ -106,9 +106,23 @@ module Ea
             [source[0] + 3, ((source[1] + bend[1]) / 2).floor - 1]
           end
 
+          # LMB is the row below the midpoint; LMT carries the name above it.
+          def stored_stereotype_position(connector, points)
+            return nil unless connector.is_a?(Ea::Model::DiagramConnector) && measured_name_font?
+            return nil unless stereotype_label(connector)
+
+            box = connector.label_boxes.to_h[:lmb]
+            return nil unless default_name_box?(box)
+
+            stored_position(connector, points, box, LINE_PITCH)
+          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)
+            stored_position(connector, points, stored_name_box(connector), -3)
+          end
+
+          def stored_position(connector, points, box, baseline)
             return nil unless box
 
             width = Ea::Fonts::Metrics.text_length(midpoint_content(connector), font_size, family: font_family)
@@ -116,7 +130,7 @@ module Ea
 
             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]
+            [x + offset_x - (width / 2.0).floor, y + offset_y + baseline]
           end
 
           def stored_name_box(connector)

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

@@ -129,7 +129,7 @@ module Ea
 
           box = source_dock_bounds(connector)
           face = box && dock_face_heading(points.first, box)
-          return face if face && face.zip(heading).any? { |axis, delta| (axis * delta).positive? }
+          return face if face && face_leads_leg?(connector, face, heading, box)
 
           stored_upward_heading(connector, heading)
         end
@@ -147,6 +147,18 @@ module Ea
           original.any?(&:zero?) ? original : heading
         end
 
+        # A saved external ray enters the source through the face it first
+        # meets, even when the clipped leg then runs back across the box.
+        def face_leads_leg?(connector, face, heading, box)
+          anchor = connector.source_anchor
+          if face == [0, 1] && anchor && anchor.y > box.y + box.height &&
+             connector.style.to_h[:stored_association_ray] == true
+            return true
+          end
+
+          face.zip(heading).any? { |axis, delta| (axis * delta).positive? }
+        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.112"
+  VERSION = "0.6.114"
 end

metadata

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