cmis_server 1.0.3 → 1.2.1

data/lib/cmis_server/engine.rb

@@ -1,60 +1,19 @@
-module CmisServer
+module CmisServer 
   class Engine < ::Rails::Engine
-    config.autoload_paths << File.expand_path("../../app/services", __FILE__)
     isolate_namespace CmisServer
     
-    # Enregistrement des types MIME selon les conventions de Rails 7+
-    initializer "cmis_server.register_mime_types" do
-      Mime::Type.register "application/atom+xml", :atom_xml
-      Mime::Type.register "application/atom+xml;type=feed", :atom_feed
-      Mime::Type.register "application/atom+xml;type=entry", :atom_entry
-      Mime::Type.register "application/atomsvc+xml", :atom_service
+    # Add paths
+    config.autoload_paths << File.join(root, "lib")
+    config.autoload_paths << File.join(root, "app", "controllers")
+    config.autoload_paths << File.join(root, "app", "helpers")
+    config.autoload_paths << File.join(root, "app", "models")
+    
+    # Register MIME types according to Rails conventions
+    initializer "cmis_server.register_mime_types", before: :load_config_initializers do
+      Mime::Type.register "application/atom+xml", :atom_xml unless Mime::Type.lookup_by_extension(:atom_xml)
+      Mime::Type.register "application/atom+xml;type=feed", :atom_feed unless Mime::Type.lookup_by_extension(:atom_feed)
+      Mime::Type.register "application/atom+xml;type=entry", :atom_entry unless Mime::Type.lookup_by_extension(:atom_entry)
+      Mime::Type.register "application/atomsvc+xml", :atom_service unless Mime::Type.lookup_by_extension(:atom_service)
     end
   end
 end
-
-require 'cmis_server/version'
-require 'cmis_server/constants'
-require 'cmis_server/configuration'
-
-require 'cmis_server/exceptions'
-
-#CMIS special types
-require 'cmis_server/id'
-require 'cmis_server/content_stream'
-
-require 'cmis_server/repository'
-require 'cmis_server/property_definition'
-require 'cmis_server/property'
-
-# Charger BaseType en premier
-require 'cmis_server/base_objects/base_type'
-
-require 'cmis_server/type'
-require 'cmis_server/base_types'
-require 'cmis_server/type_registry'
-require 'cmis_server/cmis_object'
-require 'cmis_server/document_type'
-require 'cmis_server/document_object'
-require 'cmis_server/folder_type'
-require 'cmis_server/folder_object'
-require 'cmis_server/item_type'
-require 'cmis_server/item_object'
-require 'cmis_server/secondary_type'
-# require 'cmis_server/type_registry'
-
-
-require 'cmis_server/object_adapter'
-require 'cmis_server/item_adapter'
-require 'cmis_server/base_objects/base_type'
-require 'cmis_server/base_objects/document'
-require 'cmis_server/base_objects/folder'
-require 'cmis_server/base_objects/item'
-
-require 'cmis_server/atom_pub/entry_parser'
-
-require 'cmis_server/context'
-
-require 'cmis_server/query'
-require 'cmis_server/renderable_object'
-require 'cmis_server/renderable_collection'

data/lib/cmis_server/engine_diagnostics.rb

@@ -0,0 +1,56 @@
+module CmisServer
+  # Engine diagnostics utilities for testing and troubleshooting
+  class EngineDiagnostics
+    class << self
+      # Check if engine routes are properly loaded
+      def routes_loaded?
+        CmisServer::Engine.routes.routes.any?
+      end
+      
+      # Force reload engine routes
+      def reload_engine_routes!
+        routes_file = File.expand_path('../../../config/routes.rb', __FILE__)
+        if File.exist?(routes_file)
+          CmisServer::Engine.routes.clear!
+          load routes_file
+          true
+        else
+          false
+        end
+      end
+      
+      # Get detailed diagnostics information
+      def diagnostic_info
+        {
+          engine_routes_count: CmisServer::Engine.routes.routes.size,
+          engine_routes_loaded: routes_loaded?,
+          engine_controllers: engine_controllers,
+          rails_version: Rails::VERSION::STRING,
+          zeitwerk_enabled: defined?(Zeitwerk) && Rails.autoloaders.main.is_a?(Zeitwerk::Loader),
+          frozen_arrays: check_frozen_arrays
+        }
+      end
+      
+      private
+      
+      # Get list of engine controllers
+      def engine_controllers
+        Dir.glob(File.expand_path('../../../app/controllers/cmis_server/**/*.rb', __FILE__)).map do |file|
+          file.split('/').last.gsub('.rb', '')
+        end
+      end
+      
+      # Check if Rails is using frozen arrays
+      def check_frozen_arrays
+        return false unless defined?(Rails)
+        
+        begin
+          app = Rails::Application.new
+          app.config.autoload_paths.frozen?
+        rescue => e
+          e.message.include?('frozen')
+        end
+      end
+    end
+  end
+end

data/lib/cmis_server/folder_object.rb

@@ -3,7 +3,7 @@ module CmisServer
 
     def self.root_folder
       unless @root
-        @root=new(CmisServer.configuration.arguments_for_root_folder)
+        @root=new(**CmisServer.configuration.arguments_for_root_folder)
         @root.define_singleton_method :is_root?,(lambda { true })
       end
       @root
@@ -11,8 +11,19 @@ module CmisServer
 
     def initialize(type:, properties: {})
       raise InvalidType unless type.base_id == 'cmis:folder'
+      # Initialiser les attributs avant d'appeler super
+      @cmis_object_id = nil
+      @cmis_name = nil
+      @cmis_description = nil
+      @cmis_last_modification_date = nil
+      @cmis_creation_date = nil
+      @cmis_created_by = nil
       super
     end
 
+    # Ajouter les setters pour les propriétés CMIS
+    attr_accessor :cmis_object_id, :cmis_name, :cmis_description, 
+                  :cmis_last_modification_date, :cmis_creation_date, :cmis_created_by
+
   end
 end

data/lib/cmis_server/inflections.rb

@@ -0,0 +1,13 @@
+# CMIS Server inflections configuration
+# This file configures Rails inflections to handle the CMIS acronym correctly
+
+# Configure inflections to prevent CMIS -> CMIS transformation
+if defined?(ActiveSupport)
+  ActiveSupport::Inflector.inflections(:en) do |inflect|
+    # We explicitly do NOT want to add 'CMIS' as an acronym
+    # because that would make Rails look for CMISServer instead of CmisServer
+    
+    # Ensure proper handling of our module names
+    inflect.irregular 'cmis_server', 'cmis_servers'
+  end
+end

data/lib/cmis_server/repository.rb

@@ -1,12 +1,12 @@
 module CmisServer
   class Repository
 
-    class Capabitilies
+    class Capabilities
 
       attr_reader :acl, :all_versions_searchable, :changes, :content_stream_updatability, :get_descendants, :get_folder_tree, :multifiling, :pwc_searchable, :pwc_updatable, :query, :renditions, :unfiling, :version_specific_filing, :join, :secondary_types
       
       # CMIS 1.1 capabilities
-      attr_reader :create_type, :bulk_update, :append_content_stream, :update_type, :delete_type
+      attr_reader :create_type, :bulk_update, :append_content_stream, :update_type, :delete_type, :bulk_delete_properties, :bulk_move, :extended_query, :extended_acl
 
       def initialize(attrs={})
         @acl                        = attrs.fetch(:acl, :none)
@@ -31,19 +31,81 @@ module CmisServer
         @append_content_stream     = attrs.fetch(:append_content_stream, false)
         @update_type               = attrs.fetch(:update_type, false)
         @delete_type               = attrs.fetch(:delete_type, false)
+        @bulk_delete_properties    = attrs.fetch(:bulk_delete_properties, false)
+        @bulk_move                 = attrs.fetch(:bulk_move, false)
+        @extended_query            = attrs.fetch(:extended_query, false)
+        @extended_acl              = attrs.fetch(:extended_acl, false)
       end
 
       def [](attr)
         self.send(attr)
       end
+      
+      def to_h
+        {
+          acl: @acl,
+          all_versions_searchable: @all_versions_searchable,
+          changes: @changes,
+          content_stream_updatability: @content_stream_updatability,
+          get_descendants: @get_descendants,
+          get_folder_tree: @get_folder_tree,
+          multifiling: @multifiling,
+          pwc_searchable: @pwc_searchable,
+          pwc_updatable: @pwc_updatable,
+          query: @query,
+          renditions: @renditions,
+          unfiling: @unfiling,
+          version_specific_filing: @version_specific_filing,
+          join: @join,
+          secondary_types: @secondary_types,
+          create_type: @create_type,
+          bulk_update: @bulk_update,
+          append_content_stream: @append_content_stream,
+          update_type: @update_type,
+          delete_type: @delete_type,
+          bulk_delete_properties: @bulk_delete_properties,
+          bulk_move: @bulk_move,
+          extended_query: @extended_query,
+          extended_acl: @extended_acl
+        }
+      end
     end
 
 
-    attr_accessor :id, :name, :description, :vendor_name, :product_name, :product_version, :root_folder_id, :capabilities, :latest_change_log_token, :cmis_version_supported, :capabilities
+    attr_accessor :id, :name, :description, :vendor_name, :product_name, :product_version, :root_folder_id, :capabilities, :latest_change_log_token, :cmis_version_supported
 
     alias_method :repository_id, :id
     alias_method :repository_name, :name
     alias_method :repository_description, :description
+    
+    # Méthodes pour les informations supplémentaires du repository
+    def extensions
+      {
+        extended_features: ["bulk_operations", "secondary_types", "type_management"],
+        vendor_extensions: {},
+        namespace: "http://docs.oasis-open.org/ns/cmis/core/200908/"
+      }
+    end
+    
+    def acl_capabilities
+      {
+        supported_permissions: ["cmis:read", "cmis:write", "cmis:all"],
+        propagation: "repositorydetermined",
+        permissions: [
+          { permission: "cmis:read", description: "Read permission" },
+          { permission: "cmis:write", description: "Write permission" },
+          { permission: "cmis:all", description: "All permissions" }
+        ]
+      }
+    end
+    
+    def repository_specific_information
+      {
+        implementation: "CmisServer Ruby Gem",
+        version: CmisServer::VERSION,
+        core_integration: true
+      }
+    end
 
 
     def initialize(attrs={})
@@ -64,13 +126,17 @@ module CmisServer
                     root_folder_id:          CmisServer::FolderObject.root_folder.cmis_object_id,
                     latest_change_log_token: 0,
                     cmis_version_supported:  CmisServer::CMIS_VERSION_SUPPORTED,
-                    capabilities:            Capabitilies.new(
+                    capabilities:            Capabilities.new(
                       # Activer les capacités CMIS 1.1 par défaut
                       create_type: true,
                       bulk_update: true,
                       append_content_stream: true,
                       update_type: true,
-                      delete_type: true
+                      delete_type: true,
+                      bulk_delete_properties: true,
+                      bulk_move: true,
+                      extended_query: true,
+                      extended_acl: false
                     )
       )
       repo
@@ -86,6 +152,51 @@ module CmisServer
       # Cette méthode devrait retourner l'objet CMIS correspondant à l'ID ou nil
       nil
     end
+    
+    # Extensions du repository (CMIS 1.1)
+    def extensions
+      {
+        extended_features: ['bulk_operations', 'secondary_types', 'type_management'],
+        vendor_extensions: {},
+        namespace: 'http://docs.oasis-open.org/ns/cmis/core/200908/'
+      }
+    end
+    
+    # Types disponibles dans le repository
+    def types
+      CmisServer::TypeRegistry.types || {}
+    end
+    
+    # ACL Capabilities
+    def acl_capabilities
+      {
+        supported_permissions: ['cmis:read', 'cmis:write', 'cmis:all'],
+        acl_propagation: 'repositorydetermined',
+        permissions: [
+          {
+            permission: 'cmis:read',
+            description: 'Read permission for objects'
+          },
+          {
+            permission: 'cmis:write', 
+            description: 'Write permission for objects'
+          },
+          {
+            permission: 'cmis:all',
+            description: 'All permissions for objects'
+          }
+        ]
+      }
+    end
+    
+    # Repository specific information
+    def repository_specific_information
+      {
+        implementation: 'CmisServer Ruby Gem',
+        version: CmisServer::VERSION,
+        features: ['atom_pub', 'browser_binding', 'rest_api']
+      }
+    end
 
   end
 end

data/lib/cmis_server/type.rb

@@ -35,7 +35,7 @@ module CmisServer
       @fulltext_indexed            = attrs.fetch(:fulltext_indexed, false)
       @included_in_supertype_query = attrs.fetch(:included_in_supertype_query, false)
 
-      @self_property_definitions = attrs.fetch(:property_definitions, [])
+      @self_property_definitions = attrs.fetch(:property_definitions, []).dup
     end
 
     def parent_id

data/lib/cmis_server/version.rb

@@ -1,4 +1,4 @@
 module CmisServer
-  VERSION = "1.0.3"
+  VERSION = "1.2.1"
   CMIS_VERSION_SUPPORTED = '1.1'
 end

data/lib/cmis_server/zeitwerk_configuration.rb

@@ -0,0 +1,39 @@
+module CmisServer
+  # Configuration for Zeitwerk autoloading
+  # This ensures proper class loading in Rails 7+
+  class ZeitwerkConfiguration
+    def self.setup
+      # Get main paths
+      lib_path = File.expand_path('../../', __FILE__)
+      app_path = File.expand_path('../../../app', __FILE__)
+      
+      # Setup for Rails 6+ with Zeitwerk
+      if defined?(Rails) && Rails.respond_to?(:autoloaders) && Rails.autoloaders.respond_to?(:main)
+        Rails.autoloaders.main.push_dir(lib_path, namespace: CmisServer)
+        
+        # Add controller directories with proper namespacing
+        controllers_path = File.join(app_path, 'controllers', 'cmis_server')
+        Rails.autoloaders.main.push_dir(controllers_path, namespace: CmisServer) if Dir.exist?(controllers_path)
+        
+        # Explicitly handle nested controllers
+        atom_pub_path = File.join(controllers_path, 'atom_pub')
+        if Dir.exist?(atom_pub_path)
+          Rails.autoloaders.main.push_dir(atom_pub_path, namespace: CmisServer::AtomPub)
+        end
+        
+        # Add models, views and services
+        %w[models views services].each do |dir|
+          path = File.join(app_path, dir, 'cmis_server')
+          Rails.autoloaders.main.push_dir(path, namespace: CmisServer) if Dir.exist?(path)
+        end
+        
+        Rails.logger&.info "CMIS: Zeitwerk autoloading configured"
+      end
+    end
+  end
+end
+
+# Setup Zeitwerk when this file is loaded
+if defined?(Rails) && Rails.application && !Rails.application.config.eager_load
+  CmisServer::ZeitwerkConfiguration.setup
+end

data/lib/cmis_server.rb

@@ -1,7 +1,16 @@
+# Load inflections first to prevent autoloading issues
+require "cmis_server/inflections"
+require "cmis_server/version"
+require "cmis_server/configuration"
+require "cmis_server/exceptions"
+require "cmis_server/zeitwerk_configuration" if File.exist?(File.expand_path("cmis_server/zeitwerk_configuration.rb", __dir__))
 require "cmis_server/engine"
+require "cmis_server/engine_diagnostics"
+require "cmis_server/connectors/base_connector"
+require "cmis_server/connectors/core_connector" 
+require "cmis_server/connectors/connector_factory"
 
 module CmisServer
-
   class << self
     attr_writer :configuration
   end
@@ -17,6 +26,261 @@ module CmisServer
   def self.configure
     yield(configuration)
   end
+  
+  # Method to properly mount CmisServer in a Rails application
+  # Usage in host app: CmisServer.mount_engine(Rails.application, "/path", mount_name: 'custom_name')
+  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
+
+  # Méthode de diagnostic pour vérifier l'état du moteur CMIS
+  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
+
+  # Méthode pour forcer le chargement et diagnostic des routes du moteur
+  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
+
+  # Méthode pour afficher le diagnostic des routes du moteur
+  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
 
 
 end
+  # Méthode pour initialiser les propriétés custom de façon sécurisée  
+  def self.add_custom_properties
+    return unless defined?(DocumentType) && defined?(PropertyDefinition)
+    
+    Rails.logger&.info "[CMIS] Ajout des propriétés de document"
+    
+    # Propriété metadata pour les documents
+    DocumentType.base.self_property_definitions.push(
+      PropertyDefinition.register_property_definition({
+        id: 'plugandwork:metadata'.freeze,
+        type: String,
+        required: false,
+        cardinality: :single,
+        updatability: :readwrite,
+        description: 'Document metadata serialized as XML'
+      })
+    )
+    
+    Rails.logger&.info "[CMIS] Propriétés ajoutées"
+    true
+  rescue => e
+    Rails.logger&.error "[CMIS] Erreur ajout propriétés: #{e.message}"
+    false
+  end