elkrb 1.0.0

data/examples/self_loop_demo.rb

@@ -0,0 +1,391 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/elkrb"
+
+# Example 1: Simple Self-loop
+puts "=" * 70
+puts "Example 1: Simple Self-loop with Default Settings"
+puts "=" * 70
+
+graph1 = Elkrb::Graph::Graph.new(
+  id: "simple_self_loop",
+  children: [
+    Elkrb::Graph::Node.new(
+      id: "state1",
+      width: 100.0,
+      height: 60.0,
+    ),
+  ],
+  edges: [
+    Elkrb::Graph::Edge.new(
+      id: "loop1",
+      sources: ["state1"],
+      targets: ["state1"],
+    ),
+  ],
+  layout_options: Elkrb::Graph::LayoutOptions.new(
+    algorithm: "layered",
+  ),
+)
+
+result1 = Elkrb.layout(graph1)
+puts "\nNode position: (#{result1.children[0].x}, #{result1.children[0].y})"
+puts "Self-loop section: #{result1.edges[0].sections.length} section(s)"
+puts "Bend points: #{result1.edges[0].sections[0].bend_points.length}"
+puts "Start: (#{result1.edges[0].sections[0].start_point.x.round(1)}, " \
+     "#{result1.edges[0].sections[0].start_point.y.round(1)})"
+puts "End: (#{result1.edges[0].sections[0].end_point.x.round(1)}, " \
+     "#{result1.edges[0].sections[0].end_point.y.round(1)})"
+
+# Example 2: Self-loop with Custom Side
+puts "\n#{'=' * 70}"
+puts "Example 2: Self-loop on Different Sides"
+puts "=" * 70
+
+%w[EAST WEST NORTH SOUTH].each do |side|
+  graph = Elkrb::Graph::Graph.new(
+    id: "self_loop_#{side.downcase}",
+    children: [
+      Elkrb::Graph::Node.new(
+        id: "node",
+        width: 80.0,
+        height: 60.0,
+      ),
+    ],
+    edges: [
+      Elkrb::Graph::Edge.new(
+        id: "loop",
+        sources: ["node"],
+        targets: ["node"],
+        layout_options: Elkrb::Graph::LayoutOptions.new(
+          "elk.selfLoopSide" => side,
+        ),
+      ),
+    ],
+    layout_options: Elkrb::Graph::LayoutOptions.new(
+      algorithm: "layered",
+    ),
+  )
+
+  result = Elkrb.layout(graph)
+  section = result.edges[0].sections[0]
+  puts "\n#{side} side:"
+  puts "  Start: (#{section.start_point.x.round(1)}, " \
+       "#{section.start_point.y.round(1)})"
+  puts "  Bend points: #{section.bend_points.length}"
+end
+
+# Example 3: Multiple Self-loops on Same Node
+puts "\n#{'=' * 70}"
+puts "Example 3: Multiple Self-loops on Same Node"
+puts "=" * 70
+
+graph3 = Elkrb::Graph::Graph.new(
+  id: "multiple_self_loops",
+  children: [
+    Elkrb::Graph::Node.new(
+      id: "state",
+      width: 100.0,
+      height: 80.0,
+    ),
+  ],
+  edges: [
+    Elkrb::Graph::Edge.new(
+      id: "loop1",
+      sources: ["state"],
+      targets: ["state"],
+    ),
+    Elkrb::Graph::Edge.new(
+      id: "loop2",
+      sources: ["state"],
+      targets: ["state"],
+    ),
+    Elkrb::Graph::Edge.new(
+      id: "loop3",
+      sources: ["state"],
+      targets: ["state"],
+    ),
+  ],
+  layout_options: Elkrb::Graph::LayoutOptions.new(
+    algorithm: "layered",
+  ),
+)
+
+result3 = Elkrb.layout(graph3)
+result3.edges.each_with_index do |edge, i|
+  section = edge.sections[0]
+  first_bend = section.bend_points[0]
+  puts "\nLoop #{i + 1} (#{edge.id}):"
+  puts "  First bend point x: #{first_bend.x.round(1)}"
+  puts "  Offset from node edge: " \
+       "#{(first_bend.x - result3.children[0].x -
+           result3.children[0].width).round(1)}"
+end
+
+# Example 4: Self-loop with Spline Routing
+puts "\n#{'=' * 70}"
+puts "Example 4: Self-loop with Spline (Curved) Routing"
+puts "=" * 70
+
+graph4 = Elkrb::Graph::Graph.new(
+  id: "spline_self_loop",
+  children: [
+    Elkrb::Graph::Node.new(
+      id: "node",
+      width: 100.0,
+      height: 60.0,
+    ),
+  ],
+  edges: [
+    Elkrb::Graph::Edge.new(
+      id: "curved_loop",
+      sources: ["node"],
+      targets: ["node"],
+    ),
+  ],
+  layout_options: Elkrb::Graph::LayoutOptions.new(
+    algorithm: "layered",
+    edge_routing: "SPLINES",
+  ),
+)
+
+result4 = Elkrb.layout(graph4)
+section4 = result4.edges[0].sections[0]
+puts "\nSpline self-loop:"
+puts "  Control points: #{section4.bend_points.length}"
+puts "  Control point 1: (#{section4.bend_points[0].x.round(1)}, " \
+     "#{section4.bend_points[0].y.round(1)})"
+puts "  Control point 2: (#{section4.bend_points[1].x.round(1)}, " \
+     "#{section4.bend_points[1].y.round(1)})"
+
+# Example 5: State Machine with Self-loops
+puts "\n#{'=' * 70}"
+puts "Example 5: State Machine with Self-loops and Transitions"
+puts "=" * 70
+
+graph5 = Elkrb::Graph::Graph.new(
+  id: "state_machine",
+  children: [
+    Elkrb::Graph::Node.new(
+      id: "idle",
+      width: 80.0,
+      height: 50.0,
+    ),
+    Elkrb::Graph::Node.new(
+      id: "running",
+      width: 80.0,
+      height: 50.0,
+    ),
+    Elkrb::Graph::Node.new(
+      id: "error",
+      width: 80.0,
+      height: 50.0,
+    ),
+  ],
+  edges: [
+    # Self-loops (states that can transition to themselves)
+    Elkrb::Graph::Edge.new(
+      id: "idle_wait",
+      sources: ["idle"],
+      targets: ["idle"],
+    ),
+    Elkrb::Graph::Edge.new(
+      id: "running_continue",
+      sources: ["running"],
+      targets: ["running"],
+    ),
+    # Regular transitions
+    Elkrb::Graph::Edge.new(
+      id: "start",
+      sources: ["idle"],
+      targets: ["running"],
+    ),
+    Elkrb::Graph::Edge.new(
+      id: "fail",
+      sources: ["running"],
+      targets: ["error"],
+    ),
+    Elkrb::Graph::Edge.new(
+      id: "reset",
+      sources: ["error"],
+      targets: ["idle"],
+    ),
+  ],
+  layout_options: Elkrb::Graph::LayoutOptions.new(
+    algorithm: "layered",
+    direction: "RIGHT",
+  ),
+)
+
+result5 = Elkrb.layout(graph5)
+puts "\nState machine layout:"
+result5.children.each do |node|
+  puts "  #{node.id}: (#{node.x.round(1)}, #{node.y.round(1)})"
+end
+puts "\nEdges:"
+result5.edges.each do |edge|
+  is_self_loop = edge.sources[0] == edge.targets[0]
+  puts "  #{edge.id}: #{is_self_loop ? 'self-loop' : 'transition'}"
+end
+
+# Example 6: Self-loop with Ports
+puts "\n#{'=' * 70}"
+puts "Example 6: Self-loop Between Ports"
+puts "=" * 70
+
+graph6 = Elkrb::Graph::Graph.new(
+  id: "port_self_loop",
+  children: [
+    Elkrb::Graph::Node.new(
+      id: "component",
+      width: 120.0,
+      height: 80.0,
+      ports: [
+        Elkrb::Graph::Port.new(
+          id: "out1",
+          x: 120.0,
+          y: 20.0,
+          side: "EAST",
+        ),
+        Elkrb::Graph::Port.new(
+          id: "in1",
+          x: 120.0,
+          y: 60.0,
+          side: "EAST",
+        ),
+      ],
+    ),
+  ],
+  edges: [
+    Elkrb::Graph::Edge.new(
+      id: "feedback",
+      sources: ["out1"],
+      targets: ["in1"],
+    ),
+  ],
+  layout_options: Elkrb::Graph::LayoutOptions.new(
+    algorithm: "layered",
+  ),
+)
+
+result6 = Elkrb.layout(graph6)
+section6 = result6.edges[0].sections[0]
+puts "\nPort-based self-loop:"
+puts "  Start (out1): (#{section6.start_point.x.round(1)}, " \
+     "#{section6.start_point.y.round(1)})"
+puts "  End (in1): (#{section6.end_point.x.round(1)}, " \
+     "#{section6.end_point.y.round(1)})"
+puts "  Bend points: #{section6.bend_points.length}"
+
+# Example 7: Finite Automaton
+puts "\n#{'=' * 70}"
+puts "Example 7: Finite Automaton with Self-loops"
+puts "=" * 70
+
+graph7 = Elkrb::Graph::Graph.new(
+  id: "finite_automaton",
+  children: [
+    Elkrb::Graph::Node.new(
+      id: "q0",
+      width: 60.0,
+      height: 60.0,
+    ),
+    Elkrb::Graph::Node.new(
+      id: "q1",
+      width: 60.0,
+      height: 60.0,
+    ),
+    Elkrb::Graph::Node.new(
+      id: "q2",
+      width: 60.0,
+      height: 60.0,
+    ),
+  ],
+  edges: [
+    # Self-loops for states reading same symbol
+    Elkrb::Graph::Edge.new(
+      id: "q0_0",
+      sources: ["q0"],
+      targets: ["q0"],
+      layout_options: Elkrb::Graph::LayoutOptions.new(
+        "elk.selfLoopSide" => "NORTH",
+      ),
+    ),
+    Elkrb::Graph::Edge.new(
+      id: "q1_1",
+      sources: ["q1"],
+      targets: ["q1"],
+      layout_options: Elkrb::Graph::LayoutOptions.new(
+        "elk.selfLoopSide" => "NORTH",
+      ),
+    ),
+    # State transitions
+    Elkrb::Graph::Edge.new(
+      id: "q0_to_q1",
+      sources: ["q0"],
+      targets: ["q1"],
+    ),
+    Elkrb::Graph::Edge.new(
+      id: "q1_to_q2",
+      sources: ["q1"],
+      targets: ["q2"],
+    ),
+  ],
+  layout_options: Elkrb::Graph::LayoutOptions.new(
+    algorithm: "layered",
+    direction: "RIGHT",
+  ),
+)
+
+result7 = Elkrb.layout(graph7)
+puts "\nFinite automaton states:"
+result7.children.each do |node|
+  puts "  #{node.id}: (#{node.x.round(1)}, #{node.y.round(1)})"
+end
+
+self_loops = result7.edges.select { |e| e.sources[0] == e.targets[0] }
+puts "\nSelf-loops (same symbol transitions):"
+self_loops.each do |edge|
+  section = edge.sections[0]
+  puts "  #{edge.id}: #{section.bend_points.length} bend points"
+end
+
+# Example 8: Mixed Routing Styles
+puts "\n#{'=' * 70}"
+puts "Example 8: Comparing Routing Styles"
+puts "=" * 70
+
+%w[ORTHOGONAL SPLINES POLYLINE].each do |style|
+  graph = Elkrb::Graph::Graph.new(
+    id: "style_#{style.downcase}",
+    children: [
+      Elkrb::Graph::Node.new(
+        id: "node",
+        width: 80.0,
+        height: 60.0,
+      ),
+    ],
+    edges: [
+      Elkrb::Graph::Edge.new(
+        id: "loop",
+        sources: ["node"],
+        targets: ["node"],
+      ),
+    ],
+    layout_options: Elkrb::Graph::LayoutOptions.new(
+      algorithm: "layered",
+      edge_routing: style,
+    ),
+  )
+
+  result = Elkrb.layout(graph)
+  section = result.edges[0].sections[0]
+  puts "\n#{style} routing:"
+  puts "  Bend points: #{section.bend_points.length}"
+  puts "  Path length: #{section.length.round(2)}"
+end
+
+puts "\n#{'=' * 70}"
+puts "All examples completed successfully!"
+puts "=" * 70

data/examples/simple_graph.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "elkrb"
+
+# Simple graph layout example
+# This demonstrates the basic usage of ElkRb with a simple node graph
+
+# Create a graph with 4 nodes connected in sequence
+graph = Elkrb::Graph.new(
+  id: "root",
+  children: [
+    { id: "n1", width: 100, height: 50 },
+    { id: "n2", width: 100, height: 50 },
+    { id: "n3", width: 100, height: 50 },
+    { id: "n4", width: 100, height: 50 },
+  ],
+  edges: [
+    { id: "e1", sources: ["n1"], targets: ["n2"] },
+    { id: "e2", sources: ["n2"], targets: ["n3"] },
+    { id: "e3", sources: ["n3"], targets: ["n4"] },
+  ],
+)
+
+# Configure layout options
+graph.layout_options = {
+  "algorithm" => "layered",
+  "elk.direction" => "DOWN",
+  "spacing.nodeNode" => 50,
+}
+
+# Perform layout
+engine = Elkrb::Layout::LayoutEngine.new
+result = engine.layout(graph)
+
+# Display results
+puts "Graph layout completed!"
+puts "=" * 60
+puts "Root dimensions: #{result.width}x#{result.height}"
+puts "\nNode positions:"
+result.children.each do |node|
+  puts "  #{node.id}: (#{node.x}, #{node.y})"
+end
+
+puts "\nEdge routing:"
+result.edges.each do |edge|
+  puts "  #{edge.id}: #{edge.sections&.first&.start_point} -> " \
+       "#{edge.sections&.first&.end_point}"
+end

data/examples/spline_routing_demo.rb

@@ -0,0 +1,235 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Spline Edge Routing Demo
+#
+# This example demonstrates the use of smooth Bezier curve routing for edges
+# in ElkRb, comparing different routing styles.
+
+require_relative "../lib/elkrb"
+
+def create_sample_graph(routing_style, curvature = 0.5)
+  Elkrb::Graph::Graph.new(
+    id: "root",
+    layout_options: Elkrb::Graph::LayoutOptions.new(
+      algorithm: "layered",
+      direction: "RIGHT",
+      edge_routing: routing_style,
+      spline_curvature: curvature,
+      spacing_node_node: 80.0,
+    ),
+    children: [
+      Elkrb::Graph::Node.new(
+        id: "n1",
+        width: 80,
+        height: 40,
+        labels: [
+          Elkrb::Graph::Label.new(text: "Start", width: 40, height: 15),
+        ],
+      ),
+      Elkrb::Graph::Node.new(
+        id: "n2",
+        width: 80,
+        height: 40,
+        labels: [
+          Elkrb::Graph::Label.new(text: "Process", width: 50, height: 15),
+        ],
+      ),
+      Elkrb::Graph::Node.new(
+        id: "n3",
+        width: 80,
+        height: 40,
+        labels: [
+          Elkrb::Graph::Label.new(text: "Decision", width: 55, height: 15),
+        ],
+      ),
+      Elkrb::Graph::Node.new(
+        id: "n4",
+        width: 80,
+        height: 40,
+        labels: [
+          Elkrb::Graph::Label.new(text: "End", width: 30, height: 15),
+        ],
+      ),
+    ],
+    edges: [
+      Elkrb::Graph::Edge.new(
+        id: "e1",
+        sources: ["n1"],
+        targets: ["n2"],
+      ),
+      Elkrb::Graph::Edge.new(
+        id: "e2",
+        sources: ["n2"],
+        targets: ["n3"],
+      ),
+      Elkrb::Graph::Edge.new(
+        id: "e3",
+        sources: ["n3"],
+        targets: ["n4"],
+      ),
+      Elkrb::Graph::Edge.new(
+        id: "e4",
+        sources: ["n3"],
+        targets: ["n2"],
+        labels: [
+          Elkrb::Graph::Label.new(text: "retry", width: 30, height: 15),
+        ],
+      ),
+    ],
+  )
+end
+
+def print_edge_info(edge, style_name)
+  section = edge.sections&.first
+  return unless section
+
+  puts "\n  Edge #{edge.id} (#{style_name}):"
+  puts "    Start: (#{section.start_point.x.round(1)}, " \
+       "#{section.start_point.y.round(1)})"
+
+  if section.bend_points&.any?
+    section.bend_points.each_with_index do |point, i|
+      puts "    Control #{i + 1}: (#{point.x.round(1)}, #{point.y.round(1)})"
+    end
+  end
+
+  puts "    End: (#{section.end_point.x.round(1)}, " \
+       "#{section.end_point.y.round(1)})"
+  puts "    Length: #{section.length.round(2)}"
+end
+
+puts "=" * 70
+puts "ElkRb Spline Edge Routing Demo"
+puts "=" * 70
+
+# Demo 1: Orthogonal Routing (Default)
+puts "\n1. ORTHOGONAL ROUTING (90-degree bends)"
+puts "-" * 70
+
+graph1 = create_sample_graph("ORTHOGONAL")
+result1 = Elkrb::Layout::LayoutEngine.layout(graph1)
+
+puts "\nGraph dimensions: #{result1.width.round(1)} x #{result1.height.round(1)}"
+result1.edges.each { |edge| print_edge_info(edge, "ORTHOGONAL") }
+
+# Demo 2: Polyline Routing
+puts "\n\n2. POLYLINE ROUTING (Straight lines)"
+puts "-" * 70
+
+graph2 = create_sample_graph("POLYLINE")
+result2 = Elkrb::Layout::LayoutEngine.layout(graph2)
+
+puts "\nGraph dimensions: #{result2.width.round(1)} x #{result2.height.round(1)}"
+result2.edges.each { |edge| print_edge_info(edge, "POLYLINE") }
+
+# Demo 3: Spline Routing (Smooth curves - Default curvature)
+puts "\n\n3. SPLINE ROUTING (Smooth curves - curvature: 0.5)"
+puts "-" * 70
+
+graph3 = create_sample_graph("SPLINES", 0.5)
+result3 = Elkrb::Layout::LayoutEngine.layout(graph3)
+
+puts "\nGraph dimensions: #{result3.width.round(1)} x #{result3.height.round(1)}"
+result3.edges.each { |edge| print_edge_info(edge, "SPLINES") }
+
+# Demo 4: Spline Routing with Low Curvature
+puts "\n\n4. SPLINE ROUTING (Gentle curves - curvature: 0.2)"
+puts "-" * 70
+
+graph4 = create_sample_graph("SPLINES", 0.2)
+result4 = Elkrb::Layout::LayoutEngine.layout(graph4)
+
+puts "\nGraph dimensions: #{result4.width.round(1)} x #{result4.height.round(1)}"
+result4.edges.each { |edge| print_edge_info(edge, "SPLINES 0.2") }
+
+# Demo 5: Spline Routing with High Curvature
+puts "\n\n5. SPLINE ROUTING (Strong curves - curvature: 0.9)"
+puts "-" * 70
+
+graph5 = create_sample_graph("SPLINES", 0.9)
+result5 = Elkrb::Layout::LayoutEngine.layout(graph5)
+
+puts "\nGraph dimensions: #{result5.width.round(1)} x #{result5.height.round(1)}"
+result5.edges.each { |edge| print_edge_info(edge, "SPLINES 0.9") }
+
+# Demo 6: Port-based Spline Routing
+puts "\n\n6. PORT-BASED SPLINE ROUTING"
+puts "-" * 70
+
+port_graph = Elkrb::Graph::Graph.new(
+  id: "port_demo",
+  layout_options: Elkrb::Graph::LayoutOptions.new(
+    algorithm: "layered",
+    direction: "RIGHT",
+    edge_routing: "SPLINES",
+    spline_curvature: 0.6,
+  ),
+  children: [
+    Elkrb::Graph::Node.new(
+      id: "source",
+      width: 100,
+      height: 60,
+      ports: [
+        Elkrb::Graph::Port.new(id: "out1", x: 100, y: 15),
+        Elkrb::Graph::Port.new(id: "out2", x: 100, y: 45),
+      ],
+      labels: [
+        Elkrb::Graph::Label.new(text: "Source", width: 45, height: 15),
+      ],
+    ),
+    Elkrb::Graph::Node.new(
+      id: "target",
+      width: 100,
+      height: 60,
+      ports: [
+        Elkrb::Graph::Port.new(id: "in1", x: 0, y: 15),
+        Elkrb::Graph::Port.new(id: "in2", x: 0, y: 45),
+      ],
+      labels: [
+        Elkrb::Graph::Label.new(text: "Target", width: 45, height: 15),
+      ],
+    ),
+  ],
+  edges: [
+    Elkrb::Graph::Edge.new(
+      id: "pe1",
+      sources: ["out1"],
+      targets: ["in1"],
+    ),
+    Elkrb::Graph::Edge.new(
+      id: "pe2",
+      sources: ["out2"],
+      targets: ["in2"],
+    ),
+  ],
+)
+
+port_result = Elkrb::Layout::LayoutEngine.layout(port_graph)
+puts "\nGraph dimensions: #{port_result.width.round(1)} x " \
+     "#{port_result.height.round(1)}"
+port_result.edges.each { |edge| print_edge_info(edge, "PORT SPLINES") }
+
+# Comparison Summary
+puts "\n\n#{'=' * 70}"
+puts "COMPARISON SUMMARY"
+puts "=" * 70
+
+puts "\nRouting Style Characteristics:"
+puts "  • ORTHOGONAL: Right-angle bends, clear paths, traditional look"
+puts "  • POLYLINE:   Direct straight lines, minimal space, technical look"
+puts "  • SPLINES:    Smooth curves, aesthetic appeal, natural flow"
+
+puts "\nSpline Curvature Guide:"
+puts "  • 0.0-0.3: Gentle curves, closer to straight lines"
+puts "  • 0.4-0.6: Moderate curves, balanced appearance (recommended)"
+puts "  • 0.7-1.0: Strong curves, very pronounced arcs"
+
+puts "\nWhen to Use Each Style:"
+puts "  • ORTHOGONAL: Technical diagrams, flowcharts, circuit diagrams"
+puts "  • POLYLINE:   Simple connections, space-constrained layouts"
+puts "  • SPLINES:    Presentation diagrams, organic layouts, visual appeal"
+
+puts "\n#{'=' * 70}"
+puts "Demo complete! See SPLINE_ROUTING_GUIDE.md for more information."
+puts "=" * 70

data/exe/elkrb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "elkrb"
+require "elkrb/cli"
+
+Elkrb::Cli.start(ARGV)