ea 0.4.0 → 0.5.1

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

@@ -4,40 +4,64 @@ module Ea
   module Svg
     module EaEmitter
       # Top-level orchestrator: emits a complete standalone SVG
-      # document matching EA's structure. Calls the layer emitters
-      # in EA's canonical order.
+      # document matching EA's encoding. Bound computation and
+      # layer sequencing delegated to BoundsCalculator and
+      # LayerSequencer respectively (SRP).
       class Document
-        BUILD_ID = "1628"
+        BUILD_ID = "1624"
 
-        attr_reader :diagram, :model_index, :options
+        attr_reader :diagram, :model_index, :frame, :document
 
-        def initialize(diagram, model_index:, **_options)
+        def initialize(diagram, model_index:, frame: true, document: nil, **_options)
           @diagram = diagram
           @model_index = model_index
+          @frame = frame
+          @document = document
         end
 
         def render
-          canvas = Canvas.from(diagram)
-          layers = [
-            Background.render(canvas),
-            Elements.new(diagram, model_index: model_index).render,
-            Connectors.new(diagram).render,
-            Markers.new(diagram, model_index: model_index).render,
-            Labels.new(diagram).render
-          ].reject { |s| s.nil? || s.empty? }
-
-          <<~SVG
-            <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-            <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
-
-            <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="#{canvas.width_cm}" height="#{canvas.height_cm}" viewBox="#{canvas.view_box}">
-            <title></title>
-            <desc>Created with Enterprise Architect (Build: #{BUILD_ID}) 2</desc>
-
-            #{layers.join("\n\n")}
-            </svg>
-          SVG
+          canvas = Canvas.from(diagram, model_index: model_index)
+          layers = LayerSequencer.new(diagram, model_index: model_index,
+                                        canvas: canvas, frame: frame,
+                                        document: document)
+                                  .layers
+                                  .reject { |s| s.nil? || s.empty? }
+          image_layer = emit_images
+          layers << image_layer if image_layer
+
+          %(<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">\n\n<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="#{canvas.width_cm}" height="#{canvas.height_cm}" viewBox="#{canvas.view_box}">\n<title></title>\n<desc>Created with Enterprise Architect (Build: #{BUILD_ID}) 2</desc>\n#{layers.join("\n")}\n</svg>)
+        end
+
+        # Walks t_image rows (when the document carries a Database
+        # with an :images collection) and invokes EmfRenderer on
+        # each. Emits an `<image>` element per successfully converted
+        # SVG, or returns nil when no images or all conversions fail.
+        #
+        # The emfsvg gem currently can't parse EA's specific EMF
+        # variant (see TODO.diagrams/87 + TODO.complete/56). Until
+        # upstream emfsvg supports it, this method returns nil
+        # gracefully. The wiring is correct infrastructure for when
+        # emfsvg catches up.
+        def emit_images
+          return nil unless document
+          return nil unless document.is_a?(Ea::Qea::Database)
+
+          images = document.collections[:images] || []
+          return nil if images.empty?
+
+          fragments = images.filter_map { |image| render_image(image) }
+          return nil if fragments.empty?
+
+          %(<g id="images">\n#{fragments.join("\n")}\n</g>)
+        end
+
+        def render_image(image)
+          svg = Ea::Image::EmfRenderer.render(image.bytes)
+          return nil unless svg
+
+          %(<g>#{svg}</g>)
         end
+        private :render_image
       end
     end
   end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Builds the text representation of a single property line
+        # for the attribute compartment. Encapsulates the four EA
+        # rendering rules:
+        #
+        #   1. Visibility marker (+, -, #, ~).
+        #   2. Namespace prefix on properties inherited from a
+        #      classifier in a different package ("core::mimeType").
+        #   3. Primitive type name stripping ("xs::double" → "double").
+        #   4. Multiplicity shorthand ("[2..2]" → "[2]") and
+        #      `{ordered}` modifier.
+        #
+        # Stateless: each call returns a fresh line String. Pass a
+        # `Lookup` to enable cross-classifier resolution (namespace
+        # prefix). Without a lookup, the line is rendered as-is
+        # (backwards-compatible).
+        class AttributeLineBuilder
+          # XSD primitive types whose namespace prefix EA drops in
+          # the rendered attribute line. The full set is not yet
+          # reverse-engineered — leave empty for now so we never
+          # wrongly strip a prefix. TODO-D 47 will populate this
+          # once verified per-diagram.
+          PRIMITIVE_TYPES = Set.new([]).freeze
+
+          attr_reader :property, :host, :lookup
+
+          # property - the Ea::Model::Property to render
+          # host     - the Ea::Model::Classifier whose compartment
+          #            we're rendering (determines "inherited" status)
+          # lookup   - object responding to `#call(id) -> Classifier`
+          #            used to resolve the property's declaring
+          #            classifier (defaults to no lookup).
+          def initialize(property, host: nil, lookup: nil)
+            @property = property
+            @host = host
+            @lookup = lookup
+          end
+
+          def to_s
+            parts = ["#{visibility_marker} "]
+            parts << namespaced_name
+            type_str = formatted_type
+            parts << ": #{type_str}" unless type_str.empty?
+            mult = multiplicity
+            parts << " #{mult}" unless mult.empty?
+            parts << " = #{property.default_value}" if property.default_value && !property.default_value.to_s.empty?
+            parts.join.rstrip
+          end
+
+          private
+
+          def visibility_marker
+            case property.visibility
+            when "private"   then "-"
+            when "protected" then "#"
+            when "package"   then "~"
+            else "+"
+            end
+          end
+
+          # Property name, prefixed with the declaring classifier's
+          # package name when the property is inherited from a
+          # different package than the host classifier.
+          def namespaced_name
+            prefix = inherited_namespace_prefix
+            base = property.name.to_s
+            prefix && !prefix.empty? ? "#{prefix}::#{base}" : base
+          end
+
+          # Returns the declaring classifier's package name when it
+          # differs from the host's package; nil otherwise.
+          def inherited_namespace_prefix
+            return nil unless host && lookup
+            return nil if property.owner_id.nil? || property.owner_id == host.id
+
+            owner = lookup.call(property.owner_id)
+            return nil unless owner.is_a?(Ea::Model::Classifier)
+            return nil if owner.package_id.nil?
+            return nil if owner.package_id == host.package_id
+
+            owner.package_name
+          end
+
+          # Format the type name. Primitive types from the PRIMITIVE_TYPES
+          # set render bare; everything else renders verbatim from the
+          # source. The source already provides the correct colon form
+          # (single for XSD, double for UML package qualifiers).
+          def formatted_type
+            raw = property.type_name.to_s
+            return "" if raw.empty?
+
+            simple = raw.split(":").last.to_s.split("::").last.to_s
+            PRIMITIVE_TYPES.member?(simple) ? simple : raw
+          end
+
+          def multiplicity
+            lower = property.multiplicity_lower
+            upper = property.multiplicity_upper
+            return "" if lower.nil? && upper.nil?
+            return "" if lower == 1 && upper == 1
+
+            "[#{lower || 0}..#{bound_text(upper)}]"
+          end
+
+          def bound_text(value)
+            value == -1 ? "*" : value.to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the attribute compartment text `<g>`. Each attribute
+        # renders as TWO `<text>` elements (visibility marker +
+        # content) matching EA's encoding.
+        class AttributeRenderer
+          DEFAULT_VISIBILITY_X_OFFSET = 5
+          DEFAULT_CONTENT_X_OFFSET = 26
+          DEFAULT_FONT_UNIT = "pt"
+
+          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
+            text_blocks = []
+            lines.each_with_index do |line, idx|
+              y = first_y + (idx * line_h)
+              visibility, rest = split_visibility(line)
+              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)
+              else
+                text_blocks << build_text(bounds.x + visibility_x_offset, y, line.strip, family, size, size_unit, fill)
+              end
+            end
+            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#{text_blocks.join("\n")}\n</g>)
+          end
+
+          # Builds attribute display lines from classifier properties,
+          # hiding properties that are navigable association ends
+          # (those are rendered as connector lines).
+          #
+          # When a property carries a stereotype (e.g. «voidable»),
+          # EA renders the stereotype label as a separate line above
+          # the property's own line. We insert those labels here so
+          # the renderer's per-line spacing naturally places them.
+          #
+          # 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)
+            return [] unless props
+
+            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
+
+          # Internal helpers
+
+          def self.split_visibility(line)
+            stripped = line.strip
+            return [nil, stripped] unless stripped.match?(/^[-+~#]\s/)
+
+            visibility = "#{stripped[0]} "
+            rest = stripped[2..].to_s.strip
+            [visibility, rest]
+          end
+          private_class_method :split_visibility
+
+          def self.build_text(x, y, content, family, size, size_unit = DEFAULT_FONT_UNIT, fill = "#000000")
+            TextRenderer.new(content: content, x: x, y: y,
+                              family: family, size: size, size_unit: size_unit, fill: fill).to_svg
+          end
+          private_class_method :build_text
+
+          def self.displayable_properties(classifier)
+            return nil unless classifier.properties
+
+            classifier.properties.reject(&:association_id)
+          end
+          private_class_method :displayable_properties
+
+          # Returns the first stereotype ref for a property, or nil.
+          # Used to emit «voidable» (and similar) labels above the
+          # property's own line.
+          def self.property_stereotype(property)
+            refs = property.stereotype_refs
+            return nil unless refs&.any?
+
+            refs.first.to_s
+          end
+          private_class_method :property_stereotype
+
+          # EA renders namespace separators as "::" (UML standard)
+          # even when the source XMI stores them as ":" (XML style).
+          def self.namespace_double_colon(type_name)
+            return nil if type_name.nil? || type_name.empty?
+
+            type_name.to_s.gsub(/([A-Za-z0-9_]):([A-Za-z])/, '\1::\2')
+          end
+          private_class_method :namespace_double_colon
+
+          def self.multiplicity_text(property)
+            lower = property.multiplicity_lower
+            upper = property.multiplicity_upper
+            return "" if lower.nil? && upper.nil?
+            return "" if lower == 1 && upper == 1
+            return "[#{upper == -1 ? "*" : upper}]" if lower == upper
+
+            "[#{lower || 0}..#{upper == -1 ? "*" : upper}]"
+          end
+          private_class_method :multiplicity_text
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Decodes EA's BGR-encoded BCol/LCol integers into "#RRGGBB"
+        # hex strings. EA stores color as a Win32 COLORREF: R in low
+        # byte, G in mid byte, B in high byte.
+        #
+        # Returns nil when bgr_int is nil OR equals -1 (EA's sentinel
+        # for "no color override" — callers fall through to a
+        # stereotype-derived default).
+        class BColDecoder
+          SENTINEL = -1
+
+          def self.to_hex(bgr_int)
+            return nil if bgr_int.nil? || bgr_int == SENTINEL
+
+            r = bgr_int & 0xff
+            g = (bgr_int >> 8) & 0xff
+            b = (bgr_int >> 16) & 0xff
+            format("#%02X%02X%02X", r, g, b)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Y-coordinate calculator for the compartments of an element
+        # box: header text, header divider, attribute rows, operation
+        # rows, enum literals, tagged-value rows.
+        #
+        # Owns its own coordinate math; the rest of Elements only
+        # reads `header_first_y`, `divider_y`, `attr_first_y`, etc.
+        # Construction takes the bounds, font size, line counts,
+        # and per-region offsets from the theme.
+        #
+        # Extracted from Elements.rb to keep each concern in one
+        # place (MECE). Element rendering reads these values;
+        # coordinate math changes don't ripple into rendering.
+        class CompartmentGeometry
+          attr_reader :bounds, :size, :header_lines_count,
+                      :attr_lines_count, :op_lines_count,
+                      :tagged_values_count,
+                      :header_top_padding, :header_line_offset,
+                      :divider_offset, :attr_line_offset,
+                      :attr_first_offset
+
+          def initialize(bounds:, size:, header_lines_count:,
+                          attr_lines_count:, op_lines_count:,
+                          tagged_values_count:,
+                          header_top_padding: 9,
+                          header_line_offset: 6,
+                          divider_offset: 8,
+                          attr_line_offset: 4,
+                          attr_first_offset: 7)
+            @bounds = bounds
+            @size = size
+            @header_lines_count = header_lines_count
+            @attr_lines_count = attr_lines_count
+            @op_lines_count = op_lines_count
+            @tagged_values_count = tagged_values_count
+            @header_top_padding = header_top_padding
+            @header_line_offset = header_line_offset
+            @divider_offset = divider_offset
+            @attr_line_offset = attr_line_offset
+            @attr_first_offset = attr_first_offset
+          end
+
+          def header_first_y
+            bounds.y + size + (header_top_padding || 9)
+          end
+
+          # Y of the divider line between header and the rest.
+          # Returns nil when there's no header content to separate
+          # from empty below-header content.
+          def divider_y
+            return nil if header_lines_count.zero?
+
+            header_first_y +
+              ([header_lines_count, 1].max - 1) * (size + (header_line_offset || 6)) +
+              (divider_offset || 8)
+          end
+
+          def attr_first_y
+            return bounds.y + size + (header_top_padding || 9) + 12 unless divider_y
+
+            divider_y + size + (attr_first_offset || 7)
+          end
+
+          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))
+          end
+
+          def op_divider_y
+            attr_bottom_y + size + 5
+          end
+
+          def op_first_y
+            return nil unless op_lines_count&.positive?
+
+            op_divider_y + size + 5
+          end
+
+          def op_bottom_y
+            return op_divider_y unless op_lines_count&.positive?
+
+            op_first_y + (op_lines_count - 1) * (size + 4)
+          end
+
+          def enum_divider_y
+            op_bottom_y + size + 5
+          end
+
+          def enum_literal_first_y
+            enum_divider_y + size + 5
+          end
+
+          # Tagged values appear after attributes (or after ops if
+          # present). EA does not emit a separate divider — the
+          # italic "tags" header marks the compartment.
+          def tagged_value_first_y
+            return nil unless tagged_values_count&.positive?
+
+            base = attr_bottom_y
+            base = op_bottom_y if op_lines_count&.positive?
+            base + size + 5
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the constraints compartment text `<g>`. EA renders
+        # constraints as a sub-compartment with an italic "constraints"
+        # header followed by `{name}` lines:
+        #
+        #   <text style="...font-style:italic;...">constraints</text>
+        #   <text style="...font-style:normal;...">{pattern}</text>
+        class ConstraintRenderer
+          HEADER_TEXT = "constraints"
+          HEADER_X_OFFSET = 5
+          LINE_X_OFFSET = 5
+
+          def self.render(constraints, bounds:, first_y:, family:, size:,
+                          fill: "#000000")
+            line_h = size + 4
+            text_blocks = []
+            text_blocks << build_text(
+              bounds.x + centered_x_offset(bounds, size), first_y,
+              HEADER_TEXT, family, size, fill, style: "italic"
+            )
+            constraints.each_with_index do |constraint, idx|
+              y = first_y + ((idx + 1) * line_h)
+              text_blocks << build_text(
+                bounds.x + LINE_X_OFFSET, y,
+                "{#{constraint.name}}", family, size, fill
+              )
+            end
+            %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
+          end
+
+          def self.build_text(x, y, content, family, size, fill, style: "normal")
+            TextRenderer.new(content: content, x: x, y: y,
+                              family: family, size: size, fill: fill,
+                              style: style).to_svg
+          end
+          private_class_method :build_text
+
+          def self.centered_x_offset(bounds, size)
+            text_width = HEADER_TEXT.length * (size / 2)
+            centered = (bounds.width / 2 - text_width / 2).floor
+            [HEADER_X_OFFSET, centered].max
+          end
+          private_class_method :centered_x_offset
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the horizontal divider path between header and
+        # attribute compartments.
+        class DividerRenderer
+          def self.render(bounds, y:, stroke:, stroke_width:)
+            %(<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 #{Canvas.coord(bounds.x)} #{Canvas.coord(y)} L #{Canvas.coord(bounds.x + bounds.width)} #{Canvas.coord(y)}" shape-rendering="auto"/>\n</g>)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the enumeration literal compartment text `<g>`. Each
+        # literal appears as a separate text element matching EA's
+        # encoding:
+        #
+        #   <text>literal_name</text>
+        #
+        # Rendered as a third compartment below the attribute
+        # compartment for Enumeration classifiers.
+        class EnumerationLiteralRenderer
+          def self.render(literals, bounds:, first_y:, family:, size:)
+            line_h = size + 4
+            text_blocks = literals.each_with_index.map do |literal, idx|
+              y = first_y + (idx * line_h)
+              build_text(bounds.x + 5, y, literal.name.to_s, family, size)
+            end
+            %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
+          end
+
+          def self.build_text(x, y, content, family, size)
+            TextRenderer.new(content: content, x: x, y: y,
+                              family: family, size: size).to_svg
+          end
+          private_class_method :build_text
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Predicate: should this element be rendered, or is it a
+        # diagram-frame placeholder that EA skips?
+        class Filter
+          attr_reader :model_index
+
+          def initialize(model_index:)
+            @model_index = model_index
+          end
+
+          # Returns true if the element should be SKIPPED.
+          # EA emits a "diagram frame placeholder" Classifier with
+          # no name and no properties on some diagrams — those get
+          # dropped. Packages and named Classifiers are always kept.
+          def skip?(element)
+            return false unless element.background_color == -1
+
+            classifier = classifier_for(element)
+            return false unless classifier
+
+            classifier.name.to_s.strip.empty? && (classifier.properties.nil? || classifier.properties.empty?)
+          end
+
+          private
+
+          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)
+
+            candidate
+          end
+        end
+      end
+    end
+  end
+end