ea 0.4.0 → 0.5.1

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

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Note text compartment. When diagram.show_notes is true,
+        # renders the classifier's documentation note (from
+        # t_object.Note) as wrapped text lines in the element body.
+        # Lines are estimated by character width and split at word
+        # boundaries to fit the element bounds.
+        module NoteText
+          X_PADDING = 5
+          Y_FIRST_OFFSET = 15
+          LINE_OFFSET = 13
+          CHAR_WIDTH_FACTOR = 0.55
+
+          module_function
+
+          def render(context)
+            return nil unless show_notes?(context)
+            return nil unless context.classifier&.is_a?(Ea::Model::Classifier)
+
+            notes = note_bodies(context.classifier)
+            return nil if notes.empty?
+
+            first_y = context.geometry.attr_first_y + Y_FIRST_OFFSET
+            bounds = context.bounds
+            fill = context.theme.attribute_text_color
+            usable_width = bounds.width - (X_PADDING * 2)
+            max_chars = (usable_width / (context.size * CHAR_WIDTH_FACTOR)).floor
+
+            texts = []
+            y = first_y
+            notes.each do |body|
+              wrapped_lines(body, max_chars).each do |line|
+                texts << build_text(line, bounds.x + X_PADDING, y, context, fill)
+                y += LINE_OFFSET
+              end
+            end
+            wrap_group(texts.join("\n"), fill)
+          end
+
+          def show_notes?(context)
+            context.diagram && context.diagram.show_notes
+          end
+          module_function :show_notes?
+
+          def note_bodies(classifier)
+            (classifier.annotations || []).filter_map do |a|
+              body = a.body.to_s.strip
+              body.empty? ? nil : body
+            end
+          end
+          module_function :note_bodies
+
+          # Word-wrap text at max_chars, preserving word boundaries.
+          def wrapped_lines(text, max_chars)
+            return [text] if text.length <= max_chars
+
+            words = text.split(" ")
+            lines = []
+            current = ""
+            words.each do |word|
+              if current.empty?
+                current = word
+              elsif (current + " " + word).length <= max_chars
+                current = "#{current} #{word}"
+              else
+                lines << current
+                current = word
+              end
+            end
+            lines << current unless current.empty?
+            lines
+          end
+          module_function :wrapped_lines
+
+          def build_text(content, x_pos, y_pos, context, fill)
+            TextRenderer.new(
+              content: content,
+              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 :build_text
+
+          def wrap_group(body, fill)
+            style = "stroke-width:1;stroke-linecap:round;" \
+                    "stroke-linejoin:bevel; fill:#{fill};" \
+                    "fill-opacity:1.00; stroke:#000000;" \
+                    " stroke-opacity:0.00"
+            %(<g style="#{style}">\n#{body}\n</g>)
+          end
+          module_function :wrap_group
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Operation compartment: divider line + operation signatures.
+        # Skipped when no operations or when geometry cannot fit them.
+        module Operations
+          module_function
+
+          def render(context)
+            return nil unless context.op_lines.any?
+            return nil unless context.geometry.op_first_y
+            return nil unless context.classifier
+
+            parts = []
+            if context.attr_lines.any?
+              parts << Element::DividerRenderer.render(
+                context.bounds,
+                y: context.geometry.op_divider_y,
+                stroke: context.stroke,
+                stroke_width: context.stroke_width
+              )
+            end
+            parts << Element::OperationRenderer.render(
+              context.classifier.operations,
+              bounds: context.bounds,
+              first_y: context.geometry.op_first_y,
+              family: context.family, size: context.size
+            )
+            parts.join("\n")
+          end
+        end
+      end
+    end
+  end
+end