lutaml 0.10.18 → 0.11.2

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

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,256 +0,0 @@
-# frozen_string_literal: true
-
-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