lutaml 0.10.19 → 0.11.2

data/lib/lutaml/cli/interactive_shell.rb

@@ -1,254 +0,0 @@
-# frozen_string_literal: true
-
-require "readline"
-require "pathname"
-
-module Lutaml
-  module Cli
-    class InteractiveShell
-      autoload :CommandBase, "lutaml/cli/interactive_shell/command_base"
-      autoload :NavigationCommands,
-               "lutaml/cli/interactive_shell/navigation_commands"
-      autoload :QueryCommands, "lutaml/cli/interactive_shell/query_commands"
-      autoload :BookmarkCommands,
-               "lutaml/cli/interactive_shell/bookmark_commands"
-      autoload :ExportHandler, "lutaml/cli/interactive_shell/export_handler"
-      autoload :HelpDisplay, "lutaml/cli/interactive_shell/help_display"
-      HISTORY_FILE = File.expand_path("~/.lutaml-xmi-history")
-      MAX_HISTORY = 1000
-
-      attr_reader :repository, :config, :bookmarks,
-                  :path_history,
-                  :navigation, :query, :bookmarks_cmd, :export, :help
-
-      attr_accessor :current_path, :last_results
-
-      def initialize(lur_path_or_repo, config: nil)
-        @config = default_config.merge(config || {})
-        @repository = load_repository(lur_path_or_repo)
-
-        @current_path = "ModelRoot"
-        @bookmarks = {}
-        @last_results = nil
-        @path_history = ["ModelRoot"]
-        @running = false
-
-        init_commands
-        setup_readline
-        load_history
-      end
-
-      def start
-        @running = true
-        @help.display_welcome
-
-        run_repl_loop
-
-        save_history
-        puts "\nGoodbye!"
-      end
-
-      private
-
-      def default_config
-        {
-          color: true,
-          icons: true,
-          show_counts: true,
-          page_size: 50,
-        }
-      end
-
-      def load_repository(lur_path_or_repo)
-        if lur_path_or_repo.is_a?(String)
-          OutputFormatter.progress("Loading repository")
-          repo = Lutaml::UmlRepository::Repository.from_package(lur_path_or_repo)
-          OutputFormatter.progress_done
-          repo
-        else
-          lur_path_or_repo
-        end
-      end
-
-      def init_commands
-        @navigation = NavigationCommands.new(self)
-        @query = QueryCommands.new(self)
-        @bookmarks_cmd = BookmarkCommands.new(self)
-        @export = ExportHandler.new(self)
-        @help = HelpDisplay.new(self)
-      end
-
-      def run_repl_loop
-        while @running
-          begin
-            input = Readline.readline(prompt, true)
-            break if input.nil?
-            next if input.strip.empty?
-
-            deduplicate_history(input)
-            execute_command(input.strip)
-          rescue Interrupt
-            handle_interrupt
-          rescue StandardError => e
-            handle_error(e)
-          end
-        end
-      end
-
-      def handle_interrupt
-        puts "\nUse 'exit' or 'quit' to exit the shell"
-      end
-
-      def handle_error(error)
-        puts OutputFormatter.error("Error: #{error.message}")
-        puts error.backtrace.first(3).join("\n") if ENV["DEBUG"]
-      end
-
-      def deduplicate_history(input)
-        if Readline::HISTORY.length > 1 && Readline::HISTORY[-2] == input
-          Readline::HISTORY.pop
-        end
-      end
-
-      COMMAND_DISPATCH = {
-        # Navigation
-        "cd" => :navigation, "pwd" => :navigation,
-        "ls" => :navigation, "list" => :navigation,
-        "tree" => :navigation, "up" => :navigation,
-        "root" => :navigation, "back" => :navigation,
-        # Query
-        "find" => :query, "f" => :query,
-        "show" => :query, "s" => :query,
-        "search" => :query, "?" => :query,
-        "results" => :query,
-        # Bookmarks
-        "bookmark" => :bookmarks_cmd, "bm" => :bookmarks_cmd,
-        # Export
-        "export" => :export,
-        # Utilities
-        "help" => :help, "h" => :help,
-        "history" => :help,
-        "clear" => :help, "cls" => :help,
-        "config" => :help,
-        "stats" => :help
-      }.freeze
-
-      METHOD_MAP = {
-        "cd" => :cmd_cd, "pwd" => :cmd_pwd,
-        "ls" => :cmd_ls, "list" => :cmd_ls,
-        "tree" => :cmd_tree, "up" => :cmd_up,
-        "root" => :cmd_root, "back" => :cmd_back,
-        "find" => :cmd_find, "f" => :cmd_find,
-        "show" => :cmd_show, "s" => :cmd_show,
-        "search" => :cmd_search, "?" => :cmd_search,
-        "results" => :cmd_results,
-        "bookmark" => :cmd_bookmark, "bm" => :cmd_bookmark,
-        "export" => :cmd_export,
-        "help" => :cmd_help, "h" => :cmd_help,
-        "history" => :cmd_history,
-        "clear" => :cmd_clear, "cls" => :cmd_clear,
-        "config" => :cmd_config,
-        "stats" => :cmd_stats
-      }.freeze
-
-      def execute_command(input)
-        parts = input.split(/\s+/)
-        command = parts[0].downcase
-        args = parts[1..]
-
-        if ["exit", "quit", "q"].include?(command)
-          @running = false
-          return
-        end
-
-        handler_var = COMMAND_DISPATCH[command]
-        method_name = METHOD_MAP[command]
-
-        if handler_var && method_name
-          public_send(handler_var).public_send(method_name, args)
-        else
-          puts OutputFormatter.warning("Unknown command: #{command}")
-          puts "Type 'help' for available commands"
-        end
-      end
-
-      # Delegate methods for backward compatibility with tests
-      def cmd_cd(args) = @navigation.cmd_cd(args)
-      def cmd_pwd(args) = @navigation.cmd_pwd(args)
-      def cmd_ls(args) = @navigation.cmd_ls(args)
-      def cmd_tree(args) = @navigation.cmd_tree(args)
-      def cmd_up(args) = @navigation.cmd_up(args)
-      def cmd_root(args) = @navigation.cmd_root(args)
-      def cmd_back(args) = @navigation.cmd_back(args)
-      def resolve_path(path) = @navigation.resolve_path(path)
-      def cmd_find(args) = @query.cmd_find(args)
-      def cmd_show(args) = @query.cmd_show(args)
-      def cmd_search(args) = @query.cmd_search(args)
-      def cmd_results(args) = @query.cmd_results(args)
-      def show_class(qname) = @query.show_class(qname)
-      def show_package(path) = @query.show_package(path)
-      def show_numbered_result(number) = @query.show_numbered_result(number)
-      def display_search_results(results) = @query.display_search_results(results)
-      def cmd_bookmark(args) = @bookmarks_cmd.cmd_bookmark(args)
-      def bookmark_add(name) = @bookmarks_cmd.bookmark_add(name)
-      def bookmark_list = @bookmarks_cmd.bookmark_list
-      def bookmark_go(name) = @bookmarks_cmd.bookmark_go(name)
-      def bookmark_remove(name) = @bookmarks_cmd.bookmark_remove(name)
-      def cmd_export(args) = @export.cmd_export(args)
-      def export_csv(path) = @export.export_csv(path)
-      def export_json(path) = @export.export_json(path)
-      def export_yaml(path) = @export.export_yaml(path)
-      def display_welcome = @help.display_welcome
-      def display_general_help = @help.display_general_help
-      def display_command_help(cmd) = @help.display_command_help(cmd)
-      def cmd_help(args) = @help.cmd_help(args)
-      def cmd_history(args) = @help.cmd_history(args)
-      def cmd_clear(args) = @help.cmd_clear(args)
-      def cmd_config(args) = @help.cmd_config(args)
-      def cmd_stats(args) = @help.cmd_stats(args)
-
-      def prompt
-        path_display = @current_path == "ModelRoot" ? "/" : "/#{@current_path}"
-        prompt_text = "lutaml[#{path_display}]> "
-
-        if @config[:color] && $stdout.tty?
-          OutputFormatter.colorize(prompt_text, :green)
-        else
-          prompt_text
-        end
-      end
-
-      def setup_readline
-        Readline.completion_proc = proc { |word| complete_command(word) }
-        Readline.completion_append_character = " "
-      end
-
-      def load_history
-        return unless File.exist?(HISTORY_FILE)
-
-        File.readlines(HISTORY_FILE).each do |line|
-          Readline::HISTORY.push(line.chomp)
-        end
-      rescue StandardError => e
-        warn "Warning: Could not load history: #{e.message}" if ENV["DEBUG"]
-      end
-
-      def save_history
-        history_lines = Readline::HISTORY.to_a.last(MAX_HISTORY)
-        File.write(HISTORY_FILE, history_lines.join("\n"))
-      rescue StandardError => e
-        warn "Warning: Could not save history: #{e.message}"
-      end
-
-      def complete_command(word)
-        %w[
-          cd pwd ls list tree up root back
-          find show search
-          bookmark bm
-          results export
-          help history clear config stats exit quit
-        ].grep(/^#{Regexp.escape(word)}/)
-      end
-    end
-  end
-end

data/lib/lutaml/cli/lml_commands.rb

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-
-require "thor"
-require "pathname"
-
-module Lutaml
-  module Cli
-    # LmlCommands provides CLI commands for LutaML DSL diagram generation
-    #
-    # This subcommand handles operations related to the LutaML textual DSL
-    # notation (.lutaml files), including generating diagrams and validating
-    # DSL syntax.
-    class LmlCommands < Thor
-      include ::Lutaml::Uml::HasAttributes
-
-      SUPPORTED_FORMATS = %w[yaml lutaml exp].freeze
-      DEFAULT_INPUT_FORMAT = "lutaml"
-
-      def initialize(*args)
-        super
-        # Only initialize Graphviz formatter if available
-        if defined?(::Lutaml::Formatter::Graphviz)
-          @formatter = ::Lutaml::Formatter::Graphviz.new
-        end
-        @out_object = $stdout
-      end
-
-      desc "generate [PATHS]", "Generate diagram output from LutaML DSL files"
-      long_desc <<-DESC
-        Generate diagram output from one or more LutaML DSL files.
-
-        Supports multiple input formats (lutaml, yaml, exp) and can output
-        to various formats depending on the configured formatter.
-
-        Examples:
-          lutaml lml generate model.lutaml -o diagram.png
-
-          lutaml lml generate model.lutaml -o diagram.dot -t dot
-
-          lutaml lml generate model.lutaml project.lutaml -o output/
-      DESC
-      method_option :output, type: :string, aliases: "-o",
-                             desc: "Output path (file or directory)"
-      method_option :formatter, type: :string, aliases: "-f",
-                                desc: "Output formatter (default: graphviz)"
-      method_option :type, type: :string, aliases: "-t",
-                           desc: "Output format type (png, svg, dot, etc.)"
-      method_option :input_format, type: :string, aliases: "-i",
-                                   desc: "Input format (lutaml, yaml, exp)"
-      method_option :graph, type: :string, aliases: "-g",
-                            desc: "Graph attributes (key=value,key2=value2)"
-      method_option :edge, type: :string, aliases: "-e",
-                           desc: "Edge attributes (key=value,key2=value2)"
-      method_option :node, type: :string, aliases: "-n",
-                           desc: "Node attributes (key=value,key2=value2)"
-      method_option :all, type: :string, aliases: "-a",
-                          desc: "Set attributes for graph, edge, and node"
-      def generate(*paths) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        if paths.empty?
-          raise Thor::Error,
-                "No input files provided. Please specify at least " \
-                "one .lutaml file."
-        end
-
-        setup_options
-        @paths = paths.map { |path| Pathname.new(path) }
-
-        if @output_path&.file? && @paths.length > 1
-          raise Thor::Error,
-                "Output path must be a directory if multiple input files " \
-                "are given"
-        end
-
-        @paths.each do |input_path|
-          unless input_path.exist?
-            raise Thor::Error, "File does not exist: #{input_path}"
-          end
-
-          document = parse_document(input_path)
-          result = @formatter.format(document)
-
-          if @output_path
-            output_path = @output_path
-            if output_path.directory?
-              output_path = output_path.join(
-                input_path.basename(".*").to_s + ".#{@formatter.type}",
-              )
-            end
-
-            output_path.open("w+") { |file| file.write(result) }
-            say "Generated: #{output_path}", :green
-          else
-            @out_object.puts(result)
-          end
-        end
-      end
-
-      desc "validate [PATHS]", "Validate LutaML DSL syntax"
-      long_desc <<-DESC
-        Validate the syntax of one or more LutaML DSL files.
-
-        Checks for syntax errors and structural issues in the DSL files
-        without generating output.
-
-        Examples:
-          lutaml lml validate model.lutaml
-
-          lutaml lml validate model.lutaml project.lutaml
-      DESC
-      def validate(*paths) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        if paths.empty?
-          raise Thor::Error,
-                "No input files provided. Please specify at least " \
-                "one .lutaml file."
-        end
-
-        errors = []
-        paths.each do |path_string|
-          input_path = Pathname.new(path_string)
-
-          unless input_path.exist?
-            errors << "File does not exist: #{input_path}"
-            next
-          end
-
-          begin
-            parse_document(input_path)
-            say "✓ #{input_path}", :green
-          rescue StandardError => e
-            errors << "#{input_path}: #{e.message}"
-            say "✗ #{input_path}: #{e.message}", :red
-          end
-        end
-
-        if errors.any?
-          say "\nValidation failed with #{errors.size} error(s)", :red
-          exit 1
-        else
-          say "\nAll files valid!", :green
-        end
-      end
-
-      no_commands do # rubocop:disable Metrics/BlockLength
-        def parse_document(input_path)
-          case @input_format
-          when "lutaml"
-            Lutaml::Uml::Parsers::Dsl.parse(File.new(input_path))
-          when "yaml", "yml"
-            Lutaml::Uml::Parsers::Yaml.parse(input_path.to_s)
-          when "exp"
-            Lutaml::Express::Parsers::Exp.parse(File.new(input_path))
-          else
-            raise Thor::Error,
-                  "Unsupported input format: #{@input_format}"
-          end
-        end
-
-        def setup_options # rubocop:disable Metrics/AbcSize
-          @formatter = options[:formatter] if options[:formatter]
-          @type = options[:type] if options[:type]
-          @output_path = Pathname.new(options[:output]) if options[:output]
-          @input_format = options[:input_format] || DEFAULT_INPUT_FORMAT
-
-          setup_formatter_options
-        end
-
-        def setup_formatter_options # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          return unless @formatter
-
-          @formatter.type = @type if @type
-
-          if options[:graph]
-            Parsers::Attribute.parse(options[:graph]).each do |key, value|
-              @formatter.graph[key] = value
-            end
-          end
-
-          if options[:edge]
-            Parsers::Attribute.parse(options[:edge]).each do |key, value|
-              @formatter.edge[key] = value
-            end
-          end
-
-          if options[:node]
-            Parsers::Attribute.parse(options[:node]).each do |key, value|
-              @formatter.node[key] = value
-            end
-          end
-
-          if options[:all]
-            Parsers::Attribute.parse(options[:all]).each do |key, value|
-              @formatter.graph[key] = value
-              @formatter.edge[key] = value
-              @formatter.node[key] = value
-            end
-          end
-        end
-      end
-
-      def self.exit_on_failure?
-        true
-      end
-    end
-  end
-end