ea 0.4.0 → 0.5.0

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

@@ -3,32 +3,35 @@
 module Ea
   module Svg
     module EaEmitter
-      # Emits the elements layer: for each DiagramElement on the
-      # diagram, emits the EA-shape group (filled rect) plus the
-      # EA-text group (stereotype + name + attributes + operations).
-      #
-      # Each element is rendered in z_order (ascending). Output
-      # follows EA's pattern of layered groups per element:
-      #
-      #   <g style="fill:COLOR;..."><rect x y w h/></g>
-      #   <g style="fill:#000000;..."><text>...</text></g>
-      #   <g style="..."><path d="M x y L x2 y2"/></g>   (divider)
-      #   <g style="..."><text>attr1</text>...</g>
+      # Emits the elements layer. Orchestrates per-element rendering
+      # by delegating to specialized compartment renderers (shape,
+      # header, divider, attribute). Frame-element filtering and
+      # stereotype-color fallback also live in dedicated
+      # collaborators.
       class Elements
         DEFAULT_FILL = "#FFFFFF"
         DEFAULT_STROKE = "#000000"
-        DEFAULT_FONT_FAMILY = "Calibri"
-        DEFAULT_FONT_SIZE = 13
+        DEFAULT_STROKE_WIDTH = 2
+        DEFAULT_TEXT_COLOR = "#000000"
 
-        attr_reader :diagram, :model_index
+        attr_reader :diagram, :model_index, :canvas, :document
 
-        def initialize(diagram, model_index:)
+        def initialize(diagram, model_index:, canvas: nil, document: nil)
           @diagram = diagram
           @model_index = model_index
+          @canvas = canvas
+          @document = document
         end
 
         def render
-          ordered_elements.map { |e| render_one(e) }.join("\n")
+          groups.join("\n")
+        end
+
+        # Returns an Array of per-entity `<g>...</g>` strings.
+        # Each element contributes up to 4 groups (shape, header,
+        # divider, attrs) in EA's per-entity layer order.
+        def groups
+          ordered_elements.flat_map { |e| groups_for(e) }
         end
 
         private
@@ -37,131 +40,316 @@ module Ea
           (diagram.elements || []).sort_by { |e| e.z_order || 0 }
         end
 
-        def render_one(element)
-          bounds = element.image_bounds || element.bounds
-          return "" unless bounds
+        def groups_for(element)
+          return [] if element_filter.skip?(element)
+
+          context = build_context(element)
+          return [] unless context
+
+          Compartment.render_all(context).compact
+        end
+
+        # Build the RenderContext for one element. Returns nil when
+        # the element has no usable bounds (skip rendering).
+        def build_context(element)
+          raw_bounds = element.bounds || element.image_bounds
+          return nil unless raw_bounds
+
+          bounds = translate_bounds(raw_bounds)
+          model_element = model_element_for(element)
+          classifier = classifier_for(element)
+          size = font_resolver.size_for(element)
+          family = font_resolver.family_for(element)
+          size_unit = font_resolver.size_unit_for(element)
+          parent_name = off_canvas_parent_name_for(classifier)
+
+          header_lines = classifier ? Element::HeaderLines.for(classifier,
+                                                                diagram_package_id: diagram.package_id,
+                                                                visually_nested: visually_nested?(element),
+                                                                umldi_keyword: element.umldi_keyword,
+                                                                bounds_width: raw_bounds&.width,
+                                                                font_size: size,
+                                                                off_canvas_parent_name: parent_name) : []
+          is_classifier = classifier.is_a?(Ea::Model::Classifier)
+          attr_lines = (is_classifier && show_attributes?) ? Element::AttributeRenderer.lines_for(classifier, lookup: attribute_lookup) : []
+          op_lines = (is_classifier && show_operations?) ? Element::OperationRenderer.lines_for(classifier) : []
+          geometry = CompartmentGeometry.new(bounds: bounds, size: size,
+                                              header_lines_count: header_lines.size,
+                                              attr_lines_count: attr_lines.size,
+                                              op_lines_count: op_lines.size,
+                                              tagged_values_count: tagged_values_for(classifier).size,
+                                              header_top_padding: theme.compartments.header_top_padding,
+                                              header_line_offset: theme.compartments.header_line_offset,
+                                              divider_offset: theme.compartments.divider_offset,
+                                              attr_line_offset: theme.compartments.attr_line_offset,
+                                              attr_first_offset: theme.compartments.attr_first_offset)
+          RenderContext.new(
+            element: element,
+            bounds: bounds,
+            model_element: model_element,
+            classifier: classifier,
+            fill: resolve_fill(element, classifier),
+            stroke: resolve_stroke,
+            stroke_width: resolve_stroke_width,
+            text_fill: theme.text_color,
+            family: family, size: size, size_unit: size_unit,
+            header_lines: header_lines,
+            attr_lines: attr_lines,
+            op_lines: op_lines,
+            enum_literals: enum_literals_for(classifier),
+            tagged_values: element.show_tagged_values ? tagged_values_for(classifier) : [],
+            constraints: constraints_for(classifier),
+            package_content_lines: package_content_lines_for(model_element),
+            geometry: geometry,
+            theme: theme,
+            canvas: canvas,
+            diagram: diagram,
+            model_index: model_index,
+            off_canvas_parent_name: parent_name
+          )
+        end
 
-          classifier = model_element_for(element)
-          fill = color_from_ea(element.background_color) || fill_for_classifier(classifier)
-          stroke = color_from_ea(element.line_color) || DEFAULT_STROKE
-          stroke_width = element.line_width || 2
+        def enum_literals_for(classifier)
+          return [] unless classifier.is_a?(Ea::Model::Enumeration)
 
-          parts = []
-          parts << render_shape_group(bounds, fill, stroke, stroke_width)
-          parts << render_header_text(element, bounds, classifier)
-          parts << render_divider(bounds, stroke, stroke_width) if classifier
-          parts << render_attribute_text(element, bounds, classifier) if classifier
-          parts.compact.join("\n")
+          classifier.literals || []
         end
 
-        def render_shape_group(bounds, fill, stroke, stroke_width)
-          %(<g style="stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#{fill};fill-opacity:1.00; stroke:#{stroke}; stroke-opacity:1.00">\n  <rect x="#{bounds.x}" y="#{bounds.y}" width="#{bounds.width}" height="#{bounds.height}" rx="0.00" shape-rendering="auto"  />\n</g>)
+        def tagged_values_for(classifier)
+          return [] unless classifier.is_a?(Ea::Model::Classifier)
+
+          classifier.tagged_values || []
         end
 
-        def render_header_text(element, bounds, classifier)
-          return "" unless classifier
+        def constraints_for(classifier)
+          return [] unless classifier.is_a?(Ea::Model::Classifier)
+
+          classifier.constraints || []
+        end
 
-          lines = header_lines(classifier)
-          return "" if lines.empty?
+        # EA renders the off-canvas parent classifier's name as an
+        # italic line at the top of a placed element's header when
+        # ALL of these hold:
+        #
+        #   1. The diagram's HideParents flag is 0 (the default).
+        #      HideParents=1 suppresses the ghost line entirely.
+        #   2. The parent (general) of a Generalization is NOT placed
+        #      on the current diagram.
+        #   3. No other element from the parent's package is placed
+        #      on the diagram — EA treats the parent's package as
+        #      "represented" and omits the ghost as redundant.
+        def off_canvas_parent_name_for(classifier)
+          return nil unless classifier.is_a?(Ea::Model::Classifier)
+          return nil unless document
+          return nil unless diagram.show_parents
+
+          gen = parent_generalization_for(classifier)
+          return nil unless gen
+
+          parent = model_index[gen.general_id]
+          return nil unless parent
+          return nil if placed_on_diagram?(gen.general_id)
+          return nil if parent_package_represented_on_diagram?(parent)
+
+          name = parent.name.to_s
+          name.empty? ? nil : name
+        end
 
-          family = element.font_family || DEFAULT_FONT_FAMILY
-          size = element.font_size || DEFAULT_FONT_SIZE
-          text_blocks = lines.each_with_index.map do |(text, style), idx|
-            weight = style == :bold ? 700 : 400
-            font_style = style == :italic ? "italic" : "normal"
-            y = bounds.y + 17 + (idx * 17)
-            %(  <text x="#{bounds.x + (bounds.width / 2.0)}" y="#{y}" textLength="#{text.length * 7}" style="font-family:#{family}; font-weight:#{weight}; font-style:#{font_style}; font-size:#{size}px; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00 stroke-width:0; white-space: pre;" xml:space="preserve">#{escape(text)}</text>)
+        def parent_generalization_for(classifier)
+          document.relationships.find do |rel|
+            rel.is_a?(Ea::Model::Generalization) &&
+              rel.specific_id == classifier.id
           end
-          %(<g style="stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00">\n#{text_blocks.join("\n")}\n</g>)
         end
 
-        def render_divider(bounds, stroke, stroke_width)
-          y = bounds.y + 50
-          %(<g style="stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#{stroke}; stroke-opacity:1.00">\n  <path d="M #{bounds.x} #{y} L #{bounds.x + bounds.width} #{y}" shape-rendering="auto"/>\n</g>)
+        def placed_on_diagram?(model_element_ref)
+          (diagram.elements || []).any? { |e| e.model_element_ref == model_element_ref }
         end
 
-        def render_attribute_text(element, bounds, classifier)
-          return "" unless classifier.properties || classifier.operations
+        # Returns true when any element placed on the current diagram
+        # lives in the same package as `parent`. EA suppresses the
+        # parent-class ghost line in that case — the parent's package
+        # is already "represented" on the diagram, so the off-canvas
+        # parent is implicitly visible to the reader.
+        def parent_package_represented_on_diagram?(parent)
+          parent_pkg = parent.is_a?(Ea::Model::Classifier) ? parent.package_id : nil
+          return false unless parent_pkg
+
+          (diagram.elements || []).any? do |e|
+            sibling = model_index[e.model_element_ref]
+            sibling.is_a?(Ea::Model::Classifier) && sibling.package_id == parent_pkg
+          end
+        end
 
-          attr_lines = (classifier.properties || []).map do |p|
-            "+ #{p.name}: #{p.type_name || ''} #{mult_text(p)}"
+        # EA renders a package's child classifiers and sub-packages as
+        # alphabetical "+ Name" rows in the body compartment, but
+        # only when the diagram's t_diagram.ShowPackageContents flag
+        # is non-zero. Returns [] when the diagram suppresses
+        # package contents or the model element isn't a Package.
+        # Each entry is a Struct(name:, kind:) so the renderer can
+        # pick the correct per-type icon (Enumeration vs default).
+        def package_content_lines_for(model_element)
+          return [] unless model_element.is_a?(Ea::Model::Package)
+          return [] unless diagram.show_package_contents
+
+          children = package_children(model_element)
+          return [] if children.empty?
+
+          children.sort_by { |c| c.name.to_s }.map do |c|
+            PackageContentRow.new(name: c.name.to_s, kind: row_icon_kind(c))
           end
-          return "" if attr_lines.empty?
+        end
+
+        def package_children(package)
+          return [] unless model_index
 
-          family = element.font_family || DEFAULT_FONT_FAMILY
-          size = element.font_size || DEFAULT_FONT_SIZE
-          text_blocks = attr_lines.each_with_index.map do |line, idx|
-            y = bounds.y + 68 + (idx * 17)
-            %(  <text x="#{bounds.x + 5}" y="#{y}" textLength="#{line.length * 7}" style="font-family:#{family}; font-weight:400; font-style:normal; font-size:#{size}px; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00 stroke-width:0; white-space: pre;" xml:space="preserve">#{escape(line.strip)}</text>)
+          model_index.values.select do |obj|
+            (obj.is_a?(Ea::Model::Classifier) && obj.package_id == package.id) ||
+              (obj.is_a?(Ea::Model::Package) && obj.parent_id == package.id)
           end
-          %(<g style="stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00">\n#{text_blocks.join("\n")}\n</g>)
         end
 
-        def header_lines(classifier)
-          lines = []
-          if classifier.is_a?(Ea::Model::Klass) && classifier.is_abstract
-            lines << ["_#{classifier.name}", :italic]
-          elsif classifier.stereotype_refs&.any?
-            lines << ["«#{classifier.stereotype_refs.first}»", :normal]
-            lines << [(classifier.qualified_name || classifier.name).to_s, :bold]
+        # Discriminator for the per-row icon shape. EA draws a
+        # list-style icon for Enumeration children (or classifiers
+        # stereotyped "enumeration"), a small 13×9 folder icon for
+        # sub-Packages, and a "folded paper" icon for other
+        # classifiers.
+        def row_icon_kind(child)
+          if child.is_a?(Ea::Model::Package)
+            :package
+          elsif child.is_a?(Ea::Model::Enumeration) ||
+                enumeration_stereotype?(child)
+            :enumeration
           else
-            lines << [(classifier.qualified_name || classifier.name).to_s, :bold]
+            :default
           end
-          lines
         end
 
-        def mult_text(p)
-          lower = p.multiplicity_lower
-          upper = p.multiplicity_upper
-          return "" if lower.nil? && upper.nil?
-          return "" if lower == 1 && upper == 1
+        def enumeration_stereotype?(child)
+          return false unless child.is_a?(Ea::Model::Classifier)
 
-          "[#{lower || 0}..#{upper == -1 ? "*" : upper}]"
+          refs = child.stereotype_refs
+          refs&.any? { |r| r.to_s.downcase == "enumeration" }
         end
 
-        def fill_for_classifier(classifier)
-          return DEFAULT_FILL unless classifier
+        PackageContentRow = Struct.new(:name, :kind, keyword_init: true)
+
+        # Computes y-coordinates for header/divider/attr compartments
+        # given bounds, font size, and line count. See
+        # Element::CompartmentGeometry for the coordinate math.
+        CompartmentGeometry = Element::CompartmentGeometry
+
+        # Returns true when this element's bounds are geometrically
+        # inside another element's bounds in the same diagram. EA
+        # shows qualified names (ParentClass::ChildClass) for
+        # visually-nested classes and simple names for separately-
+        # placed classes.
+        def visually_nested?(element)
+          my_bounds = element.bounds || element.image_bounds
+          return false unless my_bounds
+
+          (diagram.elements || []).any? do |other|
+            next if other.id == element.id
 
-          stereotype = primary_stereotype(classifier)
-          return DEFAULT_FILL unless stereotype
+            other_bounds = other.bounds || other.image_bounds
+            next unless other_bounds
 
-          stereotype_color_resolver.fill_for(stereotype)
+            bounds_contain?(other_bounds, my_bounds)
+          end
         end
 
-        def stereotype_color_resolver
-          @stereotype_color_resolver ||= Ea::Svg::StereotypeColorResolver.new
+        def bounds_contain?(outer, inner)
+          outer.x <= inner.x &&
+            outer.y <= inner.y &&
+            outer.x + outer.width >= inner.x + inner.width &&
+            outer.y + outer.height >= inner.y + inner.height
         end
 
-        def primary_stereotype(classifier)
-          refs = classifier.stereotype_refs
-          return nil if refs.nil? || refs.empty?
+        def resolve_fill(element, classifier)
+          color_resolver.fill_for(element, classifier)
+        end
 
-          refs.first.to_s.split("::").last
+        def resolve_stroke
+          color_resolver.stroke_for(nil)
         end
 
-        def model_element_for(element)
+        def resolve_stroke_width
+          theme.themed? ? theme.stroke_width : DEFAULT_STROKE_WIDTH
+        end
+
+        def color_resolver
+          @color_resolver ||= ColorResolver.new(theme: theme)
+        end
+
+        def theme
+          @theme ||= diagram.theme
+        end
+
+        def display_config
+          @display_config ||= diagram.display_config
+        end
+
+        def show_attributes?
+          display_config.show_attributes?
+        end
+
+        def show_operations?
+          display_config.show_operations?
+        end
+
+        # EA only renders a header→content divider when there's
+        # actual content below (attributes, operations, literals, or
+        # tagged values). Classes with only a header (no displayed
+        # features) omit the divider entirely.
+        def has_content_below_header?(attr_lines, op_lines, enum_literals, tagged_values = [])
+          !attr_lines.empty? || !op_lines.empty? || enum_literals.any? || tagged_values.any?
+        end
+
+        def font_resolver
+          @font_resolver ||= FontResolver.new(diagram, theme: theme)
+        end
+
+        def element_filter
+          @element_filter ||= Element::Filter.new(model_index: model_index)
+        end
+
+        def classifier_for(element)
           ref = element.model_element_ref
           return nil unless ref
 
           candidate = model_index[ref]
-          return nil unless candidate.is_a?(Ea::Model::Classifier)
+          return nil unless candidate.is_a?(Ea::Model::Classifier) ||
+                            candidate.is_a?(Ea::Model::InstanceSpecification)
 
           candidate
         end
 
-        def color_from_ea(bgr_int)
-          return nil if bgr_int.nil?
-
-          r = bgr_int & 0xff
-          g = (bgr_int >> 8) & 0xff
-          b = (bgr_int >> 16) & 0xff
-          format("#%02X%02X%02X", r, g, b)
+        # Lookup proc for AttributeLineBuilder: resolves a
+        # classifier id to the Classifier instance. Returns nil
+        # when not found or not a Classifier.
+        def attribute_lookup
+          lambda { |id| model_index[id] if model_index && model_index[id].is_a?(Ea::Model::Classifier) }
         end
 
-        def escape(text)
-          return "" if text.nil?
+        def model_element_for(element)
+          ref = element.model_element_ref
+          return nil unless ref
+
+          model_index[ref]
+        end
 
-          text.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub("\"", "&quot;")
+        def translate_bounds(b)
+          return b unless canvas
+
+          # Reuse the model's Bounds value object rather than an
+          # ad-hoc OpenStruct. Keeps the type uniform across the
+          # pipeline and avoids require "ostruct".
+          Ea::Model::Bounds.new(
+            x: canvas.translate_x(b.x),
+            y: canvas.translate_y(b.y),
+            width: b.width,
+            height: b.height
+          )
         end
       end
     end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Resolves the effective font family + size for a DiagramElement,
+      # using EA's fallback chain:
+      #
+      #   1. element.font_family / element.font_size (per-element override)
+      #   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)
+      #
+      # Lives outside the Elements emitter so the resolution rule is
+      # defined once (MECE) and reusable by Labels and any future
+      # text-emitting layer.
+      class FontResolver
+        DEFAULT_FONT_FAMILY = "Yu Gothic UI"
+        # EA's default element compartment font size (matches
+        # reference SVGs which use 9pt for classifier header,
+        # attributes, operations, etc. — distinct from theme's
+        # diagram-level font size which applies only to frame
+        # label and swimlanes).
+        DEFAULT_ELEMENT_FONT_SIZE = 9
+
+        attr_reader :diagram, :theme
+
+        def initialize(diagram, theme: nil)
+          @diagram = diagram
+          @theme = theme || Ea::Theme::Registry.default
+        end
+
+        def family_for(element)
+          explicit = element&.font_family
+          return explicit if explicit && !explicit.empty?
+          return theme.font_family if theme.themed? && theme.font_family
+
+          diagram_default_family || DEFAULT_FONT_FAMILY
+        end
+
+        def size_for(element)
+          explicit = element&.font_size
+          explicit = nil if explicit&.zero?
+          return explicit if explicit
+          return diagram_default_size if diagram_default_size
+
+          DEFAULT_ELEMENT_FONT_SIZE
+        end
+
+        def size_unit_for(_element)
+          theme.font_size_unit || "pt"
+        end
+
+        def weight_for(element)
+          bold = element&.font_bold ? 700 : nil
+          bold || (theme.themed? ? theme.text_weight_normal : 400)
+        end
+
+        def style_for(element)
+          element&.font_italic ? "italic" : "normal"
+        end
+
+        private
+
+        # 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.
+        def diagram_default_family
+          families = element_families
+          return FALLBACK_DEFAULT_FAMILY if families.empty?
+
+          most_common(families)
+        end
+
+        def diagram_default_size
+          sizes = element_sizes
+          return nil if sizes.empty?
+
+          most_common(sizes)
+        end
+
+        FALLBACK_DEFAULT_FAMILY = "Calibri"
+
+        def most_common(values)
+          return nil if values.empty?
+
+          tally = tally_values(values)
+          tally.max_by { |_, count| count }.first
+        end
+
+        def element_families
+          (diagram.elements || []).map(&:font_family).compact
+        end
+
+        def element_sizes
+          (diagram.elements || []).map(&:font_size).compact.reject(&:zero?)
+        end
+
+        def tally_values(values)
+          values.each_with_object(Hash.new(0)) { |v, acc| acc[v] += 1 }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Emits ghost classifier name `<text>` elements for connector
+      # endpoints that reference off-canvas classifiers. Each ghost
+      # label appears as italic text near the connector's on-canvas
+      # endpoint.
+      class GhostLabels
+        DEFAULT_FAMILY = "Carlito"
+        DEFAULT_SIZE = 9
+        DEFAULT_UNIT = "pt"
+        DEFAULT_FILL = "#000000"
+
+        attr_reader :diagram, :canvas, :family, :size, :size_unit, :fill
+
+        def initialize(diagram, canvas: nil, family: DEFAULT_FAMILY,
+                       size: DEFAULT_SIZE, size_unit: DEFAULT_UNIT,
+                       fill: DEFAULT_FILL)
+          @diagram = diagram
+          @canvas = canvas
+          @family = family
+          @size = size
+          @size_unit = size_unit
+          @fill = fill
+        end
+
+        def render
+          texts = visible_connectors.flat_map do |connector|
+            (connector.ghost_labels || []).map { |g| text_for(g) }
+          end
+          return "" if texts.empty?
+
+          group_style = "stroke-width:1;stroke-linecap:round;" \
+                        "stroke-linejoin:bevel; fill:#{fill};" \
+                        "fill-opacity:1.00; stroke:#000000;" \
+                        " stroke-opacity:0.00"
+          %(<g style="#{group_style}">\n#{texts.join("\n")}\n</g>)
+        end
+
+        private
+
+        def visible_connectors
+          (diagram.connectors || []).select(&:renderable?)
+        end
+
+        def text_for(ghost)
+          tx, ty = translate(ghost.anchor_x, ghost.anchor_y)
+          TextRenderer.new(
+            content: ghost.name.to_s,
+            x: tx, y: ty,
+            family: family, size: size, size_unit: size_unit,
+            style: "italic", fill: fill
+          ).to_svg
+        end
+
+        def translate(x, y)
+          return [x, y] unless canvas
+
+          [canvas.translate_x(x), canvas.translate_y(y)]
+        end
+      end
+    end
+  end
+end