yaccl 0.1.5 → 1.0.pre.alpha

data/lib/yaccl/services/navigation_services.rb

@@ -1,84 +0,0 @@
-module YACCL
-  module NavigationServices
-    def get_children(repository_id, folder_id, filter, order_by, include_allowable_actions, include_relationships, rendition_filter, include_path_segment, max_items, skip_count, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'children',
-                  repositoryId: repository_id,
-                  objectId: folder_id}
-      optional = {filter: filter,
-                  orderBy: order_by,
-                  includeAllowableActions: include_allowable_actions,
-                  includeRelationships: include_relationships,
-                  renditionFilter: rendition_filter,
-                  includePathSegment: include_path_segment,
-                  maxItems: max_items,
-                  skipCount: skip_count}
-      perform_request(required, optional)
-    end
-
-    def get_descendants(repository_id, folder_id, depth, filter, include_allowable_actions, include_relationships, rendition_filter, include_path_segment, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'descendants',
-                  repositoryId: repository_id,
-                  objectId: folder_id}
-      optional = {depth: depth,
-                  filter: filter,
-                  includeAllowableActions: include_allowable_actions,
-                  includeRelationships: include_relationships,
-                  renditionFilter: rendition_filter,
-                  includePathSegment: include_path_segment}
-      perform_request(required, optional)
-    end
-
-    def get_folder_tree(repository_id, folder_id, depth, filter, include_allowable_actions, include_relationships, rendition_filter, include_path_segment, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'folderTree',
-                  repositoryId: repository_id,
-                  objectId: folder_id}
-      optional = {depth: depth,
-                  filter: filter,
-                  includeAllowableActions: include_allowable_actions,
-                  includeRelationships: include_relationships,
-                  renditionFilter: rendition_filter,
-                  includePathSegment: include_path_segment}
-      perform_request(required, optional)
-    end
-
-    def get_folder_parent(repository_id, folder_id, filter, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'parent',
-                  repositoryId: repository_id,
-                  objectId: folder_id}
-      optional = {filter: filter}
-      perform_request(required, optional)
-    end
-
-    def get_object_parents(repository_id, cmis_object_id, filter, include_allowable_actions, include_relationships, rendition_filter, include_relative_path_segment, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'parents',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {filter: filter,
-                  includeAllowableActions: include_allowable_actions,
-                  includeRelationships: include_relationships,
-                  renditionFilter: rendition_filter,
-                  includeRelativePathSegment: include_relative_path_segment}
-      perform_request(required, optional)
-    end
-
-    def get_checked_out_docs(repository_id, folder_id, filter, order_by, include_allowable_actions, include_relationships, rendition_filter, max_items, skip_count, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'checkedout',
-                  repositoryId: repository_id}
-      optional =  {objectId: folder_id,
-                   filter: filter,
-                   orderBy: order_by,
-                   includeAllowableActions: include_allowable_actions,
-                   includeRelationships: include_relationships,
-                   renditionFilter: rendition_filter,
-                   maxItems: max_items,
-                   skipCount: skip_count}
-      perform_request(required, optional)
-    end
-  end
-end

data/lib/yaccl/services/object_services.rb

@@ -1,211 +0,0 @@
-module YACCL
-  module ObjectServices
-    def get_object(repository_id, cmis_object_id, filter, include_allowable_actions, include_relationships, rendition_filter, include_policy_ids, include_acl, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'object',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {filter: filter,
-                  includeAllowableActions: include_allowable_actions,
-                  includeRelationships: include_relationships,
-                  renditionFilter: rendition_filter,
-                  includePolicyIds: include_policy_ids,
-                  includeAcl: include_acl}
-      perform_request(required, optional)
-    end
-
-    def get_properties(repository_id, cmis_object_id, filter, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'properties',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {filter: filter}
-      perform_request(required, optional)
-    end
-
-    def create_document(repository_id, properties, folder_id, content, versioning_state, policies, add_aces, remove_aces, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'createDocument',
-                  repositoryId: repository_id,
-                  properties: properties,
-                  objectId: folder_id}
-      optional = {folderId: folder_id,
-                  content: content,
-                  versioningState: versioning_state,
-                  policies: policies,
-                  addACEs: add_aces,
-                  removeACEs: remove_aces}
-      perform_request(required, optional)
-    end
-
-    def create_document_from_source(repository_id, source_id, properties, folder_id, versioning_state, policies, add_aces, remove_aces, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'createDocument',
-                  repositoryId: repository_id,
-                  sourceId: source_id}
-      optional = {properties: properties,
-                  objectId: folder_id,
-                  versioningState: versioning_state,
-                  policies: policies,
-                  addACEs: add_aces,
-                  removeACEs: remove_aces}
-      perform_request(required, optional)
-    end
-
-    def create_folder(repository_id, properties, folder_id, policies, add_aces, remove_aces, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'createFolder',
-                  repositoryId: repository_id,
-                  properties: properties,
-                  objectId: folder_id}
-      optional = {policies: policies,
-                  addACEs: add_aces,
-                  removeACEs: remove_aces}
-      perform_request(required, optional)
-    end
-
-    def create_relationship(repository_id, properties, policies, add_aces, remove_aces, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'createRelationship',
-                  repositoryId: repository_id,
-                  properties: properties}
-      optional  = {policies: policies,
-                   addACEs: add_aces,
-                   removeACEs: remove_aces}
-      perform_request(required, optional)
-    end
-
-    def create_policy(repository_id, properties, folder_id, policies, add_aces, remove_aces, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'createPolicy',
-                  repositoryId: repository_id,
-                  properties: properties}
-      optional = {objectId: folder_id,
-                  policies: policies,
-                  addACEs: add_aces,
-                  removeACEs: remove_aces}
-      perform_request(required, optional)
-    end
-
-    def create_item(repository_id, properties, folder_id, policies, add_aces, remove_aces, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'createItem',
-                  repositoryId: repository_id,
-                  properties: properties}
-      optional = {objectId: folder_id,
-                  policies: policies,
-                  addACEs: add_aces,
-                  removeACEs: remove_aces}
-      perform_request(required, optional)
-    end
-
-    def get_allowable_actions(repository_id, cmis_object_id, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'allowableActions',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      perform_request(required)
-    end
-
-    def get_renditions(repository_id, cmis_object_id, rendition_filter, max_items, skip_count, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'renditions',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {renditionFilter: rendition_filter,
-                  maxItems: max_items,
-                  skipCount: skip_count}
-      perform_request(required, optional)
-    end
-
-    def get_object_by_path(repository_id, path, filter, include_allowable_actions, include_relationships, rendition_filter, include_policy_ids, include_acl, succinct=false)
-      raise 'Not supported.'
-    end
-
-    def get_content_stream(repository_id, cmis_object_id, stream_id, offset, length, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'content',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {streamId: stream_id,
-                  offset: offset,
-                  length: length}
-      perform_request(required, optional)
-    end
-
-    def update_properties(repository_id, cmis_object_id, change_token, properties, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'update',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id,
-                  properties: properties}
-      optional = {changeToken: change_token}
-      perform_request(required, optional)
-    end
-
-    def bulk_update_properties(repository_id, cmis_object_ids_and_change_tokens, properties, add_secondary_type_ids, remove_secondary_type_ids, succinct=false)
-      # TODO
-    end
-
-    def move_object(repository_id, cmis_object_id, target_folder_id, source_folder_id, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'move',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id,
-                  targetFolderId: target_folder_id,
-                  sourceFolderId: source_folder_id}
-      perform_request(required)
-    end
-
-    def delete_object(repository_id, cmis_object_id, all_versions, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'delete',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {allVersions: all_versions}
-      perform_request(required, optional)
-    end
-
-    def delete_tree(repository_id, folder_id, all_versions, unfile_objects, continue_on_failure, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'deleteTree',
-                  repositoryId: repository_id,
-                  objectId: folder_id}
-      optional = {allVersions: all_versions,
-                  unfileObjects: unfile_objects,
-                  continueOnFailure: continue_on_failure}
-      perform_request(required, optional)
-    end
-
-    def set_content_stream(repository_id, cmis_object_id, overwrite_flag, change_token, content, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'setContent',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id,
-                  content: content}
-      optional = {overwriteFlag: overwrite_flag,
-                  changeToken:change_token}
-      perform_request(required, optional)
-    end
-
-    def delete_content_stream(repository_id, cmis_object_id, change_token, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'deleteContent',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {changeToken: change_token}
-      perform_request(required, optional)
-    end
-
-    def append_content_stream(repository_id, cmis_object_id, change_token, content, is_last_chunk, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'appendContent',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id,
-                  content: content}
-      optional = {isLastChunk: is_last_chunk,
-                  changeToken: change_token}
-      perform_request(required, optional)
-    end
-  end
-end

data/lib/yaccl/services/policy_services.rb

@@ -1,30 +0,0 @@
-module YACCL
-  module PolicyServices
-    def apply_policy(repository_id, policy_id, cmis_object_id, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'applyPolicy',
-                  repositoryId: repository_id,
-                  policyId: policy_id,
-                  objectId: cmis_object_id}
-      perform_request(required)
-    end
-
-    def remove_policy(repository_id, policy_id, cmis_object_id, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'removePolicy',
-                  repositoryId: repository_id,
-                  policyId: policy_id,
-                  objectId: cmis_object_id}
-      perform_request(required)
-    end
-
-    def get_applied_policies(repository_id, cmis_object_id, filter, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'policies',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {filter: filter}
-      perform_request(required, optional)
-    end
-  end
-end

data/lib/yaccl/services/relationship_services.rb

@@ -1,18 +0,0 @@
-module YACCL
-  module RelationshipServices
-    def get_object_relationships(repository_id, cmis_object_id, include_sub_relationship_types, relationship_direction, type_id, filter, include_allowable_actions, max_items, skip_count, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'relationships',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {includeSubRelationshipTypes: include_sub_relationship_types,
-                  relationshipDirection: relationship_direction,
-                  typeId: type_id,
-                  filter: filter,
-                  includeAllowableActions: include_allowable_actions,
-                  maxItems: max_items,
-                  skipCount: skip_count}
-      perform_request(required, optional)
-    end
-  end
-end

data/lib/yaccl/services/repository_services.rb

@@ -1,67 +0,0 @@
-module YACCL
-  module RepositoryServices
-    def get_repositories
-      perform_request
-    end
-
-    def get_repository_info(repository_id, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'repositoryInfo',
-                  repositoryId: repository_id}
-      perform_request(required)
-    end
-
-    def get_type_children(repository_id, type_id, include_property_definitions, max_items, skip_count, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'typeChildren',
-                  repositoryId: repository_id}
-      optional = {typeId: type_id,
-                  includePropertyDefinitions: include_property_definitions,
-                  maxItems: max_items,
-                  skipCount: skip_count}
-      perform_request(required, optional)
-    end
-
-    def get_type_descendants(repository_id, type_id, depth, include_property_definitions, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'typeDescendants',
-                  repositoryId: repository_id}
-      optional = {typeId: type_id,
-                  depth: depth,
-                  includePropertyDefinitions: include_property_definitions}
-      perform_request(required, optional)
-    end
-
-    def get_type_definition(repository_id, type_id, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'typeDefinition',
-                  repositoryId: repository_id,
-                  typeId: type_id}
-      perform_request(required)
-    end
-
-    def create_type(repository_id, type, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'createType',
-                  repositoryId: repository_id,
-                  type: MultiJson.dump(type)}
-      perform_request(required)
-    end
-
-    def update_type(repository_id, type, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'updateType',
-                  repositoryId: repository_id,
-                  type: MultiJson.dump(type)}
-      perform_request(required)
-    end
-
-    def delete_type(repository_id, type_id, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'deleteType',
-                  repositoryId: repository_id,
-                  typeId: type_id}
-      perform_request(required)
-    end
-  end
-end

data/lib/yaccl/services/versioning_services.rb

@@ -1,69 +0,0 @@
-module YACCL
-  module VersioningServices  # TODO Check 'version_series_id' confusion.
-    def check_out(repository_id, cmis_object_id, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'checkOut',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      perform_request(required)
-    end
-
-    def cancel_check_out(repository_id, cmis_object_id, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'cancelCheckOut',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      perform_request(required)
-    end
-
-    def check_in(repository_id, cmis_object_id, major, properties, content, checkin_comment, policies, add_aces, remove_aces, succinct=false)
-      required = {succinct: succinct,
-                  cmisaction: 'checkIn',
-                  repositoryId: repository_id,
-                  objectId: cmis_object_id}
-      optional = {major: major,
-                  properties: properties,
-                  content: content,
-                  checkinComment: checkin_comment,
-                  policies: policies,
-                  addACEs: add_aces,
-                  removeACEs: remove_aces}
-      perform_request(required, optional)
-    end
-
-    def get_object_of_latest_version(repository_id, version_series_id, major, filter, include_allowable_actions, include_relationships, rendition_filter, include_policy_ids, include_acl, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'object',
-                  repositoryId: repository_id,
-                  objectId: version_series_id}
-      optional = {major: major,
-                  filter: filter,
-                  includeAllowableActions: include_allowable_actions,
-                  includeRelationships: include_relationships,
-                  renditionFilter: rendition_filter,
-                  includePolicyIds: include_policy_ids,
-                  includeACL: include_acl}
-      perform_request(required, optional)
-    end
-
-    def get_properties_of_latest_version(repository_id, version_series_id, major, filter, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'properties',
-                  repositoryId: repository_id,
-                  objectId: version_series_id}
-      optional = {major: major,
-                  filter: filter}
-      perform_request(required, optional)
-    end
-
-    def get_all_versions(repository_id, version_series_id, filter, include_allowable_actions, succinct=false)
-      required = {succinct: succinct,
-                  cmisselector: 'versions',
-                  repositoryId: repository_id,
-                  objectId: version_series_id}
-      optional = {filter: filter,
-                  includeAllowableActions: include_allowable_actions}
-      perform_request(required, optional)
-    end
-  end
-end

data/lib/yaccl/services.rb

@@ -1,34 +0,0 @@
-require 'yaccl/services/internal/browser_binding_service'
-require 'yaccl/services/repository_services'
-require 'yaccl/services/navigation_services'
-require 'yaccl/services/object_services'
-require 'yaccl/services/multi_filing_services'
-require 'yaccl/services/discovery_services'
-require 'yaccl/services/versioning_services'
-require 'yaccl/services/relationship_services'
-require 'yaccl/services/policy_services'
-require 'yaccl/services/acl_services'
-
-module YACCL
-  module Services
-    class << self
-      def perform_request(*params)
-        service = Internal::BrowserBindingService.new(YACCL::SERVICE_URL,
-                                                      YACCL::BASIC_AUTH_USERNAME,
-                                                      YACCL::BASIC_AUTH_PASSWORD,
-                                                      YACCL::SUCCINCT_PROPERTIES)
-        service.perform_request(*params)
-      end
-
-      include RepositoryServices
-      include NavigationServices
-      include ObjectServices
-      include MultiFilingServices
-      include DiscoveryServices
-      include VersioningServices
-      include RelationshipServices
-      include PolicyServices
-      include ACLServices
-    end
-  end
-end

data/spec/model/relationship_spec.rb

@@ -1,15 +0,0 @@
-require_relative '../helper'
-
-describe YACCL::Model::Relationship do
-
-  it 'should make properties accessible through method' do
-    new_object = YACCL::Model::Relationship.new('repoId', {succinctProperties: {myProp: 'myValue'}})
-    new_object.myProp.should eq 'myValue'
-  end
-
-  it 'should raise methodmissing for unknown property' do
-    new_object = YACCL::Model::Relationship.new('repoId', {succinctProperties: {'myProp' => 'myValue'}})
-    expect {new_object.myOtherProp}.to raise_error(NoMethodError, /undefined method `myOtherProp'/)
-  end
-
-end

data/spec/model/repository_spec.rb

@@ -1,138 +0,0 @@
-require_relative '../helper'
-
-describe YACCL::Model::Repository do
-
-  context 'generic' do
-    before do
-      @id = 'meta'
-      @repo = YACCL::Model::Server.repository(@id)
-    end
-
-    it 'id' do
-      @repo.id.should.eql? @id
-    end
-
-    it 'fields' do
-      @repo.id.should_not be_nil
-      @repo.name.should_not be_nil
-      @repo.product_version.should_not be_nil
-      @repo.description.should_not be_nil
-      @repo.root_folder_id.should_not be_nil
-      @repo.capabilities.should_not be_nil
-      @repo.url.should_not be_nil
-      @repo.changes_on_type.should_not be_nil
-      @repo.root_folder_url.should_not be_nil
-      @repo.product_name.should_not be_nil
-      @repo.product_version.should_not be_nil
-
-      %w(1.0 1.1).should include @repo.cmis_version_supported
-    end
-
-    it 'new object' do
-      @repo.new_folder.should be_a_kind_of YACCL::Model::Folder
-      @repo.new_document.should be_a_kind_of YACCL::Model::Document
-      @repo.new_relationship.should be_a_kind_of YACCL::Model::Relationship
-      @repo.new_policy.should be_a_kind_of YACCL::Model::Policy
-      @repo.new_item.should be_a_kind_of YACCL::Model::Item
-    end
-
-    it 'root' do
-      root = @repo.root
-      root.should be_a_kind_of YACCL::Model::Folder
-      root.cmis_object_id.should eq @repo.root_folder_id
-    end
-
-    it 'object' do
-      id = @repo.root_folder_id
-      object = @repo.object(id)
-      object.should be_a_kind_of YACCL::Model::Folder
-      object.cmis_object_id.should eq id
-    end
-
-    it 'type - document' do
-      document = @repo.type('cmis:document')
-      document.should be_a_kind_of YACCL::Model::Type
-      document.id.should eq 'cmis:document'
-    end
-
-    it 'type - folder' do
-      folder = @repo.type('cmis:folder')
-      folder.should be_a_kind_of YACCL::Model::Type
-      folder.id.should eq 'cmis:folder'
-    end
-  end
-
-  context 'upn' do
-    before :all do
-      @repo = create_repository('testrepository')
-    end
-
-    after :all do
-      delete_repository('testrepository')
-    end
-
-    it 'type - relationship' do
-      relationship = @repo.type('cmis:relationship')
-      relationship.should be_a_kind_of YACCL::Model::Type
-      relationship.id.should eq 'cmis:relationship'
-    end
-
-    it 'type - policy' do
-      policy = @repo.type('cmis:policy')
-      policy.should be_a_kind_of YACCL::Model::Type
-      policy.id.should eq 'cmis:policy'
-    end
-
-    it 'type - item' do
-      begin
-        item = @repo.type('cmis:item')
-        item.should be_a_kind_of YACCL::Model::Type
-        item.id.should eq 'cmis:item'
-      end unless @repo.cmis_version_supported < '1.1'
-    end
-
-    it 'create, get, delete type - document' do
-      begin
-        type_id = 'apple'
-
-        type = YACCL::Model::Type.new
-        type.id = type_id
-        type.local_name = 'apple'
-        type.query_name = 'apple'
-        type.display_name = 'apple'
-        type.parent_id = 'cmis:document'
-        type.base_id = 'cmis:document'
-        type.description = 'appel'
-        type.creatable = true
-        type.fileable = true
-        type.queryable = true
-        type.controllable_policy = true
-        type.controllable_acl = true
-        type.fulltext_indexed = true
-        type.included_in_supertype_query = true
-        type.content_stream_allowed = 'allowed'
-        type.versionable = false
-
-        type.add_property_definition(id: 'color',
-                                     localName: 'color',
-                                     queryName: 'color',
-                                     displayName: 'color',
-                                     description: 'color',
-                                     propertyType: 'string',
-                                     cardinality: 'single',
-                                     updatability: 'readwrite',
-                                     inherited: false,
-                                     required: false,
-                                     queryable: true,
-                                     orderable: true)
-
-        @repo.create_type(type)
-        @repo.type(type_id).tap do |t|
-          t.should be_a_kind_of YACCL::Model::Type
-          t.id.should eq type_id
-        end
-        @repo.type(type_id).delete
-      end unless @repo.cmis_version_supported < '1.1'
-    end
-  end
-end

data/spec/model/server_spec.rb

@@ -1,16 +0,0 @@
-require_relative '../helper'
-
-describe YACCL::Model::Server do
-  it 'repositories' do
-    YACCL::Model::Server.repositories.each do |repo|
-      repo.should be_a_kind_of YACCL::Model::Repository
-    end
-  end
-
-  it 'repository' do
-    id = 'meta'
-    repo = YACCL::Model::Server.repository(id)
-    repo.should be_a_kind_of YACCL::Model::Repository
-    repo.id.should eq id
-  end
-end