ea 0.3.1 → 0.5.0

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # 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
+
+        attr_reader :min_x, :min_y, :width, :height
+
+        def initialize(min_x:, min_y:, width:, height:)
+          @min_x = min_x
+          @min_y = min_y
+          @width = width
+          @height = height
+        end
+
+        # 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
+          "0 0 #{width} #{height}"
+        end
+
+        def width_cm
+          format_cm(width)
+        end
+
+        def height_cm
+          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)
+          return "0cm" if px.nil? || px.zero?
+
+          cm = (px / PX_PER_CM.to_f)
+          format("%.2fcm", cm)
+        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

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Instance-name underline for object diagrams. EA draws a
+        # short horizontal line just below each instance name to
+        # denote that it is an instance (UML convention). Rendered
+        # only when the diagram's `diagram_type` is "Object".
+        module InstanceUnderline
+          Y_OFFSET = 2
+          WIDTH_FACTOR = 0.65
+
+          module_function
+
+          def render(context)
+            return nil unless context.diagram
+            return nil unless object_diagram?(context)
+            return nil if context.header_lines.empty?
+
+            name_line = context.header_lines.last
+            text = name_line.first.to_s
+            return nil if text.empty?
+
+            underline_path(context, text)
+          end
+
+          def object_diagram?(context)
+            context.diagram && context.diagram.diagram_type == "Object"
+          end
+          module_function :object_diagram?
+
+          def underline_path(context, text)
+            bounds = context.bounds
+            text_width = TextRenderer.estimate_width(text, context.size,
+                                                     WIDTH_FACTOR)
+            x_start = bounds.x + (bounds.width - text_width) / 2.0
+            y_pos = context.geometry.header_first_y + Y_OFFSET
+            build_path_tag(x_start, y_pos, text_width)
+          end
+          module_function :underline_path
+
+          def build_path_tag(x_start, y_pos, text_width)
+            x_end = x_start + text_width
+            coords = format_coords(x_start, y_pos, x_end)
+            d = "M #{coords[:x1]} #{coords[:y1]} L #{coords[:x2]} #{coords[:y1]}"
+            style = "stroke-width:1;stroke-linecap:square;" \
+                    "stroke-linejoin:miter; fill:none; stroke:#000000;" \
+                    " stroke-opacity:1.00"
+            %(<g style="#{style}">\n  <path d="#{d}" shape-rendering="auto"/>\n</g>)
+          end
+          module_function :build_path_tag
+
+          def format_coords(x_start, y_pos, x_end)
+            {
+              x1: Ea::Svg::EaEmitter::Canvas.coord(x_start),
+              x2: Ea::Svg::EaEmitter::Canvas.coord(x_end),
+              y1: Ea::Svg::EaEmitter::Canvas.coord(y_pos)
+            }
+          end
+          module_function :format_coords
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Note body text wrapped inside a Note element's bounds.
+        # Renders only when the host element is a Note with a
+        # non-empty body.
+        module NoteBody
+          module_function
+
+          def render(context)
+            return nil if context.model_element.is_a?(Ea::Model::Note) &&
+                          context.model_element.legend
+
+            body = context.note_body
+            return nil unless body
+
+            text_blocks = wrapped_lines(context, body)
+            %(<g style="#{group_style(context)}">\n#{text_blocks.join("\n")}\n</g>)
+          end
+
+          def wrapped_lines(context, body)
+            max_chars = [(context.bounds.width / (context.size * 0.6)).floor, 10].max
+            body.to_s.split(/\n/).flat_map do |para|
+              para.gsub(/(.{1,#{max_chars}})(\s+|$)/, "\\1\n").strip.split(/\n/)
+            end.each_with_index.map do |line, idx|
+              y = context.bounds.y + context.theme.note.text_y_offset +
+                  (idx * context.theme.note.line_height)
+              TextRenderer.new(
+                content: line,
+                x: context.bounds.x + context.theme.note.text_x_offset,
+                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
+          end
+
+          def group_style(context)
+            "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
+              "fill:#{context.theme.text_color};fill-opacity:1.00; " \
+              "stroke:#000000; stroke-opacity:0.00"
+          end
+        end
+      end
+    end
+  end
+end