lutaml 0.9.43 → 0.10.0

data/lib/lutaml/ea/diagram/layout_engine.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative "util"
+
+module Lutaml
+  module Ea
+    module Diagram
+      # Layout engine for positioning diagram elements
+      #
+      # This engine calculates optimal positions for diagram elements
+      # based on their relationships and EA diagram data. It handles
+      # automatic layout for elements that don't have explicit positions.
+      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
+
+        # Calculate bounds for the entire diagram
+        # @param diagram_data [Hash] Diagram data with elements and connectors
+        # @return [Hash] Bounds with x, y, width, height
+        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?
+
+          # Find min/max coordinates
+          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
+
+        # Apply padding to bounds
+        # @param bounds [Hash] Bounds with x, y, width, height
+        # @return [Hash] Padded bounds
+        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
+
+        # Apply automatic layout to elements without positions
+        # @param elements [Array] Array of diagram elements
+        # @param connectors [Array] Array of connectors
+        # @return [Array] Elements with calculated positions
+        def apply_layout(elements, connectors = []) # rubocop:disable Metrics/MethodLength
+          positioned_elements, unpositioned_elements = elements.partition do |e|
+            e[:x] && e[:y]
+          end
+
+          # Apply force-directed layout for unpositioned elements
+          if unpositioned_elements.any?
+            positioned_elements += apply_force_directed_layout(
+              unpositioned_elements,
+              connectors,
+              positioned_elements,
+            )
+          end
+
+          positioned_elements
+        end
+
+        # Calculate optimal position for a single element
+        # @param element [Hash] Element data
+        # @param related_elements [Array] Related elements
+        # @return [Hash] Element with calculated position
+        def calculate_element_position(element, related_elements = []) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return element if element[:x] && element[:y]
+
+          # Simple positioning: place to the right of related elements
+          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
+
+        # Backward compatibility methods (deprecated)
+        # These methods are no longer used in the current architecture
+        # but kept for test compatibility
+
+        # Convert EA coordinates (deprecated - now handled by DiagramPresenter)
+        # @deprecated Use DiagramPresenter coordinate handling instead
+        def convert_ea_coordinates(diagram_object)
+          left = diagram_object.left || 0
+          top = diagram_object.top || 0
+          right = diagram_object.right || 100
+          bottom = diagram_object.bottom || 100
+
+          {
+            x: left,
+            y: top,
+            width: right - left,
+            height: bottom - top,
+          }
+        end
+
+        # Normalize coordinates (deprecated)
+        # @deprecated No longer needed in current architecture
+        def normalize_coordinates(elements) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return elements if elements.empty?
+
+          largest_negative_x = elements.map { |e| e[:x] || 0 }.min
+          largest_negative_y = elements.map { |e| e[:y] || 0 }.min
+          offset_x = largest_negative_x.negative? ? -largest_negative_x : 0
+          offset_y = largest_negative_y.negative? ? -largest_negative_y : 0
+
+          return elements if offset_x.zero? && offset_y.zero?
+
+          elements.each do |e|
+            e[:x] = 0 if e[:x].nil?
+            e[:y] = 0 if e[:y].nil?
+            e[:width] = 0 if e[:width].nil?
+            e[:height] = 0 if e[:height].nil?
+            e[:x] = e[:x].to_i + offset_x
+            e[:y] = e[:y].to_i + offset_y
+            e[:width] = -e[:width] if e[:width].negative?
+            e[:height] = -e[:height] if e[:height].negative?
+          end
+        end
+
+        # Calculate min/max bounds from connector endpoints
+        # @param connectors [Array] Array of connectors with geometry
+        # @return [Hash, nil] Bounds hash with min_x, max_x, min_y, max_y
+        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
+
+        private
+
+        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) # rubocop:disable Metrics/MethodLength
+          if element[:width]
+            return element[:width].zero? ? ELEMENT_WIDTH : element[:width]
+          end
+
+          # Could be customized based on element content
+          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) # rubocop:disable Metrics/MethodLength
+          if element[:height]
+            return element[:height].zero? ? ELEMENT_HEIGHT : element[:height]
+          end
+
+          # Could be customized based on element content
+          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
+          # Simple force-directed layout implementation
+          # In a real implementation, this would use iterative relaxation
+
+          positioned = []
+          elements.each_with_index do |element, index|
+            # Start with a grid-like initial position
+            cols = Math.sqrt(elements.size).ceil
+            row = index / cols
+            col = index % cols
+
+            x = col * (ELEMENT_WIDTH + spacing)
+            y = row * (ELEMENT_HEIGHT + spacing)
+
+            # Adjust based on fixed elements
+            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
+end

data/lib/lutaml/ea/diagram/path_builder.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require_relative "util"
+
+module Lutaml
+  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
+
+        private
+
+        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
+
+        def start_point
+          return nil unless source_element
+
+          calculate_element_center_point(source_element)
+        end
+
+        def end_point
+          return nil unless target_element
+
+          calculate_element_center_point(target_element)
+        end
+
+        def calculate_element_center_point(element)
+          # Calculate center point based on element bounds
+          x = element[:x] || 0
+          y = element[:y] || 0
+          width = element[:width] || 120
+          height = element[:height] || 80
+
+          [x + (width / 2), y + (height / 2)]
+        end
+
+        def calculate_start_end_point(geometry_data, type) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          point = if type == :source
+                    start_point
+                  else
+                    end_point
+                  end
+
+          if point.nil? || !geometry_data[:has_relative_coords]
+            return nil
+          end
+
+          offsets = [
+            geometry_data[:source_offset_x] || 0,
+            geometry_data[:source_offset_y] || 0,
+            geometry_data[:target_offset_x] || 0,
+            geometry_data[:target_offset_y] || 0,
+          ]
+
+          apply_offset(point, offsets, type)
+        end
+
+        def calculate_start_point(geometry_data)
+          calculate_start_end_point(geometry_data, :source)
+        end
+
+        def calculate_end_point(geometry_data)
+          calculate_start_end_point(geometry_data, :target)
+        end
+      end
+    end
+  end
+end