lutaml 0.10.19 → 0.11.2

data/lib/lutaml/uml_repository/query_dsl/query_builder.rb

@@ -1,290 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    module QueryDSL
-      # Fluent query builder for advanced queries against UML repositories
-      #
-      # Provides a domain-specific language for building complex queries
-      # with method chaining, lazy evaluation, and composable filters.
-      #
-      # @example Basic class query
-      #   results = repo.query do |q|
-      #     q.classes.where(stereotype: 'featureType')
-      #   end.all
-      #
-      # @example Complex query with chaining
-      #   results = repo.query do |q|
-      #     q.classes
-      #       .in_package('ModelRoot::i-UR', recursive: true)
-      #       .where { |c| c.attributes&.size.to_i > 10 }
-      #       .order_by(:name, direction: :desc)
-      #       .limit(5)
-      #   end.execute
-      class QueryBuilder
-        # Initialize a new query builder
-        #
-        # @param repository [UmlRepository] The repository to query against
-        def initialize(repository)
-          @repository = repository
-          @conditions = []
-          @scope = nil
-          @order = nil
-          @limit = nil
-          @includes = []
-        end
-
-        # Start a class query
-        #
-        # @return [QueryBuilder] Self for method chaining
-        # @example
-        #   builder.classes.where(stereotype: 'featureType')
-        def classes
-          @scope = :classes
-          self
-        end
-
-        # Start a package query
-        #
-        # @return [QueryBuilder] Self for method chaining
-        # @example
-        #   builder.packages.in_package('ModelRoot')
-        def packages
-          @scope = :packages
-          self
-        end
-
-        # Add a condition to the query
-        #
-        # Supports both hash-based and block-based conditions.
-        #
-        # @param conditions [Hash, nil] Hash of attribute-value pairs to match
-        # @param block [Proc] Block for custom filtering logic
-        # @return [QueryBuilder] Self for method chaining
-        # @example Hash condition
-        #   builder.where(stereotype: 'featureType')
-        #
-        # @example Block condition
-        #   builder.where { |c| c.attributes.size > 10 }
-        #
-        # @example Regex matching
-        #   builder.where(name: /^Building/)
-        def where(conditions = nil, &block)
-          if conditions
-            @conditions << Conditions::HashCondition.new(conditions)
-          elsif block
-            @conditions << Conditions::BlockCondition.new(&block)
-          end
-          self
-        end
-
-        # Filter by stereotype
-        #
-        # @param stereotype [String] The stereotype to filter by
-        # @return [QueryBuilder] Self for method chaining
-        # @example
-        #   builder.with_stereotype('featureType')
-        def with_stereotype(stereotype)
-          where(stereotype: stereotype)
-        end
-
-        # Filter by package membership
-        #
-        # @param package_path [String, PackagePath] The package path
-        # @param recursive [Boolean] Include descendants (default: false)
-        # @return [QueryBuilder] Self for method chaining
-        # @example Non-recursive
-        #   builder.in_package('ModelRoot::i-UR')
-        #
-        # @example Recursive
-        #   builder.in_package('ModelRoot::i-UR', recursive: true)
-        def in_package(package_path, recursive: false)
-          @conditions << Conditions::PackageCondition.new(package_path,
-                                                          recursive: recursive)
-          self
-        end
-
-        # Order results by a field
-        #
-        # @param field [Symbol, String] The field to order by
-        # @param direction [Symbol] The direction (:asc or :desc)
-        # @return [QueryBuilder] Self for method chaining
-        # @example Ascending
-        #   builder.order_by(:name)
-        #
-        # @example Descending
-        #   builder.order_by(:name, direction: :desc)
-        def order_by(field, direction: :asc)
-          @order = Order.new(field, direction)
-          self
-        end
-
-        # Limit the number of results
-        #
-        # @param count [Integer] Maximum number of results
-        # @return [QueryBuilder] Self for method chaining
-        # @example
-        #   builder.limit(10)
-        def limit(count)
-          @limit = count
-          self
-        end
-
-        # Specify related data to include (placeholder for future enhancement)
-        #
-        # @param relations [Array<Symbol>] Relations to eager load
-        # @return [QueryBuilder] Self for method chaining
-        # @example
-        #   builder.includes(:attributes, :associations)
-        def includes(*relations)
-          @includes.concat(relations)
-          self
-        end
-
-        # Execute the query and return all results
-        #
-        # @return [Array] The query results
-        # @example
-        #   results = builder.classes.where(stereotype: 'featureType').execute
-        def execute
-          results = fetch_base_results
-          results = apply_conditions(results)
-          results = apply_order(results) if @order
-          results = apply_limit(results) if @limit
-          results = apply_includes(results) if @includes.any?
-          results
-        end
-
-        # Alias for execute
-        #
-        # @return [Array] The query results
-        # @example
-        #   results = builder.classes.all
-        def all
-          execute
-        end
-
-        # Get the first result
-        #
-        # @return [Object, nil] The first result or nil if none
-        # @example
-        #   first_class = builder.classes.with_stereotype('featureType').first
-        def first
-          limit(1).execute.first
-        end
-
-        # Get the last result
-        #
-        # @return [Object, nil] The last result or nil if none
-        # @example
-        #   last_class = builder.classes.order_by(:name).last
-        def last
-          execute.last
-        end
-
-        # Count the number of results
-        #
-        # @return [Integer] The count of matching results
-        # @example
-        #   count = builder.classes.with_stereotype('featureType').count
-        def count
-          execute.size
-        end
-
-        # Check if any results exist
-        #
-        # @return [Boolean] true if results exist, false otherwise
-        # @example
-        #   has_results = builder.classes.with_stereotype('featureType').any?
-        def any?
-          execute.any?
-        end
-
-        # Check if no results exist
-        #
-        # @return [Boolean] true if no results exist, false otherwise
-        # @example
-        #   is_empty = builder.classes.with_stereotype('nonexistent').empty?
-        def empty?
-          execute.empty?
-        end
-
-        private
-
-        # Fetch base results based on scope
-        #
-        # @return [Array] Base collection to filter
-        # @raise [RuntimeError] if no scope specified
-        def fetch_base_results
-          case @scope
-          when :classes
-            fetch_classes
-          when :packages
-            fetch_packages
-          else
-            raise "No scope specified. Use .classes or .packages"
-          end
-        end
-
-        # Fetch all classes from the repository
-        #
-        # @return [Array<Lutaml::Uml::Class>] Array of class objects
-        def fetch_classes
-          indexes = @repository.indexes
-          qnames_index = indexes[:qualified_names] || {}
-
-          qnames_index.values.select do |obj|
-            obj.is_a?(Lutaml::Uml::Class) ||
-              obj.is_a?(Lutaml::Uml::DataType) ||
-              obj.is_a?(Lutaml::Uml::Enum)
-          end
-        end
-
-        # Fetch all packages from the repository
-        #
-        # @return [Array<Lutaml::Uml::Package>] Array of package objects
-        def fetch_packages
-          indexes = @repository.indexes
-          package_paths_index = indexes[:package_paths] || {}
-          package_paths_index.values
-        end
-
-        # Apply all conditions to results
-        #
-        # @param results [Array] The collection to filter
-        # @return [Array] The filtered collection
-        def apply_conditions(results)
-          @conditions.each do |condition|
-            results = condition.apply(results)
-          end
-          results
-        end
-
-        # Apply ordering to results
-        #
-        # @param results [Array] The collection to sort
-        # @return [Array] The sorted collection
-        def apply_order(results)
-          @order.apply(results)
-        end
-
-        # Apply limit to results
-        #
-        # @param results [Array] The collection to limit
-        # @return [Array] The limited collection
-        def apply_limit(results)
-          results.first(@limit)
-        end
-
-        # Apply includes (placeholder for future enhancement)
-        #
-        # @param results [Array] The collection to enhance
-        # @return [Array] The enhanced collection
-        def apply_includes(results)
-          # Future: Eager load associations, attributes, etc.
-          results
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/repository/deprecated.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    class Repository
-      # Deprecated API methods kept for backward compatibility.
-      #
-      # These methods delegate to the current API but are marked for removal
-      # in a future major version. Include this module to maintain backward
-      # compatibility with older callers.
-      module Deprecated
-        # @deprecated Use {Repository#search} with types: [:class] instead
-        def search_classes(query_string)
-          search(query_string, types: [:class])[:classes]
-        end
-
-        # @deprecated Use {Repository#subtypes_of} instead
-        def find_children(class_or_qname, recursive: false)
-          subtypes_of(class_or_qname, recursive: recursive)
-        end
-
-        # @deprecated Use {Repository#associations_of} instead
-        def find_associations(class_or_qname, options = {})
-          associations_of(class_or_qname, options)
-        end
-
-        # @deprecated Use {Repository#diagrams_in_package} or {#all_diagrams}
-        def find_diagrams(package_path)
-          diagrams_in_package(package_path)
-        end
-
-        # @deprecated Use {Repository#export_to_package} instead
-        def export(output_path, options = {})
-          export_to_package(output_path, options)
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/uml_repository/repository/loader.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module UmlRepository
-    class Repository
-      # Handles loading Repository instances from various file formats.
-      #
-      # Encapsulates all file I/O and format detection logic, keeping the
-      # main Repository class focused on querying.
-      #
-      # @example Load from XMI
-      #   repo = Loader.from_xmi('model.xmi')
-      #
-      # @example Load from LUR package
-      #   repo = Loader.from_package('model.lur')
-      #
-      # @example Auto-detect format
-      #   repo = Loader.from_file('model.xmi')
-      module Loader
-        # Build a Repository from an XMI file.
-        #
-        # @param xmi_path [String] Path to the XMI file
-        # @param options [Hash] Options for parsing
-        # @return [Repository]
-        def self.from_xmi(xmi_path, options = {})
-          document = Lutaml::Xmi::Parsers::Xml.parse(File.new(xmi_path))
-          indexes = IndexBuilder.build_all(document)
-          new(document: document, indexes: indexes, options: options)
-        end
-
-        # Build a Repository from an XMI file with lazy index loading.
-        #
-        # @param xmi_path [String] Path to the XMI file
-        # @param options [Hash] Options for parsing
-        # @return [LazyRepository]
-        def self.from_xmi_lazy(xmi_path, _options = {})
-          document = Lutaml::Xmi::Parsers::Xml.parse(File.new(xmi_path))
-          LazyRepository.new(document: document, lazy: true)
-        end
-
-        # Auto-detect file type and load appropriately.
-        #
-        # @param path [String] Path to the file (.xmi or .lur)
-        # @return [Repository]
-        # @raise [ArgumentError] If the file type is unknown
-        def self.from_file(path)
-          case File.extname(path).downcase
-          when ".xmi" then from_xmi(path)
-          when ".lur" then from_package(path)
-          else
-            raise ArgumentError,
-                  "Unknown file type: #{path}. Expected .xmi or .lur"
-          end
-        end
-
-        # Smart caching - use LUR if newer than XMI, otherwise rebuild.
-        #
-        # @param xmi_path [String] Path to the XMI file
-        # @param lur_path [String, nil] Path to the LUR package
-        # @return [Repository]
-        def self.from_file_cached(xmi_path, lur_path: nil)
-          lur_path ||= xmi_path.sub(/\.xmi$/i, ".lur")
-
-          if cache_valid?(lur_path, xmi_path)
-            puts "Using cached LUR package: #{lur_path}" if $VERBOSE
-            from_package(lur_path)
-          else
-            build_and_cache(xmi_path, lur_path)
-          end
-        end
-
-        def self.cache_valid?(lur_path, xmi_path)
-          File.exist?(lur_path) && File.mtime(lur_path) >= File.mtime(xmi_path)
-        end
-
-        def self.build_and_cache(xmi_path, lur_path)
-          puts "Building repository from XMI..." if $VERBOSE
-          repo = from_xmi(xmi_path)
-          puts "Caching as LUR package: #{lur_path}" if $VERBOSE
-          repo.export_to_package(lur_path)
-          repo
-        end
-
-        # Load a Repository from a LUR package file.
-        #
-        # @param lur_path [String] Path to the .lur package file
-        # @return [Repository]
-        def self.from_package(lur_path)
-          PackageLoader.load(lur_path)
-        end
-
-        # Load a Repository from a LUR package with lazy loading.
-        #
-        # @param lur_path [String] Path to the .lur package file
-        # @return [LazyRepository]
-        def self.from_package_lazy(lur_path)
-          PackageLoader.load_document_only(lur_path)
-        end
-
-        # Auto-detect file type with lazy loading.
-        #
-        # @param path [String] Path to the file (.xmi or .lur)
-        # @return [LazyRepository]
-        # @raise [ArgumentError] If the file type is unknown
-        def self.from_file_lazy(path)
-          case File.extname(path).downcase
-          when ".xmi" then from_xmi_lazy(path)
-          when ".lur" then from_package_lazy(path)
-          else
-            raise ArgumentError,
-                  "Unknown file type: #{path}. Expected .xmi or .lur"
-          end
-        end
-      end
-    end
-  end
-end