ea 0.6.3 → 0.6.5

data/lib/ea/spa/projector.rb

@@ -76,7 +76,22 @@ module Ea
       def metadata_hash
         base = document.metadata
         merged = configuration ? configuration.apply_to_metadata(base) : base
-        JSON.parse(merged.to_json)
+        hash = JSON.parse(merged.to_json)
+        hash["statistics"] = statistics_hash
+        hash
+      end
+
+      def statistics_hash
+        {
+          "packages" => document.packages.size,
+          "classes" => document.classifiers.size,
+          "attributes" => document.classifiers.sum { |c| c.properties.size },
+          "operations" => document.classifiers.sum { |c| c.operations.size },
+          "associations" => document.relationships.count do |r|
+            r.is_a?(Ea::Model::Association)
+          end,
+          "diagrams" => render_diagrams? ? document.diagrams.size : 0
+        }
       end
 
       def view_extras
@@ -84,14 +99,16 @@ module Ea
       end
 
       def build_package_tree
+        sub_ids_by_parent = document.packages.group_by(&:parent_id)
         nodes = document.packages.map do |pkg|
           PackageTreeNode.new(
             id: pkg.id,
             name: pkg.name,
             parent_id: pkg.parent_id,
-            child_ids: pkg.sub_package_ids,
+            child_ids: (pkg.sub_package_ids +
+                        (sub_ids_by_parent[pkg.id] || []).map(&:id)).uniq,
             classifier_ids: classifiers_in_package_ids(pkg.id),
-            diagram_ids: pkg.diagram_ids
+            diagram_ids: diagram_ids_for_package(pkg.id)
           )
         end
         PackageTree.new(
@@ -105,7 +122,7 @@ module Ea
       end
 
       def build_entries
-        document.classifiers.map do |c|
+        classifier_entries = document.classifiers.map do |c|
           SkeletonEntry.new(
             id: c.id,
             name: c.name,
@@ -115,6 +132,27 @@ module Ea
             shard_url: shard_url_for.call(c)
           )
         end
+        package_entries = document.packages.map do |p|
+          SkeletonEntry.new(
+            id: p.id,
+            name: p.name,
+            kind: "package",
+            package_id: p.parent_id,
+            qualified_name: p.qualified_name,
+            shard_url: shard_url_for.call(p)
+          )
+        end
+        diagram_entries = render_diagrams? ? document.diagrams.map do |d|
+          SkeletonEntry.new(
+            id: d.id,
+            name: d.name,
+            kind: "diagram",
+            package_id: d.package_id,
+            qualified_name: d.name,
+            shard_url: shard_url_for.call(d)
+          )
+        end : []
+        classifier_entries + package_entries + diagram_entries
       end
 
       def build_search_entries
@@ -191,8 +229,72 @@ module Ea
         end
       end
 
-      def payload_for(element)
-        JSON.parse(element.to_json)
+      def payload_for(model_element)
+        payload = JSON.parse(model_element.to_json)
+        case model_element
+        when Ea::Model::Classifier
+          augment_classifier_payload!(payload, model_element)
+        when Ea::Model::Package
+          payload["classifierIds"] = classifiers_in_package_ids(model_element.id)
+          payload["diagramIds"] = diagram_ids_for_package(model_element.id)
+        when Ea::Model::Diagram
+          augment_diagram_payload!(payload, model_element)
+        end
+        payload
+      end
+
+      def diagram_ids_for_package(package_id)
+        (document.packages.find { |p| p.id == package_id }&.diagram_ids ||
+          []) + document.diagrams.select { |d| d.package_id == package_id }.map(&:id)
+      end
+
+      def augment_classifier_payload!(payload, classifier)
+        rels = document.relationships_for(classifier.id)
+        payload["generalizations"] = rels
+          .select { |r| r.is_a?(Ea::Model::Generalization) && r.specific_id == classifier.id }
+          .map { |r| { "id" => r.id, "targetId" => r.general_id } }
+        payload["specializations"] = rels
+          .select { |r| r.is_a?(Ea::Model::Generalization) && r.general_id == classifier.id }
+          .map { |r| { "id" => r.id, "targetId" => r.specific_id } }
+        payload["associations"] = rels
+          .select { |r| r.is_a?(Ea::Model::Association) }
+          .map { |r| association_stub(r, classifier.id) }
+        payload
+      end
+
+      def association_stub(assoc, classifier_id)
+        {
+          "id" => assoc.id,
+          "name" => assoc.name,
+          "sourceId" => assoc.source_id,
+          "targetId" => assoc.target_id,
+          "thisEndRoleName" => assoc.source_id == classifier_id ? assoc.source_role_name : assoc.target_role_name,
+          "otherEndRoleName" => assoc.source_id == classifier_id ? assoc.target_role_name : assoc.source_role_name,
+          "otherEndId" => assoc.source_id == classifier_id ? assoc.target_id : assoc.source_id,
+          "otherEndMultiplicity" => cardinality(assoc, classifier_id),
+          "otherEndAggregation" => assoc.source_id == classifier_id ? assoc.target_aggregation : assoc.source_aggregation
+        }
+      end
+
+      def cardinality(assoc, classifier_id)
+        if assoc.source_id == classifier_id
+          [assoc.target_multiplicity_lower, assoc.target_multiplicity_upper]
+        else
+          [assoc.source_multiplicity_lower, assoc.source_multiplicity_upper]
+        end
+      end
+
+      def augment_diagram_payload!(payload, diagram)
+        payload["svg"] = Ea::Svg::EaEmitter::Document.new(
+          diagram,
+          model_index: document.index_by_id,
+          document: document
+        ).render
+        payload
+      rescue StandardError => e
+        warn "ea: skipping SVG render for diagram #{diagram.id} " \
+             "(#{diagram.name.inspect}): #{e.class}: #{e.message}"
+        payload
       end
     end
   end

data/lib/ea/svg/ea_emitter/compartment/attributes.rb

@@ -10,6 +10,7 @@ module Ea
 
           def render(context)
             return nil if context.attr_lines.empty?
+            return nil unless context.geometry.attr_first_y
 
             Element::AttributeRenderer.render(
               context.attr_lines,

data/lib/ea/svg/ea_emitter/compartment/constraints.rb

@@ -14,6 +14,7 @@ module Ea
 
           def render(context)
             return nil unless context.constraints&.any?
+            return nil unless context.geometry.tagged_value_first_y
 
             Element::ConstraintRenderer.render(
               context.constraints,

data/lib/ea/svg/ea_emitter/compartment/enum_literals.rb

@@ -10,45 +10,29 @@ module Ea
         module EnumLiterals
           module_function
 
+          # EA: literal rows sit directly under the header divider,
+          # 13px apart at 7pt (attr rows use 14), first row at
+          # divider + 14. No compartment divider, no header label.
+          LITERAL_LINE_OFFSET = 6
+
           def render(context)
             return nil unless context.enum_literals.any?
             return nil unless context.geometry.enum_literal_first_y
 
-            [
-              Element::DividerRenderer.render(
-                context.bounds,
-                y: context.geometry.enum_divider_y,
-                stroke: context.stroke,
-                stroke_width: context.stroke_width
-              ),
-              render_literals_block(context)
-            ].join("\n")
+            render_literals_block(context)
           end
 
           def render_literals_block(context)
-            line_h = context.size + (context.theme.compartments.attr_line_offset || 4)
-            text_blocks = [literal_header_text(context)]
+            line_h = context.size + LITERAL_LINE_OFFSET
+            text_blocks = []
             context.enum_literals.each_with_index do |literal, idx|
-              y = context.geometry.enum_literal_first_y + ((idx + 1) * line_h)
+              y = context.geometry.enum_literal_first_y + (idx * line_h)
               text_blocks << visibility_placeholder(context, y)
               text_blocks << literal_name_text(context, literal, y)
             end
             wrap_group(text_blocks, context.theme.text_color)
           end
 
-          def literal_header_text(context)
-            TextRenderer.new(
-              content: "literals",
-              x: context.bounds.x + (context.bounds.width / 2.0) -
-                (8 * context.size * context.theme.text_width_factor) / 2,
-              y: context.geometry.enum_literal_first_y,
-              family: context.family, size: context.size, size_unit: context.size_unit,
-              style: "italic", fill: context.theme.text_color,
-              stroke_in_text: context.theme.stroke_in_text_color,
-              width_factor: context.theme.text_width_factor
-            ).to_svg
-          end
-
           def visibility_placeholder(context, y)
             TextRenderer.new(
               content: " ",

data/lib/ea/svg/ea_emitter/compartment/header.rb

@@ -11,6 +11,7 @@ module Ea
 
           def render(context)
             return nil if context.header_lines.empty?
+            return nil unless context.geometry.header_first_y
 
             Element::HeaderRenderer.render(
               context.header_lines,

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

@@ -103,6 +103,11 @@ module Ea
           end
 
           def bound_text(value)
+            # EA renders a stored literal bound ("n") verbatim, and a
+            # computed-unbounded upper as "*" (verified against
+            # EA-published reference SVGs).
+            return property.multiplicity_upper_raw if value == -1 && property.multiplicity_upper_raw
+
             value == -1 ? "*" : value.to_s
           end
         end

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

@@ -9,15 +9,19 @@ module Ea
         # content) matching EA's encoding.
         class AttributeRenderer
           DEFAULT_VISIBILITY_X_OFFSET = 5
-          DEFAULT_CONTENT_X_OFFSET = 26
+          DEFAULT_CONTENT_X_OFFSET = 22
           DEFAULT_FONT_UNIT = "pt"
+          # EA seats compartment stereotype headers («Property») 12px
+          # from the box edge and spaces rows 13px at 7pt.
+          STEREOTYPE_HEADER_X_OFFSET = 12
+          ROW_LINE_OFFSET = 6
 
           def self.render(lines, bounds:, first_y:, family:,
                           size:, size_unit: DEFAULT_FONT_UNIT,
                           fill: "#000000",
                           visibility_x_offset: DEFAULT_VISIBILITY_X_OFFSET,
                           content_x_offset: DEFAULT_CONTENT_X_OFFSET)
-            line_h = size + 4
+            line_h = size + ROW_LINE_OFFSET
             text_blocks = []
             lines.each_with_index do |line, idx|
               y = first_y + (idx * line_h)
@@ -25,6 +29,8 @@ module Ea
               if visibility
                 text_blocks << build_text(bounds.x + visibility_x_offset, y, visibility, family, size, size_unit, fill)
                 text_blocks << build_text(bounds.x + content_x_offset, y, rest, family, size, size_unit, fill)
+              elsif line.strip.start_with?("«")
+                text_blocks << build_text(bounds.x + STEREOTYPE_HEADER_X_OFFSET, y, line.strip, family, size, size_unit, fill)
               else
                 text_blocks << build_text(bounds.x + visibility_x_offset, y, line.strip, family, size, size_unit, fill)
               end
@@ -44,19 +50,44 @@ module Ea
           #
           # Pass a `lookup` (any callable returning a Classifier for
           # an id) to enable inherited-property namespace prefixing.
-          def self.lines_for(classifier, lookup: nil)
-            props = displayable_properties(classifier)
+          def self.lines_for(classifier, lookup: nil,
+                            exclude_association_ids: nil)
+            props = displayable_properties(classifier, exclude_association_ids)
             return [] unless props
 
-            props.flat_map do |prop|
-              lines = []
-              stereotype = property_stereotype(prop)
-              lines << "«#{stereotype}»" if stereotype
-              lines << AttributeLineBuilder.new(prop, host: classifier,
+            stereotypes = props.map { |p| property_stereotype(p) }.compact.uniq
+            if stereotypes.size == 1 && props.all? { |p| property_stereotype(p) }
+              # EA renders ONE compartment stereotype header for a
+              # uniformly-stereotyped attribute set (e.g. «Property»
+              # above GML property rows) and lists rows
+              # alphabetically - verified against EA-published SVGs.
+              header = "«#{canonical_stereotype(stereotypes.first)}»"
+              [header] + props.sort_by { |p| p.name.to_s }.map do |prop|
+                AttributeLineBuilder.new(prop, host: classifier,
+                                         lookup: lookup).to_s
+              end
+            else
+              props.flat_map do |prop|
+                lines = []
+                stereotype = property_stereotype(prop)
+                lines << "«#{stereotype}»" if stereotype
+                lines << AttributeLineBuilder.new(prop, host: classifier,
                                                   lookup: lookup).to_s
+              end
             end
           end
 
+          STEREOTYPE_DISPLAY = {
+            "property" => "Property",
+            "featuretype" => "FeatureType",
+            "objecttype" => "ObjectType",
+            "codelist" => "CodeList"
+          }.freeze
+
+          def self.canonical_stereotype(ref)
+            STEREOTYPE_DISPLAY.fetch(ref.to_s.downcase, ref.to_s)
+          end
+
           # Internal helpers
 
           def self.split_visibility(line)
@@ -75,10 +106,19 @@ module Ea
           end
           private_class_method :build_text
 
-          def self.displayable_properties(classifier)
+          # Association-end properties render in the box only when
+          # their association is NOT drawn on the diagram (drawn ones
+          # render as connector role labels). exclude_association_ids
+          # carries the diagram's drawn association ids; nil preserves
+          # the legacy hide-all behavior.
+          def self.displayable_properties(classifier, exclude_association_ids)
             return nil unless classifier.properties
 
-            classifier.properties.reject(&:association_id)
+            classifier.properties.reject do |prop|
+              prop.association_id &&
+                (exclude_association_ids.nil? ||
+                 exclude_association_ids.include?(prop.association_id))
+            end
           end
           private_class_method :displayable_properties
 

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

@@ -27,10 +27,10 @@ module Ea
           def initialize(bounds:, size:, header_lines_count:,
                           attr_lines_count:, op_lines_count:,
                           tagged_values_count:,
-                          header_top_padding: 9,
+                          header_top_padding: 12,
                           header_line_offset: 6,
                           divider_offset: 8,
-                          attr_line_offset: 4,
+                          attr_line_offset: 6,
                           attr_first_offset: 7)
             @bounds = bounds
             @size = size
@@ -46,7 +46,7 @@ module Ea
           end
 
           def header_first_y
-            bounds.y + size + (header_top_padding || 9)
+            bounds.y + size + (header_top_padding || 12)
           end
 
           # Y of the divider line between header and the rest.
@@ -61,7 +61,7 @@ module Ea
           end
 
           def attr_first_y
-            return bounds.y + size + (header_top_padding || 9) + 12 unless divider_y
+            return bounds.y + size + (header_top_padding || 12) + 12 unless divider_y
 
             divider_y + size + (attr_first_offset || 7)
           end
@@ -69,7 +69,7 @@ module Ea
           def attr_bottom_y
             return attr_first_y unless attr_lines_count&.positive?
 
-            attr_first_y + (attr_lines_count - 1) * (size + (attr_line_offset || 4))
+            attr_first_y + (attr_lines_count - 1) * (size + (attr_line_offset || 6))
           end
 
           def op_divider_y
@@ -88,12 +88,14 @@ module Ea
             op_first_y + (op_lines_count - 1) * (size + 4)
           end
 
-          def enum_divider_y
-            op_bottom_y + size + 5
-          end
-
+          # EA draws a single divider under the header and seats
+          # enumeration literals directly after it (+14 at 7pt),
+          # exactly like attribute rows - no second divider and no
+          # "literals" header. Verified against EA-published SVGs.
           def enum_literal_first_y
-            enum_divider_y + size + 5
+            return nil unless divider_y
+
+            divider_y + size + (attr_first_offset || 7)
           end
 
           # Tagged values appear after attributes (or after ops if

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

@@ -51,22 +51,13 @@ module Ea
                 (bounds_width - QUALIFIED_WRAP_PADDING)
             end
 
-            def self.display_name(classifier, diagram_package_id = nil,
+            # EA renders the plain classifier name in element headers
+            # (element ownership qualification is a display option the
+            # corpus diagrams leave off - verified against EA-published
+            # reference SVGs).
+            def self.display_name(classifier, _diagram_package_id = nil,
                                   _visually_nested = false)
-              name = if classifier.is_a?(Ea::Model::Classifier)
-                       (classifier.qualified_name || classifier.name).to_s
-                     else
-                       classifier.name.to_s
-                     end
-              return name if diagram_package_id.nil?
-              return name unless name.include?("::")
-
-              if classifier.is_a?(Ea::Model::Classifier) &&
-                 classifier.package_id == diagram_package_id
-                name.split("::").last
-              else
-                name
-              end
+              classifier.name.to_s
             end
           end
         end

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

@@ -18,25 +18,26 @@ module Ea
               classifier = context.classifier
               return [] if classifier.is_a?(Ea::Model::InstanceSpecification)
 
-              label = label_for(classifier, context.umldi_keyword)
-              return [] unless label
+              labels = label_for(classifier, context.umldi_keyword)
+              return [] if labels.empty?
 
-              [[label, :normal]]
+              labels.map { |l| [l, :normal] }
             end
 
-            # @return [String, nil] «name» label or nil
+            # @return [Array<String>] «name» labels (EA renders one
+            # line per applied stereotype)
             def self.label_for(classifier, umldi_keyword)
-              return "«#{umldi_keyword}»" if umldi_keyword && !umldi_keyword.empty?
+              return ["«#{umldi_keyword}»"] if umldi_keyword && !umldi_keyword.empty?
 
               explicit = explicit_stereotype(classifier)
               return explicit if explicit
 
               case classifier
               when Ea::Model::Klass, Ea::Model::Package, Ea::Model::Note
-                nil
+                []
               else
                 fallback = fallback_name(classifier)
-                fallback ? "«#{fallback}»" : nil
+                fallback ? ["«#{fallback}»"] : []
               end
             end
 
@@ -47,7 +48,23 @@ module Ea
               refs = classifier.stereotype_refs
               return nil unless refs&.any?
 
-              "«#{refs.first}»"
+              refs.map { |ref| "«#{canonical(ref)}»" }
+            end
+
+            # EA displays canonical stereotype spellings regardless of
+            # how the QEA stored them (property → Property). Prefer the
+            # MDG alias registry when its definition is available; the
+            # overrides map covers the spellings verified directly
+            # against EA-published reference SVGs.
+            DISPLAY_OVERRIDES = {
+              "property" => "Property",
+              "featuretype" => "FeatureType",
+              "objecttype" => "ObjectType",
+              "codelist" => "CodeList"
+            }.freeze
+
+            def self.canonical(ref)
+              DISPLAY_OVERRIDES.fetch(ref.downcase, ref)
             end
 
             def self.fallback_name(classifier)

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

@@ -14,7 +14,7 @@ module Ea
           def self.render(lines, bounds:, first_y:, family:,
                           size:, size_unit: "pt",
                           fill: "#000000", weight_normal: 400, weight_bold: 700,
-                          stroke_in_text: "#000000", width_factor: 0.65,
+                          stroke_in_text: "#000000", width_factor: 0.612,
                           line_offset: 6)
             line_h = size + line_offset
             text_blocks = lines.each_with_index.map do |(text, style), idx|
@@ -23,11 +23,23 @@ module Ea
                        else weight_normal
                        end
               font_style = (style == :italic || style == :bold_italic) ? "italic" : "normal"
-              y = first_y + (idx * line_h)
-              centered_x = center_x_for(text, bounds, size, width_factor)
+              # EA spaces the line AFTER a right-aligned ghost 6px
+              # wider (ghost +13, next +32 at 7pt) - verified against
+              # EA-published reference SVGs.
+              y = first_y + (idx * line_h) +
+                  (idx >= 1 && lines.first.last == :italic ? 6 : 0)
+              x = if style == :italic
+                    # EA right-aligns the off-canvas parent ghost at
+                    # the box's right edge (verified across EA-published
+                    # reference SVGs).
+                    bounds.x + bounds.width -
+                      Ea::Svg::EaEmitter::TextRenderer.estimate_width(text, size, width_factor)
+                  else
+                    center_x_for(text, bounds, size, width_factor)
+                  end
               TextRenderer.new(
                 content: text,
-                x: centered_x, y: y,
+                x: x, y: y,
                 family: family, size: size, size_unit: size_unit,
                 weight: weight, style: font_style, fill: fill,
                 stroke_in_text: stroke_in_text, width_factor: width_factor

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

@@ -24,8 +24,8 @@ module Ea
         class LegendRenderer
           CONTAINER_RX = 3
           ICON_SIZE = 17
-          TITLE_Y_OFFSET = 19
-          FIRST_ITEM_Y_OFFSET = 30
+          TITLE_Y_OFFSET = 22
+          FIRST_ITEM_Y_OFFSET = 33
           ITEM_SPACING = 19
           ICON_X_OFFSET = 10
           ICON_LABEL_GAP = 22
@@ -130,11 +130,36 @@ module Ea
           end
 
           def title_text
-            x = bounds.x + (bounds.width / 2) - (title_text_width / 2)
+            x = title_x
             y = bounds.y + TITLE_Y_OFFSET
             build_text(legend.title, x: x, y: y, size: title_font_size, weight: 700)
           end
 
+          # EA centers the title over the ITEM BLOCK (icon left edge
+          # to the right end of the widest label), not the container
+          # box - verified against EA-published reference SVGs.
+          def title_x
+            icon_left = bounds.x + ICON_X_OFFSET
+            block_right = icon_left + ICON_LABEL_GAP +
+                          widest_item_label_width
+            block_left = icon_left
+            block_left + (block_right - block_left - title_text_width) / 2.0
+          end
+
+          CJK_RANGE = /[\u3000-\u9fff\uff00-\uffef]/
+
+          # CJK glyphs run ~0.82em, others ~0.612em (regressed from
+          # EA's own textLength values on mixed-script labels).
+          def estimated_width(text, size)
+            text.to_s.each_char.sum do |ch|
+              ch.match?(CJK_RANGE) ? size * 0.70 : size * 0.612
+            end
+          end
+
+          def widest_item_label_width
+            legend.items.map { |i| estimated_width(i.name, item_font_size) }.max || 0.0
+          end
+
           def item_top_y(index)
             bounds.y + FIRST_ITEM_Y_OFFSET + (index * ITEM_SPACING)
           end
@@ -148,7 +173,7 @@ module Ea
           end
 
           def title_text_width
-            legend.title.to_s.length * title_font_size * 0.6
+            estimated_width(legend.title, title_font_size)
           end
 
           def build_text(content, x:, y:, size:, weight:)