yaccl 0.1.5 → 1.0.pre.alpha

data/lib/yaccl/model/repository.rb

@@ -1,155 +0,0 @@
-module YACCL
-  module Model
-    class Repository
-      attr_reader :id
-      attr_reader :name
-      attr_reader :description
-      attr_reader :root_folder_id
-      attr_reader :capabilities
-      attr_reader :url
-      attr_reader :latest_change_log_token
-      attr_reader :vendor_name
-      attr_reader :cmis_version_supported
-      attr_reader :acl_capabilities
-      attr_reader :product_name
-      attr_reader :product_version
-      attr_reader :thin_client_uri
-      attr_reader :changes_on_type
-      attr_reader :root_folder_url
-
-      def ==(other)
-        return true if other.equal?(self)
-        return false unless other.kind_of?(self.class)
-        id == other.id
-      end
-
-      def to_s
-        name
-      end
-
-      def self.create(raw_repository)
-        Repository.new(raw_repository)
-      end
-
-      def initialize(raw)
-        @id = raw[:repositoryId]
-        @name = raw[:repositoryName]
-        @description = raw[:repositoryDescription]
-        @root_folder_id = raw[:rootFolderId]
-        @capabilities = raw[:capabilities]
-        @url = raw[:repositoryUrl]
-        @latest_change_log_token = raw[:latestChangeLogToken]
-        @vendor_name = raw[:vendorName]
-        @cmis_version_supported = raw[:cmisVersionSupported]
-        @acl_capabilities = raw[:aclCapabilities]
-        @product_name = raw[:productName]
-        @product_version = raw[:productVersion]
-        @thin_client_uri = raw[:thinClientUri]
-        @changes_on_type = raw[:changesOnType]
-        @root_folder_url = raw[:rootFolderUrl]
-      end
-
-      def new_folder
-        Folder.new(id)
-      end
-
-      def new_document
-        Document.new(id)
-      end
-
-      def new_relationship
-        Relationship.new(id)
-      end
-
-      def new_policy
-        Policy.new(id)
-      end
-
-      def new_item
-        Item.new(id)
-      end
-
-      # object
-
-      def root
-        ObjectFactory.create(id, Services.get_object(id, root_folder_id, nil, false, nil, nil, false, false))
-      end
-
-      def object(cmis_object_id)
-        ObjectFactory.create(id, Services.get_object(id, cmis_object_id, nil, false, nil, nil, false, false))
-      end
-
-      # type
-
-      def type(type_id)
-        Type.create(id, Services.get_type_definition(id, type_id))
-      end
-
-      def types
-        _types(Services.get_type_descendants(id, nil, nil, true))
-      end
-
-      def create_type(type)
-        Type.create(id, Services.create_type(id, type.to_hash))
-      end
-
-      # relationship
-
-      def create(object)
-        properties = object.create_properties
-        if object.is_a? Folder
-          raise 'create object in folder'
-        elsif object.is_a? Document
-          raise 'create document in folder'
-        elsif object.is_a? Relationship
-          o = Services.create_relationship(id, properties, nil, nil, nil)
-        elsif object.is_a? Policy
-          raise 'create policy in folder'
-        elsif object.is_a? Item
-          raise 'create item in folder'
-        else
-          raise "Unexpected base_type_id: #{object.base_type_id}"
-        end
-        ObjectFactory.create(id, o)
-      end
-
-      # discovery
-
-      def query(statement, max_items=nil, skip_count=nil, &block)
-        result = Services.query(id, statement, nil, nil, nil, nil, max_items, skip_count)
-        result[:results].map! { |o| ObjectFactory.create(id, o) }
-        result[:num_items] = result.delete(:numItems)
-        result[:has_more_items] = result.delete(:hasMoreItems)
-
-        yield(result) if block_given?
-        result[:results]
-      end
-
-      def query_for_each_chunk(statement, chunk_size, &block)
-        skip_count = 0
-        has_more_items = true
-        while has_more_items
-          result = Services.query(id, statement, nil, nil, nil, nil, chunk_size, skip_count)
-          yield(result[:results].map! { |o| ObjectFactory.create(id, o) }) unless result[:results].empty?
-          has_more_items = result[:hasMoreItems]
-          skip_count += result[:results].size
-        end
-      end
-
-      def content_changes(change_log_token)
-        Services.get_content_changes(id, change_log_token, nil, nil, nil, nil)
-      end
-
-      private
-
-      def _types(arr)
-        types = []
-        arr.each do |t|
-          types << Type.create(id, t[:type])
-          types << _types(t[:children]) if t.has_key?(:children)
-        end
-        types.flatten
-      end
-    end
-  end
-end

data/lib/yaccl/model/server.rb

@@ -1,13 +0,0 @@
-module YACCL
-  module Model
-    class Server
-      def self.repositories
-        Services.get_repositories.values.map { |r| Repository.create(r) }
-      end
-
-      def self.repository(repository_id)
-        Repository.create(Services.get_repository_info(repository_id).values.first)
-      end
-    end
-  end
-end

data/lib/yaccl/model/type.rb

@@ -1,146 +0,0 @@
-module YACCL
-  module Model
-    class Type
-      attr_accessor :repository_id
-      attr_accessor :id
-      attr_accessor :local_name
-      attr_accessor :local_namespace
-      attr_accessor :query_name
-      attr_accessor :display_name
-      attr_accessor :base_id
-      attr_accessor :parent_id
-      attr_accessor :description
-      attr_accessor :creatable
-      attr_accessor :fileable
-      attr_accessor :queryable
-      attr_accessor :controllable_policy
-      attr_accessor :controllable_acl
-      attr_accessor :fulltext_indexed
-      attr_accessor :included_in_supertype_query
-      attr_accessor :property_definitions
-      # document type
-      attr_accessor :versionable
-      attr_accessor :content_stream_allowed
-      # relationship type
-      attr_accessor :allowed_source_types
-      attr_accessor :allowed_target_types
-
-      def self.create(repository_id, raw)
-        type = Type.new(raw)
-        type.repository_id = repository_id
-        type
-      end
-
-      def initialize(hash={})
-        @id = hash[:id]
-        @local_name = hash[:localName]
-        @local_namespace = hash[:localNamespace]
-        @query_name = hash[:queryName]
-        @display_name = hash[:displayName]
-        @base_id = hash[:baseId]
-        @parent_id = hash[:parentId]
-        @description = hash[:description]
-        @creatable = hash[:creatable]
-        @fileable = hash[:fileable]
-        @queryable = hash[:queryable]
-        @controllable_policy = hash[:controllablePolicy]
-        @controllable_acl = hash[:controllableACL]
-        @fulltext_indexed = hash[:fulltextIndexed]
-        @included_in_supertype_query = hash[:includedInSupertypeQuery]
-        @property_definitions = hash[:propertyDefinitions] || {}
-        @property_definitions.each { |k, v| @property_definitions[k] = PropertyDefinition.new(v) }
-        # document type
-        @versionable = hash[:versionable]
-        @content_stream_allowed = hash[:contentStreamAllowed]
-        # relationship type
-        @allowed_source_types = hash[:allowedSourceTypes]
-        @allowed_target_types = hash[:allowedTargetTypes]
-      end
-
-      def add_property_definition(property)
-        @property_definitions[property[:id]] = property
-      end
-
-      def update(changed_property_defs)
-        hash = to_hash
-        new_defs = changed_property_defs.map(&:to_hash).inject({}) do |result, element|
-          result[element[:id]] = element
-          result
-        end
-        hash[:propertyDefinitions] = new_defs
-
-        Type.create(repository_id, Services.update_type(repository_id, hash))
-      end
-
-      def delete
-        Services.delete_type(repository_id, id)
-      end
-
-      def new_object
-        object = case base_id
-        when 'cmis:document'
-          Document.new(repository_id)
-        when 'cmis:folder'
-          Folder.new(repository_id)
-        when 'cmis:relationship'
-          Relationship.new(repository_id)
-        when 'cmis:policy'
-          Policy.new(repository_id)
-        when 'cmis:item'
-          Item.new(repository_id)
-        else
-          raise "Unsupported base type: #{base_id}"
-        end
-        object.object_type_id = id
-        object
-      end
-
-      def document_type?
-        base_id == 'cmis:document'
-      end
-
-      def folder_type?
-        base_id == 'cmis:folder'
-      end
-
-      def relationship_type?
-        base_id == 'cmis:relationship'
-      end
-
-      def policy_type?
-        base_id == 'cmis:policy'
-      end
-
-      def item_type?
-        base_id == 'cmis:item'
-      end
-
-      def to_hash
-        hash = {}
-        hash[:id] = id
-        hash[:localName] = local_name
-        hash[:localNamespace] = local_namespace
-        hash[:queryName]= query_name
-        hash[:displayName]= display_name
-        hash[:baseId]= base_id
-        hash[:parentId]= parent_id
-        hash[:description]= description
-        hash[:creatable]= creatable
-        hash[:fileable]= fileable
-        hash[:queryable]= queryable
-        hash[:controllablePolicy]= controllable_policy
-        hash[:controllableACL]= controllable_acl
-        hash[:fulltextIndexed]= fulltext_indexed
-        hash[:includedInSupertypeQuery]= included_in_supertype_query
-        hash[:propertyDefinitions]= property_definitions.to_hash
-        # document type
-        hash[:versionable] = versionable unless versionable.nil?
-        hash[:contentStreamAllowed] = content_stream_allowed unless content_stream_allowed.nil?
-        # relationship type
-        hash[:allowedSourceTypes] = allowed_source_types unless allowed_source_types.nil?
-        hash[:allowedTargetTypes] = allowed_target_types unless allowed_target_types.nil?
-        hash
-      end
-    end
-  end
-end

data/lib/yaccl/model.rb

@@ -1,11 +0,0 @@
-require 'yaccl/model/object'
-require 'yaccl/model/object_factory'
-require 'yaccl/model/document'
-require 'yaccl/model/folder'
-require 'yaccl/model/item'
-require 'yaccl/model/policy'
-require 'yaccl/model/relationship'
-require 'yaccl/model/repository'
-require 'yaccl/model/type'
-require 'yaccl/model/property_definition'
-require 'yaccl/model/server'

data/lib/yaccl/services/acl_services.rb

@@ -1,23 +0,0 @@
-module YACCL
-  module ACLServices
-    def get_acl(repository_id, cmis_object_id, only_basic_permissions, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'acl',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {onlyBasicPermissions: only_basic_permissions}
-      perform_request(required, optional)
-    end
-
-    def apply_acl(repository_id, cmis_object_id, add_aces, remove_aces, acl_propagation, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'applyACL',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {addACEs: add_aces,
-                  removeACEs: remove_aces,
-                  ACLPropagation: acl_propagation}
-      perform_request(required, optional)
-    end
-  end
-end

data/lib/yaccl/services/discovery_services.rb

@@ -1,29 +0,0 @@
-module YACCL
-  module DiscoveryServices
-    def query(repository_id, statement, search_all_versions, include_relationships, rendition_filter, include_allowable_actions, max_items, skip_count, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'query',
-                  repositoryId: repository_id,
-                  q: statement}
-      optional = {searchAllVersions: search_all_versions,
-                  includeRelationships: include_relationships,
-                  renditionFilter: rendition_filter,
-                  includeAllowableActions: include_allowable_actions,
-                  maxItems: max_items,
-                  skipCount: skip_count}
-      perform_request(required, optional)
-    end
-
-    def get_content_changes(repository_id, change_log_token, include_properties, include_policy_ids, include_acl, max_items, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'contentChanges',
-                  repositoryId: repository_id}
-      optional = {changeLogToken: change_log_token,
-                  includeProperties: include_properties,
-                  includePolicyIds: include_policy_ids,
-                  includeAcl: include_acl,
-                  maxItems: max_items}
-      perform_request(required, optional)
-    end
-  end
-end

data/lib/yaccl/services/internal/browser_binding_service.rb

@@ -1,170 +0,0 @@
-require 'date'
-require 'typhoeus'
-require 'net/http/post/multipart'
-require 'multi_json'
-require_relative 'simple_cache'
-
-module YACCL
-  module Services
-    class CMISRequestError < RuntimeError; end
-
-    module Internal
-      class BrowserBindingService
-
-        @@url_cache = SimpleCache::MemoryCache.new
-
-        def initialize(service_url, basic_auth_username=nil, basic_auth_password=nil, succinct_properties=true)
-          @service_url = service_url
-          @basement = Basement.new(basic_auth_username, basic_auth_password)
-          @succinct_properties = succinct_properties
-        end
-
-        def perform_request(required_params={}, optional_params={})
-          headers = required_params[:properties].delete(:headers) if required_params[:properties]
-          headers ||= {}
-          url = get_url(required_params.delete(:repositoryId), required_params[:objectId])
-
-          required_params[:succinct] ||= @succinct_properties
-          optional_params.reject! { |_, v| v.nil? }
-
-          params = transform_hash(required_params.merge(optional_params))
-
-          check(params)
-
-          response = if params.has_key?(:cmisaction)
-            if params.has_key?(:content)
-              @basement.multipart_post(url, params, headers)
-            else
-              @basement.post(url: url, body: params, headers: headers)
-            end
-          else
-            @basement.get(url: url, query: params, headers: headers)
-          end
-
-
-          result = response.body
-
-          content_type = if response.respond_to?(:content_type)
-            response.content_type
-          else
-            response.headers['Content-Type']
-          end
-
-          result = MultiJson.load(result, symbolize_keys: true) if content_type =~ /application\/json/
-
-          unless (200...300).include?(response.code.to_i)
-            if result.is_a?(Hash) && result.has_key?(:exception)
-              raise CMISRequestError, "#{response.code} -- #{result[:exception]} -- #{result[:message]}"
-            else
-              raise CMISRequestError, "#{response.code} -- #{result}"
-            end
-          end
-
-          result
-        end
-
-        private
-
-        def get_url(repository_id, cmis_object_id)
-          if repository_id.nil?
-            @service_url
-          else
-            repository_urls(repository_id)[cmis_object_id ? :root_folder_url : :repository_url]
-          end
-        end
-
-        def repository_urls(repository_id)
-          if @@url_cache[repository_id].nil?
-            repository_infos = MultiJson.load(@basement.get(url: @service_url).body , symbolize_keys: false)            
-            raise "No repository found with ID #{repository_id}." unless repository_infos.has_key?(repository_id)
-            repository_info = repository_infos[repository_id]
-            @@url_cache[repository_id] = { repository_url: repository_info['repositoryUrl'],
-                                           root_folder_url: repository_info['rootFolderUrl'] }
-          end
-          @@url_cache[repository_id]
-        end
-
-        def check(hash)
-          check_in(hash, :includeRelationships, [:none, :source, :target, :both])
-        end
-
-        def check_in(hash, key, arr)
-          value = hash[key]
-          unless value.nil?
-            unless arr.include?(value)
-              raise ArgumentError, "#{key} must be one of #{arr}."
-            end
-          end
-        end
-
-        def transform_hash(hash)
-          if hash.has_key?(:content)
-            content = hash.delete(:content)
-            hash[:content] = UploadIO.new(content[:stream],
-                                          content[:mime_type],
-                                          content[:filename])
-          end
-          if hash.has_key?(:properties)
-            props = hash.delete(:properties)
-            if props.is_a?(Hash)
-              props.each_with_index do |(id, value), index|
-                value = value.to_time if value.is_a?(Date) or value.is_a?(DateTime)
-                value = (value.to_f * 1000).to_i if value.is_a?(Time)
-                if value.is_a?(Array)
-                  hash.merge!("propertyId[#{index}]" => id)
-                  value.each_with_index { |v, idx|
-                    hash.merge!("propertyValue[#{index}][#{idx}]" => value[idx])
-                  }
-                else
-                  hash.merge!("propertyId[#{index}]" => id,
-                              "propertyValue[#{index}]" => value)
-                end
-              end
-            end
-          end
-          hash
-        end
-
-        class Basement
-
-          def initialize(user, pass)
-            @username = user
-            @password = pass
-          end
-
-          def get(params)
-            Typhoeus::Request.new(
-              params[:url],
-              userpwd: "#{@username}:#{@password}",
-              method: :get,
-              body: params[:body],
-              params: params[:query],
-              headers: params[:headers],
-              followlocation: true
-            ).run
-          end
-
-          def post(params)            
-            Typhoeus::Request.new(
-              params[:url],
-              userpwd: "#{@username}:#{@password}",
-              method: :post,
-              body: params[:body],
-              params: params[:query],
-              headers: params[:headers]
-            ).run
-          end
-
-          def multipart_post(url, options, headers)
-            url = URI.parse(url)
-            req = Net::HTTP::Post::Multipart.new(url.path, options)
-            headers.each {|key, value| req[key] = value }
-            req.basic_auth @username, @password unless @username.nil?
-            opts = url.scheme == 'https' ? { use_ssl: true , verify_mode: OpenSSL::SSL::VERIFY_NONE } : {}
-            Net::HTTP.start(url.host, url.port, opts) { |http| http.request(req) }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/yaccl/services/internal/simple_cache.rb

@@ -1,103 +0,0 @@
-=begin
-Code taken mostly from ActiveRecord::Cache
-Copyright (c) 2005-2011 David Heinemeier Hansson
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-=end
-require 'digest/md5'
-module SimpleCache
-  #TODO: add a super-class and implement FileSystemCache
-  class MemoryCache
-
-    attr_reader :cache_size
-
-    def initialize(options = {})
-      @cache = {}
-      @cache_size = 0
-      @key_access = {}
-      @max_size = options[:max_size] || 32 * 1024 #32 megabytes
-      @timeout  = options[:timeout]  || 60*30 #30 minutes
-    end
-
-    def encode(key)
-      Digest::MD5.hexdigest key
-    end
-
-    def delete(key)
-      entry = @cache.delete key
-      @key_access.delete key
-      @cache_size -= entry.size
-    end
-
-    def [](key)
-      key = encode(key)
-      entry = @cache[key]
-      if entry
-        @key_access[key] = Time.now.to_f
-      else
-        @key_access.delete key
-      end
-      entry
-    end
-
-    def []=(key, value)
-      key = encode(key)
-      old_entry = @cache[key]
-      @cache_size -= old_entry.size if old_entry
-      @key_access[key] = Time.now.to_f
-      @cache[key] = value
-      @cache_size += value.to_s.size
-      prune if @cache_size > @max_size
-    end
-
-    def has_key?(key)
-      !!@cache[encode(key)]
-    end
-
-    def prune
-      # first, the obvious cleanup
-      @cache.keys.each do |key|
-        delete(key) if stale? key
-      end
-
-      # now, try to leave it a 3/4 of it's capacity
-      target_size = 0.75 * @max_size
-
-      # delete the older entries
-      sorted_keys = @key_access.keys.sort{|a,b| @key_access[a].to_f <=> @key_access[b].to_f}
-      sorted_keys.each do |key|
-        return if @cache_size <= target_size
-        delete key
-      end
-    end
-
-    def stale?(key)
-      (Time.now.to_f - @key_access[key]) > @timeout.to_f
-    end
-
-    def clear
-      @cache = {}
-      @cache_size = 0
-      @key_access = {}
-    end
-
-  end
-end

data/lib/yaccl/services/multi_filing_services.rb

@@ -1,22 +0,0 @@
-module YACCL
-  module MultiFilingServices
-    def add_object_to_folder(repository_id, cmis_object_id, folder_id, all_versions, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'addObjectToFolder',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id,
-                  folderId: folder_id}
-      optional = {allVersions: all_versions}
-      perform_request(required, optional)
-    end
-
-    def remove_object_from_folder(repository_id, cmis_object_id, folder_id, succinct=false)
-      required = {succinct: succinct,
-                  repositoryId: repository_id,
-                  cmisaction: 'removeObjectFromFolder',
-                  objectId: cmis_object_id}
-      optional = {folderId: folder_id}
-      perform_request(required, optional)
-    end
-  end
-end