cmis_server 1.2.1 → 1.3.0

data/lib/cmis_server/folder_adapter.rb

@@ -0,0 +1,126 @@
+module CmisServer
+  class FolderAdapter
+    attr_reader :object, :context
+    
+    def initialize(object, context:)
+      @object = object
+      @context = context
+    end
+    
+    def self.class_adapter(context:)
+      new(nil, context: context)
+    end
+    
+    def find(id)
+      if id == 'root_folder' || id == 'root_folder_id' || id == 'core_root' || id == 'root'
+        # Utiliser le connector pour récupérer l'objet root virtuel
+        connector = CmisServer::Connectors::ConnectorFactory.create_connector(
+          user: @context.is_a?(Hash) ? @context[:current_user] : @context.current_user
+        )
+        root_object = connector.find_object_by_id(id)
+        
+        if root_object && root_object.respond_to?(:is_virtual) && root_object.is_virtual
+          # Convertir l'objet virtuel en FolderObject CMIS
+          folder_obj = virtual_folder_to_folder_object(root_object)
+        else
+          # Fallback : utiliser le root folder par défaut
+          folder_obj = CmisServer::FolderObject.root_folder
+        end
+        self.class.new(folder_obj, context: @context)
+      else
+        # Chercher un Tagset dans Core
+        tagset = ::Tagset.find(id)
+        # Convertir le Tagset en FolderObject CMIS
+        folder_obj = tagset_to_folder_object(tagset)
+        self.class.new(folder_obj, context: @context)
+      end
+    end
+    
+    def save!
+      # Créer un espace Core (Tagset)
+      tagset = ::Tagset.new
+      
+      # Mapper les propriétés CMIS vers Core
+      if @object && @object.properties
+        # Extraire la valeur si c'est un objet Property
+        name_value = @object.properties['cmis:name']
+        name_value = name_value.value if name_value.respond_to?(:value)
+        tagset.title = name_value || 'Untitled Folder'
+      end
+      
+      # Définir le responsable (obligatoire)
+      current_user = @context.is_a?(Hash) ? @context[:current_user] : @context.current_user
+      if current_user
+        tagset.responsible = current_user.id.to_s
+      end
+      
+      # Gérer la hiérarchie si un parent est spécifié
+      if @object && @object.properties && @object.properties['cmis:parentId']
+        parent_value = @object.properties['cmis:parentId']
+        parent_value = parent_value.value if parent_value.respond_to?(:value)
+        if parent_value && parent_value != 'root_folder'
+          tagset.parent_ids = [parent_value.to_s]
+        end
+      end
+      
+      # Sauvegarder l'espace
+      if tagset.save
+        # Mettre à jour l'objet CMIS avec l'ID du tagset créé
+        @object.cmis_object_id = tagset.id.to_s if @object
+        true
+      else
+        raise "Failed to save folder: #{tagset.errors.full_messages.join(', ')}"
+      end
+    end
+    
+    def cmis_object_id
+      @object.respond_to?(:cmis_object_id) ? @object.cmis_object_id : @object.id
+    end
+    
+    def to_renderable_object
+      CmisServer::RenderableObject.new(base_object: @object)
+    end
+    
+    private
+    
+    def tagset_to_folder_object(tagset)
+      # Créer un FolderObject à partir d'un Tagset Core
+      folder_type = CmisServer::TypeRegistry.get_type('cmis:folder')
+      properties = {
+        'cmis:objectId' => CmisServer::Property.new(id: 'cmis:objectId', value: tagset.id.to_s),
+        'cmis:objectTypeId' => CmisServer::Property.new(id: 'cmis:objectTypeId', value: 'cmis:folder'),
+        'cmis:name' => CmisServer::Property.new(id: 'cmis:name', value: tagset.title),
+        'cmis:createdBy' => CmisServer::Property.new(id: 'cmis:createdBy', value: tagset.responsible),
+        'cmis:parentId' => CmisServer::Property.new(id: 'cmis:parentId', value: tagset.parent_ids&.first || 'root_folder')
+      }
+      
+      folder = CmisServer::FolderObject.new(type: folder_type, properties: properties)
+      folder.cmis_object_id = tagset.id.to_s
+      folder.cmis_name = tagset.title
+      folder
+    end
+    
+    def virtual_folder_to_folder_object(virtual_obj)
+      # Créer un FolderObject à partir d'un objet virtuel (comme le root)
+      folder_type = CmisServer::TypeRegistry.get_type('cmis:folder') || CmisServer::FolderType.base
+      properties = {
+        'cmis:objectId' => CmisServer::Property.new(id: 'cmis:objectId', value: virtual_obj.id.to_s),
+        'cmis:objectTypeId' => CmisServer::Property.new(id: 'cmis:objectTypeId', value: 'cmis:folder'),
+        'cmis:name' => CmisServer::Property.new(id: 'cmis:name', value: virtual_obj.title),
+        'cmis:description' => CmisServer::Property.new(id: 'cmis:description', value: virtual_obj.description),
+        'cmis:createdBy' => CmisServer::Property.new(id: 'cmis:createdBy', value: virtual_obj.responsible),
+        'cmis:creationDate' => CmisServer::Property.new(id: 'cmis:creationDate', value: virtual_obj.created_at),
+        'cmis:lastModificationDate' => CmisServer::Property.new(id: 'cmis:lastModificationDate', value: virtual_obj.updated_at)
+      }
+      
+      folder = CmisServer::FolderObject.new(type: folder_type, properties: properties)
+      folder.cmis_object_id = virtual_obj.id.to_s
+      folder.cmis_name = virtual_obj.title
+      folder.cmis_description = virtual_obj.description
+      folder.cmis_created_by = virtual_obj.responsible
+      folder.cmis_creation_date = virtual_obj.created_at
+      folder.cmis_last_modification_date = virtual_obj.updated_at
+      folder
+    end
+  end
+end

data/lib/cmis_server/property.rb

@@ -1,3 +1,6 @@
+require 'ostruct'
+require 'active_support/core_ext/string/inflections'
+
 module CmisServer
   class Property
 
@@ -12,7 +15,11 @@ module CmisServer
     end
 
     def value
-      self.property_definition.value ? self.property_definition.value_for(@object) : @value
+      if self.property_definition.respond_to?(:value) && self.property_definition.value
+        self.property_definition.value_for(@object)
+      else
+        @value
+      end
     end
 
     def set_default
@@ -20,9 +27,38 @@ module CmisServer
     end
 
     def initialize(property_definition, value=nil, object=nil)
-      @object             =object
-      @property_definition=property_definition
-      @value              =value
+      # Support des deux formes d'arguments
+      if property_definition.is_a?(Hash) && property_definition[:id]
+        # Forme avec arguments nommés : Property.new(id: 'cmis:name', value: 'foo')
+        # Déterminer le type en fonction de la valeur
+        type_class = case property_definition[:value]
+        when String then String
+        when Integer then Integer
+        when Float then Float
+        when Time, DateTime then DateTime
+        when TrueClass, FalseClass then OpenStruct.new(name: 'Boolean')
+        else String
+        end
+        
+        # Créer un type object si ce n'est pas déjà un OpenStruct
+        type = type_class.is_a?(OpenStruct) ? type_class : OpenStruct.new(name: type_class.name)
+        
+        @property_definition = OpenStruct.new(
+          id: property_definition[:id],
+          type: type,
+          query_name: property_definition[:id],
+          display_name: property_definition[:id].split(':').last.humanize,
+          local_name: property_definition[:id].split(':').last,
+          value: nil  # Les PropertyDefinition n'ont pas de value fixe
+        )
+        @value = property_definition[:value]
+        @object = property_definition[:object]
+      else
+        # Forme classique : Property.new(property_def, value, object)
+        @object             =object
+        @property_definition=property_definition
+        @value              =value
+      end
     end
 
   end

data/lib/cmis_server/query/parser.rb

@@ -0,0 +1,11 @@
+module CmisServer
+  module Query
+    class Parser
+      def self.parse(sql)
+        # Utiliser le SimpleParser au lieu du ParserRacc qui ne fonctionne pas
+        result = SimpleParser.parse(sql)
+        result
+      end
+    end
+  end
+end

data/lib/cmis_server/query/{parser.racc.rb → parser_racc.rb}

@@ -6,11 +6,11 @@
 
 require 'racc/parser.rb'
 
-require File.dirname(__FILE__) + '/parser.rex.rb'
+require File.dirname(__FILE__) + '/parser_rex'
 
 module CmisServer
   module Query
-    class Parser < Racc::Parser
+    class ParserRacc < Racc::Parser
 
 module_eval(<<'...end parser.racc/module_eval...', 'parser.racc', 219)
 

data/lib/cmis_server/query/{parser.rex.rb → parser_rex.rb}

@@ -5,7 +5,10 @@
 #++
 
 require 'racc/parser'
-class CmisServer::Query::Parser < Racc::Parser
+
+module CmisServer
+  module Query
+    class ParserRex < Racc::Parser
   require 'strscan'
 
   class ScanError < StandardError ; end
@@ -236,3 +239,5 @@ class CmisServer::Query::Parser < Racc::Parser
   end  # def _next_token
 
 end # class
+    end
+  end

data/lib/cmis_server/query/simple_parser.rb

@@ -0,0 +1,276 @@
+module CmisServer
+  module Query
+    # Simple CMIS SQL parser for basic queries
+    class SimpleParser
+      class ParseError < StandardError; end
+      
+      # Parse a CMIS SQL statement
+      def self.parse(sql)
+        result = new(sql).parse
+        result
+      end
+      
+      def initialize(sql)
+        @sql = sql.strip
+        @tokens = tokenize(@sql)
+        @position = 0
+      end
+      
+      def parse
+        statement = ParsedStatement.new
+        
+        # Parse SELECT clause
+        expect_keyword('SELECT')
+        statement.select_list = parse_select_list
+        
+        # Parse FROM clause
+        expect_keyword('FROM')
+        statement.from_clause = parse_from_clause
+        
+        # Parse optional WHERE clause
+        if current_token_is?('WHERE')
+          consume_token
+          statement.where_clause = parse_where_clause
+        end
+        
+        # Parse optional ORDER BY clause
+        if current_token_is?('ORDER')
+          consume_token
+          expect_keyword('BY')
+          statement.order_by = parse_order_by
+        end
+        
+        statement
+      end
+      
+      private
+      
+      def tokenize(sql)
+        # Simple tokenizer - splits on whitespace and special characters
+        # Include : in word characters to handle cmis:document style identifiers
+        sql.scan(/[\w:]+\.[\w:]+|[\w:]+|'[^']*'|"[^"]*"|>=|<=|<>|!=|[<>=(),*]/)
+      end
+      
+      def current_token
+        @tokens[@position]
+      end
+      
+      def consume_token
+        token = @tokens[@position]
+        @position += 1
+        token
+      end
+      
+      def current_token_is?(expected)
+        current_token&.upcase == expected.upcase
+      end
+      
+      def expect_keyword(keyword)
+        unless current_token_is?(keyword)
+          raise ParseError, "Expected #{keyword} but got #{current_token}"
+        end
+        consume_token
+      end
+      
+      def parse_select_list
+        select_list = []
+        
+        if current_token == '*'
+          consume_token
+          select_list << SelectItem.new('*')
+        else
+          loop do
+            # Parse property name (may include alias like d.cmis:name)
+            property = consume_token
+            if current_token == '.'
+              consume_token
+              property += ".#{consume_token}"
+            end
+            
+            select_list << SelectItem.new(property)
+            
+            break unless current_token == ','
+            consume_token # consume comma
+          end
+        end
+        
+        select_list
+      end
+      
+      def parse_from_clause
+        # Parse table name
+        table_name = consume_token
+        from_clause = FromClause.new(table_name)
+        
+        # Parse optional alias
+        if current_token && !%w[WHERE ORDER].include?(current_token.upcase)
+          from_clause.alias = consume_token
+        end
+        
+        from_clause
+      end
+      
+      def parse_where_clause
+        # Simple WHERE clause parser
+        # For now, just parse simple conditions like "cmis:name = 'test'"
+        conditions = []
+        
+        loop do
+          left = parse_expression
+          operator = consume_token
+          right = parse_expression
+          
+          conditions << WhereCondition.new(left, operator, right)
+          
+          # Check for AND/OR
+          if current_token_is?('AND') || current_token_is?('OR')
+            connector = consume_token
+            conditions << connector
+          else
+            break
+          end
+        end
+        
+        WhereClause.new(conditions)
+      end
+      
+      def parse_expression
+        expr = consume_token
+        
+        # Handle property with alias (e.g., d.cmis:name)
+        if current_token == '.'
+          consume_token
+          expr += ".#{consume_token}"
+        end
+        
+        # Remove quotes from string literals
+        if expr =~ /^['"](.*)['"]$/
+          expr = $1
+        end
+        
+        expr
+      end
+      
+      def parse_order_by
+        order_items = []
+        
+        loop do
+          property = consume_token
+          if current_token == '.'
+            consume_token
+            property += ".#{consume_token}"
+          end
+          
+          direction = 'ASC'
+          if current_token_is?('ASC') || current_token_is?('DESC')
+            direction = consume_token.upcase
+          end
+          
+          order_items << OrderByItem.new(property, direction)
+          
+          break unless current_token == ','
+          consume_token
+        end
+        
+        order_items
+      end
+    end
+    
+    # Data structures for parsed statement
+    class ParsedStatement
+      attr_accessor :select_list, :from_clause, :where_clause, :order_by
+      
+      def initialize
+        @select_list = []
+        @from_clause = nil
+        @where_clause = nil
+        @order_by = []
+      end
+      
+      # Convert to format expected by existing code
+      def query_expression
+        OpenStruct.new(
+          from: OpenStruct.new(
+            tables: [@from_clause].map { |fc| 
+              OpenStruct.new(
+                name: fc.table_name,
+                is_a?: ->(klass) { klass == CmisServer::Query::Statement::Table }
+              )
+            }
+          ),
+          where: @where_clause
+        )
+      end
+    end
+    
+    class SelectItem
+      attr_accessor :property
+      
+      def initialize(property)
+        @property = property
+      end
+    end
+    
+    class FromClause
+      attr_accessor :table_name, :alias
+      
+      def initialize(table_name)
+        @table_name = table_name
+        @alias = nil
+      end
+    end
+    
+    class WhereClause
+      attr_accessor :conditions
+      
+      def initialize(conditions)
+        @conditions = conditions
+      end
+      
+      # Convert to hash format for the connector
+      def to_h
+        # For now, convert simple conditions to a hash
+        result = {}
+        
+        @conditions.each do |cond|
+          next unless cond.is_a?(WhereCondition)
+          
+          # Map CMIS properties to search parameters
+          property = cond.left.sub(/^\w+\./, '') # Remove alias if present
+          
+          case property
+          when 'cmis:name'
+            result['name'] = cond.right
+          when 'cmis:objectTypeId'
+            result['type_id'] = cond.right
+          when 'cmis:parentId'
+            result['parent_id'] = cond.right
+          else
+            result[property] = cond.right
+          end
+        end
+        
+        result
+      end
+    end
+    
+    class WhereCondition
+      attr_accessor :left, :operator, :right
+      
+      def initialize(left, operator, right)
+        @left = left
+        @operator = operator
+        @right = right
+      end
+    end
+    
+    class OrderByItem
+      attr_accessor :property, :direction
+      
+      def initialize(property, direction)
+        @property = property
+        @direction = direction
+      end
+    end
+  end
+end