elkrb 1.0.2 → 2.0.0

data/lib/elkrb/graph/layout_options.rb

@@ -1,247 +0,0 @@
-# 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/sig/elkrb/constraints.rbs

@@ -1,114 +0,0 @@
-# Type signatures for ElkRb layout constraints
-
-module Elkrb
-  module Graph
-    # Relative offset for positioning
-    class RelativeOffset < Lutaml::Model::Serializable
-      attr_accessor x: Float
-      attr_accessor y: Float
-
-      def initialize: (?x: Float, ?y: Float) -> void
-    end
-
-    # Node positioning constraints
-    class NodeConstraints < Lutaml::Model::Serializable
-      attr_accessor fixed_position: bool
-      attr_accessor layer: Integer?
-      attr_accessor align_group: String?
-      attr_accessor align_direction: String?
-      attr_accessor relative_to: String?
-      attr_accessor relative_offset: RelativeOffset?
-      attr_accessor position_priority: Integer
-
-      HORIZONTAL: String
-      VERTICAL: String
-      ALIGN_DIRECTIONS: Array[String]
-
-      def initialize: (
-        ?fixed_position: bool,
-        ?layer: Integer?,
-        ?align_group: String?,
-        ?align_direction: String?,
-        ?relative_to: String?,
-        ?relative_offset: RelativeOffset?,
-        ?position_priority: Integer
-      ) -> void
-
-      def align_direction=: (String? value) -> String?
-    end
-  end
-
-  module Layout
-    module Constraints
-      # Base constraint class
-      class BaseConstraint
-        def apply: (Graph::Graph graph) -> Graph::Graph
-        def validate: (Graph::Graph graph) -> Array[String]
-        def applies_to?: (Graph::Node node) -> bool
-
-        private
-
-        def find_node: (Graph::Graph graph, String node_id) -> Graph::Node?
-        def all_nodes: (Graph::Graph graph) -> Array[Graph::Node]
-      end
-
-      # Fixed position constraint
-      class FixedPositionConstraint < BaseConstraint
-        def apply: (Graph::Graph graph) -> Graph::Graph
-        def validate: (Graph::Graph graph) -> Array[String]
-        def restore_fixed_positions: (Graph::Graph graph) -> Graph::Graph
-      end
-
-      # Alignment constraint
-      class AlignmentConstraint < BaseConstraint
-        def apply: (Graph::Graph graph) -> Graph::Graph
-        def validate: (Graph::Graph graph) -> Array[String]
-
-        private
-
-        def group_by_alignment: (Array[Graph::Node] nodes) -> Hash[[String, String], Array[Graph::Node]]
-        def align_nodes: (Array[Graph::Node] nodes, String direction) -> void
-        def align_horizontally: (Array[Graph::Node] nodes) -> void
-        def align_vertically: (Array[Graph::Node] nodes) -> void
-        def validate_group_alignment: (Array[Graph::Node] nodes, String group_name, String direction) -> Array[String]
-      end
-
-      # Layer constraint
-      class LayerConstraint < BaseConstraint
-        def apply: (Graph::Graph graph) -> Graph::Graph
-        def validate: (Graph::Graph graph) -> Array[String]
-      end
-
-      # Relative position constraint
-      class RelativePositionConstraint < BaseConstraint
-        def apply: (Graph::Graph graph) -> Graph::Graph
-        def validate: (Graph::Graph graph) -> Array[String]
-
-        private
-
-        def apply_relative_position: (Graph::Node node, Graph::Graph graph) -> void
-      end
-
-      # Constraint processor
-      class ConstraintProcessor
-        PRE_LAYOUT_CONSTRAINTS: Array[singleton(BaseConstraint)]
-        POST_LAYOUT_CONSTRAINTS: Array[singleton(BaseConstraint)]
-
-        @pre_constraints: Array[BaseConstraint]
-        @post_constraints: Array[BaseConstraint]
-        @all_constraints: Array[BaseConstraint]
-
-        def initialize: () -> void
-        def apply_pre_layout: (Graph::Graph graph) -> Graph::Graph
-        def enforce_post_layout: (Graph::Graph graph) -> Graph::Graph
-        def apply_all: (Graph::Graph graph) -> Graph::Graph
-        def validate_all: (Graph::Graph graph) -> Array[String]
-        def has_constraints?: (Graph::Graph graph) -> bool
-
-        private
-
-        def has_constraints_recursive?: (Graph::Node node) -> bool
-      end
-    end
-  end
-end

data/sig/elkrb/geometry.rbs

@@ -1,61 +0,0 @@
-module Elkrb
-  module Geometry
-    class Point
-      attr_reader x: Float
-      attr_reader y: Float
-
-      def initialize: (Float x, Float y) -> void
-      def +: (Point other) -> Point
-      def -: (Point other) -> Point
-      def *: (Float scalar) -> Point
-      def /: (Float scalar) -> Point
-      def distance_to: (Point other) -> Float
-      def ==: (untyped other) -> bool
-      def to_h: () -> Hash[Symbol, Float]
-    end
-
-    class Dimension
-      attr_reader width: Float
-      attr_reader height: Float
-
-      def initialize: (Float width, Float height) -> void
-      def area: () -> Float
-      def ==: (untyped other) -> bool
-      def to_h: () -> Hash[Symbol, Float]
-    end
-
-    class Rectangle
-      attr_reader x: Float
-      attr_reader y: Float
-      attr_reader width: Float
-      attr_reader height: Float
-
-      def initialize: (Float x, Float y, Float width, Float height) -> void
-      def left: () -> Float
-      def right: () -> Float
-      def top: () -> Float
-      def bottom: () -> Float
-      def center: () -> Point
-      def contains?: (Point | Rectangle point_or_rect) -> bool
-      def intersects?: (Rectangle other) -> bool
-      def ==: (untyped other) -> bool
-      def to_h: () -> Hash[Symbol, Float]
-    end
-
-    class Vector
-      attr_reader x: Float
-      attr_reader y: Float
-
-      def initialize: (Float x, Float y) -> void
-      def +: (Vector other) -> Vector
-      def -: (Vector other) -> Vector
-      def *: (Float scalar) -> Vector
-      def /: (Float scalar) -> Vector
-      def magnitude: () -> Float
-      def normalize: () -> Vector
-      def dot: (Vector other) -> Float
-      def ==: (untyped other) -> bool
-      def to_h: () -> Hash[Symbol, Float]
-    end
-  end
-end

data/sig/elkrb/graph.rbs

@@ -1,112 +0,0 @@
-module Elkrb
-  module Graph
-    class LayoutOptions
-      attr_accessor algorithm: String?
-      attr_accessor direction: String?
-      attr_accessor spacing_node_node: Float?
-      attr_accessor spacing_edge_node: Float?
-      attr_accessor spacing_edge_edge: Float?
-      attr_accessor edge_routing: String?
-      attr_accessor padding: Hash[Symbol, Float]?
-      attr_accessor aspect_ratio: Float?
-
-      def self.from_hash: (Hash[String | Symbol, untyped] hash) -> LayoutOptions
-      def to_json: () -> String
-      def to_yaml: () -> String
-    end
-
-    class Label
-      attr_accessor id: String?
-      attr_accessor text: String?
-      attr_accessor x: Float?
-      attr_accessor y: Float?
-      attr_accessor width: Float?
-      attr_accessor height: Float?
-
-      def self.from_hash: (Hash[String | Symbol, untyped] hash) -> Label
-      def to_json: () -> String
-      def to_yaml: () -> String
-    end
-
-    class Port
-      attr_accessor id: String?
-      attr_accessor x: Float?
-      attr_accessor y: Float?
-      attr_accessor width: Float?
-      attr_accessor height: Float?
-      attr_accessor labels: Array[Label]?
-
-      def self.from_hash: (Hash[String | Symbol, untyped] hash) -> Port
-      def to_json: () -> String
-      def to_yaml: () -> String
-    end
-
-    class EdgeSection
-      attr_accessor id: String?
-      attr_accessor start_point: Hash[String, Float]?
-      attr_accessor end_point: Hash[String, Float]?
-      attr_accessor bend_points: Array[Hash[String, Float]]?
-      attr_accessor incoming_shape: String?
-      attr_accessor outgoing_shape: String?
-
-      def self.from_hash: (Hash[String | Symbol, untyped] hash) -> EdgeSection
-      def to_json: () -> String
-      def to_yaml: () -> String
-    end
-
-    class Edge
-      attr_accessor id: String?
-      attr_accessor sources: Array[String]?
-      attr_accessor targets: Array[String]?
-      attr_accessor labels: Array[Label]?
-      attr_accessor sections: Array[EdgeSection]?
-      attr_accessor layout_options: LayoutOptions?
-      attr_accessor properties: Hash[String, untyped]?
-
-      def self.from_hash: (Hash[String | Symbol, untyped] hash) -> Edge
-      def to_json: () -> String
-      def to_yaml: () -> String
-    end
-
-    class Node
-      attr_accessor id: String?
-      attr_accessor x: Float?
-      attr_accessor y: Float?
-      attr_accessor width: Float?
-      attr_accessor height: Float?
-      attr_accessor labels: Array[Label]?
-      attr_accessor ports: Array[Port]?
-      attr_accessor children: Array[Node]?
-      attr_accessor edges: Array[Edge]?
-      attr_accessor layout_options: LayoutOptions?
-      attr_accessor properties: Hash[String, untyped]?
-
-      def self.from_hash: (Hash[String | Symbol, untyped] hash) -> Node
-      def to_json: () -> String
-      def to_yaml: () -> String
-      def hierarchical?: () -> bool
-      def find_node: (String node_id) -> Node?
-      def all_nodes: () -> Array[Node]
-    end
-
-    class Graph
-      attr_accessor id: String?
-      attr_accessor x: Float?
-      attr_accessor y: Float?
-      attr_accessor width: Float?
-      attr_accessor height: Float?
-      attr_accessor children: Array[Node]?
-      attr_accessor edges: Array[Edge]?
-      attr_accessor layout_options: LayoutOptions?
-      attr_accessor properties: Hash[String, untyped]?
-
-      def self.from_hash: (Hash[String | Symbol, untyped] hash) -> Graph
-      def to_json: () -> String
-      def to_yaml: () -> String
-      def hierarchical?: () -> bool
-      def find_node: (String node_id) -> Node?
-      def all_nodes: () -> Array[Node]
-      def all_edges: () -> Array[Edge]
-    end
-  end
-end

data/sig/elkrb/layout.rbs

@@ -1,107 +0,0 @@
-module Elkrb
-  module Layout
-    type algorithmMetadata = {
-      name: String,
-      description: String,
-      category: String?,
-      supports_hierarchy: bool?
-    }
-
-    type algorithmInfo = {
-      id: String,
-      name: String,
-      description: String,
-      category: String,
-      supports_hierarchy: bool
-    }
-
-    class AlgorithmRegistry
-      def self.register: (String name, singleton(Algorithms::BaseAlgorithm) algorithm_class, ?algorithmMetadata metadata) -> void
-      def self.get: (String name) -> singleton(Algorithms::BaseAlgorithm)?
-      def self.available_algorithms: () -> Array[String]
-      def self.algorithm_info: (String name) -> algorithmInfo?
-      def self.all_algorithm_info: () -> Array[algorithmInfo]
-
-      private
-
-      def self.normalize_name: (String name) -> String
-    end
-
-    class LayoutEngine
-      def self.layout: (Hash[String | Symbol, untyped] | Graph::Graph graph, Hash[String | Symbol, untyped] options) -> Graph::Graph
-      def self.known_layout_algorithms: () -> Array[algorithmInfo]
-      def self.known_layout_options: () -> Array[untyped]
-
-      private
-
-      def self.convert_to_graph: (Hash[String | Symbol, untyped] hash) -> Graph::Graph
-    end
-
-    module Algorithms
-      class BaseAlgorithm
-        attr_reader options: Hash[String | Symbol, untyped]
-
-        def initialize: (Hash[String | Symbol, untyped] options) -> void
-        def layout: (Graph::Graph graph) -> Graph::Graph
-
-        private
-
-        def option: (String | Symbol key, ?untyped default) -> untyped
-        def node_spacing: () -> Float
-        def padding: () -> Hash[Symbol, Float]
-        def calculate_bounding_box: (Array[Graph::Node] nodes) -> Geometry::Rectangle
-        def apply_padding: (Graph::Graph graph) -> void
-      end
-
-      class Random < BaseAlgorithm
-        def layout: (Graph::Graph graph) -> Graph::Graph
-      end
-
-      class Fixed < BaseAlgorithm
-        def layout: (Graph::Graph graph) -> Graph::Graph
-      end
-
-      class Box < BaseAlgorithm
-        def layout: (Graph::Graph graph) -> Graph::Graph
-      end
-
-      class Force < BaseAlgorithm
-        DEFAULT_ITERATIONS: Integer
-        DEFAULT_REPULSION: Float
-        DEFAULT_TEMPERATURE: Float
-
-        def layout: (Graph::Graph graph) -> Graph::Graph
-
-        private
-
-        def iterations: () -> Integer
-        def repulsion: () -> Float
-        def temperature: () -> Float
-        def collect_edges: (Graph::Graph graph) -> Array[Graph::Edge]
-        def initialize_positions: (Graph::Graph graph) -> void
-        def apply_forces: (Graph::Graph graph, Float repulsion, Float temperature, Integer iteration, Integer total_iterations) -> void
-        def calculate_repulsive_forces: (Array[Graph::Node] nodes, Float repulsion) -> Hash[String, Geometry::Vector]
-        def calculate_attractive_forces: (Array[Graph::Edge] edges, Float temperature) -> Hash[String, Geometry::Vector]
-        def apply_displacement: (Array[Graph::Node] nodes, Hash[String, Geometry::Vector] forces, Float cooling_factor) -> void
-      end
-
-      class Stress < BaseAlgorithm
-        DEFAULT_ITERATIONS: Integer
-        DEFAULT_EPSILON: Float
-
-        def layout: (Graph::Graph graph) -> Graph::Graph
-
-        private
-
-        def iterations: () -> Integer
-        def epsilon: () -> Float
-        def collect_edges: (Graph::Graph graph) -> Array[Graph::Edge]
-        def initialize_positions: (Graph::Graph graph) -> void
-        def calculate_distances: (Graph::Graph graph) -> Hash[String, Hash[String, Float]]
-        def calculate_stress: (Graph::Graph graph, Hash[String, Hash[String, Float]] distances) -> Float
-        def optimize_positions: (Graph::Graph graph, Hash[String, Hash[String, Float]] distances) -> void
-        def euclidean_distance: (Graph::Node n1, Graph::Node n2) -> Float
-      end
-    end
-  end
-end