ea 0.4.0 → 0.5.0

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Computes the (min_x, min_y, width, height) tuple for a
+      # Diagram's canvas. Encapsulates the union rules so Canvas
+      # stays a small value-object with just coordinate translation
+      # and formatting concerns.
+      #
+      # Sources contributing to the bounds:
+      #   - ElementBounds:    logical x-extent, logical+image y-extent
+      #   - ConnectorBounds:  waypoint positions
+      #   - MarkerExtent:     MARKER_EXTENT padding around end points
+      #   - PackageTabExtent: extra space above Package elements for
+      #                       the tab polygon (which sits above the
+      #                       element's logical top).
+      #
+      # Each source is a method returning an Array<[x, y]> points.
+      # Composing new sources = adding a method, no modification of
+      # existing ones (OCP).
+      class BoundsCalculator
+        MARKER_EXTENT = 15
+        PACKAGE_TAB_HEIGHT = 20
+        # EA's canvas includes non-uniform frame insets around the
+        # element content. Reverse-engineered from reference SVG
+        # byte-diff: maintenance diagram has element 169x80 at
+        # logical (0,0), ref canvas is 254x177 with element at
+        # (35, 40). So:
+        #   canvas_width  = element_width + INSET_LEFT + INSET_RIGHT
+        #   canvas_height = element_height + INSET_TOP + INSET_BOTTOM
+        # The top inset accommodates the frame tab + label space
+        # above the element.
+        INSET_LEFT = 35
+        INSET_RIGHT = 50
+        INSET_TOP = 40
+        INSET_BOTTOM = 57
+
+        attr_reader :diagram, :model_index
+
+        def initialize(diagram, model_index: nil)
+          @diagram = diagram
+          @model_index = model_index
+        end
+
+        def compute
+          points = []
+          points.concat(element_points)
+          points.concat(connector_points)
+          points.concat(marker_points)
+          points.concat(package_tab_points)
+          return [0, 0, 1, 1] if points.empty?
+
+          xs = points.map(&:first)
+          ys = points.map(&:last)
+          min_x = xs.min || 0
+          min_y = ys.min || 0
+          [
+            min_x,
+            min_y,
+            (xs.max - min_x) + INSET_LEFT + INSET_RIGHT,
+            (ys.max - min_y) + INSET_TOP + INSET_BOTTOM
+          ]
+        end
+
+        private
+
+        # Element x-extent: logical bounds only (matches EA's canvas
+        # left/right exactly).
+        # Element y-extent: union of logical + image_bounds (image
+        # extends below bounds for shadow / image padding).
+        def element_points
+          pts = []
+          (diagram.elements || []).each do |e|
+            primary = e.bounds || e.image_bounds
+            if primary
+              pts << [primary.x, primary.y]
+              pts << [primary.x + primary.width, primary.y + primary.height]
+            end
+            if e.bounds && e.image_bounds
+              ib = e.image_bounds
+              pts << [ib.x, ib.y]
+              pts << [ib.x + ib.width, ib.y + ib.height]
+            end
+          end
+          pts
+        end
+
+        # Package elements render with a tab polygon ABOVE the
+        # element's logical top edge (height PACKAGE_TAB_HEIGHT).
+        # Include those points so the canvas reserves space.
+        def package_tab_points
+          return [] if model_index.nil?
+
+          pts = []
+          (diagram.elements || []).each do |e|
+            ref = e.model_element_ref
+            next unless ref
+
+            candidate = model_index[ref]
+            next unless candidate.is_a?(Ea::Model::Package)
+
+            primary = e.bounds || e.image_bounds
+            next unless primary
+
+            pts << [primary.x, primary.y - PACKAGE_TAB_HEIGHT]
+            pts << [primary.x + primary.width, primary.y]
+          end
+          pts
+        end
+
+        def connector_points
+          pts = []
+          (diagram.connectors || []).each do |c|
+            (c.waypoints || []).each do |wp|
+              next unless wp.position
+
+              pts << [wp.position.x, wp.position.y]
+            end
+          end
+          pts
+        end
+
+        def marker_points
+          pts = []
+          (diagram.connectors || []).each do |c|
+            waypoints = (c.waypoints || []).map(&:position).compact
+            next unless waypoints.size >= 2
+
+            source = waypoints.first
+            target = waypoints.last
+            pts << [source.x - MARKER_EXTENT, source.y - MARKER_EXTENT]
+            pts << [source.x + MARKER_EXTENT, source.y + MARKER_EXTENT]
+            pts << [target.x - MARKER_EXTENT, target.y - MARKER_EXTENT]
+            pts << [target.x + MARKER_EXTENT, target.y + MARKER_EXTENT]
+          end
+          pts
+        end
+      end
+    end
+  end
+end

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

@@ -3,44 +3,47 @@
 module Ea
   module Svg
     module EaEmitter
-      # Computes the canvas dimensions for the root <svg> element.
-      # Union of all element image_bounds (the padded bounds EA
-      # uses for the visual box), with a 10 px outer margin.
-      # Emits cm dimensions (px / 28.346 at 72 DPI).
-      Canvas = Struct.new(:min_x, :min_y, :width, :height, keyword_init: true) do
-        PX_PER_CM = 28.3464567
+      # Canvas carries the diagram's computed pixel bounds plus the
+      # coordinate-translation helpers that align element (0,0) with
+      # EA's content origin (35, 40). Bound computation itself is
+      # delegated to BoundsCalculator (SRP).
+      #
+      # Promoted from a Struct.new + `do ... end` block to a proper
+      # class so the public API is explicit (attr_reader vs implicit
+      # struct fields) and behavior is named rather than implicit.
+      # Struct definitions with instance methods conflate "data" and
+      # "behavior" — a class keeps them separable while the values
+      # stay immutable.
+      class Canvas
+        # EA's diagram canvas places element (0,0) at SVG (35, 40) —
+        # the diagram's content origin inset from the canvas top-left
+        # corner. Reverse-engineered from reference SVG byte-diff
+        # against the maintenance diagram.
+        PX_PER_CM = 37.795275591
+        FRAME_INSET_LEFT = 35
+        FRAME_INSET_TOP = 40
 
-        def self.from(diagram)
-          points = []
-          (diagram.elements || []).each do |e|
-            b = e.image_bounds || e.bounds
-            next unless b
+        attr_reader :min_x, :min_y, :width, :height
 
-            points << [b.x, b.y]
-            points << [b.x + b.width, b.y + b.height]
-          end
-          (diagram.connectors || []).each do |c|
-            (c.waypoints || []).each do |wp|
-              next unless wp.position
-
-              points << [wp.position.x, wp.position.y]
-            end
-          end
-          return new(min_x: 0, min_y: 0, width: 1, height: 1) if points.empty?
+        def initialize(min_x:, min_y:, width:, height:)
+          @min_x = min_x
+          @min_y = min_y
+          @width = width
+          @height = height
+        end
 
-          xs = points.map(&:first)
-          ys = points.map(&:last)
-          margin = 10
-          new(
-            min_x: (xs.min || 0) - margin,
-            min_y: (ys.min || 0) - margin,
-            width: (xs.max - xs.min) + (2 * margin),
-            height: (ys.max - ys.min) + (2 * margin)
-          )
+        # Build a Canvas for a diagram by running the bound
+        # calculator. Defaults model_index to nil (no canvas-aware
+        # element bounds needed) for callers that only need a
+        # frame-size estimate.
+        def self.from(diagram, model_index: nil)
+          min_x, min_y, width, height =
+            BoundsCalculator.new(diagram, model_index: model_index).compute
+          new(min_x: min_x, min_y: min_y, width: width, height: height)
         end
 
         def view_box
-          "#{min_x} #{min_y} #{width} #{height}"
+          "0 0 #{width} #{height}"
         end
 
         def width_cm
@@ -51,6 +54,26 @@ module Ea
           format_cm(height)
         end
 
+        # Translate a content-space point into SVG-space. EA insets
+        # the content area from the canvas top-left by
+        # FRAME_INSET_LEFT/TOP.
+        def translate_x(x)
+          x - min_x + FRAME_INSET_LEFT
+        end
+
+        def translate_y(y)
+          y - min_y + FRAME_INSET_TOP
+        end
+
+        # Compact coordinate formatter. Integers lose the decimal
+        # point; floats keep up to two digits with trailing zeros
+        # stripped (matches EA's emitted numeric format).
+        def self.coord(value)
+          return value.to_i.to_s if value == value.to_i
+
+          format("%.2f", value).sub(/\.?0+$/, "")
+        end
+
         private
 
         def format_cm(px)
@@ -62,4 +85,4 @@ module Ea
       end
     end
   end
-end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Single source of truth for fill + stroke color decisions.
+      #
+      # Theme :119 applies:
+      #   - Border color (#9A8484) for element strokes
+      #   - Attribute color (#66413F) for attribute text
+      #   - Method color for operation text
+      # Theme :119 does NOT apply:
+      #   - Per-type fill colors (elements use default #FFFFFF)
+      #   - Text color (#000000 black for non-attribute text)
+      #
+      # Precedence chain for fill:
+      #   1. Element's BCol int (when present and not sentinel)
+      #   2. Default fill (#FFFFFF)
+      #
+      # Precedence chain for stroke:
+      #   1. Element's LCol int (when present and not sentinel)
+      #   2. Theme border color (when theme is themed)
+      #   3. Default stroke (#000000)
+      class ColorResolver
+        DEFAULT_FILL = "#FFFFFF"
+        DEFAULT_STROKE = "#000000"
+
+        attr_reader :theme, :stereotype_resolver
+
+        def initialize(theme: nil, stereotype_resolver: Ea::Svg::StereotypeColorResolver.new)
+          @theme = theme || Ea::Theme::Registry.default
+          @stereotype_resolver = stereotype_resolver
+        end
+
+        def fill_for(element, classifier)
+          bcol = Element::BColDecoder.to_hex(element&.background_color)
+          return bcol if bcol
+
+          DEFAULT_FILL
+        end
+
+        def stroke_for(element)
+          lcol = Element::BColDecoder.to_hex(element&.line_color)
+          return lcol if lcol
+          return theme.border_color if theme.themed?
+
+          DEFAULT_STROKE
+        end
+
+        def attribute_text_color
+          theme.themed? ? (theme.attribute_color || DEFAULT_STROKE) : DEFAULT_STROKE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Attribute compartment. Skipped when no attribute lines.
+        module Attributes
+          module_function
+
+          def render(context)
+            return nil if context.attr_lines.empty?
+
+            Element::AttributeRenderer.render(
+              context.attr_lines,
+              bounds: context.bounds,
+              first_y: context.geometry.attr_first_y,
+              family: context.family, size: context.size, size_unit: context.size_unit,
+              fill: context.theme.attribute_text_color,
+              visibility_x_offset: context.theme.attribute_spec.visibility_x_offset,
+              content_x_offset: context.theme.attribute_spec.content_x_offset
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Constraints compartment. Skipped when the classifier has no
+        # constraints. Renders an italic "constraints" header and one
+        # "{name}" line per constraint.
+        module Constraints
+          DEFAULT_TEXT_COLOR = "#000000"
+
+          module_function
+
+          def render(context)
+            return nil unless context.constraints&.any?
+
+            Element::ConstraintRenderer.render(
+              context.constraints,
+              bounds: context.bounds,
+              first_y: context.geometry.tagged_value_first_y,
+              family: context.family, size: context.size,
+              fill: DEFAULT_TEXT_COLOR
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Enumeration literal compartment: divider line + "literals"
+        # italic header + each literal name. Skipped when the
+        # classifier has no literals or the geometry cannot fit them.
+        module EnumLiterals
+          module_function
+
+          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")
+          end
+
+          def render_literals_block(context)
+            line_h = context.size + (context.theme.compartments.attr_line_offset || 4)
+            text_blocks = [literal_header_text(context)]
+            context.enum_literals.each_with_index do |literal, idx|
+              y = context.geometry.enum_literal_first_y + ((idx + 1) * 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: " ",
+              x: context.bounds.x + (context.theme.attribute_spec.visibility_x_offset || 5),
+              y: y,
+              family: context.family, size: context.size, size_unit: context.size_unit,
+              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 literal_name_text(context, literal, y)
+            TextRenderer.new(
+              content: literal.name.to_s,
+              x: context.bounds.x + (context.theme.attribute_spec.content_x_offset || 26),
+              y: y,
+              family: context.family, size: context.size, size_unit: context.size_unit,
+              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 wrap_group(text_blocks, text_color)
+            style = "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
+                    "fill:#{text_color};fill-opacity:1.00; " \
+                    "stroke:#000000; stroke-opacity:0.00"
+            %(<g style="#{style}">\n#{text_blocks.join("\n")}\n</g>)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Header compartment: stereotype label + class name. Skips
+        # rendering when the classifier produces no header lines.
+        module Header
+          module_function
+
+          def render(context)
+            return nil if context.header_lines.empty?
+
+            Element::HeaderRenderer.render(
+              context.header_lines,
+              bounds: context.bounds,
+              first_y: context.geometry.header_first_y,
+              family: context.family, size: context.size, size_unit: context.size_unit,
+              fill: context.theme.text_color,
+              weight_normal: context.theme.text_weight_normal,
+              weight_bold: context.theme.text_weight_bold,
+              stroke_in_text: context.theme.stroke_in_text_color,
+              width_factor: context.theme.text_width_factor,
+              line_offset: context.theme.compartments.header_line_offset
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Horizontal divider between header and the first content
+        # compartment (attributes / operations / literals / tagged
+        # values). Skipped when there is no content below.
+        module HeaderDivider
+          module_function
+
+          def render(context)
+            return nil unless context.geometry
+            return nil unless context.geometry.divider_y
+            return nil unless divider_required?(context)
+
+            Element::DividerRenderer.render(
+              context.bounds,
+              y: context.geometry.divider_y,
+              stroke: context.stroke,
+              stroke_width: context.stroke_width
+            )
+          end
+
+          # EA shows a header divider on Object diagrams when the
+          # element is large enough to hold a slot compartment (height
+          # > 50). The starter Object diagram uses 90×50 boxes with
+          # no slots and no divider; richer Object diagrams use
+          # 133×53+ boxes with the divider always present. On
+          # HandDraw diagrams (Domain Model), every element shows a
+          # divider regardless of content. For other diagrams the
+          # divider is shown only when there is content below the
+          # header.
+          def divider_required?(context)
+            return true if hand_draw?(context)
+            return object_element_with_slots?(context) if object_diagram?(context)
+
+            context.content_below_header?
+          end
+
+          def object_diagram?(context)
+            context.diagram && context.diagram.diagram_type == "Object"
+          end
+
+          def hand_draw?(context)
+            context.diagram && context.diagram.hand_draw
+          end
+
+          def object_element_with_slots?(context)
+            context.bounds && context.bounds.height.to_i > 50
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Instance slot compartment. Renders each slot on an
+        # InstanceSpecification as "name op value", then appends
+        # "(from PackageName)" in italics below the slots when the
+        # instance has a classifier. Skipped entirely when the model
+        # element is not an InstanceSpecification or has neither
+        # slots nor a classifier.
+        module InstanceSlots
+          ROW_OFFSET = 13
+          SUBTITLE_EXTRA_OFFSET = 10
+
+          module_function
+
+          def render(context)
+            return nil unless instance?(context)
+
+            instance = context.model_element
+            slots = instance.slots || []
+            subtitle = from_package_subtitle(instance)
+            return nil if slots.empty? && subtitle.nil?
+
+            first_y = context.geometry.attr_first_y
+            bounds = context.bounds
+            fill = context.theme.attribute_text_color
+            blocks = []
+            slots.each_with_index do |slot, idx|
+              y = first_y + (idx * ROW_OFFSET)
+              blocks << line_text(slot, bounds, y, context, fill)
+            end
+            if subtitle
+              y = first_y + (slots.size * ROW_OFFSET) + SUBTITLE_EXTRA_OFFSET
+              blocks << subtitle_text(subtitle, bounds, y, context, fill)
+            end
+            wrap(blocks.join("\n"), fill)
+          end
+
+          def instance?(context)
+            context.model_element.is_a?(Ea::Model::InstanceSpecification)
+          end
+          module_function :instance?
+
+          def from_package_subtitle(instance)
+            pkg = instance.package_name
+            return nil if pkg.nil? || pkg.empty?
+
+            classifier = instance.classifier_name
+            return nil if classifier.nil? || classifier.empty?
+
+            "(from #{pkg})"
+          end
+          module_function :from_package_subtitle
+
+          def line_text(slot, bounds, y_pos, context, fill)
+            content = "#{slot.name} #{slot.op} #{slot.value}"
+            TextRenderer.new(
+              content: content,
+              x: bounds.x + (context.theme.attribute_spec.content_x_offset || 26),
+              y: y_pos,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, fill: fill
+            ).to_svg
+          end
+          module_function :line_text
+
+          def subtitle_text(text, bounds, y_pos, context, fill)
+            estimated_width = text.length * context.size * 0.5
+            x_pos = bounds.x + (bounds.width - estimated_width) / 2.0
+            TextRenderer.new(
+              content: text,
+              x: x_pos,
+              y: y_pos,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, fill: fill,
+              style: "italic"
+            ).to_svg
+          end
+          module_function :subtitle_text
+
+          def wrap(body, fill)
+            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#{body}\n</g>)
+          end
+          module_function :wrap
+        end
+      end
+    end
+  end
+end