active_cmis 0.1.0

data/lib/active_cmis/server.rb

@@ -0,0 +1,88 @@
+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 [Server] Cached by endpoint and logger
+    def self.new(endpoint, logger = nil)
+      endpoint = case endpoint
+                 when URI; endpoint
+                 else URI(endpoint.to_s)
+                 end
+      endpoints[[endpoint, logger]] ||= super(endpoint, logger || ActiveCMIS.default_logger)
+    end
+
+    # @return [{(URI, Logger) => Server}] The cache of known Servers
+    def self.endpoints
+      @endpoints ||= {}
+    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
+    def initialize(endpoint, logger)
+      @endpoint = endpoint
+      @logger = logger
+    end
+
+    # @param (see ActiveCMIS::Internal::Connection#authenticate)
+    # @see Internal::Connection#authenticate
+    # @return [void]
+    def authenticate(method, *params)
+      conn.authenticate(method, *params)
+    end
+
+    # Returns the _Repository identified by the ID
+    #
+    # Cached by the repository_id, no way to reset cache yet
+    # @param [String] repository_id
+    # @return [Repository]
+    def repository(repository_id)
+      cached_repositories[repository_id] ||= begin
+                                               repository_data = repository_info.
+                                                 xpath("/app:service/app:workspace[cra:repositoryInfo/c:repositoryId[child::text() = '#{repository_id}']]", NS::COMBINED)
+                                               if repository_data.empty?
+                                                 raise Error::ObjectNotFound.new("The repository #{repository_id} doesn't exist")
+                                               else
+                                                 Repository.new(conn.dup, logger.dup, repository_data)
+                                               end
+                                             end
+    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)
+    end
+  end
+end

data/lib/active_cmis/type.rb

@@ -0,0 +1,193 @@
+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
+        @attributes.freeze
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: active_cmis
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Joeri Samson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-09 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 1
+        version: 1.4.1
+  type: :runtime
+  version_requirements: *id001
+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: 
+- TODO
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- VERSION
+- 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/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
+has_rdoc: yard
+homepage: http://xaop.com/labs/activecmis/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+- --default-return
+- "::Object"
+- --query
+- "!@private"
+- --hide-void-return
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 6
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A library to interact with CMIS repositories through the AtomPub/REST binding
+test_files: []
+