cmis_server 1.0.3

data/lib/cmis_server/query/statement.rb

@@ -0,0 +1,395 @@
+module CmisServer
+
+  module Query
+
+    module Statement
+
+      class Node
+
+        # def accept(visitor)
+        #   klass = self.class.ancestors.find do |ancestor|
+        #     visitor.respond_to?("visit_#{demodulize(ancestor.name)}")
+        #   end
+        #
+        #   if klass
+        #     visitor.__send__("visit_#{demodulize(klass.name)}", self)
+        #   else
+        #     raise "No visitor for #{self.class.name}"
+        #   end
+        # end
+        #
+        # def to_sql
+        #   SQLVisitor.new.visit(self)
+        # end
+
+        private
+
+        def demodulize(str)
+          str.split('::')[-1]
+        end
+
+      end
+
+      class CmisQuery < Node
+        def initialize(query_expression, order_by)
+          @query_expression = query_expression
+          @order_by = order_by
+        end
+
+        attr_reader :query_expression
+        attr_reader :order_by
+      end
+
+      class Select < Node
+        def initialize(select_list,from,where)
+          @select_list=select_list
+          @from=from
+          @where=where
+        end
+        attr_reader :select_list, :from, :where
+      end
+
+      class All < Node
+
+        def initialize(table=nil)
+          @column=table
+        end
+
+        attr_reader :table
+      end
+
+      class SelectList < Node
+
+        def initialize(columns)
+          @columns = Array(columns)
+        end
+
+        attr_reader :columns
+
+      end
+
+      class As < Node
+
+        def initialize(value, column)
+          @value = value
+          @column = column
+        end
+
+        attr_reader :value
+        attr_reader :column
+
+      end
+
+      class QualifiedColumn < Node
+
+        def initialize(column, table, secondary_table=nil)
+          @table = table
+          @column = column
+        end
+
+        attr_reader :table
+        attr_reader :column
+
+      end
+
+      class FromClause < Node
+
+        def initialize(tables)
+          @tables = Array(tables)
+        end
+
+        attr_reader :tables
+
+      end
+
+      class WhereClause < Node
+
+        def initialize(search_condition)
+          @search_condition = search_condition
+        end
+
+        attr_reader :search_condition
+
+        def to_h
+          search_condition.to_h
+        end
+
+      end
+
+      class OrderBy < Node
+
+        def initialize(sort_specification)
+          @sort_specification = Array(sort_specification)
+        end
+
+        attr_reader :sort_specification
+
+      end
+
+      class JoinedTable < Node
+
+        def initialize(left, right)
+          @left = left
+          @right = right
+        end
+
+        attr_reader :left
+        attr_reader :right
+
+      end
+
+      class QualifiedJoin < JoinedTable
+
+        def initialize(left, right, search_condition)
+          super(left, right)
+          @search_condition = search_condition
+        end
+
+        attr_reader :search_condition
+
+      end
+
+      class InnerJoin < QualifiedJoin
+      end
+
+      class LeftJoin < QualifiedJoin
+      end
+
+      class LeftOuterJoin < QualifiedJoin
+      end
+
+      class ComparisonPredicate < Node
+
+        def initialize(left, right)
+          @left = left
+          @right = right
+        end
+
+        attr_reader :left
+        attr_reader :right
+
+      end
+
+      class Is < ComparisonPredicate
+      end
+
+      class Like < ComparisonPredicate
+      end
+
+      class In < ComparisonPredicate
+      end
+
+      class QuantifiedIn < ComparisonPredicate
+      end
+
+      class InValueList < Node
+
+        def initialize(values)
+          @values = values
+        end
+
+        attr_reader :values
+
+      end
+
+      class FolderPredicate
+
+        def initialize(folder_id, qualifier=nil)
+          @folder_id = folder_id
+          @qualifier = qualifier
+        end
+
+        attr_reader :folder_id
+        attr_reader :qualifier
+
+      end
+
+      class InFolder < FolderPredicate
+      end
+
+      class InTree < FolderPredicate
+      end
+
+      class InColumnList < Node
+
+        def initialize(columns)
+          @columns = columns
+        end
+
+        attr_reader :columns
+
+      end
+
+      class Between < Node
+
+        def initialize(left, min, max)
+          @left = left
+          @min = min
+          @max = max
+        end
+
+        attr_reader :left
+        attr_reader :min
+        attr_reader :max
+
+      end
+
+      class SearchCondition < Node
+
+        def initialize(left, right)
+          @left = left
+          @right = right
+        end
+
+        attr_reader :left
+        attr_reader :right
+
+      end
+
+      class Or < SearchCondition
+      end
+
+      class And < SearchCondition
+
+        def to_h
+          self.left.to_h.merge(self.right.to_h)
+        end
+
+      end
+
+
+      class GreaterOrEquals < ComparisonPredicate
+      end
+
+      class LessOrEquals < ComparisonPredicate
+      end
+
+      class Greater < ComparisonPredicate
+      end
+
+      class Less < ComparisonPredicate
+      end
+
+      class Equals < ComparisonPredicate
+        def to_h
+          {self.left.to_cmis_where_key => self.right.value}
+        end
+
+      end
+
+      class QuantifiedComparison < ComparisonPredicate
+      end
+
+      class Identifier < Node
+
+        def initialize(name)
+          @name = name
+        end
+
+        def to_cmis_where_key
+          CmisServer::Id.new(self.name).to_method_name.to_sym
+        end
+
+        attr_reader :name
+        alias_method :value, :name
+
+      end
+
+      class Table < Identifier
+      end
+
+      class Column < Identifier
+      end
+
+      class FolderId < Identifier
+      end
+
+
+      class Score < Node
+      end
+
+      class True < Node
+      end
+
+      class False < Node
+      end
+
+      class Null < Node
+      end
+
+      class Literal < Node
+
+        def initialize(value)
+          @value = value
+        end
+
+        attr_reader :value
+
+      end
+
+      class DateTime < Literal
+      end
+
+      class Date < Literal
+      end
+
+      class String < Literal
+      end
+
+      class ApproximateFloat < Node
+
+        def initialize(mantissa, exponent)
+          @mantissa = mantissa
+          @exponent = exponent
+        end
+
+        attr_reader :mantissa
+        attr_reader :exponent
+
+      end
+
+      class Float < Literal
+      end
+
+      class Integer < Literal
+      end
+
+      class Unary < Node
+
+        def initialize(value)
+          @value = value
+        end
+
+        attr_reader :value
+
+      end
+
+      class Not < Unary
+      end
+
+      class UnaryPlus < Unary
+      end
+
+      class UnaryMinus < Unary
+      end
+
+      class OrderSpecification < Node
+
+        def initialize(column)
+          @column = column
+        end
+
+        attr_reader :column
+
+      end
+
+      class Ascending < OrderSpecification
+      end
+
+      class Descending < OrderSpecification
+      end
+
+    end
+  end
+end
+

data/lib/cmis_server/query.rb

@@ -0,0 +1,2 @@
+require 'cmis_server/query/statement'
+require 'cmis_server/query/parser.racc'

data/lib/cmis_server/renderable_collection.rb

@@ -0,0 +1,45 @@
+require 'securerandom'
+
+module CmisServer
+  class RenderableCollection
+
+    attr_reader :base_object
+    attr_reader :items
+
+    def initialize(base_object:, items:, atompub_properties: nil)
+      @base_object=base_object
+      @items      =items
+      if atompub_properties
+        @atompub_properties={
+            id:      atompub_properties[:id]||SecureRandom.uuid,
+            title:   atompub_properties[:title]||'Collection',
+            edited:  atompub_properties[:edited]||DateTime.now,
+            updated: atompub_properties[:updated]||DateTime.now,
+            author:  atompub_properties[:author]||'Unknown',
+        }
+      end
+    end
+
+    def filter_properties!(filter)
+      @properties=@properties.slice(*filter)
+    end
+
+    def atompub_properties
+      return @atompub_properties if @atompub_properties
+      if @base_object
+        {
+            id:      @base_object.cmis_object_id,
+            title:   @base_object.cmis_name,
+            edited:  DateTime.now,
+            updated: DateTime.now,
+            author:  'unknown',
+        }
+      end
+    end
+
+    def total_items_count
+      nil
+    end
+
+  end
+end

data/lib/cmis_server/renderable_object.rb

@@ -0,0 +1,49 @@
+module CmisServer
+  class RenderableObject
+
+    attr_reader :base_object
+    attr_reader :properties
+
+    def initialize(base_object:, properties: nil, include_relationships: :none, include_policies: false, rendition_filter: "cmis:none", include_acl: false, include_allowable_actions: false)
+      @base_object=base_object
+      @properties =properties||@base_object.properties.values
+    end
+
+    def filter_properties!(filter)
+      @properties.slice!(*filter)
+    end
+
+    def atompub_entry_properties
+      {
+          id:      @base_object.cmis_object_id,
+          title:   @base_object.cmis_name,
+          summary: @base_object.cmis_description,
+          edited:  @base_object.cmis_creation_date,
+          updated: @base_object.cmis_last_modification_date,
+          author:  @base_object.cmis_created_by,
+          content: @base_object.try(:content_stream)
+      }
+    end
+
+    def policies
+      nil
+    end
+
+    def relastionships
+      nil
+    end
+
+    def renditions
+      nil
+    end
+
+    def acl
+      nil
+    end
+
+    def allowable_actions
+      nil
+    end
+
+  end
+end

data/lib/cmis_server/repository.rb

@@ -0,0 +1,91 @@
+module CmisServer
+  class Repository
+
+    class Capabitilies
+
+      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
+
+      def initialize(attrs={})
+        @acl                        = attrs.fetch(:acl, :none)
+        @all_versions_searchable    = attrs.fetch(:all_versions_searchable, :false)
+        @changes                    = attrs.fetch(:changes, :none)
+        @content_stream_updatability= attrs.fetch(:content_stream_updatability, :none)
+        @get_descendants            = attrs.fetch(:get_descendants, :false)
+        @get_folder_tree            = attrs.fetch(:get_folder_tree, :false)
+        @multifiling                = attrs.fetch(:multifiling, :false)
+        @pwc_searchable             = attrs.fetch(:pwc_searchable, :false)
+        @pwc_updatable              = attrs.fetch(:pwc_updatable, :false)
+        @query                      = attrs.fetch(:query, :metadataonly)
+        @renditions                 = attrs.fetch(:renditions, :none)
+        @unfiling                   = attrs.fetch(:unfiling, :true)
+        @version_specific_filing    = attrs.fetch(:version_specific_filing, :false)
+        @join                       = attrs.fetch(:join, :none)
+        @secondary_types            = attrs.fetch(:secondary_types, :true)
+        
+        # CMIS 1.1 capabilities
+        @create_type               = attrs.fetch(:create_type, false)
+        @bulk_update               = attrs.fetch(:bulk_update, false)
+        @append_content_stream     = attrs.fetch(:append_content_stream, false)
+        @update_type               = attrs.fetch(:update_type, false)
+        @delete_type               = attrs.fetch(:delete_type, false)
+      end
+
+      def [](attr)
+        self.send(attr)
+      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
+
+    alias_method :repository_id, :id
+    alias_method :repository_name, :name
+    alias_method :repository_description, :description
+
+
+    def initialize(attrs={})
+      attrs.to_h.each do |property, value|
+        self.send(property.to_s+"=", value)
+      end
+    end
+
+
+    def self.find(id)
+      #Todo this is a mockup
+      repo=self.new(id:                      id,
+                    name:                    "My Repo",
+                    description:             "This is my repo !",
+                    vendor_name:             "AGSI",
+                    product_name:            "Plugandwork",
+                    product_version:         "CmisServer Gem v#{CmisServer::VERSION}",
+                    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(
+                      # 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
+                    )
+      )
+      repo
+    end
+
+    def infos
+      [:repository_id, :repository_name, :repository_description, :vendor_name, :product_name, :product_version, :root_folder_id, :cmis_version_supported].map { |p| [p.to_s.camelize(:lower), self.send(p)] }.to_h
+    end
+    
+    # Méthode pour récupérer un objet CMIS par son ID
+    def get_object(object_id)
+      # À implémenter selon votre système de stockage
+      # Cette méthode devrait retourner l'objet CMIS correspondant à l'ID ou nil
+      nil
+    end
+
+  end
+end

data/lib/cmis_server/secondary_type.rb

@@ -0,0 +1,11 @@
+module CmisServer
+  class SecondaryType < Type
+    def base_id
+      'cmis:secondary'
+    end
+
+    def create
+      raise "Secondary types cannot be created directly"
+    end
+  end
+end

data/lib/cmis_server/type.rb

@@ -0,0 +1,62 @@
+module CmisServer
+  class Type
+
+    attr_accessor :id,
+                  :local_name,
+                  :local_namespace,
+                  :query_name,
+                  :display_name,
+                  :base_id,
+                  :parent_type,
+                  :description,
+                  :creatable,
+                  :fileable,
+                  :queryable,
+                  :controllable_policy,
+                  :controllable_acl,
+                  :fulltext_indexed,
+                  :included_in_supertype_query,
+                  :self_property_definitions
+
+
+    def initialize(attrs={})
+      @id                          = CmisServer::Id.new(attrs.fetch(:id).to_s)
+      @parent_type                 = attrs.fetch(:parent_type)
+      @local_name                  = attrs.fetch(:local_name, id)
+      @local_namespace             = attrs.fetch(:local_namespace, 'local')
+      @query_name                  = attrs.fetch(:query_name, id)
+      @display_name                = attrs.fetch(:display_name, id)
+      @description                 = attrs.fetch(:description, 'No description provided')
+      @creatable                   = attrs.fetch(:creatable, false)
+      @fileable                    = attrs.fetch(:fileable, false)
+      @queryable                   = attrs.fetch(:queryable, false)
+      @controllable_policy         = attrs.fetch(:controllable_policy, false)
+      @controllable_acl            = attrs.fetch(:controllable_acl, false)
+      @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, [])
+    end
+
+    def parent_id
+      self.parent_type&.id
+    end
+
+    def base_type
+      self.parent_type ? self.parent_type.base_type : self
+    end
+
+    def base_id
+      self.parent_type ? self.parent_type.base_id : self.id
+    end
+
+    def property_definitions
+      @self_property_definitions.to_a+parent_property_definitions
+    end
+
+    def parent_property_definitions
+      #Decorate parent property_definitions as inherited
+      self.parent_type&.property_definitions.to_a.map { |pd| InheritedDecorator.new(pd) }
+    end
+  end
+end