active_cmis2 0.3.8

data/lib/active_cmis/server.rb

@@ -0,0 +1,121 @@
+module ActiveCMIS
+  # This class is used to manage different CMIS servers.
+  class Server
+    include Internal::Caching
+    # @return [URI] The location of the server
+    attr_reader :endpoint
+    # @return [Logger] A default logger for derived repositories
+    attr_reader :logger
+    # @return [Hash] Options to be used by the HTTP objects
+    attr_reader :options
+
+    # @return [Server] Cached by endpoint and logger
+    def self.new(endpoint, logger = nil, authentication_info = nil, options = nil)
+      endpoint = case endpoint
+                 when URI; endpoint
+                 else URI(endpoint.to_s)
+                 end
+      server = super(endpoint, logger || ActiveCMIS.default_logger, authentication_info, options)
+      endpoints[endpoint.to_s][authentication_info][logger] ||= server
+    end
+
+    # @return [{(URI, Logger) => Server}] The cache of known Servers
+    def self.endpoints
+      @endpoints ||= Hash.new {|h, k| h[k] = Hash.new {|h2, k2| h2[k2] = {}}}
+    end
+
+    # @return [String]
+    def inspect
+      "Server #{@endpoint}"
+    end
+    # @return [String]
+    def to_s
+      "Server " + @endpoint.to_s + " : " + repositories.map {|h| h[:name] + "(#{h[:id]})"}.join(", ")
+    end
+
+    # A connection needs the URL to a CMIS REST endpoint.
+    #
+    # It's used to manage all communication with the CMIS Server
+    # @param endpoint [URI] The URL where the CMIS AtomPub REST endpoint can be found
+    # @param logger [Logger] The logger that will be used to log debug/info messages
+    # @param authentication_info [Array?] Optional authentication info to be used when retrieving the data from the AtomPub endpoint
+    def initialize(endpoint, logger, authentication_info = nil, options = nil)
+      @endpoint = endpoint
+      @logger = logger
+      @options = options || {}
+
+      method, *params = authentication_info
+      @authentication_info = authentication_info
+      if method
+        conn.authenticate(method, *params)
+      end
+    end
+
+    # This returns a new Server object using the specified authentication info
+    #
+    # @param (see ActiveCMIS::Internal::Connection#authenticate)
+    # @see Internal::Connection#authenticate
+    # @return [void]
+    def authenticate(*authentication_info)
+      self.class.new(endpoint, logger, authentication_info)
+    end
+
+    # Returns the _Repository identified by the ID
+    # Authentication will take place with the optional second paramater, if it
+    # is absent and there is server authentcation then the server authentication
+    # will be used
+    #
+    # Cached by the repository_id and, authentcation info. The cache can be reset
+    # by calling clear_repositories.
+    #
+    # @param [String] repository_id
+    # @param [Array] authentication_info
+    # @return [Repository]
+    def repository(repository_id, authentication_info = @authentication_info)
+      key = [repository_id, authentication_info]
+      cached_repositories[key] ||= uncached_repository(*key)
+    end
+
+    def uncached_repository(repository_id, authentication_info)
+      path = "/app:service/app:workspace[cra:repositoryInfo/c:repositoryId[child::text() = '#{repository_id}']]"
+      repository_data = repository_info.xpath(path, NS::COMBINED)
+      if repository_data.empty?
+        raise Error::ObjectNotFound.new("The repository #{repository_id} doesn't exist")
+      else
+        Repository.new(self, conn.dup, logger.dup, repository_data, authentication_info)
+      end
+    end
+    private :uncached_repository
+
+    # Reset cache of Repository objects
+    #
+    # @return [void]
+    def clear_repositories
+      @cached_repositories = {}
+    end
+
+
+    # Lists all the available repositories
+    #
+    # @return [<{:id, :name} => String>]
+    def repositories
+      repositories = repository_info.xpath("/app:service/app:workspace/cra:repositoryInfo", NS::COMBINED)
+      repositories.map {|ri| next {:id => ri.xpath("ns:repositoryId", "ns" => NS::CMIS_CORE).text,
+        :name => ri.xpath("ns:repositoryName", "ns" => NS::CMIS_CORE).text }}
+    end
+
+    private
+    def repository_info
+      @repository_info ||= conn.get_xml(endpoint)
+    end
+    cache :repository_info
+
+    def cached_repositories
+      @cached_repositories ||= {}
+    end
+
+    def conn
+      @conn ||= Internal::Connection.new(logger.dup, @options)
+    end
+  end
+end

data/lib/active_cmis/type.rb

@@ -0,0 +1,200 @@
+module ActiveCMIS
+  module Type
+    # @private
+    def self.create(param_conn, repository, klass_data)
+      parent_id = klass_data.xpath("cra:type/c:parentId/text()", NS::COMBINED)
+      superclass = if parent = parent_id.first
+                     repository.type_by_id(parent.to_s)
+                   else
+                     base_type_id = klass_data.xpath("cra:type/c:baseId", NS::COMBINED).text
+                     case base_type_id
+                     when "cmis:document"
+                       Document
+                     when "cmis:folder"
+                       Folder
+                     when "cmis:relationship"
+                       Relationship
+                     when "cmis:policy"
+                       Policy
+                     else
+                       raise ActiveCMIS::Error.new("Type #{klass_data.xpath("cra:type/c:id", NS::COMBINED).text} without supertype, and not actually a valid base_type (#{base_type_id.inspect})\n" + klass_data.to_s)
+                     end
+                   end
+
+      klass = ::Class.new(superclass) do
+        extend ActiveCMIS::Type::ClassMethods
+        include ActiveCMIS::Type::InstanceMethods
+
+        @repository = repository
+        @conn = param_conn
+        @data = klass_data
+        @self_link = klass_data.xpath("at:link[@rel = 'self']/@href", NS::COMBINED).text
+
+      end
+      klass
+    end
+
+    # Instance Methods on CMIS Types
+    module InstanceMethods
+      # Creates a new CMIS Object
+      # @overload initialize(attributes)
+      #   @param [Hash] attributes Attributes for a newly created object of the current type
+      #   @return [Object]
+      def initialize(rep = nil, data = nil, parameters = {})
+        case rep
+        when Hash
+          attributes = rep
+          rep = nil
+          data = nil # Force data and parameters to be empty in that case (NOTE: assert may be better?)
+          parameters = {}
+        when NilClass
+        else
+          if rep != self.class.repository
+            raise "Trying to create element in different repository than type"
+          end
+        end
+        super(rep || self.class.repository, data, parameters)
+        unless attributes.nil?
+          update(attributes)
+        end
+      end
+    end
+
+    # Class Methods on CMIS Types
+    #
+    # The following info is also available:
+    #  id, local_name, local_namespace, display_name, query_name, description, base_id, parent_id, creatable, fileable,
+    #  queryable, fulltext_indexed, controllable_policy, controllable_acl, versionable, content_stream_allowed
+    module ClassMethods
+      include Internal::Caching
+
+      cached_reader :id, :local_name, :local_namespace, :display_name, :query_name, :description, :base_id,
+        :parent_id, :creatable, :fileable, :queryable, :fulltext_indexed, :controllable_policy, :controllable_acl,
+        :versionable, :content_stream_allowed
+
+      # @param [Boolean] inherited (false) *Ignored*
+      # @return [{String => PropertyDefinition}] A list of propery definitions for all properties on the type
+      def attributes(inherited = false)
+        load_from_data unless defined?(@attributes)
+        if inherited && superclass.respond_to?(:attributes)
+          super.merge(@attributes)
+        else
+          @attributes
+        end
+      end
+
+      # @return [{String => PropertyDefinition}] A list of all required definitions (includes inherited attributes)
+      def required_attributes
+        attributes(true).reject {|key, value| !value.required}
+      end
+
+      # @return [<String>] A list of prefixes that can be used for adressing attributes (like cmis:)
+      def attribute_prefixes
+        @prefixes ||= attributes(true).keys.map do |key|
+          if key =~ /^([^:]+):/
+            $1
+          end
+        end.compact.uniq
+      end
+
+      # @return [void]
+      def reload
+        remove_instance_variable(:@attributes) if defined? @attributes
+        [:attributes] + __reload # Could also do if defined?(super) then super else __reload end, but we don't do anything but remove_instance_variable @attributes in superclasses anyway
+      end
+
+      # @return [String]
+      def inspect
+        "#<#{repository.key}::Class #{key}>"
+      end
+
+      # @return [String] The CMIS ID of the type
+      def key
+        @key ||= data.xpath("cra:type/c:id", NS::COMBINED).text
+      end
+
+      # @return [Collection<Class>] All direct subtypes (1 level deep)
+      def subtypes
+        types_feed = Internal::Utils.extract_links(data, 'down', 'application/atom+xml', 'type' => 'feed')
+        raise "No subtypes link for #{id}" if types_feed.empty?
+
+        Collection.new(repository, types_feed.first) do |entry|
+          id = entry.xpath("cra:type/c:id", NS::COMBINED).text
+          repository.type_by_id id
+        end
+      end
+      cache :subtypes
+
+      # @return [Array<Class>] All subtypes
+      def all_subtypes
+        subtypes.map do |t|
+          t.all_subtypes
+        end.flatten << self
+      end
+      cache :all_subtypes
+
+      private
+      # @private
+      attr_reader :self_link, :conn
+      def data
+        @data ||= conn.get_atom_entry(self_link)
+      end
+      cache :data
+
+      def load_from_data
+        @attributes = {}
+        data.xpath('cra:type', NS::COMBINED).children.each do |node|
+          next unless node.namespace
+          next unless node.namespace.href == NS::CMIS_CORE
+
+          case node.node_name
+          when "id"
+            @id = node.text
+          when "localName"
+            @local_name = node.text
+          when "localNamespace"
+            @local_namespace = node.text
+          when "displayName"
+            @display_name = node.text
+          when "queryName"
+            @query_name = node.text
+          when "description"
+            @description = node.text
+          when "baseId"
+            @base_id = node.text
+          when "parentId"
+            @parent_id = node.text
+          when "creatable"
+            @creatable = AtomicType::Boolean.xml_to_bool(node.text)
+          when "fileable"
+            @fileable = AtomicType::Boolean.xml_to_bool(node.text)
+          when "queryable"
+            @queryable = AtomicType::Boolean.xml_to_bool(node.text)
+          when "fulltextIndexed"
+            @fulltext_indexed = AtomicType::Boolean.xml_to_bool(node.text)
+          when "controllablePolicy"
+            @controllable_policy = AtomicType::Boolean.xml_to_bool(node.text)
+          when "controllableACL"
+            @controllable_acl = AtomicType::Boolean.xml_to_bool(node.text)
+          when "versionable"
+            @versionable = AtomicType::Boolean.xml_to_bool(node.text)
+          when "contentStreamAllowed"
+            # FIXME? this is an enumeration, should perhaps wrap
+            @content_stream_allowed = node.text
+          when /^property(?:DateTime|String|Html|Id|Boolean|Integer|Decimal)Definition$/
+            attr = PropertyDefinition.new(self, node.children)
+            @attributes[attr.id] = attr
+          end
+        end
+        if %w(cmis:folder cmis:document).include? @base_id and not @fileable
+          repository.logger.warn "The server behaved strange: #{@id}, with basetype #{@base_id} MUST be fileable"
+          @fileable = true
+        elsif @base_id == "cmis:relationship" and @fileable
+          repository.logger.warn "The server behaved strange: #{@id}, with basetype #{@base_id} MUST NOT be fileable"
+          @fileable = false
+        end
+        @attributes.freeze
+      end
+    end
+  end
+end

data/lib/active_cmis/version.rb

@@ -0,0 +1,10 @@
+require 'yaml'
+module ActiveCMIS
+  module Version
+    yaml = YAML.load_file(File.join(File.dirname(__FILE__), '/../../VERSION.yml'))
+    MAJOR = yaml[:major]
+    MINOR = yaml[:minor]
+    PATCH = yaml[:patch]
+    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: active_cmis2
+version: !ruby/object:Gem::Version
+  version: 0.3.8
+platform: ruby
+authors:
+- Joeri Samson
+- Linagora
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+- !ruby/object:Gem::Dependency
+  name: ntlm-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: require_relative
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A CMIS library implementing both reading and updating capabilities through
+  the AtomPub/REST binding to CMIS.
+email: joeri@xaop.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+- TODO
+files:
+- AUTHORS
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- VERSION.yml
+- active_cmis.gemspec
+- lib/active_cmis.rb
+- lib/active_cmis/acl.rb
+- lib/active_cmis/acl_entry.rb
+- lib/active_cmis/active_cmis.rb
+- lib/active_cmis/atomic_types.rb
+- lib/active_cmis/attribute_prefix.rb
+- lib/active_cmis/collection.rb
+- lib/active_cmis/document.rb
+- lib/active_cmis/exceptions.rb
+- lib/active_cmis/folder.rb
+- lib/active_cmis/internal/caching.rb
+- lib/active_cmis/internal/connection.rb
+- lib/active_cmis/internal/utils.rb
+- lib/active_cmis/ns.rb
+- lib/active_cmis/object.rb
+- lib/active_cmis/policy.rb
+- lib/active_cmis/property_definition.rb
+- lib/active_cmis/query_result.rb
+- lib/active_cmis/rel.rb
+- lib/active_cmis/relationship.rb
+- lib/active_cmis/rendition.rb
+- lib/active_cmis/repository.rb
+- lib/active_cmis/server.rb
+- lib/active_cmis/type.rb
+- lib/active_cmis/version.rb
+homepage: https://github.com/linagora/activecmis
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A library to interact with CMIS repositories through the AtomPub/REST binding
+test_files: []