Module: CmisServer

Defined in:
lib/cmis_server.rb,
lib/cmis_server/id.rb,
lib/cmis_server/type.rb,
lib/cmis_server/query.rb,
lib/cmis_server/engine.rb,
lib/cmis_server/context.rb,
lib/cmis_server/version.rb,
lib/cmis_server/property.rb,
lib/cmis_server/constants.rb,
lib/cmis_server/item_type.rb,
lib/cmis_server/base_types.rb,
lib/cmis_server/exceptions.rb,
lib/cmis_server/repository.rb,
lib/cmis_server/cmis_object.rb,
lib/cmis_server/folder_type.rb,
lib/cmis_server/item_object.rb,
lib/cmis_server/item_adapter.rb,
lib/cmis_server/query/parser.rb,
lib/cmis_server/configuration.rb,
lib/cmis_server/document_type.rb,
lib/cmis_server/folder_object.rb,
lib/cmis_server/type_registry.rb,
lib/cmis_server/content_stream.rb,
lib/cmis_server/folder_adapter.rb,
lib/cmis_server/object_adapter.rb,
lib/cmis_server/secondary_type.rb,
lib/cmis_server/document_object.rb,
lib/cmis_server/query/statement.rb,
lib/cmis_server/document_adapter.rb,
lib/cmis_server/query/parser_rex.rb,
lib/cmis_server/base_objects/item.rb,
lib/cmis_server/query/parser_racc.rb,
lib/cmis_server/renderable_object.rb,
lib/cmis_server/engine_diagnostics.rb,
lib/cmis_server/base_objects/folder.rb,
lib/cmis_server/property_definition.rb,
lib/cmis_server/query/simple_parser.rb,
lib/cmis_server/atom_pub/entry_parser.rb,
lib/cmis_server/base_objects/document.rb,
lib/cmis_server/renderable_collection.rb,
lib/cmis_server/base_objects/base_type.rb,
lib/cmis_server/zeitwerk_configuration.rb,
app/services/cmis_server/object_service.rb,
app/models/cmis_server/application_record.rb,
lib/cmis_server/connectors/base_connector.rb,
lib/cmis_server/connectors/core_connector.rb,
app/helpers/cmis_server/application_helper.rb,
app/services/cmis_server/discovery_service.rb,
app/services/cmis_server/navigation_service.rb,
app/services/cmis_server/repository_service.rb,
app/services/cmis_server/bulk_update_service.rb,
lib/cmis_server/connectors/connector_factory.rb,
app/services/cmis_server/content_stream_service.rb,
app/services/cmis_server/secondary_type_service.rb,
app/services/cmis_server/type_management_service.rb,
app/controllers/cmis_server/application_controller.rb,
app/controllers/cmis_server/atom_pub/base_controller.rb,
app/controllers/cmis_server/atom_pub/bulk_controller.rb,
app/controllers/cmis_server/atom_pub/query_controller.rb,
app/controllers/cmis_server/atom_pub/types_controller.rb,
app/controllers/cmis_server/atom_pub/content_controller.rb,
app/controllers/cmis_server/atom_pub/entries_controller.rb,
app/controllers/cmis_server/atom_pub/repository_controller.rb,
app/controllers/cmis_server/atom_pub/uri_templates_controller.rb,
app/controllers/cmis_server/atom_pub/secondary_types_controller.rb,
app/controllers/cmis_server/atom_pub/folder_collection_controller.rb,
app/controllers/cmis_server/atom_pub/service_documents_controller.rb,
app/controllers/concerns/cmis_server/atom_pub/repository_scopable.rb

Defined Under Namespace

Modules: ApplicationHelper, AtomPub, BaseObjects, Connectors, Query Classes: ApplicationController, ApplicationRecord, BaseType, BaseTypeDefinition, Boolean, BulkUpdateService, CmisObject, CmisStandardError, Configuration, ConstraintViolation, ContentStream, ContentStreamService, Context, DiscoveryService, Document, DocumentAdapter, DocumentObject, DocumentType, Engine, EngineDiagnostics, EntryParser, Folder, FolderAdapter, FolderObject, FolderType, Id, InheritedDecorator, InvalidArgument, InvalidOperation, InvalidType, InvalidTypeDefinition, ItemAdapter, ItemObject, ItemType, NavigationService, NotSupported, ObjectAdapter, ObjectNotFound, ObjectService, Property, PropertyDefinition, RenderableCollection, RenderableObject, Repository, RepositoryService, RuntimeError, SecondaryType, SecondaryTypeService, Type, TypeManagementService, TypeRegistry, ZeitwerkConfiguration

Constant Summary collapse

VERSION = 
"1.3.1"
CMIS_VERSION_SUPPORTED = 
"1.1"
CMIS_NAMESPACE =

CMIS 1.1 namespaces

"http://docs.oasis-open.org/ns/cmis/core/201103/"
CMIS_REST_ATOM_NAMESPACE = 
"http://docs.oasis-open.org/ns/cmis/restatom/201103/"
SECONDARY_TYPE =

Secondary Type Definition - déplacé ici pour éviter les dépendances circulaires

CmisServer::BaseTypeDefinition.new(id:                   'cmis:secondary',
                           parent_type:          nil,
                           description:          "A CMIS secondary type",
                           display_name:         'Secondary',
                           creatable:            false,
                           fileable:             false,
                           queryable:            true,
                           controllable_policy:  false,
                           controllable_acl:     false,
                           property_definitions: [
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:name'.freeze, type: String, required: true}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:description'.freeze, type: String, required: false}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:objectId'.freeze, type: CmisServer::Id, required: true, updatability: :readonly}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:baseTypeId'.freeze, type: CmisServer::Id, required: true, updatability: :readonly, value: ->(obj) { obj.type.base_id }}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:objectTypeId'.freeze, type: CmisServer::Id, required: true, updatability: :oncreate, value: ->(obj) { obj.type.id }}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:createdBy'.freeze, type: String, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:creationDate'.freeze, type: DateTime, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:lastModifiedBy'.freeze, type: String, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:lastModificationDate'.freeze, type: DateTime, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:changeToken'.freeze, type: String, required: false, updatability: :readonly}),
                                                 ]
)
ITEM_TYPE =

Item Type Definition - déplacé ici pour éviter les dépendances circulaires

CmisServer::BaseTypeDefinition.new(id:                   'cmis:item',
                      parent_type:          nil,
                      description:          "A CMIS item",
                      display_name:         'Item',
                      creatable:            true,
                      fileable:             true,
                      queryable:            true,
                      property_definitions: [
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:name'.freeze, type: String, required: true}),
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:description'.freeze, type: String, required: false}),
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:objectId'.freeze, type: CmisServer::Id, required: true, updatability: :readonly}),
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:baseTypeId'.freeze, type: CmisServer::Id, required: true, updatability: :readonly, value: ->(obj) { obj.type.base_id }}),
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:objectTypeId'.freeze, type: CmisServer::Id, required: true, updatability: :oncreate, value: ->(obj) { obj.type.id }}),
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:secondaryObjectTypeIds'.freeze, type: CmisServer::Id, required: false, updatability: :readwrite, cardinality: :multi}),
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:createdBy'.freeze, type: String, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:creationDate'.freeze, type: DateTime, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:lastModifiedBy'.freeze, type: String, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:lastModificationDate'.freeze, type: DateTime, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                              CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:changeToken'.freeze, type: String, required: false, updatability: :readonly}),
                                            ]
)
DOCUMENT_TYPE = 
CmisServer::BaseTypeDefinition.new(id:                   'cmis:document',
                           parent_type:          nil,
                           description:          "A CMIS document",
                           display_name:         'Document',
                           creatable:            true,
                           fileable:             true,
                           queryable:            true,
                           property_definitions: [
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:name'.freeze, type: String, required: true, updatability: :readwrite}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:description'.freeze, type: String, required: false, updatability: :readwrite}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:objectId'.freeze, type: CmisServer::Id, required: true, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:baseTypeId'.freeze, type: CmisServer::Id, required: true, updatability: :readonly, value: ->(obj) { obj.type.base_id }}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:objectTypeId'.freeze, type: CmisServer::Id, required: true, updatability: :oncreate, value: ->(obj) { obj.type.id }}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:secondaryObjectTypeIds'.freeze, type: CmisServer::Id, required: false, updatability: :readwrite, cardinality: :multi}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:createdBy'.freeze, type: String, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:creationDate'.freeze, type: DateTime, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:lastModifiedBy'.freeze, type: String, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:lastModificationDate'.freeze, type: DateTime, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:changeToken'.freeze, type: String, required: false, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isImmutable'.freeze, type: Boolean, required: false, updatability: :readonly, default: false}),

                                                     # Versionning properties
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isLatestVersion'.freeze, type: Boolean, required: false, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isMajorVersion'.freeze, type: Boolean, required: false, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isLatestMajorVersion'.freeze, type: Boolean, required: false, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isPrivateWorkingCopy'.freeze, type: Boolean, required: false, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:versionLabel'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:versionSeriesId'.freeze, type: CmisServer::Id, required: false, cardinality: :single, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:isVersionSeriesCheckedOut'.freeze, type: Boolean, required: false, cardinality: :single, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:versionSeriesCheckedOutBy'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:versionSeriesCheckedOutId'.freeze, type: Id, required: false, cardinality: :single, updatability: :readonly}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:checkinComment'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly}),

                                                     # ContentStream properties
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:contentStreamLength'.freeze, type: Integer, required: false, cardinality: :single, updatability: :readonly, value: ->(obj) { obj.content_stream&.length }}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:contentStreamMimeType'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly, value: ->(obj) { obj.content_stream&.media_type }}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:contentStreamFileName'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly, value: ->(obj) { obj.content_stream&.filename }}),
                                                     CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:contentStreamId'.freeze, type: String, required: false, cardinality: :single, updatability: :readonly, value: ->(obj) { obj.content_stream&.id }}),
                                                 ]
)
FOLDER_TYPE = 
CmisServer::BaseTypeDefinition.new(id:                   'cmis:folder',
                         parent_type:          nil,
                         description:          "A CMIS folder",
                         display_name:         'Folder',
                         creatable:            true,
                         fileable:             true,
                         queryable:            true,
                         property_definitions: [
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:name'.freeze, type: String, required: true}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:description'.freeze, type: String, required: false}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:objectId'.freeze, type: CmisServer::Id, required: true, updatability: :readonly}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:baseTypeId'.freeze, type: CmisServer::Id, required: true, updatability: :readonly, value: ->(obj) { obj.type.base_id }}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:objectTypeId'.freeze, type: CmisServer::Id, required: true, updatability: :oncreate, value: ->(obj) { obj.type.id }}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:secondaryObjectTypeIds'.freeze, type: CmisServer::Id, required: false, updatability: :readonly, cardinality: :multi}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:createdBy'.freeze, type: String, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:creationDate'.freeze, type: DateTime, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:lastModifiedBy'.freeze, type: String, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:lastModificationDate'.freeze, type: DateTime, required: false, updatability: :readonly, queryable: true, orderable: true}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:changeToken'.freeze, type: String, required: false, updatability: :readonly}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:parentId'.freeze, type: CmisServer::Id, required: false, updatability: :readonly}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:path'.freeze, type: CmisServer::Id, required: false, updatability: :readonly}),
                                                   CmisServer::PropertyDefinition.register_property_definition({id: 'cmis:allowedChildObjectTypeIds'.freeze, type: CmisServer::Id, required: false, updatability: :readonly, cardinality: :multi}),
                                               ]
)
BASE_TYPES = 
base_types_array

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.configuration ⇒ Object 



31
32
33
 
# File 'lib/cmis_server.rb', line 31

def self.configuration
  @configuration ||= Configuration.new
end

Class Method Details

.base_types ⇒ Object

Pour compatibilité ascendante



125
126
127
 
# File 'lib/cmis_server/base_types.rb', line 125

def self.base_types
  base_types_array
end

.base_types_array ⇒ Object

Utiliser une méthode au lieu d’une constante pour éviter les problèmes de gel automatique



120
121
122
 
# File 'lib/cmis_server/base_types.rb', line 120

def self.base_types_array
  @base_types_array ||= [DOCUMENT_TYPE, FOLDER_TYPE, SECONDARY_TYPE, ITEM_TYPE]
end

.configure {|configuration| ... } ⇒ Object

Yields:



39
40
41
 
# File 'lib/cmis_server.rb', line 39

def self.configure
  yield(configuration)
end

.debug_engine_routes ⇒ Object

Méthode pour forcer le chargement et diagnostic des routes du moteur



183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/cmis_server.rb', line 183

def self.debug_engine_routes
  result = {
    engine_class_loaded: false,
    routes_file_exists: false,
    routes_content_sample: nil,
    routes_loaded: false,
    route_count: 0,
    routes_list: [],
    load_errors: []
  }
  
  begin
    # Vérifier si la classe Engine existe
    if defined?(CmisServer::Engine)
      result[:engine_class_loaded] = true
      
      # Vérifier si le fichier routes existe  
      routes_file = File.expand_path('../../config/routes.rb', __FILE__)
      if File.exist?(routes_file)
        result[:routes_file_exists] = true
        result[:routes_content_sample] = File.read(routes_file).lines.first(5).join
        
        # Vérifier les routes chargées
        begin
          result[:route_count] = CmisServer::Engine.routes.routes.size
          result[:routes_loaded] = result[:route_count] > 0
          
          # Lister quelques routes
          CmisServer::Engine.routes.routes.first(10).each do |route|
            result[:routes_list] << "#{route.verb} #{route.path.spec}"
          end
          
        rescue => e
          result[:load_errors] << "Error accessing routes: #{e.message}"
        end
        
        # Tenter de forcer le rechargement des routes
        begin
          CmisServer::Engine.routes.clear!
          load routes_file
          result[:route_count] = CmisServer::Engine.routes.routes.size
          result[:routes_loaded] = result[:route_count] > 0
          result[:load_errors] << "Routes reloaded successfully" if result[:routes_loaded]
        rescue => e
          result[:load_errors] << "Error reloading routes: #{e.message}"
        end
        
      else
        result[:load_errors] << "Routes file not found: #{routes_file}"
      end
    else
      result[:load_errors] << "CmisServer::Engine not defined"
    end
    
  rescue => e
    result[:load_errors] << "General error: #{e.message}"
  end
  
  result
end

.diagnostic ⇒ Object

Méthode de diagnostic pour vérifier l’état du moteur CMIS



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
 
# File 'lib/cmis_server.rb', line 117

def self.diagnostic
  result = {
    gem_loaded: true,
    version: defined?(VERSION) ? VERSION : "unknown",
    engine_defined: defined?(Engine),
    engine_routes_count: nil,
    engine_mounted: false,
    rails_routes_count: nil,
    cmis_routes_found: 0,
    configuration_valid: false,
    errors: []
  }
  
  begin
    # Vérifier la version
    require 'cmis_server/version'
    result[:version] = CmisServer::VERSION if defined?(CmisServer::VERSION)
  rescue => e
    result[:errors] << "Version error: #{e.message}"
  end
  
  begin
    # Vérifier le moteur
    if defined?(CmisServer::Engine)
      result[:engine_defined] = true
      result[:engine_routes_count] = CmisServer::Engine.routes.routes.size
    else
      result[:errors] << "CmisServer::Engine not defined"
    end
  rescue => e
    result[:errors] << "Engine error: #{e.message}"
  end
  
  begin
    # Vérifier la configuration
    if configuration && configuration.respond_to?(:repository_info)
      result[:configuration_valid] = !configuration.repository_info.nil?
    end
  rescue => e
    result[:errors] << "Configuration error: #{e.message}"
  end
  
  # Vérifier Rails si disponible
  if defined?(Rails) && Rails.application
    begin
      result[:rails_routes_count] = Rails.application.routes.routes.size
      
      # Chercher les routes CMIS montées
      cmis_routes = Rails.application.routes.routes.select { |r| 
        r.path.spec.to_s.include?('cmis') ||
        (r.app.class.name.include?('Engine') && r.path.spec.to_s.include?('cmis'))
      }
      result[:cmis_routes_found] = cmis_routes.size
      result[:engine_mounted] = cmis_routes.any? { |r| r.app.class.name.include?('CmisServer') }
      
    rescue => e
      result[:errors] << "Rails routes error: #{e.message}"
    end
  else
    result[:errors] << "Rails not available or not initialized"
  end
  
  result
end

.mount_engine(application, mount_path, mount_name: nil, debug: false) ⇒ Object

Method to properly mount CmisServer in a Rails application Usage in host app: CmisServer.mount_engine(Rails.application, “/path”, mount_name: ‘custom_name’)



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
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
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/cmis_server.rb', line 45

def self.mount_engine(application, mount_path, mount_name: nil, debug: false)
  if application && application.routes && mount_path
    # Save original Rails.application
    original_rails_app = Rails.application
    Rails.application = application
    
    # Make sure engine routes are loaded first
    if !EngineDiagnostics.routes_loaded?
      EngineDiagnostics.reload_engine_routes!
      
      # Log diagnostic if in debug mode
      if debug
        puts "CMIS Server Engine Diagnostics:"
        puts EngineDiagnostics.diagnostic_info.inspect
      end
    end
    
    # Check if application is already initialized
    if !application.initialized?
      puts "CMIS Server: Initializing application before mounting" if debug
      # Handle Rails 7+ with frozen arrays in autoload paths
      begin
        application.initialize!
      rescue FrozenError => e
        puts "CMIS Server: Frozen array error during initialization (Rails 7+ issue)" if debug
        puts "CMIS Server: Proceeding with mounting anyway" if debug
      end
    end
    
    # Mount the engine with a custom name if provided
    application.routes.draw do
      if mount_name
        mount CmisServer::Engine => mount_path, as: mount_name
      else
        mount CmisServer::Engine => mount_path
      end
    end
    
    # Force route drawing
    application.routes.finalize!
    
    # Check if engine routes are loaded again
    engine_routes_count = Engine.routes.routes.size
    if engine_routes_count == 0
      puts "CMIS Server: Engine routes not loaded, forcing reload again" if debug
      
      # Try once more to reload engine routes
      EngineDiagnostics.reload_engine_routes!
      
      # And refresh application routes
      application.routes.reload!
    end
    
    # Count mounted routes for verification
    cmis_routes = application.routes.routes.select do |route|
      route.path.spec.to_s.include?(mount_path) || 
      (route.defaults[:controller]&.start_with?('cmis_server'))
    end
    
    puts "CMIS Server mounted at '#{mount_path}' with #{cmis_routes.size} routes" if debug
    
    # Restore the original Rails.application
    Rails.application = original_rails_app
    
    return cmis_routes.size
  else
    puts "CMIS Server mount failed: Invalid parameters" if debug
    return 0
  end
end

.print_engine_routes_debug ⇒ Object

Méthode pour afficher le diagnostic des routes du moteur



245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/cmis_server.rb', line 245

def self.print_engine_routes_debug
  debug = debug_engine_routes
  
  puts "\n=== ENGINE ROUTES DEBUG ==="
  puts "Engine class loaded: #{debug[:engine_class_loaded] ? '✅' : '❌'}"
  puts "Routes file exists: #{debug[:routes_file_exists] ? '✅' : '❌'}"
  puts "Routes loaded: #{debug[:routes_loaded] ? '✅' : '❌'}"
  puts "Route count: #{debug[:route_count]}"
  
  if debug[:routes_content_sample]
    puts "\nRoutes file sample:"
    puts debug[:routes_content_sample]
  end
  
  if debug[:routes_list].any?
    puts "\nLoaded routes:"
    debug[:routes_list].each { |route| puts "  #{route}" }
  end
  
  if debug[:load_errors].any?
    puts "\nDebug messages:"
    debug[:load_errors].each { |error| puts "  🔍 #{error}" }
  end
  
  puts "=== END ENGINE DEBUG ==="
  
  debug
end

.reset ⇒ Object 



35
36
37
 
# File 'lib/cmis_server.rb', line 35

def self.reset
  @configuration = Configuration.new
end