elkrb 1.0.0

data/lib/elkrb/graph/edge.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "../geometry/point"
+
+module Elkrb
+  module Graph
+    # Represents a section of an edge with routing information
+    class EdgeSection < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :start_point, Geometry::Point
+      attribute :end_point, Geometry::Point
+      attribute :bend_points, Geometry::Point, collection: true
+      attribute :incoming_shape, :string
+      attribute :outgoing_shape, :string
+
+      json do
+        map "id", to: :id
+        map "startPoint", to: :start_point
+        map "endPoint", to: :end_point
+        map "bendPoints", to: :bend_points
+        map "incomingShape", to: :incoming_shape
+        map "outgoingShape", to: :outgoing_shape
+      end
+
+      yaml do
+        map "id", to: :id
+        map "start_point", to: :start_point
+        map "end_point", to: :end_point
+        map "bend_points", to: :bend_points
+        map "incoming_shape", to: :incoming_shape
+        map "outgoing_shape", to: :outgoing_shape
+      end
+
+      def initialize(**attributes)
+        super
+        @bend_points ||= []
+      end
+
+      # Add a bend point to this section
+      def add_bend_point(x, y)
+        @bend_points ||= []
+        @bend_points << Geometry::Point.new(x: x, y: y)
+      end
+
+      # Get total length of this section
+      def length
+        return 0.0 if !start_point || !end_point
+
+        total = 0.0
+        points = [start_point] + (bend_points || []) + [end_point]
+
+        (0...(points.length - 1)).each do |i|
+          p1 = points[i]
+          p2 = points[i + 1]
+          dx = p2.x - p1.x
+          dy = p2.y - p1.y
+          total += Math.sqrt((dx * dx) + (dy * dy))
+        end
+
+        total
+      end
+    end
+
+    class Edge < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :sources, :string, collection: true
+      attribute :targets, :string, collection: true
+      attribute :labels, Label, collection: true
+      attribute :sections, EdgeSection, collection: true
+      attribute :layout_options, LayoutOptions
+      attribute :properties, :hash
+
+      json do
+        map "id", to: :id
+        map "sources", to: :sources
+        map "targets", to: :targets
+        map "labels", to: :labels
+        map "sections", to: :sections
+        map "layoutOptions", to: :layout_options
+        map "properties", to: :properties
+      end
+
+      yaml do
+        map "id", to: :id
+        map "sources", to: :sources
+        map "targets", to: :targets
+        map "labels", to: :labels
+        map "sections", to: :sections
+        map "layout_options", to: :layout_options
+        map "properties", to: :properties
+      end
+    end
+  end
+end

data/lib/elkrb/graph/graph.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Elkrb
+  module Graph
+    class Graph < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :x, :float
+      attribute :y, :float
+      attribute :width, :float
+      attribute :height, :float
+      attribute :children, Node, collection: true
+      attribute :edges, Edge, collection: true
+      attribute :layout_options, LayoutOptions
+      attribute :properties, :hash
+
+      json do
+        map "id", to: :id
+        map "x", to: :x
+        map "y", to: :y
+        map "width", to: :width
+        map "height", to: :height
+        map "children", to: :children
+        map "edges", to: :edges
+        map "layoutOptions", to: :layout_options
+        map "properties", to: :properties
+      end
+
+      yaml do
+        map "id", to: :id
+        map "x", to: :x
+        map "y", to: :y
+        map "width", to: :width
+        map "height", to: :height
+        map "children", to: :children
+        map "edges", to: :edges
+        map "layout_options", to: :layout_options
+        map "properties", to: :properties
+      end
+
+      def initialize(**attributes)
+        super
+        @id ||= "root"
+        @x ||= 0.0
+        @y ||= 0.0
+        @width ||= 0.0
+        @height ||= 0.0
+        @children ||= []
+        @edges ||= []
+        @properties ||= {}
+        @layout_options ||= LayoutOptions.new
+      end
+
+      def find_node(node_id)
+        @children.each do |child|
+          found = child.find_node(node_id)
+          return found if found
+        end
+        nil
+      end
+
+      def all_nodes
+        nodes = []
+        @children.each do |child|
+          nodes.concat(child.all_nodes)
+        end
+        nodes
+      end
+
+      def all_edges
+        edges = @edges.dup
+        @children.each do |child|
+          edges.concat(child.edges) if child.respond_to?(:edges)
+          next unless child.respond_to?(:children)
+
+          child.children.each do |grandchild|
+            edges.concat(grandchild.all_edges) if
+              grandchild.respond_to?(:all_edges)
+          end
+        end
+        edges
+      end
+
+      def hierarchical?
+        @children.any?(&:hierarchical?)
+      end
+    end
+  end
+end

data/lib/elkrb/graph/label.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Elkrb
+  module Graph
+    class Label < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :text, :string
+      attribute :x, :float
+      attribute :y, :float
+      attribute :width, :float
+      attribute :height, :float
+      attribute :layout_options, LayoutOptions
+
+      json do
+        map "id", to: :id
+        map "text", to: :text
+        map "x", to: :x
+        map "y", to: :y
+        map "width", to: :width
+        map "height", to: :height
+        map "layoutOptions", to: :layout_options
+      end
+
+      yaml do
+        map "id", to: :id
+        map "text", to: :text
+        map "x", to: :x
+        map "y", to: :y
+        map "width", to: :width
+        map "height", to: :height
+        map "layout_options", to: :layout_options
+      end
+
+      def initialize(**attributes)
+        super
+        @x ||= 0.0
+        @y ||= 0.0
+        @width ||= 0.0
+        @height ||= 0.0
+      end
+    end
+  end
+end

data/lib/elkrb/graph/layout_options.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Elkrb
+  module Graph
+    class LayoutOptions < Lutaml::Model::Serializable
+      attribute :algorithm, :string
+      attribute :direction, :string
+      attribute :spacing_node_node, :float
+      attribute :spacing_edge_node, :float
+      attribute :spacing_edge_edge, :float
+      attribute :spacing_node_label, :float
+      attribute :edge_routing, :string
+      attribute :spline_curvature, :float
+      attribute :spline_segments, :integer
+      attribute :hierarchical, :boolean
+      attribute :interactive_layout, :boolean
+      attribute :aspect_ratio, :float
+      attribute :node_placement_strategy, :string
+      attribute :crossing_minimization_strategy, :string
+      attribute :layer_constraint, :string
+      attribute :cycle_breaking_strategy, :string
+      attribute :properties, :hash
+
+      json do
+        map "algorithm", to: :algorithm
+        map "direction", to: :direction
+        map "spacing.nodeNode", to: :spacing_node_node
+        map "spacing.edgeNode", to: :spacing_edge_node
+        map "spacing.edgeEdge", to: :spacing_edge_edge
+        map "spacing.nodeLabel", to: :spacing_node_label
+        map "edgeRouting", to: :edge_routing
+        map "elk.edgeRouting", to: :edge_routing
+        map "spline.curvature", to: :spline_curvature
+        map "elk.spline.curvature", to: :spline_curvature
+        map "spline.segments", to: :spline_segments
+        map "elk.spline.segments", to: :spline_segments
+        map "hierarchical", to: :hierarchical
+        map "interactiveLayout", to: :interactive_layout
+        map "aspectRatio", to: :aspect_ratio
+        map "nodePlacement.strategy", to: :node_placement_strategy
+        map "crossingMinimization.strategy",
+            to: :crossing_minimization_strategy
+        map "layerConstraint", to: :layer_constraint
+        map "cycleBreaking.strategy", to: :cycle_breaking_strategy
+        map "properties", to: :properties
+      end
+
+      yaml do
+        map "algorithm", to: :algorithm
+        map "direction", to: :direction
+        map "spacing_node_node", to: :spacing_node_node
+        map "spacing_edge_node", to: :spacing_edge_node
+        map "spacing_edge_edge", to: :spacing_edge_edge
+        map "spacing_node_label", to: :spacing_node_label
+        map "edge_routing", to: :edge_routing
+        map "spline_curvature", to: :spline_curvature
+        map "spline_segments", to: :spline_segments
+        map "hierarchical", to: :hierarchical
+        map "interactive_layout", to: :interactive_layout
+        map "aspect_ratio", to: :aspect_ratio
+        map "node_placement_strategy", to: :node_placement_strategy
+        map "crossing_minimization_strategy",
+            to: :crossing_minimization_strategy
+        map "layer_constraint", to: :layer_constraint
+        map "cycle_breaking_strategy", to: :cycle_breaking_strategy
+        map "properties", to: :properties
+      end
+
+      def initialize(hash_or_attrs = {}, **attributes)
+        # Handle both hash argument and keyword arguments
+        if hash_or_attrs.is_a?(Hash) && attributes.empty?
+          # Plain hash passed as first argument
+          # Skip calling super and set defaults manually
+          @properties = hash_or_attrs.transform_keys(&:to_s)
+          @algorithm = nil
+          @direction = nil
+          @spacing_node_node = nil
+          @spacing_edge_node = nil
+          @spacing_edge_edge = nil
+          @spacing_node_label = nil
+          @edge_routing = nil
+          @spline_curvature = nil
+          @spline_segments = nil
+          @hierarchical = nil
+          @interactive_layout = nil
+          @aspect_ratio = nil
+          @node_placement_strategy = nil
+          @crossing_minimization_strategy = nil
+          @layer_constraint = nil
+          @cycle_breaking_strategy = nil
+        else
+          # Keyword arguments
+          super(**attributes)
+          @properties ||= {}
+        end
+      end
+
+      def []=(key, value)
+        @properties[key.to_s] = value
+      end
+
+      def [](key)
+        @properties[key.to_s]
+      end
+
+      def merge(other_options)
+        return self unless other_options
+
+        other_options.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+
+      # Port constraint options
+
+      # Get port constraints setting
+      #
+      # Port constraint values:
+      # - "UNDEFINED" - No constraints (default)
+      # - "FIXED_SIDE" - Port sides are fixed
+      # - "FIXED_ORDER" - Port sides and order are fixed
+      # - "FIXED_POS" - Port positions are completely fixed
+      #
+      # @return [String] The port constraints setting
+      def port_constraints
+        properties["elk.portConstraints"] ||
+          properties["portConstraints"] ||
+          "UNDEFINED"
+      end
+
+      # Set port constraints
+      #
+      # @param value [String] The port constraints value
+      def port_constraints=(value)
+        properties["elk.portConstraints"] = value
+      end
+
+      # Get port side assignment setting
+      #
+      # Port side assignment values:
+      # - "AUTOMATIC" - Auto-detect from position (default)
+      # - "MANUAL" - Use explicitly specified sides
+      #
+      # @return [String] The port side assignment setting
+      def port_side_assignment
+        properties["elk.portSideAssignment"] ||
+          properties["portSideAssignment"] ||
+          "AUTOMATIC"
+      end
+
+      # Set port side assignment
+      #
+      # @param value [String] The port side assignment value
+      def port_side_assignment=(value)
+        properties["elk.portSideAssignment"] = value
+      end
+
+      # Get port ordering setting
+      #
+      # Port ordering values:
+      # - "DEFAULT" - Algorithm-specific default
+      # - "INDEX" - Use port index attribute
+      # - "OFFSET" - Use port offset/position
+      #
+      # @return [String] The port ordering setting
+      def port_ordering
+        properties["elk.portOrdering"] ||
+          properties["portOrdering"] ||
+          "DEFAULT"
+      end
+
+      # Set port ordering
+      #
+      # @param value [String] The port ordering value
+      def port_ordering=(value)
+        properties["elk.portOrdering"] = value
+      end
+
+      # Self-loop options
+
+      # Get self-loop side setting
+      #
+      # Self-loop side values:
+      # - "EAST" - Loop extends to the right (default)
+      # - "WEST" - Loop extends to the left
+      # - "NORTH" - Loop extends upward
+      # - "SOUTH" - Loop extends downward
+      #
+      # @return [String] The self-loop side setting
+      def self_loop_side
+        properties["elk.selfLoopSide"] ||
+          properties["selfLoopSide"] ||
+          "EAST"
+      end
+
+      # Set self-loop side
+      #
+      # @param value [String] The self-loop side value
+      def self_loop_side=(value)
+        properties["elk.selfLoopSide"] = value
+      end
+
+      # Get self-loop offset setting
+      #
+      # Controls the base distance the self-loop extends from the node.
+      # Multiple self-loops on the same node will use increasing offsets.
+      #
+      # @return [Float] The self-loop offset (default: 20.0)
+      def self_loop_offset
+        (properties["elk.selfLoopOffset"] ||
+         properties["selfLoopOffset"] ||
+         20.0).to_f
+      end
+
+      # Set self-loop offset
+      #
+      # @param value [Float] The self-loop offset value
+      def self_loop_offset=(value)
+        properties["elk.selfLoopOffset"] = value
+      end
+
+      # Get self-loop routing style
+      #
+      # Self-loop routing values:
+      # - "ORTHOGONAL" - Rectangular path with 90-degree corners (default)
+      # - "SPLINES" - Smooth curved path using Bezier curves
+      # - "POLYLINE" - Simple polyline path
+      #
+      # @return [String] The self-loop routing style
+      def self_loop_routing
+        properties["elk.selfLoopRouting"] ||
+          properties["selfLoopRouting"] ||
+          "ORTHOGONAL"
+      end
+
+      # Set self-loop routing style
+      #
+      # @param value [String] The self-loop routing style value
+      def self_loop_routing=(value)
+        properties["elk.selfLoopRouting"] = value
+      end
+    end
+  end
+end

data/lib/elkrb/graph/node.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "node_constraints"
+
+module Elkrb
+  module Graph
+    class Node < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :x, :float
+      attribute :y, :float
+      attribute :width, :float
+      attribute :height, :float
+      attribute :labels, Label, collection: true
+      attribute :ports, Port, collection: true
+      attribute :children, Node, collection: true
+      attribute :edges, Edge, collection: true
+      attribute :layout_options, LayoutOptions
+      attribute :constraints, NodeConstraints
+      attribute :properties, :hash
+
+      json do
+        map "id", to: :id
+        map "x", to: :x
+        map "y", to: :y
+        map "width", to: :width
+        map "height", to: :height
+        map "labels", to: :labels
+        map "ports", to: :ports
+        map "children", to: :children
+        map "edges", to: :edges
+        map "layoutOptions", to: :layout_options
+        map "constraints", to: :constraints
+        map "properties", to: :properties
+      end
+
+      yaml do
+        map "id", to: :id
+        map "x", to: :x
+        map "y", to: :y
+        map "width", to: :width
+        map "height", to: :height
+        map "labels", to: :labels
+        map "ports", to: :ports
+        map "children", to: :children
+        map "edges", to: :edges
+        map "layout_options", to: :layout_options
+        map "constraints", to: :constraints
+        map "properties", to: :properties
+      end
+
+      def hierarchical?
+        @children && !@children.empty?
+      end
+
+      def find_node(node_id)
+        return self if @id == node_id
+
+        return nil unless @children
+
+        @children.each do |child|
+          found = child.find_node(node_id)
+          return found if found
+        end
+        nil
+      end
+
+      def all_nodes
+        nodes = [self]
+        return nodes unless @children
+
+        @children.each do |child|
+          nodes.concat(child.all_nodes)
+        end
+        nodes
+      end
+    end
+  end
+end

data/lib/elkrb/graph/node_constraints.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Elkrb
+  module Graph
+    # Relative offset for positioning
+    #
+    # Specifies x and y offset from a reference node.
+    #
+    # @example
+    #   offset = RelativeOffset.new(x: 100, y: 50)
+    #   # Position 100px right, 50px down from reference
+    class RelativeOffset < 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
+    end
+
+    # Node positioning constraints
+    #
+    # Allows precise control over node placement through various constraint types:
+    # - Fixed position: Lock node at specific coordinates
+    # - Alignment: Align nodes horizontally or vertically
+    # - Layer: Force node into specific layer (for layered algorithm)
+    # - Relative position: Position relative to another node
+    #
+    # @example Fixed position constraint
+    #   constraints = NodeConstraints.new(fixed_position: true)
+    #   node.constraints = constraints
+    #   node.x = 100
+    #   node.y = 200
+    #   # Node won't move during layout
+    #
+    # @example Alignment constraint
+    #   constraints = NodeConstraints.new(
+    #     align_group: "databases",
+    #     align_direction: "horizontal"
+    #   )
+    #   # All nodes in "databases" group will align horizontally
+    #
+    # @example Layer constraint
+    #   constraints = NodeConstraints.new(layer: 2)
+    #   # Node forced into layer 2 (for layered algorithm)
+    #
+    # @example Relative position constraint
+    #   offset = RelativeOffset.new(x: 150, y: 0)
+    #   constraints = NodeConstraints.new(
+    #     relative_to: "backend_service",
+    #     relative_offset: offset
+    #   )
+    #   # Node positioned 150px right of backend_service
+    class NodeConstraints < Lutaml::Model::Serializable
+      attribute :fixed_position, :boolean, default: -> { false }
+      attribute :layer, :integer
+      attribute :align_group, :string
+      attribute :align_direction, :string
+      attribute :relative_to, :string
+      attribute :relative_offset, RelativeOffset
+      attribute :position_priority, :integer, default: -> { 0 }
+
+      json do
+        map "fixedPosition", to: :fixed_position
+        map "layer", to: :layer
+        map "alignGroup", to: :align_group
+        map "alignDirection", to: :align_direction
+        map "relativeTo", to: :relative_to
+        map "relativeOffset", to: :relative_offset
+        map "positionPriority", to: :position_priority
+      end
+
+      yaml do
+        map "fixedPosition", to: :fixed_position
+        map "layer", to: :layer
+        map "alignGroup", to: :align_group
+        map "alignDirection", to: :align_direction
+        map "relativeTo", to: :relative_to
+        map "relativeOffset", to: :relative_offset
+        map "positionPriority", to: :position_priority
+      end
+
+      # Valid alignment directions
+      HORIZONTAL = "horizontal"
+      VERTICAL = "vertical"
+      ALIGN_DIRECTIONS = [HORIZONTAL, VERTICAL].freeze
+
+      # Validate alignment direction
+      def align_direction=(value)
+        if value && !ALIGN_DIRECTIONS.include?(value.to_s.downcase)
+          raise ArgumentError,
+                "Invalid align_direction: #{value}. " \
+                "Must be #{ALIGN_DIRECTIONS.join(' or ')}"
+        end
+        @align_direction = value&.to_s&.downcase
+      end
+    end
+  end
+end