lutaml 0.10.19 → 0.11.2

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

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-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.public_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

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-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