Class: Lutaml::UmlRepository::RepositoryEnhanced

Inherits:
Repository
  • Object
show all
Defined in:
lib/lutaml/uml_repository/repository_enhanced.rb

Overview

Enhanced Repository with unified model transformation support.

This class extends the original Repository to support the new unified model transformation system, providing seamless integration with XMI, QEA, and future format parsers.

The enhanced repository follows SOLID principles and provides backward compatibility with existing code while enabling new transformation capabilities.

Examples:

Enhanced XMI parsing

repo = RepositoryEnhanced.from_model("model.xmi")

Enhanced QEA parsing

repo = RepositoryEnhanced.from_model("model.qea")

With custom configuration

config = ModelTransformations::Configuration.load("my_config.yml")
repo = RepositoryEnhanced.from_model("model.qea", config: config)

Constant Summary collapse

WARNING_SCORE_PENALTY = 
5
ERROR_SCORE_PENALTY = 
10
SLOW_PARSING_THRESHOLD = 
60
MAX_ERRORS_FOR_VALID = 
5
PARSING_OPTION_KEYS = 
%i[validate include_diagrams resolve_references].freeze

Instance Attribute Summary collapse

Attributes inherited from Repository

#document, #indexes, #metadata

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Repository

#all_attributes, #all_classes, #all_diagrams, #ancestors_of, #associations_index, #associations_of, #classes_in_package, #classes_index, #descendants_of, #diagrams_in_package, #diagrams_index, #export_to_package, #find_attribute, #find_class, #find_classes_by_stereotype, #find_diagram, #find_package, from_file, from_file_cached, from_file_lazy, from_package, from_package_lazy, from_xmi, from_xmi_lazy, #list_packages, #marshal_dump, #marshal_load, #package_tree, #packages_index, #qualified_name_for, #query, #query!, #search, #statistics, #subtypes_of, #supertype_of, #validate

Methods included from Lutaml::UmlRepository::Repository::Deprecated

#export, #find_associations, #find_children, #find_diagrams, #search_classes

Constructor Details

#initialize(document:, indexes: nil, transformation_engine: nil, transformation_metadata: {}) ⇒ RepositoryEnhanced

Initialize enhanced repository

ModelTransformations::TransformationEngine, nil

Custom engine

Metadata from transformation process

Parameters:

  • document (Lutaml::Uml::Document) —

    The UML document

  • indexes (Hash, nil) (defaults to: nil) —

    Pre-built indexes

  • transformation_engine (defaults to: nil)
  • transformation_metadata (Hash) (defaults to: {}) 


50
51
52
53
54
55
56
57
58
59
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 50

def initialize(
  document:, indexes: nil, transformation_engine: nil,
  transformation_metadata: {}
)
  super(document: document, indexes: indexes)

  @transformation_engine = transformation_engine ||
    ModelTransformations.engine
  @transformation_metadata = transformation_metadata.freeze
end

Instance Attribute Details

#transformation_engine ⇒ ModelTransformations::TransformationEngine (readonly)

The transformation engine

Returns:



37
38
39
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 37

def transformation_engine
  @transformation_engine
end

#transformation_metadata ⇒ Hash (readonly)

Returns Transformation metadata.

Returns:

  • (Hash) —

    Transformation metadata



40
41
42
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 40

def transformation_metadata
  @transformation_metadata
end

Class Method Details

.apply_preset(_engine, preset) ⇒ void

This method returns an undefined value.

Apply configuration preset

Engine to configure

Parameters:



307
308
309
310
311
312
313
314
315
316
317
318
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 307

def self.apply_preset(_engine, preset)
  # This would apply preset configurations from the YAML config
  # For now, this is a placeholder for future implementation
  case preset
  when :fast
    # Apply fast parsing settings
  when :comprehensive
    # Apply comprehensive parsing settings
  when :production
    # Apply production settings
  end
end

.detect_format(file_path) ⇒ String?

Detect format for a file

Parameters:

  • file_path (String) —

    Path to analyze

Returns:

  • (String, nil) —

    Detected format name or nil



203
204
205
206
207
208
209
210
211
212
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 203

def self.detect_format(file_path)
  parser_class = ModelTransformations.engine.detect_parser(file_path)
  return nil unless parser_class

  # Create temporary instance to get format name
  temp_parser = parser_class.new
  temp_parser.format_name
rescue StandardError
  nil
end

.extract_parsing_options(options) ⇒ Hash

Extract parsing options from repository options

Parameters:

  • options (Hash) —

    Repository options

Returns:

  • (Hash) —

    Parsing options



324
325
326
327
328
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 324

def self.extract_parsing_options(options)
  options.slice(*PARSING_OPTION_KEYS).tap do |parsed|
    parsed[:validate_output] = parsed.delete(:validate) if parsed.key?(:validate)
  end
end

.extract_transformation_metadata(engine, file_path) ⇒ Hash

Extract transformation metadata from engine

Transformation engine

Parameters:

Returns:

  • (Hash) —

    Transformation metadata



336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 336

def self.extract_transformation_metadata(engine, file_path) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
  # Get the most recent transformation for this file
  history = engine.history_for_file(file_path)
  latest = history.last

  if latest
    {
      source_file: file_path,
      source_format: latest[:parser]&.format_name,
      parsed_at: latest[:timestamp],
      parser: latest[:parser]&.class&.name,
      parsing_duration: latest[:duration],
      success: latest[:success],
      warnings: latest[:parser]&.warnings || [],
      errors: latest[:parser]&.errors || [],
    }
  else
    {
      source_file: file_path,
      parsed_at: Time.now,
    }
  end
end

.from_file_enhanced(file_path, options = {}) ⇒ RepositoryEnhanced

Auto-detect and load from file with enhanced capabilities

Parameters:

  • file_path (String) —

    Path to model file

  • options (Hash) (defaults to: {}) —

    Loading options

Returns:



129
130
131
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 129

def self.from_file_enhanced(file_path, options = {})
  from_model(file_path, options)
end

.from_model(model_path, options = {}) ⇒ RepositoryEnhanced

Build enhanced repository from any supported model format

This method auto-detects the format and uses the appropriate parser from the unified transformation system.

Custom configuration (:fast, :comprehensive, :production)

Parameters:

  • model_path (String) —

    Path to the model file

  • options (Hash) (defaults to: {}) —

    Parsing and repository options

Options Hash (options):

  • :config (ModelTransformations::Configuration)
  • :validate (Boolean) —

    Validate model after parsing

  • :lazy (Boolean) —

    Enable lazy loading

  • :preset (Symbol) —

    Use configuration preset

Returns:



75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 75

def self.from_model(model_path, options = {}) # rubocop:disable Metrics/MethodLength
  # Setup transformation engine with custom config if provided
  engine = setup_transformation_engine(options)

  # Apply preset if specified
  apply_preset(engine, options[:preset]) if options[:preset]

  # Parse model using unified transformation system
  document = engine.parse(model_path, extract_parsing_options(options))

  # Build indexes
  indexes = options[:lazy] ? nil : IndexBuilder.build_all(document)

  # Create enhanced repository
  enhanced_repo = new(
    document: document,
    indexes: indexes,
    transformation_engine: engine,
    transformation_metadata: extract_transformation_metadata(engine,
                                                             model_path),
  )

  # Validate if requested
  enhanced_repo.validate if options[:validate]

  enhanced_repo
end

.from_package_enhanced(lur_path, _options = {}) ⇒ RepositoryEnhanced

Load from LUR package with transformation metadata

Parameters:

  • lur_path (String) —

    Path to LUR package

  • options (Hash) —

    Loading options

Returns:



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 138

def self.from_package_enhanced(lur_path, _options = {}) # rubocop:disable Metrics/MethodLength
  # Load using original method but wrap in enhanced repository
  original_repo = from_package(lur_path)

  new(
    document: original_repo.document,
    indexes: original_repo.indexes,
    transformation_metadata: {
      source_file: lur_path,
      source_format: "LUR Package",
      loaded_at: Time.now,
      loader: "Enhanced Package Loader",
    },
  )
end

.from_qea_enhanced(qea_path, options = {}) ⇒ RepositoryEnhanced

Build enhanced repository from QEA

Parameters:

  • qea_path (String) —

    Path to QEA file

  • options (Hash) (defaults to: {}) —

    Options for parsing

Returns:



120
121
122
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 120

def self.from_qea_enhanced(qea_path, options = {})
  from_model(qea_path, options.merge(format_hint: :qea))
end

.from_xmi_enhanced(xmi_path, options = {}) ⇒ RepositoryEnhanced

Build enhanced repository from XMI with legacy compatibility

This method provides backward compatibility with the original from_xmi method while using the new transformation system internally.

Parameters:

  • xmi_path (String) —

    Path to XMI file

  • options (Hash) (defaults to: {}) —

    Options for parsing

Returns:



111
112
113
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 111

def self.from_xmi_enhanced(xmi_path, options = {})
  from_model(xmi_path, options.merge(format_hint: :xmi))
end

.setup_transformation_engine(options) ⇒ ModelTransformations::TransformationEngine

Setup transformation engine with custom configuration

Parameters:

  • options (Hash) —

    Setup options

Returns:



293
294
295
296
297
298
299
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 293

def self.setup_transformation_engine(options)
  if options[:config]
    ModelTransformations::TransformationEngine.new(options[:config])
  else
    ModelTransformations.engine
  end
end

.supported_extensions ⇒ Array<String>

Get list of supported file extensions

Returns:

  • (Array<String>) —

    Supported extensions



195
196
197
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 195

def self.supported_extensions
  ModelTransformations.engine.supported_extensions
end

.supports_file?(file_path) ⇒ Boolean

Check if repository supports a file format

Parameters:

  • file_path (String) —

    Path to check

Returns:

  • (Boolean) —

    true if format is supported



188
189
190
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 188

def self.supports_file?(file_path)
  ModelTransformations.engine.supports_file?(file_path)
end

Instance Method Details

#export_to_package_enhanced(output_path, options = {}) ⇒ void

This method returns an undefined value.

Export with enhanced metadata

Parameters:

  • output_path (String) —

    Path for output file

  • options (Hash) (defaults to: {}) —

    Export options



219
220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 219

def export_to_package_enhanced(output_path, options = {})
  # Include transformation metadata in export
  enhanced_options = options.merge(
    transformation_metadata: @transformation_metadata,
    engine_info: {
      engine_class: @transformation_engine.class.name,
      supported_formats: @transformation_engine.supported_extensions,
      configuration_version: @transformation_engine.configuration.version,
    },
  )

  export_to_package(output_path, enhanced_options)
end

#parsing_history ⇒ Array<Hash>

Get parsing history for the source file

Returns:

  • (Array<Hash>) —

    Parsing history entries



177
178
179
180
181
182
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 177

def parsing_history
  source_file = @transformation_metadata[:source_file]
  return [] unless source_file

  @transformation_engine.history_for_file(source_file)
end

#register_parser(extension, parser_class) ⇒ void

This method returns an undefined value.

Register custom parser with the transformation engine

Parameters:

  • extension (String) —

    File extension

  • parser_class (Class) —

    Parser class



275
276
277
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 275

def register_parser(extension, parser_class)
  @transformation_engine.register_parser(extension, parser_class)
end

#statistics_enhanced ⇒ Hash

Get comprehensive statistics including transformation info

Returns:

  • (Hash) —

    Enhanced statistics



255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 255

def statistics_enhanced
  base_stats = statistics

  transformation_stats = {
    source_format: @transformation_metadata[:source_format],
    parsing_duration: @transformation_metadata[:parsing_duration],
    parser_used: @transformation_metadata[:parser],
    transformation_warnings: @transformation_metadata[:warnings]&.size ||
      0,
    transformation_errors: @transformation_metadata[:errors]&.size || 0,
  }

  base_stats.merge(transformation_stats: transformation_stats)
end

#transformation_info ⇒ Hash

Get transformation statistics and metadata

Returns:

  • (Hash) —

    Comprehensive transformation information



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 157

def transformation_info # rubocop:disable Metrics/MethodLength
  base_info = {
    source_file: @transformation_metadata[:source_file],
    source_format: @transformation_metadata[:source_format],
    parsed_at: @transformation_metadata[:parsed_at],
    parser: @transformation_metadata[:parser],
    transformation_engine: @transformation_engine.class.name,
  }

  # Add engine statistics if available
  if @transformation_engine.class.method_defined?(:statistics)
    base_info[:engine_statistics] = @transformation_engine.statistics
  end

  base_info
end

#update_configuration(config) ⇒ void

This method returns an undefined value.

Update transformation engine configuration

Parameters:



283
284
285
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 283

def update_configuration(config)
  @transformation_engine.configuration = config
end

#validate_enhanced ⇒ Hash

Validate with enhanced error reporting

Returns:

  • (Hash) —

    Enhanced validation results



236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
 
# File 'lib/lutaml/uml_repository/repository_enhanced.rb', line 236

def validate_enhanced # rubocop:disable Metrics/MethodLength
  base_validation = validate

  # Add transformation-specific validation
  transformation_validation = validate_transformation_quality

  {
    base_validation: base_validation,
    transformation_validation: transformation_validation,
    overall_valid: base_validation.valid? &&
      transformation_validation[:valid],
    recommendations: generate_recommendations(base_validation,
                                              transformation_validation),
  }
end