elkrb 1.0.0

data/lib/elkrb/commands/validate_command.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Elkrb
+  module Commands
+    # Command for validating ELK graph structure
+    # Checks for required fields, valid relationships, and structural integrity
+    class ValidateCommand
+      def initialize(file, options)
+        @file = file
+        @options = options
+      end
+
+      def run
+        # Load and validate graph
+        graph = load_any_format(@file)
+        errors = validate_graph(graph)
+
+        if errors.empty?
+          puts "✅ #{@file} is valid"
+        else
+          puts "❌ #{@file} has #{errors.length} error(s):"
+          errors.each { |e| puts "  • #{e}" }
+          exit 1
+        end
+      end
+
+      private
+
+      def load_any_format(file)
+        raise ArgumentError, "File not found: #{file}" unless File.exist?(file)
+
+        require_relative "../graph/graph"
+        content = File.read(file)
+        ext = File.extname(file).downcase
+
+        graph = case ext
+                when ".json"
+                  Elkrb::Graph::Graph.from_json(content)
+                when ".yml", ".yaml"
+                  Elkrb::Graph::Graph.from_yaml(content)
+                when ".elkt"
+                  require_relative "../parsers/elkt_parser"
+                  Elkrb::Parsers::ElktParser.parse(content)
+                else
+                  detect_and_parse(content)
+                end
+
+        # Convert to hash for validation
+        if graph.is_a?(Hash)
+          graph
+        else
+          JSON.parse(graph.to_json,
+                     symbolize_names: true)
+        end
+      end
+
+      def detect_and_parse(content)
+        require_relative "../graph/graph"
+
+        # Try JSON first
+        begin
+          return Elkrb::Graph::Graph.from_json(content)
+        rescue JSON::ParserError
+          # Not JSON
+        end
+
+        # Try YAML
+        begin
+          return Elkrb::Graph::Graph.from_yaml(content)
+        rescue Psych::SyntaxError
+          # Not YAML
+        end
+
+        # Try ELKT
+        begin
+          require_relative "../parsers/elkt_parser"
+          Elkrb::Parsers::ElktParser.parse(content)
+        rescue StandardError
+          raise ArgumentError, "Unable to parse input file"
+        end
+      end
+
+      def validate_graph(graph)
+        errors = []
+
+        # Check graph structure
+        errors << "Graph must be a Hash" unless graph.is_a?(Hash)
+        return errors unless graph.is_a?(Hash)
+
+        # Check required fields
+        errors << "Graph missing 'id' field" unless graph[:id] || graph["id"]
+
+        # Validate children (nodes)
+        children = graph[:children] || graph["children"] || []
+        children.each_with_index do |node, idx|
+          errors.concat(validate_node(node, "children[#{idx}]"))
+        end
+
+        # Validate edges
+        edges = graph[:edges] || graph["edges"] || []
+        edges.each_with_index do |edge, idx|
+          errors.concat(validate_edge(edge, "edges[#{idx}]",
+                                      collect_node_ids(graph)))
+        end
+
+        # Strict mode: additional checks
+        if @options[:strict]
+          errors.concat(validate_strict(graph))
+        end
+
+        errors
+      end
+
+      def validate_node(node, path)
+        errors = []
+
+        errors << "#{path}: Node must be a Hash" unless node.is_a?(Hash)
+        return errors unless node.is_a?(Hash)
+
+        # Check required fields
+        node_id = node[:id] || node["id"]
+        errors << "#{path}: Node missing 'id' field" unless node_id
+
+        # Check dimensions (recommended but not required unless strict)
+        if @options[:strict]
+          width = node[:width] || node["width"]
+          height = node[:height] || node["height"]
+
+          errors << "#{path}: Node '#{node_id}' missing 'width'" unless width
+          errors << "#{path}: Node '#{node_id}' missing 'height'" unless height
+
+          if width && (!width.is_a?(Numeric) || width <= 0)
+            errors << "#{path}: Node '#{node_id}' has invalid width: #{width}"
+          end
+
+          if height && (!height.is_a?(Numeric) || height <= 0)
+            errors << "#{path}: Node '#{node_id}' has invalid height: #{height}"
+          end
+        end
+
+        # Validate nested children
+        children = node[:children] || node["children"] || []
+        children.each_with_index do |child, idx|
+          errors.concat(validate_node(child, "#{path}.children[#{idx}]"))
+        end
+
+        # Validate ports
+        ports = node[:ports] || node["ports"] || []
+        ports.each_with_index do |port, idx|
+          errors.concat(validate_port(port, "#{path}.ports[#{idx}]"))
+        end
+
+        errors
+      end
+
+      def validate_edge(edge, path, valid_node_ids)
+        errors = []
+
+        errors << "#{path}: Edge must be a Hash" unless edge.is_a?(Hash)
+        return errors unless edge.is_a?(Hash)
+
+        # Check required fields
+        edge_id = edge[:id] || edge["id"]
+        sources = edge[:sources] || edge["sources"]
+        targets = edge[:targets] || edge["targets"]
+
+        errors << "#{path}: Edge missing 'id' field" unless edge_id
+        errors << "#{path}: Edge '#{edge_id}' missing 'sources' field" unless sources
+        errors << "#{path}: Edge '#{edge_id}' missing 'targets' field" unless targets
+
+        # Validate sources and targets are arrays
+        if sources && !sources.is_a?(Array)
+          errors << "#{path}: Edge '#{edge_id}' sources must be an array"
+        end
+
+        if targets && !targets.is_a?(Array)
+          errors << "#{path}: Edge '#{edge_id}' targets must be an array"
+        end
+
+        # Check that sources and targets reference valid nodes (in strict mode)
+        if @options[:strict] && sources.is_a?(Array) && targets.is_a?(Array)
+          sources.each do |source|
+            unless valid_node_ids.include?(source)
+              errors << "#{path}: Edge '#{edge_id}' references unknown source node '#{source}'"
+            end
+          end
+
+          targets.each do |target|
+            unless valid_node_ids.include?(target)
+              errors << "#{path}: Edge '#{edge_id}' references unknown target node '#{target}'"
+            end
+          end
+        end
+
+        errors
+      end
+
+      def validate_port(port, path)
+        errors = []
+
+        errors << "#{path}: Port must be a Hash" unless port.is_a?(Hash)
+        return errors unless port.is_a?(Hash)
+
+        # Check required fields
+        port_id = port[:id] || port["id"]
+        errors << "#{path}: Port missing 'id' field" unless port_id
+
+        errors
+      end
+
+      def validate_strict(graph)
+        errors = []
+
+        # Check for layout options
+        layout_options = graph[:layoutOptions] || graph["layoutOptions"]
+        if layout_options && !layout_options.is_a?(Hash)
+          errors << "layoutOptions must be a Hash"
+        end
+
+        errors
+      end
+
+      def collect_node_ids(graph, ids = [])
+        children = graph[:children] || graph["children"] || []
+
+        children.each do |node|
+          node_id = node[:id] || node["id"]
+          ids << node_id if node_id
+
+          # Recursively collect from nested children
+          collect_node_ids(node, ids)
+        end
+
+        ids
+      end
+    end
+  end
+end

data/lib/elkrb/errors.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Elkrb
+  # Base error class for Elkrb
+  class Error < StandardError; end
+
+  # Exception raised when an unsupported configuration is detected
+  class UnsupportedConfigurationException < Error
+    attr_reader :option, :value
+
+    def initialize(message, option: nil, value: nil)
+      @option = option
+      @value = value
+      super(message)
+    end
+  end
+
+  # Exception raised when graph validation fails
+  class ValidationError < Error; end
+
+  # Exception raised when an algorithm is not found
+  class AlgorithmNotFoundError < Error
+    attr_reader :algorithm_name
+
+    def initialize(algorithm_name)
+      @algorithm_name = algorithm_name
+      super("Algorithm not found: #{algorithm_name}")
+    end
+  end
+end

data/lib/elkrb/geometry/bezier.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require_relative "point"
+
+module Elkrb
+  module Geometry
+    # Bezier curve implementation for smooth edge routing
+    #
+    # This class provides cubic Bezier curve calculations for creating
+    # smooth, curved edges in graph layouts. It supports calculating
+    # control points and generating points along the curve.
+    class Bezier
+      # Calculate points along a cubic Bezier curve
+      #
+      # @param start_point [Point] The starting point (P0)
+      # @param end_point [Point] The ending point (P3)
+      # @param control1 [Point] The first control point (P1)
+      # @param control2 [Point] The second control point (P2)
+      # @param segments [Integer] Number of line segments to generate
+      # @return [Array<Point>] Array of points along the curve
+      def self.calculate_curve(start_point, end_point, control1, control2,
+                               segments = 20)
+        points = []
+        segments.times do |i|
+          t = i.to_f / (segments - 1)
+          points << bezier_point(t, start_point, control1, control2, end_point)
+        end
+        points
+      end
+
+      # Calculate default control points for a smooth curve
+      #
+      # This method generates control points that create a natural-looking
+      # curve between two points. The control points are positioned
+      # perpendicular to the direct line between start and end points.
+      #
+      # @param start_point [Point] The starting point
+      # @param end_point [Point] The ending point
+      # @param curvature [Float] Curve strength (0.0 = straight, 1.0 = very
+      #   curved)
+      # @return [Array<Point>] Two control points [control1, control2]
+      def self.calculate_control_points(start_point, end_point,
+                                        curvature = 0.5)
+        dx = end_point.x - start_point.x
+        dy = end_point.y - start_point.y
+        distance = Math.sqrt((dx**2) + (dy**2))
+
+        return [start_point, end_point] if distance < 0.001
+
+        # Control points offset perpendicular to line
+        offset = distance * curvature
+
+        # Calculate perpendicular direction
+        perp_x = -dy / distance
+        perp_y = dx / distance
+
+        control1 = Point.new(
+          x: start_point.x + (dx * 0.33) + (perp_x * offset),
+          y: start_point.y + (dy * 0.33) + (perp_y * offset),
+        )
+
+        control2 = Point.new(
+          x: start_point.x + (dx * 0.66) - (perp_x * offset),
+          y: start_point.y + (dy * 0.66) - (perp_y * offset),
+        )
+
+        [control1, control2]
+      end
+
+      # Calculate a point on a cubic Bezier curve at parameter t
+      #
+      # Uses the cubic Bezier formula:
+      # B(t) = (1-t)³P₀ + 3(1-t)²tP₁ + 3(1-t)t²P₂ + t³P₃
+      #
+      # @param t [Float] Parameter value (0.0 to 1.0)
+      # @param p0 [Point] Start point
+      # @param p1 [Point] First control point
+      # @param p2 [Point] Second control point
+      # @param p3 [Point] End point
+      # @return [Point] Point on the curve at parameter t
+      def self.bezier_point(t, p0, p1, p2, p3)
+        # Clamp t to [0, 1]
+        t = [[t, 0.0].max, 1.0].min
+
+        # Calculate Bezier coefficients
+        u = 1.0 - t
+        tt = t * t
+        uu = u * u
+        uuu = uu * u
+        ttt = tt * t
+
+        # B(t) = (1-t)³P₀ + 3(1-t)²tP₁ + 3(1-t)t²P₂ + t³P₃
+        x = (uuu * p0.x) +
+          (3 * uu * t * p1.x) +
+          (3 * u * tt * p2.x) +
+          (ttt * p3.x)
+
+        y = (uuu * p0.y) +
+          (3 * uu * t * p1.y) +
+          (3 * u * tt * p2.y) +
+          (ttt * p3.y)
+
+        Point.new(x: x, y: y)
+      end
+
+      # Calculate simple control points for horizontal-first routing
+      #
+      # Creates control points that produce a curve with horizontal exit
+      # and entry directions, useful for left-to-right or right-to-left
+      # edge routing.
+      #
+      # @param start_point [Point] The starting point
+      # @param end_point [Point] The ending point
+      # @param offset_ratio [Float] How far to offset controls (0.0 to 1.0)
+      # @return [Array<Point>] Two control points [control1, control2]
+      def self.horizontal_control_points(start_point, end_point,
+                                         offset_ratio = 0.5)
+        dx = end_point.x - start_point.x
+        offset = dx.abs * offset_ratio
+
+        control1 = Point.new(
+          x: start_point.x + offset,
+          y: start_point.y,
+        )
+
+        control2 = Point.new(
+          x: end_point.x - offset,
+          y: end_point.y,
+        )
+
+        [control1, control2]
+      end
+
+      # Calculate simple control points for vertical-first routing
+      #
+      # Creates control points that produce a curve with vertical exit
+      # and entry directions, useful for top-to-bottom or bottom-to-top
+      # edge routing.
+      #
+      # @param start_point [Point] The starting point
+      # @param end_point [Point] The ending point
+      # @param offset_ratio [Float] How far to offset controls (0.0 to 1.0)
+      # @return [Array<Point>] Two control points [control1, control2]
+      def self.vertical_control_points(start_point, end_point,
+                                       offset_ratio = 0.5)
+        dy = end_point.y - start_point.y
+        offset = dy.abs * offset_ratio
+
+        control1 = Point.new(
+          x: start_point.x,
+          y: start_point.y + offset,
+        )
+
+        control2 = Point.new(
+          x: end_point.x,
+          y: end_point.y - offset,
+        )
+
+        [control1, control2]
+      end
+    end
+  end
+end

data/lib/elkrb/geometry/dimension.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Geometry
+    class Dimension
+      attr_accessor :width, :height
+
+      def initialize(width = 0.0, height = 0.0)
+        @width = width.to_f
+        @height = height.to_f
+      end
+
+      def area
+        @width * @height
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Dimension)
+
+        @width == other.width && @height == other.height
+      end
+
+      def to_h
+        { width: @width, height: @height }
+      end
+
+      def to_s
+        "#{@width}x#{@height}"
+      end
+    end
+  end
+end

data/lib/elkrb/geometry/point.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Elkrb
+  module Geometry
+    class Point < Lutaml::Model::Serializable
+      attribute :x, :float, default: -> { 0.0 }
+      attribute :y, :float, default: -> { 0.0 }
+
+      json do
+        map "x", to: :x
+        map "y", to: :y
+      end
+
+      yaml do
+        map "x", to: :x
+        map "y", to: :y
+      end
+
+      def initialize(**attributes)
+        # Handle both keyword args and positional args
+        if attributes.empty?
+          super(x: 0.0, y: 0.0)
+        elsif attributes.key?(:x) || attributes.key?(:y)
+          super
+        else
+          # Handle case where first two positional args might be passed
+          super(x: 0.0, y: 0.0)
+        end
+      end
+
+      def +(other)
+        Point.new(x: @x + other.x, y: @y + other.y)
+      end
+
+      def -(other)
+        Point.new(x: @x - other.x, y: @y - other.y)
+      end
+
+      def *(other)
+        Point.new(x: @x * other, y: @y * other)
+      end
+
+      def /(other)
+        Point.new(x: @x / other, y: @y / other)
+      end
+
+      def distance_to(other)
+        Math.sqrt(((@x - other.x)**2) + ((@y - other.y)**2))
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Point)
+
+        @x == other.x && @y == other.y
+      end
+
+      def to_h
+        { x: @x, y: @y }
+      end
+
+      def to_s
+        "(#{@x}, #{@y})"
+      end
+    end
+  end
+end

data/lib/elkrb/geometry/rectangle.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "point"
+require_relative "dimension"
+
+module Elkrb
+  module Geometry
+    class Rectangle
+      attr_accessor :x, :y, :width, :height
+
+      def initialize(x = 0.0, y = 0.0, width = 0.0, height = 0.0)
+        @x = x.to_f
+        @y = y.to_f
+        @width = width.to_f
+        @height = height.to_f
+      end
+
+      def position
+        Point.new(@x, @y)
+      end
+
+      def position=(point)
+        @x = point.x
+        @y = point.y
+      end
+
+      def size
+        Dimension.new(@width, @height)
+      end
+
+      def size=(dimension)
+        @width = dimension.width
+        @height = dimension.height
+      end
+
+      def left
+        @x
+      end
+
+      def right
+        @x + @width
+      end
+
+      def top
+        @y
+      end
+
+      def bottom
+        @y + @height
+      end
+
+      def center
+        Point.new(@x + (@width / 2.0), @y + (@height / 2.0))
+      end
+
+      def contains?(point)
+        point.x.between?(@x, right) &&
+          point.y >= @y && point.y <= bottom
+      end
+
+      def intersects?(other)
+        !(right < other.left || left > other.right ||
+          bottom < other.top || top > other.bottom)
+      end
+
+      def area
+        @width * @height
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Rectangle)
+
+        @x == other.x && @y == other.y &&
+          @width == other.width && @height == other.height
+      end
+
+      def to_h
+        { x: @x, y: @y, width: @width, height: @height }
+      end
+
+      def to_s
+        "(#{@x}, #{@y}, #{@width}x#{@height})"
+      end
+    end
+  end
+end

data/lib/elkrb/geometry/vector.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Geometry
+    class Vector
+      attr_accessor :x, :y
+
+      def initialize(x = 0.0, y = 0.0)
+        @x = x.to_f
+        @y = y.to_f
+      end
+
+      def +(other)
+        Vector.new(@x + other.x, @y + other.y)
+      end
+
+      def -(other)
+        Vector.new(@x - other.x, @y - other.y)
+      end
+
+      def *(other)
+        Vector.new(@x * other, @y * other)
+      end
+
+      def /(other)
+        Vector.new(@x / other, @y / other)
+      end
+
+      def magnitude
+        Math.sqrt((@x**2) + (@y**2))
+      end
+
+      def normalize
+        mag = magnitude
+        return Vector.new(0, 0) if mag.zero?
+
+        Vector.new(@x / mag, @y / mag)
+      end
+
+      def dot(other)
+        (@x * other.x) + (@y * other.y)
+      end
+
+      def perpendicular
+        Vector.new(-@y, @x)
+      end
+
+      def angle
+        Math.atan2(@y, @x)
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Vector)
+
+        @x == other.x && @y == other.y
+      end
+
+      def to_h
+        { x: @x, y: @y }
+      end
+
+      def to_s
+        "<#{@x}, #{@y}>"
+      end
+    end
+  end
+end