cmis_active 0.3.7

data/lib/active_cmis/active_cmis.rb

@@ -0,0 +1,87 @@
+module ActiveCMIS
+  # Default logger: no output
+  # @return [Logger]
+  def self.default_logger
+    @default_logger ||= Logger.new(nil)
+  end
+
+  # server_url and repository_id are required options
+  #
+  # server_login, server_password and server_auth can be used to authenticate against the server,
+  # server_auth is optional and defaults to :basic
+  #
+  # You can also authenticate to the repository, by replacing server_ with repository_, by default
+  # the repository will use the same authentication parameters as the server
+  #
+  # The amoung of logging can be configured by setting log_level (default WARN), this can be done either
+  # by naming a Logger::Severity constant or the equivalent integer
+  #
+  # The destination of the logger output can be set with log_file (defaults to STDOUT), (should not contain ~)
+  #
+  # Default locations for the config file are: ./cmis.yml and .cmis.yml in that order
+  # @return [Repository]
+  def self.connect(config)
+    if config.is_a? Hash
+      if config.has_key? "log_file"
+        trace_file = config["log_file"]
+        if trace_file == "-"
+          trace_file = STDOUT
+        end
+        logger = Logger.new(trace_file)
+      else
+        logger = default_logger
+      end
+      if config.has_key? "log_level"
+        logger.level = (Logger.const_get(config["log_level"].upcase) rescue config["log_level"].to_i)
+      else
+        logger.level = Logger::WARN
+      end
+
+      if user_name = config["server_login"] and password = config["server_password"]
+        auth_type = config["server_auth"] || :basic
+        authentication_info = [auth_type, user_name, password]
+      end
+      server = Server.new(config["server_url"], logger, authentication_info, { :timeout => config["timeout"], :ssl_verfiy => config["ssl_verfiy"] })
+      if user_name = config["repository_login"] and password = config["repository_password"]
+        auth_type = config["repository_auth"] || :basic
+        authentication_info = [auth_type, user_name, password]
+      end
+      repository = server.repository(config["repository_id"], authentication_info)
+      return repository
+    else
+      raise "Configuration does not have correct format (#{config.class} is not a hash)"
+    end
+  end
+
+  # Will search for a given configuration in a file, and return the equivalent Repository
+  #
+  # The options that can be used are the same as for the connect method
+  #
+  # Default locations for the config file are: ./cmis.yml and .cmis.yml in that order
+  # @return [Repository]
+  def self.load_config(config_name, file = nil)
+    if file.nil?
+      ["cmis.yml", File.join(ENV["HOME"], ".cmis.yml")].each do |sl|
+        if File.exist?(sl)
+          file ||= sl
+        end
+      end
+      if file.nil?
+        raise "No configuration provided, and none found in standard locations"
+      end
+    elsif !File.exist?(file)
+      raise "Configuration file #{file} does not exist"
+    end
+
+    config = YAML.load_file(file)
+    if config.is_a? Hash
+      if config = config[config_name]
+        connect(config)
+      else
+        raise "Configuration not found in file"
+      end
+    else
+      raise "Configuration file #{file} does not have right format (not a hash)"
+    end
+  end
+end

data/lib/active_cmis/atomic_types.rb

@@ -0,0 +1,245 @@
+module ActiveCMIS
+  module AtomicType
+    class CommonBase
+      def cmis2rb(value)
+        if value.children.empty? && value.attribute("nil")
+          nil
+        else
+          _cmis2rb(value)
+        end
+      end
+      def rb2cmis(xml, value)
+        if value.nil?
+          xml.value("xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance", "xsi:nil" => "true")
+        else
+          _rb2cmis(xml, value)
+        end
+      end
+      def can_handle?(value)
+        raise NotImplementedError
+      end
+    end
+
+    class String < CommonBase
+      attr_reader :max_length
+      def initialize(max_length = nil)
+        @max_length = max_length
+      end
+
+      def to_s
+        "String"
+      end
+
+      def _cmis2rb(value)
+        value.text
+      end
+      def _rb2cmis(xml, value)
+        v = value.to_s
+        if max_length && max_length > 0 && v.length > max_length #xCMIS says maxLength=0
+          raise Error::InvalidArgument.new("String representation is longer than maximum (max: #{max_length}, string: \n'\n#{v}\n')\n")
+        end
+        xml["c"].value v
+      end
+      def can_handle?(value)
+        value.respond_to?(:to_s)
+      end
+
+      private :_cmis2rb, :_rb2cmis
+    end
+
+    # Qarning: Precision is ignored?
+    class Decimal < CommonBase
+      attr_reader :precision, :min_value, :max_value
+      def initialize(precision = nil, min_value = nil, max_value = nil)
+        @precision, @min_value, @max_value = precision, min_value, max_value
+      end
+
+      def to_s
+        "Decimal"
+      end
+
+      def _cmis2rb(value)
+        value.text.to_f
+      end
+      def _rb2cmis(xml, value)
+        v = value.to_f
+        if (min_value && v < min_value) || (max_value && v > max_value)
+          raise Error::InvalidArgument.new("OutOfBounds: #{v} should be between #{min_value} and #{max_value}")
+        end
+        xml["c"].value("%f" % v)
+      end
+      def can_handle?(value)
+        value.respond_to?(:to_s)
+      end
+
+      private :_cmis2rb, :_rb2cmis
+    end
+
+    class Integer < CommonBase
+      attr_reader :min_value, :max_value
+      def initialize(min_value = nil, max_value = nil)
+        @min_value, @max_value = min_value, max_value
+      end
+
+      def to_s
+        "Integer"
+      end
+
+      def _cmis2rb(value)
+        value.text.to_i
+      end
+      def _rb2cmis(xml, value)
+        v = value.to_i
+        if (min_value && v < min_value) || (max_value && v > max_value)
+          raise Error::InvalidArgument.new("OutOfBounds: #{v} should be between #{min_value} and #{max_value}")
+        end
+        xml["c"].value("%i" % v)
+      end
+      def can_handle?(value)
+        value.respond_to?(:to_i)
+      end
+
+      private :_cmis2rb, :_rb2cmis
+    end
+
+    class DateTime < CommonBase
+      attr_reader :resolution
+
+      @instances ||= {}
+      def self.new(precision = TIME)
+        raise ArgumentError.new("Got precision = #{precision.inspect}") unless [YEAR, DATE, TIME].include? precision.to_s.downcase
+        @instances[precision] ||= super
+      end
+
+      def to_s
+        "DateTime"
+      end
+
+      def initialize(resolution)
+        @resolution = resolution
+      end
+      YEAR = "year"
+      DATE = "date"
+      TIME = "time"
+
+      def _cmis2rb(value)
+        case @resolution
+        when YEAR, DATE; ::DateTime.parse(value.text).to_date
+        when TIME; ::DateTime.parse(value.text)
+        end
+      end
+      def _rb2cmis(xml, value)
+        # FIXME: respect resolution, I still have to find out how to do that
+        xml["c"].value(value.strftime("%Y-%m-%dT%H:%M:%S%Z"))
+      end
+      def can_handle?(value)
+        value.respond_to?(:strftime)
+      end
+
+      private :_cmis2rb, :_rb2cmis
+    end
+
+    class Singleton < CommonBase
+      def self.new
+        @singleton ||= super
+      end
+    end
+
+    class Boolean < Singleton
+      def self.xml_to_bool(value)
+        case value
+        when "true", "1"; true
+        when "false", "0"; false
+        else raise ActiveCMIS::Error.new("An invalid boolean was found in CMIS")
+        end
+      end
+
+      def to_s
+        "Boolean"
+      end
+
+      def _cmis2rb(value)
+        self.class.xml_to_bool(value.text)
+      end
+      def _rb2cmis(xml, value)
+        xml["c"].value( (!!value).to_s )
+      end
+      def can_handle?(value)
+        [true, false].include?(value)
+      end
+
+      private :_cmis2rb, :_rb2cmis
+    end
+
+    class URI < Singleton
+      def to_s
+        "Uri"
+      end
+
+      def _cmis2rb(value)
+        URI.parse(value.text)
+      end
+      def _rb2cmis(xml, value)
+        xml["c"].value( value.to_s )
+      end
+      def can_handle?(value)
+        value.respond_to?(:to_s)
+      end
+
+      private :_cmis2rb, :_rb2cmis
+    end
+
+    class ID < Singleton
+      def to_s
+        "Id"
+      end
+
+      def _cmis2rb(value)
+        value.text
+      end
+      def _rb2cmis(xml, value)
+        case value
+        when ::ActiveCMIS::Object; value.id
+        else xml["c"].value( value.to_s )
+        end
+      end
+      def can_handle?(value)
+        value.class < ::ActiveCMIS::Object || value.respond_to?(:to_s)
+      end
+
+      private :_cmis2rb, :_rb2cmis
+    end
+
+    class HTML < Singleton
+      def to_s
+        "Html"
+      end
+
+      def _cmis2rb(value)
+        value.children
+      end
+      def _rb2cmis(xml, value)
+        # FIXME: Test that this works
+        xml["c"].value value
+      end
+      def can_handle?(value)
+        true # FIXME: this is probably incorrect
+      end
+
+      private :_cmis2rb, :_rb2cmis
+    end
+
+    # Map of XML property elements to the corresponding AtomicTypes
+    MAPPING = {
+      "propertyString" => ActiveCMIS::AtomicType::String,
+      "propertyBoolean" => ActiveCMIS::AtomicType::Boolean,
+      "propertyId" => ActiveCMIS::AtomicType::ID,
+      "propertyDateTime" => ActiveCMIS::AtomicType::DateTime,
+      "propertyInteger" => ActiveCMIS::AtomicType::Integer,
+      "propertyDecimal" => ActiveCMIS::AtomicType::Decimal,
+      "propertyHtml" => ActiveCMIS::AtomicType::HTML,
+      "propertyUri" => ActiveCMIS::AtomicType::URI,
+    }
+
+  end
+end

data/lib/active_cmis/attribute_prefix.rb

@@ -0,0 +1,35 @@
+module ActiveCMIS
+  # A class used to get and set attributes that have a prefix like cmis: in their attribute IDs
+  class AttributePrefix
+    # @return [Object] The object that the attribute getting and setting will take place on
+    attr_reader :object
+    # @return [String]
+    attr_reader :prefix
+
+    # @private
+    def initialize(object, prefix)
+      @object = object
+      @prefix = prefix
+    end
+
+    # For known attributes will act as a getter and setter
+    def method_missing(method, *parameters)
+      string = method.to_s
+      if string[-1] == ?=
+        assignment = true
+        string = string[0..-2]
+      end
+      attribute = "#{prefix}:#{string}"
+      if object.class.attributes.keys.include? attribute
+        if assignment
+          object.update(attribute => parameters.first)
+        else
+          object.attribute(attribute)
+        end
+      else
+        # TODO: perhaps here we should try to look a bit further to see if there is a second :
+        super
+      end
+    end
+  end
+end

data/lib/active_cmis/collection.rb

@@ -0,0 +1,206 @@
+module ActiveCMIS
+
+  # A Collection represents an atom feed, and can be used to lazily load data through paging
+  class Collection
+    include Internal::Caching
+    include ::Enumerable
+
+    # The repository that contains this feed
+    # @return [Repository]
+    attr_reader :repository
+    # The basic link that represents the beginning of this feed
+    # @return [URI]
+    attr_reader :url
+
+    def initialize(repository, url, first_page = nil, &map_entry)
+      @repository = repository
+      @url = URI.parse(url)
+
+      @next = @url
+      @elements = []
+      @pages = []
+
+      @map_entry = map_entry || Proc.new do |e|
+        ActiveCMIS::Object.from_atom_entry(repository, e)
+      end
+
+      if first_page
+        @next = first_page.xpath("at:feed/at:link[@rel = 'next']/@href", NS::COMBINED).first
+        @pages[0] = first_page
+      end
+    end
+
+    # @return [Integer] The length of the collection
+    def length
+      receive_page
+      if @length.nil?
+        i = 1
+        while @next
+          receive_page
+          i += 1
+        end
+        @elements.length
+      else
+        @length
+      end
+    end
+    alias size length
+    cache :length
+
+    def empty?
+      at(0)
+      @elements.empty?
+    end
+
+    # @return [Array]
+    def to_a
+      while @next
+        receive_page
+      end
+      @elements
+    end
+
+    def at(index)
+      index = sanitize_index(index)
+      if index < @elements.length
+        @elements[index]
+      elsif index > length
+        nil
+      else
+        while @next && @elements.length < index
+          receive_page
+        end
+        @elements[index]
+      end
+    end
+
+    def [](index, length = nil)
+      if length
+        index = sanitize_index(index)
+        range_get(index, index + length - 1)
+      elsif Range === index
+        range_get(sanitize_index(index.begin), index.exclude_end? ? sanitize_index(index.end) - 1 : sanitize_index(index.end))
+      else
+        at(index)
+      end
+    end
+    alias slice []
+
+    def first
+      at(0)
+    end
+
+    # Gets all object and returns last
+    def last
+      at(-1)
+    end
+
+    # @return [Array]
+    def each
+      length.times { |i| yield self[i] }
+    end
+
+    # @return [Array]
+    def reverse_each
+      (length - 1).downto(0) { |i| yield self[i] }
+    end
+
+    # @return [String]
+    def inspect
+      "#<Collection %s>" % url
+    end
+
+    # @return [String]
+    def to_s
+      to_a.to_s
+    end
+
+    # @return [Array]
+    def uniq
+      to_a.uniq
+    end
+
+    # @return [Array]
+    def sort
+      to_a.sort
+    end
+
+    # @return [Array]
+    def reverse
+      to_a.reverse
+    end
+
+    ## @return [void]
+    def reload
+      @pages = []
+      @elements = []
+      @next = @url
+      __reload
+    end
+
+    # Attempts to delete the collection.
+    # This may not work on every collection, ActiveCMIS does not (yet) try to check this client side.
+    # 
+    # For folder collections 2 options are available, again no client side checking
+    # is done to see whether the collection can handle these options
+    #
+    # @param [Hash] options
+    # @option options [String] :unfileObjects Parameter valid for items collection of folder
+    #   "delete" (default): Delete all fileable objects
+    #   "unfile": unfile all fileable objects
+    #   "deleteSingleFiled": Delete all fileable objects, whose only parent folder is the current folder. Unfile all other objects from this folder
+    # @option options [Bool] :continueOnFailure default = false, if false abort on failure of single document/folder, else try to continue with deleting child folders/documents
+    def destroy(options = {})
+      if options.empty?
+        conn.delete(@url)
+      else
+        unfileObjects = options.delete(:unfileObjects)
+        continueOnFailure = options.delete(:continueOnFailure)
+        raise ArgumentError("Unknown parameters #{options.keys.join(', ')}") unless options.empty?
+
+
+        # XXX: have less cumbersome code, more generic and more efficient code
+        new_url = @url
+        new_url = Internal::Utils.append_parameters(new_url, :unfileObjects => unfileObjects) unless unfileObjects.nil?
+        new_url = Internal::Utils.append_parameters(new_url, :continueOnFailure => continueOnFailure) unless continueOnFailure.nil?
+
+        # TODO: check that we can handle 200,202,204 responses correctly
+        conn.delete(@url)
+      end
+    end
+
+    private
+
+    def sanitize_index(index)
+      index < 0 ? size + index : index
+    end
+
+    def range_get(from, to)
+      (from..to).map { |i| at(i) }
+    end
+
+    def receive_page(i = nil)
+      i ||= @pages.length
+      @pages[i] ||= begin
+                      return nil unless @next
+                      xml = conn.get_xml(@next)
+
+                      @next = xml.xpath("at:feed/at:link[@rel = 'next']/@href", NS::COMBINED).first
+                      @next = @next.nil? ? nil : @next.text
+
+                      new_elements = xml.xpath('at:feed/at:entry', NS::COMBINED).map(&@map_entry)
+                      @elements.concat(new_elements)
+
+                      num_items = xml.xpath("at:feed/cra:numItems", NS::COMBINED).first
+                      @length ||= num_items.text.to_i if num_items # We could also test on the repository
+
+                      xml
+                    end
+    end
+
+    def conn
+      repository.conn
+    end
+
+  end
+end