active_cmis 0.1.0

data/lib/active_cmis/exceptions.rb

@@ -0,0 +1,82 @@
+module ActiveCMIS
+  # The base class for all CMIS exceptions,
+  # HTTP communication errors and the like are not catched by this
+  class Error < StandardError
+    # === Cause
+    # One or more of the input parameters to the service method is missing or invalid
+    class InvalidArgument < Error; end
+
+    # === Cause
+    # The service call has specified an object that does not exist in the Repository
+    class ObjectNotFound < Error; end
+
+    # === Cause
+    # The service method invoked requires an optional capability not supported by the repository
+    class NotSupported < Error; end
+
+    # === Cause
+    # The caller of the service method does not have sufficient permissions to perform the operation
+    class PermissionDenied < Error; end
+
+    # === Cause
+    # Any cause not expressible by another CMIS exception
+    class Runtime < Error; end
+
+    # === Intent
+    # The operation violates a Repository- or Object-level constraint defined in the CMIS domain model
+    #
+    # === Methods
+    # see the CMIS specification
+    class Constraint < Error; end
+    # === Intent
+    # The operation attempts to set the content stream for a Document
+    # that already has a content stream without explicitly specifying the
+    # "overwriteFlag" parameter
+    #
+    # === Methods
+    # see the CMIS specification
+    class ContentAlreadyExists < Error; end
+    # === Intent
+    # The property filter or rendition filter input to the operation is not valid
+    #
+    # === Methods
+    # see the CMIS specification
+    class FilterNotValid < Error; end
+    # === Intent
+    # The repository is not able to store the object that the user is creating/updating due to a name constraint violation
+    #
+    # === Methods
+    # see the CMIS specification
+    class NameConstraintViolation < Error; end
+    # === Intent
+    # The repository is not able to store the object that the user is creating/updating due to an internal storage problam
+    #
+    # === Methods
+    # see the CMIS specification
+    class Storage < Error; end
+    # === Intent
+    #
+    #
+    # === Methods
+    # see the CMIS specification
+    class StreamNotSupported < Error; end
+    # === Intent
+    #
+    #
+    # === Methods
+    # see the CMIS specification
+    class UpdateConflict < Error; end
+    # === Intent
+    #
+    #
+    # === Methods
+    # see the CMIS specification
+    class Versioning < Error; end
+  end
+
+  class HTTPError < StandardError
+    class ServerError < HTTPError; end
+    class ClientError < HTTPError; end
+    class AuthenticationError < HTTPError; end
+  end
+end

data/lib/active_cmis/folder.rb

@@ -0,0 +1,21 @@
+module ActiveCMIS
+  class Folder < ActiveCMIS::Object
+    # Returns a collection of all items contained in this folder (1 level deep)
+    # @return [Collection<Document,Folder,Policy>]
+    def items
+      item_feed = Internal::Utils.extract_links(data, 'down', 'application/atom+xml','type' => 'feed')
+      raise "No child feed link for folder" if item_feed.empty?
+      Collection.new(repository, item_feed.first)
+    end
+    cache :items
+
+    private
+    def create_url
+      if f = parent_folders.first
+        f.items.url
+      else
+        raise "Not possible"
+      end
+    end
+  end
+end

data/lib/active_cmis/internal/caching.rb

@@ -0,0 +1,86 @@
+module ActiveCMIS
+  module Internal
+    module Caching
+      def self.included(cl)
+        cl.extend ClassMethods
+      end
+
+      # A module for internal use only.
+      module ClassMethods
+
+        # Creates a proxy method for the given method names that caches the result.
+        #
+        # Parameters are passed and ignored, cached values will be returned regardless of the parameters.
+        # @param [Symbol, <Symbol>] Names of methods that will be cached
+        # @return [void]
+        def cache(*names)
+          (@cached_methods ||= []).concat(names).uniq!
+          names.each do |name|
+            alias_method("#{name}__uncached", name)
+            class_eval <<-RUBY, __FILE__, __LINE__+1
+              if private_method_defined? :"#{name}"
+                private_method = true
+              end
+              def #{name}(*a, &b)
+                if defined? @#{name}
+                  @#{name}
+                else
+                  @#{name} = #{name}__uncached(*a, &b)
+                end
+              end
+              if private_method
+                private :"#{name}__uncached"
+                private :"#{name}"
+              end
+            RUBY
+          end
+          reloadable
+        end
+
+        # Creates methods to retrieve attributes with the given names.
+        #
+        # If the given attribute does not yet exist the method #load_from_data will be called
+        #
+        # @param [Symbol, <Symbol>] Names of desired attributes
+        # @return [void]
+        def cached_reader(*names)
+          (@cached_methods ||= []).concat(names).uniq!
+          names.each do |name|
+            define_method "#{name}" do
+              if instance_variable_defined? "@#{name}"
+                instance_variable_get("@#{name}")
+              else
+                load_from_data # FIXME: make flexible?
+                instance_variable_get("@#{name}")
+              end
+            end
+          end
+          reloadable
+        end
+
+        private
+        def reloadable
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def __reload
+              #{@cached_methods.inspect}.map do |method|
+                :"@\#{method}"
+              end.select do |iv|
+                instance_variable_defined? iv
+              end.each do |iv|
+                remove_instance_variable iv
+              end + (defined?(super) ? super : [])
+            end
+            private :__reload
+          RUBY
+          unless instance_methods.include? "reload"
+            class_eval <<-RUBY, __FILE__, __LINE__
+              def reload
+                __reload
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_cmis/internal/connection.rb

@@ -0,0 +1,171 @@
+module ActiveCMIS
+  module Internal
+    class Connection
+      # @return [String, nil] The user that is used with the authentication to the server
+      attr_reader :user
+      # @return [Logger] A logger used to send debug and info messages
+      attr_reader :logger
+
+      # @param [Logger] Initialize with a logger of your choice
+      def initialize(logger)
+        @logger = logger || ActiveCMIS.default_logger
+      end
+
+      # Use authentication to access the CMIS repository
+      #
+      # @param method [Symbol] Currently only :basic is supported
+      # @param params The parameters that need to be sent to the Net::HTTP authentication method used, username and password for basic authentication
+      # @return [void]
+      # @example Basic authentication
+      #   repo.authenticate(:basic, "username", "password")
+      def authenticate(method, *params)
+        case method
+        when :basic
+          @authentication = {:method => :basic_auth, :params => params}
+          @user = params.first
+        else raise "Authentication method not supported"
+        end
+      end
+
+      # The return value is the unparsed body, unless an error occured
+      # If an error occurred, exceptions are thrown (see _ActiveCMIS::Exception
+      #
+      # @private
+      # @return [String] returns the body of the request, unless an error occurs
+      def get(url)
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Get.new(uri.request_uri)
+        handle_request(uri, req)
+      end
+
+      # Does not throw errors, returns the full response (includes status code and headers)
+      # @private
+      # @return [Net::HTTP::Response]
+      def get_response(url)
+        logger.debug "GET (response) #{url}"
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Get.new(uri.request_uri)
+        http = authenticate_request(uri, req)
+        response = http.request(req)
+        logger.debug "GOT (#{response.code}) #{url}"
+        response
+      end
+
+      # Returns the parsed body of the result
+      # @private
+      # @return [Nokogiri::XML::Document]
+      def get_xml(url)
+        Nokogiri::XML.parse(get(url))
+      end
+
+      # @private
+      # @return [Nokogiri::XML::Node]
+      def get_atom_entry(url)
+        # FIXME: add validation that first child is really an entry
+        get_xml(url).child
+      end
+
+      # @private
+      def put(url, body, headers = {})
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Put.new(uri.request_uri)
+        headers.each {|k,v| req.add_field k, v}
+        assign_body(req, body)
+        handle_request(uri, req)
+      end
+
+      # @private
+      def post(url, body, headers = {})
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Post.new(uri.request_uri)
+        headers.each {|k,v| req.add_field k, v}
+        assign_body(req, body)
+        handle_request(uri, req)
+      end
+
+      # Does not throw errors, returns the full response (includes status code and headers)
+      # @private
+      def post_response(url, body, headers = {})
+        logger.debug "POST (response) #{url}"
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Post.new(uri.request_uri)
+        headers.each {|k,v| req.add_field k, v}
+        assign_body(req, body)
+
+        http = authenticate_request(uri, req)
+        response = http.request(req)
+        logger.debug "POSTED (#{response.code}) #{url}"
+        response
+      end
+
+      # @private
+      def delete(url)
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Delete.new(uri.request_uri)
+        handle_request(uri, req)
+      end
+
+      private
+      def normalize_url(url)
+        case url
+        when URI; url
+        else URI.parse(url.to_s)
+        end
+      end
+
+      def authenticate_request(uri, req)
+        http = Net::HTTP.new(uri.host, uri.port)
+        if uri.scheme == 'https'
+          http.use_ssl = true
+        end
+        if auth = @authentication
+          req.send(auth[:method], *auth[:params])
+        end
+        http
+      end
+
+      def assign_body(req, body)
+        if body.respond_to? :length
+          req.body = body
+        else
+          req.body_stream = body
+          if body.respond_to? :stat
+            req["Content-Length"] = body.stat.size.to_s
+          elsif req["Content-Size"].nil?
+            req["Transfer-Encoding"] = 'chunked'
+          end
+        end
+      end
+
+      def handle_request(uri, req)
+        logger.debug "#{req.method} #{uri}"
+        http = authenticate_request(uri, req)
+        response = http.request(req)
+        status = response.code.to_i
+        logger.debug "RECEIVED #{response.code}"
+        if 200 <= status && status < 300
+          return response.body
+        else
+          # Problem: some codes 400, 405, 403, 409, 500 have multiple meanings
+          logger.error "Error occurred when handling request:\n#{response.body}"
+          case status
+          when 400; raise Error::InvalidArgument.new(response.body)
+            # FIXME: can also be filterNotValid
+          when 404; raise Error::ObjectNotFound.new(response.body)
+          when 403; raise Error::PermissionDenied.new(response.body)
+            # FIXME: can also be streamNotSupported (?? shouldn't that be 405??)
+          when 405; raise Error::NotSupported.new(response.body)
+          else
+            raise HTTPError.new("A HTTP #{status} error occured, for more precision update the code:\n" + response.body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_cmis/internal/utils.rb

@@ -0,0 +1,69 @@
+module ActiveCMIS
+  module Internal
+    # @private
+    module Utils
+      # @private
+      def self.escape_url_parameter(parameter)
+        control = "\x00-\x1F\x7F"
+        space   = " "
+        delims  = "<>#%\""
+        unwise  = '{}|\\\\^\[\]`'
+        query   = ";/?:@&=+,$"
+        URI.escape(parameter, /[#{control+space+delims+unwise+query}]/o)
+      end
+
+      # Given an url (string or URI) returns that url with the given parameters appended
+      #
+      # This method does not perform any encoding on the paramter or key values.
+      # This method does not check the existing parameters for duplication in keys
+      # @private
+      def self.append_parameters(uri, parameters)
+        uri       = case uri
+                    when String; string = true; URI.parse(uri)
+                    when URI;    uri.dup
+                    end
+        uri.query = [uri.query, *parameters.map {|key, value| "#{key}=#{value}"} ].compact.join "&"
+        if string
+          uri.to_s
+        else
+          uri
+        end
+      end
+
+      # FIXME?? percent_encode and escape_url_parameter serve nearly the same purpose, replace one?
+      # @private
+      def self.percent_encode(string)
+        URI.escape(string, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+      end
+
+      # Returns id if id is already an object, object_by_id if id is a string, nil otherwise
+      # @private
+      def self.string_or_id_to_object(id)
+        case id
+        when String; repository.object_by_id(id)
+        when ::ActiveCMIS::Object; id
+        end
+      end
+
+      # @private
+      def self.extract_links(xml, rel, type_main = nil, type_params = {})
+        links = xml.xpath("at:link[@rel = '#{rel}']", NS::COMBINED)
+
+        if type_main
+          type_main = Regexp.escape(type_main)
+          if type_params.empty?
+            regex = /#{type_main}/
+          else
+            parameters = type_params.map {|k,v| "#{Regexp.escape(k)}=#{Regexp.escape(v)}" }.join(";\s*")
+            regex = /#{type_main};\s*#{parameters}/
+          end
+          links = links.select do |node|
+             regex === node.attribute("type").to_s
+          end
+        end
+
+        links.map {|l| l.attribute("href").to_s}
+      end
+    end
+  end
+end

data/lib/active_cmis/ns.rb

@@ -0,0 +1,18 @@
+module ActiveCMIS
+  # This module defines namespaces that often occur in the REST/Atompub API to CMIS
+  module NS
+    CMIS_CORE = "http://docs.oasis-open.org/ns/cmis/core/200908/"
+    CMIS_REST = "http://docs.oasis-open.org/ns/cmis/restatom/200908/"
+    CMIS_MESSAGING = "http://docs.oasis-open.org/ns/cmis/messaging/200908/"
+    APP = "http://www.w3.org/2007/app"
+    ATOM = "http://www.w3.org/2005/Atom"
+
+    COMBINED = {
+      "xmlns:c" => CMIS_CORE,
+      "xmlns:cra" => CMIS_REST,
+      "xmlns:cm" => CMIS_MESSAGING,
+      "xmlns:app" => APP,
+      "xmlns:at" => ATOM
+    }
+  end
+end