lutaml 0.9.43 → 0.10.0

data/lib/lutaml/cli/uml/info_command.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "../output_formatter"
+module Lutaml
+  module Cli
+    module Uml
+      # InfoCommand displays package metadata
+      class InfoCommand
+        attr_reader :options
+
+        def initialize(options = {})
+          @options = options.transform_keys(&:to_sym)
+        end
+
+        def self.add_options_to(thor_class, _method_name)
+          thor_class.long_desc <<-DESC
+          Display metadata and statistics for a LUR package without loading
+          the full repository.
+
+          Example:
+            lutaml uml info model.lur
+
+            lutaml uml info model.lur --format json
+          DESC
+
+          thor_class.option :format, type: :string, default: "text",
+                                     desc: "Output format (text|yaml|json)"
+        end
+
+        def run(lur_path) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          unless File.exist?(lur_path)
+            puts OutputFormatter.error("Package file not found: #{lur_path}")
+            raise Thor::Error, "Package file not found: #{lur_path}"
+          end
+
+          require "zip"
+          require "yaml"
+
+          begin
+            Zip::File.open(lur_path) do |zip|
+              metadata_entry = zip.find_entry("metadata.yaml")
+              unless metadata_entry
+                puts OutputFormatter.error("Invalid package: missing metadata")
+                raise Thor::Error, "Invalid package: missing metadata"
+              end
+
+              # Permit all Lutaml::Uml classes for safe loading
+              uml_constants = Lutaml::Uml.constants
+              uml_classes = uml_constants.filter_map do |const_name|
+                constant_value = Lutaml::Uml.const_get(const_name)
+                constant_value if constant_value.is_a?(Class)
+              end
+              permitted_classes = [Symbol, Time, Date, DateTime, uml_classes]
+                .flatten
+
+              metadata = YAML.safe_load(
+                metadata_entry.get_input_stream.read,
+                permitted_classes: permitted_classes,
+                aliases: true,
+              )
+
+              if options[:format] == "text"
+                display_package_info(metadata)
+              else
+                puts OutputFormatter.format(metadata, format: options[:format])
+              end
+            end
+          rescue Thor::Error
+            raise
+          rescue StandardError => e
+            puts OutputFormatter.error("Failed to read package info: " \
+                                       "#{e.message}")
+            raise Thor::Error, "Failed to read package info: #{e.message}"
+          end
+        end
+
+        private
+
+        def display_package_info(metadata) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          puts OutputFormatter.colorize("Package Information", :cyan)
+          puts "=" * 50
+          puts ""
+          puts "Name:             #{metadata['name']}"
+          puts "Version:          #{metadata['version']}"
+          puts "Created:          #{metadata['created_at']}"
+          puts "Created by:       #{metadata['created_by']}"
+          puts "LutaML Version:   #{metadata['lutaml_version']}"
+          puts "Format:           #{metadata['serialization_format']}"
+          puts ""
+
+          if metadata["statistics"]
+            stats = metadata["statistics"]
+            puts OutputFormatter.colorize("Contents:", :yellow)
+            puts "  Packages:       #{stats['total_packages']}"
+            puts "  Classes:        #{stats['total_classes']}"
+            puts "  Data Types:     #{stats['total_data_types']}"
+            puts "  Enumerations:   #{stats['total_enums']}"
+            puts "  Diagrams:       #{stats['total_diagrams']}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/cli/uml/inspect_command.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "../output_formatter"
+require_relative "shared_helpers"
+
+module Lutaml
+  module Cli
+    module Uml
+      # InspectCommand shows detailed element information
+      class InspectCommand
+        include SharedHelpers
+
+        attr_reader :options
+
+        def initialize(options = {})
+          @options = options.transform_keys(&:to_sym)
+        end
+
+        def self.add_options_to(thor_class, _method_name)
+          thor_class.long_desc <<-DESC
+          Display detailed information about a specific element.
+
+          Element format: type:identifier
+          - package:ModelRoot::Core
+          - class:ModelRoot::Core::Building
+          - diagram:ClassDiagram1
+          - attribute:ModelRoot::Core::Building::name
+
+          Examples:
+            lutaml uml inspect model.lur class:Building
+            lutaml uml inspect model.lur package:ModelRoot::Core
+            lutaml uml inspect model.lur diagram:Overview
+          DESC
+
+          thor_class.option :format, type: :string, default: "text",
+                                     desc: "Output format (text|yaml|json)"
+          thor_class.option :include, type: :array,
+                                      desc: "Include sections (attributes, " \
+                                            "associations, operations)"
+          thor_class.option :lazy, type: :boolean, default: false,
+                                   desc: "Use lazy loading"
+        end
+
+        def run(lur_path, element_id) # rubocop:disable Metrics/MethodLength
+          repo = load_repository(lur_path, lazy: options[:lazy])
+          identifier = ElementIdentifier.parse(element_id)
+
+          element = find_element(repo, identifier)
+          unless element
+            puts OutputFormatter.error("Element not found: #{element_id}")
+            raise Thor::Error, "Element not found: #{element_id}"
+          end
+
+          display_element_details(element, identifier, repo)
+        rescue Thor::Error
+          raise
+        rescue ArgumentError => e
+          raise Thor::Error, e.message
+        rescue StandardError => e
+          raise Thor::Error, "Inspect command failed: #{e.message}"
+        end
+
+        private
+
+        def find_element(repo, identifier)
+          config = ResourceRegistry.config_for(identifier.type)
+          return nil unless config
+
+          repo.send(config[:find_method], identifier.path)
+        end
+
+        def display_element_details(element, identifier, repo)
+          presenter_class_name = ResourceRegistry
+            .config_for(identifier.type)[:presenter]
+          presenter_class = Lutaml::UmlRepository::Presenters.const_get(presenter_class_name)
+          presenter = presenter_class.new(element, repo)
+
+          if options[:format] == "text"
+            puts presenter.to_text
+          else
+            puts OutputFormatter.format(presenter.to_hash,
+                                        format: options[:format])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/cli/uml/ls_command.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../output_formatter"
+require_relative "shared_helpers"
+
+module Lutaml
+  module Cli
+    module Uml
+      # LsCommand lists elements in repository
+      class LsCommand
+        include SharedHelpers
+
+        attr_reader :options
+
+        def initialize(options = {})
+          @options = options.transform_keys(&:to_sym)
+        end
+
+        def self.add_options_to(thor_class, _method_name) # rubocop:disable Metrics/MethodLength
+          thor_class.long_desc <<-DESC
+          List elements at the specified path in the repository.
+
+          Examples:
+            lutaml uml ls model.lur                    # List top-level packages
+            lutaml uml ls model.lur ModelRoot::Core    # List in Core package
+            lutaml uml ls model.lur --type classes     # List all classes
+            lutaml uml ls model.lur --type diagrams    # List all diagrams
+          DESC
+
+          thor_class.option :type, type: :string, default: "packages",
+                                   desc: "Element type " \
+                                         "(packages|classes|diagrams|all)"
+          thor_class.option :format, type: :string, default: "text",
+                                     desc: "Output format " \
+                                           "(text|table|yaml|json)"
+          thor_class.option :filter, type: :string, desc: "Filter pattern"
+          thor_class.option :recursive, aliases: "-r", type: :boolean,
+                                        default: false,
+                                        desc: "Include nested elements"
+          thor_class.option :lazy, type: :boolean, default: false,
+                                   desc: "Use lazy loading"
+        end
+
+        def run(lur_path, path = nil) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          path = normalize_path(path)
+          repo = load_repository(lur_path, lazy: options[:lazy])
+
+          elements = case options[:type].downcase
+                     when "packages"
+                       repo.list_packages(path, recursive: options[:recursive])
+                     when "classes"
+                       if path
+                         repo.classes_in_package(path,
+                                                 recursive: options[:recursive])
+                       else
+                         repo.all_classes
+                       end
+                     when "diagrams"
+                       # Use all_diagrams when no specific path is provided
+                       if path == "ModelRoot"
+                         repo.all_diagrams
+                       else
+                         repo.diagrams_in_package(path)
+                       end
+                     when "all"
+                       list_all_elements(repo, path)
+                     else
+                       puts OutputFormatter.error(
+                         "Unknown type: #{options[:type]}",
+                       )
+                       raise Thor::Error, "Unknown type: #{options[:type]}"
+                     end
+
+          if elements.empty?
+            puts OutputFormatter.warning("No #{options[:type]} found")
+            return
+          end
+
+          display_element_list(elements, options[:type])
+        rescue Thor::Error
+          raise
+        rescue ArgumentError => e
+          raise Thor::Error, e.message
+        rescue StandardError => e
+          raise Thor::Error, "List command failed: #{e.message}"
+        end
+
+        private
+
+        def list_all_elements(repo, path)
+          elements = []
+          elements.concat(repo.list_packages(path || "ModelRoot"))
+          elements.concat(repo.classes_in_package(path || "ModelRoot")) if path
+          elements.concat(repo.diagrams_in_package(path)) if path
+          elements
+        end
+
+        def display_element_list(elements, _type)
+          output = elements.map { |elem| elem.name || elem.to_s }
+          puts OutputFormatter.format(output, format: options[:format])
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/cli/uml/repl_command.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../output_formatter"
+module Lutaml
+  module Cli
+    module Uml
+      # ReplCommand starts interactive REPL shell
+      class ReplCommand
+        attr_reader :options
+
+        def initialize(options = {})
+          @options = options.transform_keys(&:to_sym)
+        end
+
+        def self.add_options_to(thor_class, _method_name)
+          thor_class.long_desc <<-DESC
+          Start an interactive REPL for exploring the model.
+
+          Examples:
+            lutaml uml repl model.lur
+            lutaml uml repl model.lur --no-color
+          DESC
+
+          thor_class.option :color, type: :boolean, default: true,
+                                    desc: "Enable colored output"
+          thor_class.option :icons, type: :boolean, default: true,
+                                    desc: "Enable icons in output"
+        end
+
+        def run(lur_path) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          unless File.exist?(lur_path)
+            puts OutputFormatter.error("Package file not found: #{lur_path}")
+            raise Thor::Error, "Package file not found: #{lur_path}"
+          end
+
+          config = {
+            color: options[:color],
+            icons: options[:icons],
+          }
+
+          shell = InteractiveShell.new(lur_path, config: config)
+          shell.start
+        rescue StandardError => e
+          puts OutputFormatter.error("Shell error: #{e.message}")
+          raise Thor::Error, "Shell error: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/cli/uml/search_command.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "../output_formatter"
+require_relative "shared_helpers"
+
+module Lutaml
+  module Cli
+    module Uml
+      # SearchCommand performs full-text search in model
+      class SearchCommand
+        include SharedHelpers
+
+        attr_reader :options
+
+        def initialize(options = {})
+          @options = options.transform_keys(&:to_sym)
+        end
+
+        def self.add_options_to(thor_class, _method_name) # rubocop:disable Metrics/MethodLength
+          thor_class.long_desc <<-DESC
+          Perform full-text search across model elements.
+
+          Examples:
+            lutaml uml search model.lur "building"
+            lutaml uml search model.lur "building" --type class
+            lutaml uml search model.lur "urban" --in name documentation
+          DESC
+
+          thor_class.option :type, type: :array,
+                                   default: [
+                                     "class", "attribute",
+                                     "association"
+                                   ],
+                                   desc: "Types to search"
+          thor_class.option :package, type: :string,
+                                      desc: "Filter by package path"
+          thor_class.option :in, type: :array, default: ["name"],
+                                 desc: "Search in fields (name, documentation)"
+          thor_class.option :format, type: :string, default: "table",
+                                     desc: "Output format " \
+                                           "(text|table|yaml|json)"
+          thor_class.option :limit, type: :numeric, default: 100,
+                                    desc: "Maximum results"
+          thor_class.option :lazy, type: :boolean, default: false,
+                                   desc: "Use lazy loading"
+        end
+
+        def run(lur_path, query)
+          repo = load_repository(lur_path, lazy: options[:lazy])
+          types = options[:type].map(&:to_sym)
+          search_fields = options[:in].map(&:to_sym)
+
+          results = repo.search(query, types: types, fields: search_fields)
+
+          display_search_results(results, query, repo)
+        end
+
+        private
+
+        def display_search_results(results, query, _repo) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          all_results = []
+          all_results.concat(results[:classes] || [])
+          all_results.concat(results[:attributes] || [])
+          all_results.concat(results[:associations] || [])
+
+          if all_results.empty?
+            puts OutputFormatter.warning("No results found for '#{query}'")
+            return
+          end
+
+          if options[:format] == "table"
+            table_data = all_results.map do |search_result|
+              {
+                type: search_result.element_type,
+                name: search_result.qualified_name,
+                package: search_result.package_path,
+              }
+            end
+            puts OutputFormatter.format_array_table(table_data)
+          else
+            data = all_results.map(&:to_yaml_hash)
+            puts OutputFormatter.format(data, format: options[:format])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/cli/uml/serve_command.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "../output_formatter"
+module Lutaml
+  module Cli
+    module Uml
+      # ServeCommand starts interactive web UI
+      class ServeCommand
+        attr_reader :options
+
+        def initialize(options = {})
+          @options = options.transform_keys(&:to_sym)
+        end
+
+        def self.add_options_to(thor_class, _method_name)
+          thor_class.long_desc <<-DESC
+          Start a web server with an interactive UI for browsing the model.
+
+          Uses the modern single-page application with JSON API and lunr.js search.
+
+          Examples:
+            lutaml uml serve model.lur
+            lutaml uml serve model.lur --port 8080
+          DESC
+
+          thor_class.option :port, aliases: "-p", type: :numeric, default: 3000,
+                                   desc: "Port to listen on"
+          thor_class.option :host, aliases: "-h",
+                                   type: :string, default: "localhost",
+                                   desc: "Host to bind to"
+        end
+
+        def run(lur_path) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          unless File.exist?(lur_path)
+            puts OutputFormatter.error("Package file not found: #{lur_path}")
+            raise Thor::Error, "Package file not found: #{lur_path}"
+          end
+
+          puts OutputFormatter.colorize("\n=== Starting Web UI Server ===\n",
+                                        :cyan)
+          puts "Loading repository from: #{lur_path}"
+          puts "Server will be available at: " \
+               "http://#{options[:host]}:#{options[:port]}"
+          puts "\nPress Ctrl+C to stop the server\n\n"
+
+          Lutaml::Xmi::WebUi::App.serve(lur_path,
+                                        port: options[:port],
+                                        host: options[:host])
+        rescue Interrupt
+          puts "\n\n#{OutputFormatter.colorize('Server stopped', :yellow)}"
+        rescue StandardError => e
+          puts OutputFormatter.error("Server error: #{e.message}")
+          puts e.backtrace.first(5).join("\n") if options[:verbose]
+          raise Thor::Error, "Server error: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/cli/uml/shared_helpers.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../output_formatter"
+
+module Lutaml
+  module Cli
+    module Uml
+      # SharedHelpers provides common utility methods for UML commands
+      #
+      # This module is included in command classes to provide shared
+      # functionality
+      # like repository loading and path normalization, following the
+      # DRY principle.
+      module SharedHelpers
+        # Load repository from LUR file
+        #
+        # @param lur_path [String] Path to LUR package file
+        # @param lazy [Boolean] Whether to use lazy loading
+        # @return [Lutaml::UmlRepository::Repository] Loaded repository
+        def load_repository(lur_path, lazy: false) # rubocop:disable Metrics/MethodLength
+          OutputFormatter.progress("Loading repository from #{lur_path}")
+          repo = if lazy
+                   Lutaml::UmlRepository::Repository.from_package_lazy(lur_path)
+                 else
+                   Lutaml::UmlRepository::Repository.from_package(lur_path)
+                 end
+          OutputFormatter.progress_done
+          repo
+        rescue StandardError => e
+          OutputFormatter.progress_done(success: false)
+          puts OutputFormatter.error("Failed to load repository: #{e.message}")
+          raise Thor::Error, e.message
+        end
+
+        # Normalize path syntax
+        #
+        # Converts :: or <RepositoryRoot>:: to ModelRoot
+        #
+        # @param path [String, nil] Path to normalize
+        # @return [String] Normalized path
+        def normalize_path(path)
+          return "ModelRoot" if path.nil? || path.empty?
+          return "ModelRoot" if ["::", "<RepositoryRoot>"].include?(path)
+
+          path = path.sub(/^::/, "ModelRoot::")
+          path.sub(/^<RepositoryRoot>::/, "ModelRoot::")
+        end
+      end
+    end
+  end
+end