ea 0.1.0 → 0.1.4

data/lib/ea/diagram/layout_engine.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Ea
+  module Diagram
+    # Layout engine for positioning diagram elements
+    class LayoutEngine
+      include Util
+
+      DEFAULT_SPACING = 50
+      DEFAULT_PADDING = 20
+      ELEMENT_WIDTH = 120
+      ELEMENT_HEIGHT = 80
+
+      attr_reader :spacing, :element_width, :element_height
+
+      def initialize(options = {})
+        @spacing = options[:spacing] || DEFAULT_SPACING
+        @element_width = options[:element_width] || ELEMENT_WIDTH
+        @element_height = options[:element_height] || ELEMENT_HEIGHT
+      end
+
+      def calculate_bounds(diagram_data) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        elements = diagram_data[:elements] || []
+        return { x: 0, y: 0, width: 400, height: 300 } if elements.empty?
+
+        min_x = elements.map { |e| e[:x] || 0 }.min
+        min_y = elements.map { |e| e[:y] || 0 }.min
+        max_x = elements.map do |e|
+          (e[:x] || 0) + element_width_for(e)
+        end.max
+        max_y = elements.map do |e|
+          (e[:y] || 0) + element_height_for(e)
+        end.max
+
+        apply_padding_to_bounds(
+          {
+            x: min_x,
+            y: min_y,
+            width: max_x - min_x,
+            height: max_y - min_y,
+          },
+        )
+      end
+
+      def apply_padding_to_bounds(bounds) # rubocop:disable Metrics/AbcSize
+        padding_x = [bounds[:width] * 0.05, DEFAULT_PADDING].max
+        padding_y = [bounds[:height] * 0.05, DEFAULT_PADDING].max
+        {
+          x: bounds[:x] - padding_x,
+          y: bounds[:y] - padding_y,
+          width: bounds[:width] + (padding_x * 2),
+          height: bounds[:height] + (padding_y * 2),
+        }
+      end
+
+      def apply_layout(elements, connectors = []) # rubocop:disable Metrics/MethodLength
+        positioned_elements, unpositioned_elements = elements.partition do |e|
+          e[:x] && e[:y]
+        end
+
+        if unpositioned_elements.any?
+          positioned_elements += apply_force_directed_layout(
+            unpositioned_elements,
+            connectors,
+            positioned_elements,
+          )
+        end
+
+        positioned_elements
+      end
+
+      def calculate_element_position(element, related_elements = []) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        return element if element[:x] && element[:y]
+
+        if related_elements.any?
+          max_x = related_elements.map do |e|
+            (e[:x] || 0) + element_width_for(e)
+          end.max
+          element[:x] = max_x + spacing
+          element[:y] = related_elements.first[:y] || 0
+        else
+          element[:x] = 0
+          element[:y] = 0
+        end
+
+        element
+      end
+
+      def calculate_connector_bounds(connectors) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        return nil if connectors.empty?
+
+        valid = connectors.select do |c|
+          c[:source_element] && c[:target_element] && c[:geometry]
+        end
+        return nil if valid.empty?
+
+        points = valid.flat_map { |conn| connector_endpoints(conn) }
+        xs = points.map(&:first)
+        ys = points.map(&:last)
+
+        { min_x: xs.min, max_x: xs.max, min_y: ys.min, max_y: ys.max }
+      end
+
+      def connector_endpoints(conn) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        src = conn[:source_element]
+        tgt = conn[:target_element]
+        sx, sy, ex, ey = parse_geometry_offsets(conn[:geometry])
+
+        src_point = [(src[:x] || 0) + (src[:width] || 120) + sx,
+                     (src[:y] || 0) + ((src[:height] || 80) / 2) + sy]
+        tgt_point = [(tgt[:x] || 0) + ex,
+                     (tgt[:y] || 0) + ((tgt[:height] || 80) / 2) + ey]
+
+        [src_point, tgt_point]
+      end
+
+      def element_width_for(element)
+        if element[:width]
+          return element[:width].zero? ? ELEMENT_WIDTH : element[:width]
+        end
+
+        case element[:type]
+        when "class"
+          (element[:attributes]&.size.to_i * 10) + ELEMENT_WIDTH
+        when "package"
+          ELEMENT_WIDTH + 20
+        else
+          ELEMENT_WIDTH
+        end
+      end
+
+      def element_height_for(element)
+        if element[:height]
+          return element[:height].zero? ? ELEMENT_HEIGHT : element[:height]
+        end
+
+        case element[:type]
+        when "class"
+          (element[:operations]&.size.to_i * 15) + ELEMENT_HEIGHT
+        when "package"
+          ELEMENT_HEIGHT - 10
+        else
+          ELEMENT_HEIGHT
+        end
+      end
+
+      def apply_force_directed_layout(elements, _connectors, fixed_elements) # rubocop:disable Metrics/AbcSize,Metrics:MethodLength
+        positioned = []
+        elements.each_with_index do |element, index|
+          cols = Math.sqrt(elements.size).ceil
+          row = index / cols
+          col = index % cols
+
+          x = col * (ELEMENT_WIDTH + spacing)
+          y = row * (ELEMENT_HEIGHT + spacing)
+
+          if fixed_elements.any?
+            x += fixed_elements.map do |e|
+              (e[:x] || 0) + element_width_for(e)
+            end.max + (spacing * 2)
+          end
+
+          positioned << element.merge(x: x, y: y)
+        end
+
+        positioned
+      end
+    end
+  end
+end

data/lib/ea/diagram/path_builder.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Ea
+  module Diagram
+      # Path builder for connector rendering
+      #
+      # This class calculates SVG path data for connectors between
+      # diagram elements, supporting various connector types and
+      # routing algorithms.
+      class PathBuilder
+        include Util
+
+        attr_reader :connector, :source_element, :target_element
+
+        def initialize(connector, source_element = nil, target_element = nil)
+          @connector = connector
+          @source_element = source_element
+          @target_element = target_element
+        end
+
+        # Build SVG path data for the connector
+        # @return [String] SVG path data
+        def build_path
+          return straight_path if simple_connector?
+          return waypoint_path if geometry_has_waypoints?
+
+          case connector[:routing_type]
+          when "orthogonal" then orthogonal_path
+          when "bezier" then bezier_path
+          else manhattan_path
+          end
+        end
+
+
+        def simple_connector?
+          # Use straight line if both elements have direct coordinates
+          connector[:source_x] && connector[:source_y] &&
+            connector[:target_x] && connector[:target_y]
+        end
+
+        def straight_path
+          x1 = connector[:source_x] || 0
+          y1 = connector[:source_y] || 0
+          x2 = connector[:target_x] || 100
+          y2 = connector[:target_y] || 100
+
+          "M #{x1},#{y1} L #{x2},#{y2}"
+        end
+
+        def orthogonal_path
+          # Right-angle routing
+          points = calculate_orthogonal_points
+          path_from_points(points)
+        end
+
+        def manhattan_path # rubocop:disable Metrics/MethodLength
+          # Manhattan distance routing with one bend
+          x1, y1 = source_point
+          x2, y2 = target_point
+
+          # Calculate bend point (midpoint)
+          bend_x = (x1 + x2) / 2
+          bend_y = (y1 + y2) / 2
+
+          # Choose bend direction to avoid elements
+          if (x2 - x1).abs > (y2 - y1).abs
+            # Horizontal bend
+            "M #{x1},#{y1} L #{bend_x},#{y1} L #{bend_x},#{y2} L #{x2},#{y2}"
+          else
+            # Vertical bend
+            "M #{x1},#{y1} L #{x1},#{bend_y} L #{x2},#{bend_y} L #{x2},#{y2}"
+          end
+        end
+
+        def bezier_path
+          # Smooth curved path using Bezier curves
+          x1, y1 = source_point
+          x2, y2 = target_point
+
+          # Control points for smooth curve
+          cp1x = x1 + ((x2 - x1) * 0.3)
+          cp1y = y1
+          cp2x = x2 - ((x2 - x1) * 0.3)
+          cp2y = y2
+
+          "M #{x1},#{y1} C #{cp1x},#{cp1y} #{cp2x},#{cp2y} #{x2},#{y2}"
+        end
+
+        def calculate_orthogonal_points # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          x1, y1 = source_point
+          x2, y2 = target_point
+
+          points = [[x1, y1]]
+
+          # Determine direction based on relative positions
+          if (x2 - x1).abs > (y2 - y1).abs
+            # Horizontal first, then vertical
+            points << [x1 + ((x2 - x1) / 2), y1]
+            points << [x1 + ((x2 - x1) / 2), y2]
+          else
+            # Vertical first, then horizontal
+            points << [x1, y1 + ((y2 - y1) / 2)]
+            points << [x2, y1 + ((y2 - y1) / 2)]
+          end
+
+          points << [x2, y2]
+          points
+        end
+
+        def path_from_points(points)
+          return "" if points.empty?
+
+          path = "M #{points[0][0]},#{points[0][1]}"
+          points[1..].each do |point|
+            path += " L #{point[0]},#{point[1]}"
+          end
+          path
+        end
+
+        def geometry_has_waypoints?
+          return false unless connector[:geometry]
+
+          geometry_data = parse_ea_geometry(connector[:geometry])
+          geometry_data&.dig(:waypoints)&.any?
+        end
+
+        def waypoint_path
+          geometry_data = parse_ea_geometry(connector[:geometry])
+          points = []
+
+          sp = source_point
+          points << sp if sp
+
+          geometry_data[:waypoints].each do |wp|
+            points << [wp[:x], wp[:y]]
+          end
+
+          tp = target_point
+          points << tp if tp
+
+          path_from_points(points)
+        end
+
+        def source_point
+          if connector[:source_x] && connector[:source_y]
+            [connector[:source_x], connector[:source_y]]
+          else
+            calculate_element_connection_point(source_element, :source)
+          end
+        end
+
+        def target_point
+          if connector[:target_x] && connector[:target_y]
+            [connector[:target_x], connector[:target_y]]
+          else
+            calculate_element_connection_point(target_element, :target)
+          end
+        end
+
+        def calculate_element_connection_point(element, type) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return [0, 0] unless element
+
+          # Calculate connection point based on element bounds and
+          # connector type
+          x = element[:x] || 0
+          y = element[:y] || 0
+          width = element[:width] || 120
+          height = element[:height] || 80
+
+          point = case type
+                  when :source
+                    # Connect from right side for outgoing connectors
+                    [x + width, y + (height / 2)]
+                  when :target
+                    # Connect to left side for incoming connectors
+                    [x, y + (height / 2)]
+                  else
+                    [x + (width / 2), y + (height / 2)]
+                  end
+
+          return point unless connector[:geometry]
+
+          # Apply relative offsets if specified
+          offsets = parse_geometry_offsets(connector[:geometry])
+          apply_offset(point, offsets, type)
+        end
+
+        def apply_offset(point, offsets, type)
+          offset_x, offset_y = case type
+                               when :source
+                                 [offsets[0], offsets[1]]
+                               when :target
+                                 [offsets[2], offsets[3]]
+                               else
+                                 [0, 0]
+                               end
+
+          [point[0] + offset_x, point[1] + offset_y]
+        end
+      end
+  end
+end

data/lib/ea/diagram/style_parser.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# StyleParser is a thin color utility. Style orchestration (defaults,
+# EA-parsed overrides, connector-type dispatch) lives in StyleResolver.
+#
+# Historically this class held a parallel style-resolution API
+# (`parse_element_style`, `parse_connector_style`, `get_base_element_style`,
+# `element_specific_style`, `parse_ea_style_string`, `stereotype_style`).
+# That API was unused — callers went through StyleResolver's
+# `resolve_element_style` / `resolve_connector_style` instead. The duplicate
+# API was removed on 2026-06-27 to fix the MECE violation (two style
+# pipelines for the same concern).
+#
+# What remains is `color_from_ea_color`, the BGR-integer → hex color
+# converter that StyleResolver uses when parsing EA style strings.
+
+module Ea
+  module Diagram
+    class StyleParser
+      # EA's default fill color (light yellow) used when an EA color integer
+      # is zero / unset.
+      DEFAULT_FILL_COLOR = "#FFFFCC"
+
+      # Convert EA color integer (BGR) to hex color string.
+      #
+      # EA stores colors as BGR integers in DiagramObject.style strings
+      # (e.g. "BCol=16764159"). A zero value means "use the EA default".
+      #
+      # @param ea_color [Integer] EA BGR color value
+      # @return [String] Hex color string (e.g. "#FFFFCC")
+      def color_from_ea_color(ea_color)
+        return DEFAULT_FILL_COLOR if ea_color.zero?
+
+        b = (ea_color & 0xFF0000) >> 16
+        g = (ea_color & 0x00FF00) >> 8
+        r = ea_color & 0x0000FF
+
+        format("#%02X%02X%02X", r, g, b)
+      end
+    end
+  end
+end

data/lib/ea/diagram/style_resolver.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module Ea
+  module Diagram
+      # Resolves styles for diagram elements by merging multiple sources
+      #
+      # Priority order (highest to lowest):
+      # 1. EA Data from DiagramObject.style (BCol, LCol, etc.)
+      # 2. User Configuration (YAML)
+      # 3. Built-in Defaults
+      #
+      # This ensures that:
+      # - EA's original styling is preserved when present
+      # - Users can override defaults via configuration
+      # - Sensible defaults are always available
+      class StyleResolver
+        attr_reader :configuration, :style_parser
+
+        # Initialize with configuration
+        #
+        # @param config_path [String, nil] Path to configuration file
+        def initialize(config_path = nil)
+          @configuration = Configuration.new(config_path)
+          @style_parser = StyleParser.new
+        end
+
+        # Resolve complete style for an element
+        #
+        # @param element [Object] UML element (Class, DataType, etc.)
+        # @param diagram_object [Lutaml::Uml::DiagramObject, nil]
+        # Diagram placement data
+        # @return [Hash] Complete resolved style
+        def resolve_element_style(element, diagram_object = nil) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          style = {}
+
+          # Start with configuration defaults
+          style[:fill] = configuration.style_for(element, "colors.fill")
+          style[:stroke] = configuration.style_for(element, "colors.stroke")
+          style[:stroke_width] =
+            configuration.style_for(element, "box.stroke_width")
+          style[:stroke_linecap] =
+            configuration.style_for(element, "box.stroke_linecap")
+          style[:stroke_linejoin] =
+            configuration.style_for(element, "box.stroke_linejoin")
+          style[:corner_radius] =
+            configuration.style_for(element, "box.corner_radius")
+          style[:fill_opacity] =
+            configuration.style_for(element, "box.fill_opacity")
+          style[:stroke_opacity] =
+            configuration.style_for(element, "box.stroke_opacity")
+
+          # Font configuration
+          style[:font_family] =
+            configuration.style_for(element, "fonts.class_name.family")
+          style[:font_size] =
+            configuration.style_for(element, "fonts.class_name.size")
+          style[:font_weight] =
+            configuration.style_for(element, "fonts.class_name.weight")
+          style[:font_style] =
+            configuration.style_for(element, "fonts.class_name.style")
+
+          # Override with EA data if present (highest priority)
+          if diagram_object&.style
+            ea_style = parse_diagram_object_style(diagram_object.style)
+            style.merge!(ea_style)
+          end
+
+          style.compact
+        end
+
+        # Resolve complete style for a connector
+        #
+        # @param connector [Object] UML connector
+        # (Association, Generalization, etc.)
+        # @param diagram_link [Lutaml::Uml::DiagramLink, nil]
+        # Diagram routing data
+        # @return [Hash] Complete resolved style
+        def resolve_connector_style(connector, diagram_link = nil) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          # Determine connector type
+          connector_type = determine_connector_type(connector)
+
+          style = {}
+
+          # Start with configuration defaults for this connector type
+          style[:arrow_type] =
+            configuration.connector_style(connector_type, "arrow.type")
+          style[:arrow_size] =
+            configuration.connector_style(connector_type, "arrow.size")
+          style[:stroke] =
+            configuration.connector_style(connector_type, "line.stroke")
+          style[:stroke_width] =
+            configuration.connector_style(connector_type, "line.stroke_width")
+          style[:stroke_dasharray] =
+            configuration.connector_style(connector_type,
+                                          "line.stroke_dasharray")
+          style[:fill] =
+            configuration.connector_style(connector_type, "line.fill") || "none"
+
+          # Override with EA data if present (highest priority)
+          if diagram_link&.style
+            ea_style = parse_diagram_link_style(diagram_link.style)
+            style.merge!(ea_style)
+          end
+
+          style.compact
+        end
+
+        # Resolve fill color specifically
+        #
+        # @param element [Object] UML element
+        # @param diagram_object [Lutaml::Uml::DiagramObject, nil]
+        # Diagram placement data
+        # @return [String] Resolved fill color
+        def resolve_fill_color(element, diagram_object = nil)
+          # Priority 1: EA data from DiagramObject.style
+          if diagram_object&.style
+            ea_style = parse_diagram_object_style(diagram_object.style)
+            return ea_style[:fill] if ea_style[:fill]
+          end
+
+          # Priority 2: Configuration (Class > Package > Stereotype > Defaults)
+          configuration.style_for(element, "colors.fill")
+        end
+
+        # Resolve stroke color specifically
+        #
+        # @param element [Object] UML element
+        # @param diagram_object [Lutaml::Uml::DiagramObject, nil]
+        # Diagram placement data
+        # @return [String] Resolved stroke color
+        def resolve_stroke_color(element, diagram_object = nil)
+          # Priority 1: EA data from DiagramObject.style
+          if diagram_object&.style
+            ea_style = parse_diagram_object_style(diagram_object.style)
+            return ea_style[:stroke] if ea_style[:stroke]
+          end
+
+          # Priority 2: Configuration
+          configuration.style_for(element, "colors.stroke")
+        end
+
+        # Resolve font properties
+        #
+        # @param element [Object] UML element
+        # @param context [Symbol] Font context
+        # (:class_name, :attribute, :operation, :stereotype)
+        # @return [Hash] Font properties (family, size, weight, style)
+        def resolve_font(element, context = :class_name)
+          {
+            family: configuration.style_for(element, "fonts.#{context}.family"),
+            size: configuration.style_for(element, "fonts.#{context}.size"),
+            weight: configuration.style_for(element, "fonts.#{context}.weight"),
+            style: configuration.style_for(element, "fonts.#{context}.style"),
+          }.compact
+        end
+
+
+        # Parse DiagramObject.style string
+        # (EA format: "BCol=16764159;LCol=0;SOID=123")
+        #
+        # @param style_string [String] EA style string
+        # @return [Hash] Parsed style with fill and stroke colors
+        def parse_diagram_object_style(style_string) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return {} unless style_string
+
+          style = {}
+          pairs = style_string.split(";")
+
+          pairs.each do |pair|
+            key, value = pair.split("=", 2)
+            next unless key && value
+
+            case key.strip
+            when "BCol"
+              # Background color (BGR integer)
+              style[:fill] =
+                style_parser.color_from_ea_color(value.to_i)
+            when "LCol"
+              # Line color (BGR integer)
+              style[:stroke] =
+                style_parser.color_from_ea_color(value.to_i)
+            when "BFol"
+              # Bold font (0 or 1)
+              style[:font_weight] = value == "1" ? 700 : 400
+            when "IFol"
+              # Italic font (0 or 1)
+              style[:font_style] = value == "1" ? "italic" : "normal"
+            when "LWth"
+              # Line width
+              style[:stroke_width] = value.to_i
+            end
+          end
+
+          style
+        end
+
+        # Parse DiagramLink.style string
+        #
+        # @param style_string [String] EA style string
+        # @return [Hash] Parsed style
+        def parse_diagram_link_style(style_string) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          return {} unless style_string
+
+          style = {}
+          pairs = style_string.split(";")
+
+          pairs.each do |pair|
+            key, value = pair.split("=", 2)
+            next unless key && value
+
+            case key.strip
+            when "LCol"
+              # Line color
+              style[:stroke] =
+                style_parser.color_from_ea_color(value.to_i)
+            when "LWth"
+              # Line width
+              style[:stroke_width] = value.to_i
+            when "LStyle"
+              # Line style (0=solid, 1=dash, 2=dot, etc.)
+              case value.to_i
+              when 1
+                style[:stroke_dasharray] = "5,5"
+              when 2
+                style[:stroke_dasharray] = "2,2"
+              end
+            end
+          end
+
+          style
+        end
+
+        # Maps UML connector classes to their style type names.
+        # New connector types are added here — no method changes needed.
+        CONNECTOR_TYPE_MAP = {
+          Lutaml::Uml::Generalization => "generalization",
+          Lutaml::Uml::Association => "association",
+          Lutaml::Uml::Dependency => "dependency",
+          Lutaml::Uml::Realization => "realization",
+        }.freeze
+
+        # Association sub-type precedence for style resolution
+        ASSOCIATION_SUBTYPE_MAP = {
+          "aggregation" => "aggregation",
+          "composition" => "composition",
+        }.freeze
+
+        # Determine connector type from connector object
+        # @param connector [Object] UML connector
+        # @return [String] Connector type name
+        def determine_connector_type(connector)
+          return "association" unless connector
+
+          type_name = CONNECTOR_TYPE_MAP[connector.class]
+          return type_name if type_name && type_name != "association"
+          return determine_association_type(connector) if type_name == "association"
+
+          "association"
+        end
+
+        # Determine specific association type
+        # @param connector [Object] Association connector
+        # @return [String] Specific association type
+        def determine_association_type(connector)
+          return "association" unless connector.is_a?(Lutaml::Uml::Association)
+
+          [connector.owner_end_type, connector.member_end_type].each do |type|
+            resolved = ASSOCIATION_SUBTYPE_MAP[type&.downcase]
+            return resolved if resolved
+          end
+
+          "association"
+        end
+      end
+    end
+end