elkrb 1.0.0

data/lib/elkrb/cli.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require "thor"
+require "json"
+require "yaml"
+
+module Elkrb
+  # Command-line interface for elkrb
+  #
+  # Provides commands for laying out graphs from the command line.
+  # Supports JSON and YAML input/output formats.
+  class Cli < Thor
+    class_option :verbose, type: :boolean, default: false,
+                           desc: "Enable verbose output"
+
+    desc "layout FILE", "Layout a graph from a JSON or YAML file"
+    option :algorithm, type: :string, default: "layered",
+                       desc: "Layout algorithm to use"
+    option :output, type: :string, aliases: "-o",
+                    desc: "Output file (default: stdout)"
+    option :format, type: :string, default: "json",
+                    enum: %w[json yaml],
+                    desc: "Output format"
+    option :spacing, type: :numeric,
+                     desc: "Node spacing"
+    option :layer_spacing, type: :numeric,
+                           desc: "Layer spacing (for layered algorithm)"
+    option :padding_top, type: :numeric,
+                         desc: "Top padding"
+    option :padding_bottom, type: :numeric,
+                            desc: "Bottom padding"
+    option :padding_left, type: :numeric,
+                          desc: "Left padding"
+    option :padding_right, type: :numeric,
+                           desc: "Right padding"
+    def layout(file)
+      verbose_output "Loading graph from #{file}..."
+
+      # Read input file
+      graph_data = read_input_file(file)
+
+      # Build layout options
+      layout_options = build_layout_options
+
+      verbose_output "Using algorithm: #{layout_options[:algorithm]}"
+
+      # Perform layout
+      result = Layout::LayoutEngine.layout(graph_data, layout_options)
+
+      # Output result
+      output_result(result)
+
+      verbose_output "Layout complete!"
+    rescue StandardError => e
+      error_output "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "algorithms", "List available layout algorithms"
+    def algorithms
+      algos = Layout::LayoutEngine.known_layout_algorithms
+
+      say "Available Layout Algorithms:", :green
+      say ""
+
+      algos.each do |algo|
+        say "  #{algo[:id]}", :cyan
+        say "    Name: #{algo[:name]}"
+        say "    Description: #{algo[:description]}"
+        say "    Category: #{algo[:category]}" if algo[:category] != "general"
+        say "    Supports Hierarchy: Yes" if algo[:supports_hierarchy]
+        say ""
+      end
+    end
+
+    desc "diagram FILE", "Create diagram from ELK graph file"
+    option :algorithm, type: :string, default: "layered",
+                       desc: "Layout algorithm to use"
+    option :direction, type: :string,
+                       desc: "Layout direction (e.g., DOWN, RIGHT)"
+    option :spacing, type: :numeric,
+                     desc: "Node spacing"
+    option :edge_routing, type: :string,
+                          desc: "Edge routing strategy"
+    option :output, type: :string, aliases: "-o", required: true,
+                    desc: "Output file path"
+    option :format, type: :string,
+                    desc: "Output format (auto-detected from extension)"
+    option :preview, type: :boolean, default: false,
+                     desc: "Open result in default viewer"
+    def diagram(file)
+      require_relative "commands/diagram_command"
+      Commands::DiagramCommand.new(file, options).run
+    rescue StandardError => e
+      error_output "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "convert FILE", "Convert between formats (JSON/YAML/DOT/ELKT)"
+    option :output, type: :string, aliases: "-o", required: true,
+                    desc: "Output file path"
+    option :format, type: :string,
+                    desc: "Output format (auto-detected from extension)"
+    def convert(file)
+      require_relative "commands/convert_command"
+      Commands::ConvertCommand.new(file, options).run
+    rescue StandardError => e
+      error_output "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "render DOT_FILE", "Render DOT to image (requires Graphviz)"
+    option :output, type: :string, aliases: "-o", required: true,
+                    desc: "Output image file path"
+    option :engine, type: :string, default: "dot",
+                    desc: "Graphviz engine (dot, neato, fdp, etc.)"
+    option :dpi, type: :numeric, default: 96,
+                 desc: "Image resolution in DPI"
+    def render(dot_file)
+      require_relative "commands/render_command"
+      Commands::RenderCommand.new(dot_file, options).run
+    rescue StandardError => e
+      error_output "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "validate FILE", "Validate ELK graph structure"
+    option :strict, type: :boolean, default: false,
+                    desc: "Enable strict validation"
+    def validate(file)
+      require_relative "commands/validate_command"
+      Commands::ValidateCommand.new(file, options).run
+    rescue StandardError => e
+      error_output "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "batch DIR", "Process multiple files in a directory"
+    option :output_dir, type: :string, required: true,
+                        desc: "Output directory for generated files"
+    option :format, type: :string, default: "svg",
+                    desc: "Output format for all files"
+    option :algorithm, type: :string, default: "layered",
+                       desc: "Layout algorithm to use"
+    def batch(directory)
+      require_relative "commands/batch_command"
+      Commands::BatchCommand.new(directory, options).run
+    rescue StandardError => e
+      error_output "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "version", "Show elkrb version"
+    def version
+      say "elkrb version #{Elkrb::VERSION}", :green
+    end
+
+    private
+
+    def read_input_file(file)
+      require_relative "graph/graph"
+      content = File.read(file)
+
+      case File.extname(file).downcase
+      when ".json"
+        Elkrb::Graph::Graph.from_json(content)
+      when ".yml", ".yaml"
+        Elkrb::Graph::Graph.from_yaml(content)
+      else
+        # Try JSON first, then YAML
+        begin
+          Elkrb::Graph::Graph.from_json(content)
+        rescue JSON::ParserError
+          Elkrb::Graph::Graph.from_yaml(content)
+        end
+      end
+    end
+
+    def build_layout_options
+      opts = { algorithm: options[:algorithm] }
+
+      # Add spacing options
+      opts[:spacing_node_node] = options[:spacing] if options[:spacing]
+      opts[:layer_spacing] = options[:layer_spacing] if options[:layer_spacing]
+
+      # Add padding options
+      if options[:padding_top] || options[:padding_bottom] ||
+          options[:padding_left] || options[:padding_right]
+        opts[:padding] = {
+          top: options[:padding_top] || 12,
+          bottom: options[:padding_bottom] || 12,
+          left: options[:padding_left] || 12,
+          right: options[:padding_right] || 12,
+        }
+      end
+
+      opts
+    end
+
+    def output_result(result)
+      output = case options[:format]
+               when "yaml"
+                 result.to_yaml
+               else
+                 result.to_json
+               end
+
+      if options[:output]
+        File.write(options[:output], output)
+        verbose_output "Output written to #{options[:output]}"
+      else
+        say output
+      end
+    end
+
+    def verbose_output(message)
+      say message, :yellow if options[:verbose]
+    end
+
+    def error_output(message)
+      say message, :red
+    end
+  end
+end

data/lib/elkrb/commands/batch_command.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Elkrb
+  module Commands
+    # Command for processing multiple graph files in batch
+    # Useful for generating diagrams for entire directories of graph files
+    class BatchCommand
+      def initialize(directory, options)
+        @directory = directory
+        @options = options
+      end
+
+      def run
+        unless Dir.exist?(@directory)
+          raise ArgumentError,
+                "Directory not found: #{@directory}"
+        end
+
+        # Find all graph files
+        pattern = File.join(@directory, "*.{json,yml,yaml,elkt}")
+        files = Dir.glob(pattern, File::FNM_EXTGLOB)
+
+        if files.empty?
+          puts "No graph files found in #{@directory}"
+          return
+        end
+
+        # Create output directory
+        FileUtils.mkdir_p(@options[:output_dir])
+
+        # Process each file
+        success_count = 0
+        error_count = 0
+
+        files.each do |file|
+          process_file(file)
+          success_count += 1
+        rescue StandardError => e
+          error_count += 1
+          warn "⚠ Error processing #{file}: #{e.message}"
+        end
+
+        # Summary
+        puts ""
+        puts "✓ Processed #{success_count} file(s) → #{@options[:output_dir]}"
+        puts "⚠ #{error_count} error(s)" if error_count.positive?
+      end
+
+      private
+
+      def process_file(file)
+        basename = File.basename(file, File.extname(file))
+        output_file = File.join(@options[:output_dir],
+                                "#{basename}.#{@options[:format]}")
+
+        # Use DiagramCommand for each file
+        opts = @options.merge(output: output_file)
+
+        require_relative "diagram_command"
+        DiagramCommand.new(file, opts).run
+      end
+    end
+  end
+end

data/lib/elkrb/commands/convert_command.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "fileutils"
+
+module Elkrb
+  module Commands
+    # Command for converting between graph formats
+    # Supports JSON, YAML, DOT, and ELKT formats
+    class ConvertCommand
+      def initialize(file, options)
+        @file = file
+        @options = options
+      end
+
+      def run
+        # Load source file
+        graph = load_any_format(@file)
+
+        # Detect target format
+        target_format = detect_format(@options[:output])
+
+        # Convert
+        content = export_to_format(graph, target_format)
+
+        # Write output
+        write_output(content, @options[:output])
+
+        puts "✓ Converted #{@file} → #{@options[:output]} (#{target_format})"
+      end
+
+      private
+
+      def load_any_format(file)
+        raise ArgumentError, "File not found: #{file}" unless File.exist?(file)
+
+        content = File.read(file)
+        ext = File.extname(file).downcase
+
+        case ext
+        when ".json"
+          require_relative "../graph/graph"
+          Elkrb::Graph::Graph.from_json(content)
+        when ".yml", ".yaml"
+          require_relative "../graph/graph"
+          Elkrb::Graph::Graph.from_yaml(content)
+        when ".elkt"
+          require_relative "../parsers/elkt_parser"
+          Elkrb::Parsers::ElktParser.parse(content)
+        when ".dot", ".gv"
+          raise ArgumentError,
+                "DOT format input not yet supported. Use JSON, YAML, or ELKT."
+        else
+          detect_and_parse(content)
+        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. Supported formats: JSON, YAML, ELKT"
+        end
+      end
+
+      def detect_format(filename)
+        ext = File.extname(filename).downcase
+
+        case ext
+        when ".json" then :json
+        when ".yml", ".yaml" then :yaml
+        when ".dot", ".gv" then :dot
+        when ".elkt" then :elkt
+        else
+          # Use explicit format option if provided
+          if @options[:format]
+            @options[:format].to_sym
+          else
+            raise ArgumentError,
+                  "Cannot detect output format from extension: #{ext}"
+          end
+        end
+      end
+
+      def export_to_format(graph, format)
+        case format
+        when :json
+          graph.to_json
+        when :yaml
+          graph.to_yaml
+        when :dot
+          require_relative "../serializers/dot_serializer"
+          Elkrb::Serializers::DotSerializer.new.serialize(graph)
+        when :elkt
+          require_relative "../serializers/elkt_serializer"
+          Elkrb::Serializers::ElktSerializer.new.serialize(graph)
+        else
+          raise ArgumentError, "Unsupported output format: #{format}"
+        end
+      end
+
+      def write_output(content, filename)
+        dir = File.dirname(filename)
+        FileUtils.mkdir_p(dir)
+
+        File.write(filename, content)
+      end
+    end
+  end
+end

data/lib/elkrb/commands/diagram_command.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "fileutils"
+
+module Elkrb
+  module Commands
+    # Command for creating diagrams from ELK graph files
+    # Supports multiple input formats (JSON, YAML, ELKT) and output formats (DOT, PNG, SVG, PDF)
+    class DiagramCommand
+      def initialize(file, options)
+        @file = file
+        @options = options
+      end
+
+      def run
+        # Load graph
+        graph = load_graph(@file)
+
+        # Apply layout
+        layout_options = build_layout_options
+        result = Elkrb::Layout::LayoutEngine.layout(graph, layout_options)
+
+        # Determine output format
+        output_format = detect_format(@options[:output])
+
+        # Export to format
+        content = export_to_format(result, output_format)
+
+        # Write output
+        write_output(content, @options[:output])
+
+        # Render to image if needed
+        if image_format?(output_format)
+          render_to_image(@options[:output], output_format)
+        end
+
+        # Preview if requested
+        preview(@options[:output]) if @options[:preview]
+
+        puts "✓ Diagram created: #{@options[:output]}"
+      end
+
+      private
+
+      def load_graph(file)
+        raise ArgumentError, "File not found: #{file}" unless File.exist?(file)
+
+        content = File.read(file)
+        ext = File.extname(file).downcase
+
+        case ext
+        when ".json"
+          require_relative "../graph/graph"
+          Elkrb::Graph::Graph.from_json(content)
+        when ".yml", ".yaml"
+          require_relative "../graph/graph"
+          Elkrb::Graph::Graph.from_yaml(content)
+        when ".elkt"
+          require_relative "../parsers/elkt_parser"
+          Elkrb::Parsers::ElktParser.parse(content)
+        else
+          detect_and_parse(content)
+        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. Supported formats: JSON, YAML, ELKT"
+        end
+      end
+
+      def build_layout_options
+        opts = {}
+
+        opts[:algorithm] = @options[:algorithm] if @options[:algorithm]
+        opts[:direction] = @options[:direction] if @options[:direction]
+        opts[:spacing_node_node] = @options[:spacing] if @options[:spacing]
+        opts[:edge_routing] = @options[:edge_routing] if @options[:edge_routing]
+
+        opts
+      end
+
+      def detect_format(filename)
+        ext = File.extname(filename).downcase
+
+        case ext
+        when ".json" then :json
+        when ".yml", ".yaml" then :yaml
+        when ".dot", ".gv" then :dot
+        when ".elkt" then :elkt
+        when ".png" then :png
+        when ".svg" then :svg
+        when ".pdf" then :pdf
+        when ".ps" then :ps
+        when ".eps" then :eps
+        else
+          # Use explicit format option if provided
+          if @options[:format]
+            @options[:format].to_sym
+          else
+            :dot # Default to DOT
+          end
+        end
+      end
+
+      def export_to_format(result, format)
+        case format
+        when :json
+          # Use Lutaml-model's to_json for proper serialization
+          result.to_json
+        when :yaml
+          # Use Lutaml-model's to_yaml for proper serialization
+          result.to_yaml
+        when :dot, :png, :svg, :pdf, :ps, :eps
+          require_relative "../serializers/dot_serializer"
+          Elkrb::Serializers::DotSerializer.new.serialize(result)
+        when :elkt
+          require_relative "../serializers/elkt_serializer"
+          Elkrb::Serializers::ElktSerializer.new.serialize(result)
+        else
+          raise ArgumentError, "Unsupported format: #{format}"
+        end
+      end
+
+      def write_output(content, filename)
+        dir = File.dirname(filename)
+        FileUtils.mkdir_p(dir)
+
+        File.write(filename, content)
+      end
+
+      def image_format?(format)
+        %i[png svg pdf ps eps].include?(format)
+      end
+
+      def render_to_image(output_file, format)
+        # For image formats, we need to render DOT -> image
+        # First write DOT to temp file
+        dot_file = "#{output_file}.tmp.dot"
+
+        # Re-read the content we just wrote (which is DOT)
+        dot_content = File.read(output_file)
+
+        # If output is not already DOT, we need to export it
+        if File.extname(output_file).downcase == ".dot"
+          dot_file = output_file
+        else
+          File.write(dot_file, dot_content)
+        end
+
+        # Render using Graphviz
+        begin
+          require_relative "../graphviz_wrapper"
+          graphviz = Elkrb::GraphvizWrapper.new
+
+          unless graphviz.available?
+            warn "⚠ Graphviz not found. Cannot render to #{format}."
+            warn "  Install Graphviz or export to DOT format instead."
+            return
+          end
+
+          graphviz.render(dot_file, output_file, format, engine: "dot", dpi: 96)
+
+          # Clean up temp DOT file if we created one
+          File.delete(dot_file) if dot_file != output_file && File.exist?(dot_file)
+        rescue Elkrb::GraphvizWrapper::GraphvizNotFoundError => e
+          warn "⚠ #{e.message}"
+        end
+      end
+
+      def preview(file)
+        case RbConfig::CONFIG["host_os"]
+        when /darwin/
+          system("open", file)
+        when /linux/
+          system("xdg-open", file)
+        when /mswin|mingw|cygwin/
+          system("start", file)
+        else
+          warn "Preview not supported on this platform"
+        end
+      end
+    end
+  end
+end

data/lib/elkrb/commands/render_command.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Elkrb
+  module Commands
+    # Command for rendering DOT files to images using Graphviz
+    class RenderCommand
+      def initialize(dot_file, options)
+        @dot_file = dot_file
+        @options = options
+      end
+
+      def run
+        unless File.exist?(@dot_file)
+          raise ArgumentError,
+                "File not found: #{@dot_file}"
+        end
+
+        # Detect image format
+        format = detect_image_format(@options[:output])
+
+        # Render using Graphviz
+        require_relative "../graphviz_wrapper"
+        graphviz = Elkrb::GraphvizWrapper.new
+
+        engine = @options[:engine] || "dot"
+        dpi = @options[:dpi] || 96
+
+        graphviz.render(@dot_file, @options[:output], format, engine: engine,
+                                                              dpi: dpi)
+
+        puts "✓ Rendered #{@dot_file} → #{@options[:output]}"
+      end
+
+      private
+
+      def detect_image_format(filename)
+        ext = File.extname(filename).downcase
+
+        case ext
+        when ".png" then :png
+        when ".svg" then :svg
+        when ".pdf" then :pdf
+        when ".ps" then :ps
+        when ".eps" then :eps
+        else
+          raise ArgumentError, "Cannot detect image format from extension: #{ext}. " \
+                               "Supported: .png, .svg, .pdf, .ps, .eps"
+        end
+      end
+    end
+  end
+end