lutaml 0.10.18 → 0.11.2

data/lib/lutaml/uml_repository/error_handler.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    # Error handler for user-friendly error messages with suggestions.
-    #
-    # Provides helpful error messages when classes, packages, or other model
-    # elements are not found. Uses fuzzy matching (Levenshtein distance) to
-    # suggest similar names that might be what the user intended.
-    #
-    # @example Class not found
-    #   handler = ErrorHandler.new(repository)
-    #   handler.class_not_found_error("ModelRoot::Buildng")
-    #   # => Raises error with suggestion: Did you mean "ModelRoot::Building"?
-    #
-    # @example Package not found
-    #   handler.package_not_found_error("ModelRoot::i-UR::urf")
-    #   # => Raises error with suggestions for similar packages
-    class ErrorHandler
-      # Maximum Levenshtein distance for suggestions
-      MAX_SUGGESTION_DISTANCE = 3
-
-      # Maximum number of suggestions to show
-      MAX_SUGGESTIONS = 5
-
-      # @return [UmlRepository] The repository to search for suggestions
-      attr_reader :repository
-
-      # Initialize a new ErrorHandler.
-      #
-      # @param repository [UmlRepository] Repository to use for suggestions
-      def initialize(repository)
-        @repository = repository
-      end
-
-      # Raise a class not found error with suggestions.
-      #
-      # Searches for similar class names using fuzzy matching and provides
-      # helpful suggestions in the error message.
-      #
-      # @param attempted_qname [String] The qualified name that was attempted
-      # @raise [NameError] With helpful message and suggestions
-      # @example
-      #   handler.class_not_found_error("ModelRoot::Buildng")
-      def class_not_found_error(attempted_qname)
-        suggestions = suggest_similar_classes(attempted_qname)
-
-        message = "Class not found: #{attempted_qname}"
-
-        if suggestions.any?
-          message += "\n\nDid you mean one of these?"
-          suggestions.each { |s| message += "\n  - #{s}" }
-        else
-          message += "\n\nTip: Use the 'search' or 'find' commands to " \
-                     "explore available classes."
-        end
-
-        raise NameError, message
-      end
-
-      # Raise a package not found error with suggestions.
-      #
-      # Searches for similar package paths using fuzzy matching and provides
-      # helpful suggestions in the error message.
-      #
-      # @param attempted_path [String] The package path that was attempted
-      # @raise [NameError] With helpful message and suggestions
-      # @example
-      #   handler.package_not_found_error("ModelRoot::i-UR::urf")
-      def package_not_found_error(attempted_path)
-        suggestions = suggest_similar_packages(attempted_path)
-
-        message = "Package not found: #{attempted_path}"
-
-        if suggestions.any?
-          message += "\n\nDid you mean one of these?"
-          suggestions.each { |s| message += "\n  - #{s}" }
-        else
-          message += "\n\nTip: Use the 'list' or 'tree' commands to explore " \
-                     "available packages."
-        end
-
-        raise NameError, message
-      end
-
-      # Suggest similar class names based on Levenshtein distance.
-      #
-      # @param attempted [String] The attempted qualified name
-      # @return [Array<String>] Array of suggested qualified names, sorted by
-      #   similarity
-      # @example
-      #   suggestions = handler.suggest_similar_classes("ModelRoot::Buildng")
-      #   # => ["ModelRoot::Building", "ModelRoot::BuildingPart"]
-      def suggest_similar_classes(attempted)
-        return [] unless repository.indexes[:class_to_qname]
-
-        all_qnames = repository.indexes[:class_to_qname].values
-        find_similar_names(attempted, all_qnames)
-      end
-
-      # Suggest similar package paths based on Levenshtein distance.
-      #
-      # @param attempted [String] The attempted package path
-      # @return [Array<String>] Array of suggested package paths, sorted by
-      #   similarity
-      # @example
-      #   suggestions = handler.suggest_similar_packages("ModelRoot::i-UR")
-      #   # => ["ModelRoot::i-UR::urf", "ModelRoot::i-UR::core"]
-      def suggest_similar_packages(attempted)
-        return [] unless repository.indexes[:package_to_path]
-
-        all_paths = repository.indexes[:package_to_path].values
-        find_similar_names(attempted, all_paths)
-      end
-
-      # Calculate Levenshtein distance between two strings.
-      #
-      # The Levenshtein distance is the minimum number of single-character edits
-      # (insertions, deletions, or substitutions) required to change one string
-      # into another.
-      #
-      # @param str1 [String] First string
-      # @param str2 [String] Second string
-      # @return [Integer] The Levenshtein distance
-      # @example
-      #   distance = handler.levenshtein_distance("kitten", "sitting")
-      #   # => 3
-      def levenshtein_distance(str1, str2) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        return str2.length if str1.empty?
-        return str1.length if str2.empty?
-
-        # Create a matrix to store distances
-        matrix = Array.new(str1.length + 1) do |i|
-          Array.new(str2.length + 1) do |j|
-            if i.zero?
-              j
-            else
-              (j.zero? ? i : 0)
-            end
-          end
-        end
-
-        # Calculate distances
-        (1..str1.length).each do |i|
-          (1..str2.length).each do |j|
-            cost = str1[i - 1] == str2[j - 1] ? 0 : 1
-            matrix[i][j] = [
-              matrix[i - 1][j] + 1,      # deletion
-              matrix[i][j - 1] + 1,      # insertion
-              matrix[i - 1][j - 1] + cost, # substitution
-            ].min
-          end
-        end
-
-        matrix[str1.length][str2.length]
-      end
-
-      private
-
-      # Find similar names from a list using Levenshtein distance.
-      #
-      # @param attempted [String] The attempted name
-      # @param candidates [Array<String>] List of candidate names
-      # @return [Array<String>] Sorted array of similar names
-      def find_similar_names(attempted, candidates) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        # Calculate distances for all candidates
-        distances = candidates.map do |candidate|
-          distance = levenshtein_distance(
-            attempted.downcase,
-            candidate.downcase,
-          )
-          { name: candidate, distance: distance }
-        end
-
-        # Filter by maximum distance and sort
-        similar = distances
-          .select { |d| d[:distance] <= MAX_SUGGESTION_DISTANCE }
-          .sort_by { |d| d[:distance] }
-          .take(MAX_SUGGESTIONS)
-          .map { |d| d[:name] }
-
-        # If no close matches, try substring matching
-        if similar.empty?
-          similar = find_substring_matches(attempted, candidates)
-        end
-
-        similar
-      end
-
-      # Find names containing the attempted string as a substring.
-      #
-      # @param attempted [String] The attempted name
-      # @param candidates [Array<String>] List of candidate names
-      # @return [Array<String>] Array of matching names
-      def find_substring_matches(attempted, candidates)
-        attempted_lower = attempted.downcase
-        candidates
-          .select { |c| c.downcase.include?(attempted_lower) }
-          .take(MAX_SUGGESTIONS)
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/exporters/base_exporter.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module Exporters
-      # Base class for all exporters.
-      #
-      # Exporters convert a UmlRepository to various formats such as CSV,
-      # JSON, Markdown, etc. All exporters inherit from this base class and
-      # implement the [`export`](#export) method.
-      #
-      # @example Creating a custom exporter
-      #   class MyExporter < BaseExporter
-      #     def export(output_path, options = {})
-      #       # Implementation here
-      #     end
-      #   end
-      #
-      #   exporter = MyExporter.new(repository)
-      #   exporter.export("output.txt")
-      class BaseExporter
-        # @return [UmlRepository] The repository to export
-        attr_reader :repository
-
-        # Initialize a new exporter.
-        #
-        # @param repository [UmlRepository] The repository to export
-        def initialize(repository)
-          @repository = repository
-        end
-
-        # Export the repository to a file.
-        #
-        # @param output_path [String] Path to the output file
-        # @param options [Hash] Export options (exporter-specific)
-        # @raise [NotImplementedError] Must be implemented by subclasses
-        # @return [void]
-        def export(output_path, options = {})
-          raise NotImplementedError,
-                "#{self.class.name} must implement #export"
-        end
-
-        private
-
-        # Get the document from the repository.
-        #
-        # @return [Lutaml::Uml::Document] The UML document
-        def document
-          @repository.document
-        end
-
-        # Get the indexes from the repository.
-        #
-        # @return [Hash] The repository indexes
-        def indexes
-          @repository.indexes
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/exporters/json_exporter.rb

@@ -1,343 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Lutaml
-  module UmlRepository
-    module Exporters
-      # Export UML repository to JSON format.
-      #
-      # Exports the complete UML model as JSON, preserving all relationships
-      # and metadata. Supports filtering by package and optional pretty
-      # printing.
-      #
-      # @example Basic export
-      #   exporter = JsonExporter.new(repository)
-      #   exporter.export("model.json")
-      #
-      # @example Pretty-printed export
-      #   exporter.export("model.json", pretty: true)
-      #
-      # @example Export specific package
-      #   exporter.export("model.json", package: "ModelRoot::i-UR::urf")
-      class JsonExporter < BaseExporter
-        # Export repository to JSON format.
-        #
-        # @param output_path [String] Path to the output JSON file
-        # @param options [Hash] Export options
-        # @option options [Boolean] :pretty (true) Pretty-print JSON
-        # @option options [String] :package Filter by package path
-        # @option options [Boolean] :recursive (false) Include nested packages
-        #   when filtering
-        # @option options [Boolean] :include_diagrams (true) Include diagram
-        #   metadata
-        # @return [void]
-        def export(output_path, options = {})
-          data = build_export_data(options)
-
-          File.write(output_path, format_json(data, options))
-        end
-
-        private
-
-        # Build the export data structure.
-        #
-        # @param options [Hash] Export options
-        # @return [Hash] The complete data structure
-        def build_export_data(options) # rubocop:disable Metrics/MethodLength
-          {
-            metadata: build_metadata,
-            packages: build_packages(options),
-            classes: build_classes(options),
-            associations: build_associations(options),
-            diagrams: if options.fetch(:include_diagrams, true)
-                        build_diagrams(options)
-                      else
-                        []
-                      end,
-          }
-        end
-
-        # Build metadata section.
-        #
-        # @return [Hash] Metadata hash
-        def build_metadata
-          stats = repository.statistics
-          {
-            exported_at: Time.now.utc.iso8601,
-            total_packages: stats&.dig(:total_packages) || 0,
-            total_classes: stats&.dig(:total_classes) || 0,
-            total_associations: stats&.dig(:total_associations) || 0,
-            total_diagrams: stats&.dig(:total_diagrams) || 0,
-          }
-        end
-
-        # Build packages section.
-        #
-        # @param options [Hash] Export options
-        # @return [Array<Hash>] Array of package hashes
-        def build_packages(options)
-          packages = if options[:package]
-                       repository.list_packages(
-                         options[:package],
-                         recursive: options[:recursive] || false,
-                       )
-                     else
-                       repository.list_packages("ModelRoot", recursive: true)
-                     end
-
-          packages.map { |pkg| serialize_package(pkg) }
-        end
-
-        # Serialize a package to a hash.
-        #
-        # @param package [Lutaml::Uml::Package, Lutaml::Uml::Document]
-        #   The package object
-        # @return [Hash] Package data
-        def serialize_package(package)
-          {
-            id: package.xmi_id,
-            name: package.name,
-            path: package_path(package),
-            classes_count: package.classes&.size || 0,
-            packages_count: package.packages&.size || 0,
-          }
-        end
-
-        # Get package path.
-        #
-        # @param package [Object] The package object
-        # @return [String] The package path
-        def package_path(package)
-          indexes&.dig(:package_to_path, package.xmi_id) || package.name
-        end
-
-        # Build classes section.
-        #
-        # @param options [Hash] Export options
-        # @return [Array<Hash>] Array of class hashes
-        def build_classes(options) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-          classes = if options[:package]
-                      repository.classes_in_package(
-                        options[:package],
-                        recursive: options[:recursive] || false,
-                      )
-                    else
-                      indexes&.dig(:classes)&.values || []
-                    end
-
-          classes.map { |klass| serialize_class(klass) }
-        end
-
-        # Serialize a class to a hash.
-        #
-        # @param klass [Lutaml::Uml::Class, Lutaml::Uml::DataType,
-        #   Lutaml::Uml::Enum] The class object
-        # @return [Hash] Class data
-        def serialize_class(klass) # rubocop:disable Metrics/MethodLength
-          qname = qualified_name(klass)
-
-          {
-            id: klass.xmi_id,
-            qualified_name: qname,
-            name: klass.name,
-            type: class_type(klass),
-            stereotypes: normalize_stereotypes(klass.stereotype),
-            package: extract_package_path(qname),
-            attributes: serialize_attributes(klass),
-            operations: serialize_operations(klass),
-            generalizations: serialize_generalizations(klass),
-          }
-        end
-
-        # Normalize stereotypes to array format.
-        #
-        # @param stereotype [String, Array, nil] The stereotype(s)
-        # @return [Array] Array of stereotypes
-        def normalize_stereotypes(stereotype)
-          return [] unless stereotype
-
-          case stereotype
-          when Array
-            stereotype
-          when String
-            [stereotype]
-          else
-            []
-          end
-        end
-
-        # Get class type.
-        #
-        # @param klass [Object] The class object
-        # @return [String] The class type
-        def class_type(klass)
-          klass.class.name.split("::").last
-        end
-
-        # Get qualified name.
-        #
-        # @param klass [Object] The class object
-        # @return [String] The qualified name
-        def qualified_name(klass)
-          indexes&.dig(:class_to_qname, klass.xmi_id) || klass.name
-        end
-
-        # Extract package path from qualified name.
-        #
-        # @param qname [String] The qualified name
-        # @return [String] The package path
-        def extract_package_path(qname)
-          parts = qname.split("::")
-          parts.size > 1 ? parts[0..-2].join("::") : ""
-        end
-
-        # Serialize class attributes.
-        #
-        # @param klass [Object] The class object
-        # @return [Array<Hash>] Array of attribute hashes
-        def serialize_attributes(klass)
-          return [] unless klass.attributes
-
-          klass.attributes.map do |attr|
-            {
-              name: attr.name,
-              type: attr.type,
-              visibility: attr.visibility,
-              cardinality: serialize_cardinality(attr.cardinality),
-            }
-          end
-        end
-
-        # Serialize cardinality.
-        #
-        # @param cardinality [Lutaml::Uml::Cardinality, nil] The cardinality
-        # @return [Hash, nil] Cardinality data
-        def serialize_cardinality(cardinality)
-          return nil unless cardinality
-
-          {
-            min: cardinality.min,
-            max: cardinality.max,
-          }
-        end
-
-        # Serialize class operations.
-        #
-        # @param klass [Object] The class object
-        # @return [Array<Hash>] Array of operation hashes
-        def serialize_operations(klass)
-          return [] unless klass.is_a?(Lutaml::Uml::Classifier) && klass.operations
-
-          klass.operations.map do |op|
-            {
-              name: op.name,
-              visibility: op.visibility,
-              return_type: op.return_type,
-            }
-          end
-        end
-
-        # Serialize generalizations.
-        #
-        # @param klass [Object] The class object
-        # @return [Array<String>] Array of parent class qualified names
-        def serialize_generalizations(klass)
-          parent = repository.supertype_of(klass)
-          parent ? [qualified_name(parent)] : []
-        rescue StandardError
-          []
-        end
-
-        # Build associations section.
-        #
-        # @param options [Hash] Export options
-        # @return [Array<Hash>] Array of association hashes
-        def build_associations(options) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          associations = indexes[:associations]&.values || []
-
-          # Filter by package if specified
-          if options[:package]
-            classes = repository.classes_in_package(
-              options[:package],
-              recursive: options[:recursive] || false,
-            )
-            class_ids = classes.to_set(&:xmi_id)
-            associations = associations.select do |assoc|
-              class_ids.include?(assoc.member_end_xmi_id) ||
-                class_ids.include?(assoc.owner_end_xmi_id)
-            end
-          end
-
-          associations.map { |assoc| serialize_association(assoc) }
-        end
-
-        # Serialize an association.
-        #
-        # @param association [Lutaml::Uml::Association] The association object
-        # @return [Hash] Association data
-        def serialize_association(association) # rubocop:disable Metrics/MethodLength
-          {
-            id: association.xmi_id,
-            name: association.name,
-            owner_end: association.owner_end,
-            owner_end_attribute_name: association.owner_end_attribute_name,
-            owner_end_cardinality: serialize_cardinality(
-              association.owner_end_cardinality,
-            ),
-            owner_end_type: association.owner_end_type,
-            owner_end_xmi_id: association.owner_end_xmi_id,
-            member_end: association.member_end,
-            member_end_attribute_name: association.member_end_attribute_name,
-            member_end_xmi_id: association.member_end_xmi_id,
-            member_end_cardinality: serialize_cardinality(
-              association.member_end_cardinality,
-            ),
-            member_end_type: association.member_end_type,
-          }
-        end
-
-        # Build diagrams section.
-        #
-        # @param options [Hash] Export options
-        # @return [Array<Hash>] Array of diagram hashes
-        def build_diagrams(options)
-          diagrams = if options[:package]
-                       repository.diagrams_in_package(options[:package])
-                     else
-                       repository.all_diagrams
-                     end
-
-          diagrams.map { |diagram| serialize_diagram(diagram) }
-        rescue StandardError
-          []
-        end
-
-        # Serialize a diagram.
-        #
-        # @param diagram [Lutaml::Uml::Diagram] The diagram object
-        # @return [Hash] Diagram data
-        def serialize_diagram(diagram)
-          {
-            id: diagram.xmi_id,
-            name: diagram.name,
-            type: diagram.diagram_type,
-          }
-        end
-
-        # Format JSON output.
-        #
-        # @param data [Hash] The data to format
-        # @param options [Hash] Formatting options
-        # @return [String] Formatted JSON string
-        def format_json(data, options)
-          if options.fetch(:pretty, true)
-            JSON.pretty_generate(data)
-          else
-            JSON.generate(data)
-          end
-        end
-      end
-    end
-  end
-end