cmis-ruby 0.2

data/lib/cmis/query_result.rb

@@ -0,0 +1,15 @@
+module CMIS
+  class QueryResult
+
+    attr_reader :results
+    attr_reader :num_items
+    attr_reader :has_more_items
+
+    def initialize(results, num_items, has_more_items)
+      @results = results
+      @num_items = num_items
+      @has_more_items = has_more_items
+    end
+
+  end
+end

data/lib/cmis/relationship.rb

@@ -0,0 +1,18 @@
+module CMIS
+  class Relationship < Object
+
+    def initialize(raw, repository)
+      super
+      cmis_properties %w( cmis:sourceId cmis:targetId )
+    end
+
+    def source
+      repository.object(source_id)
+    end
+
+    def target
+      repository.object(target_id)
+    end
+
+  end
+end

data/lib/cmis/repository.rb

@@ -0,0 +1,112 @@
+module CMIS
+  class Repository
+
+    attr_reader :connection
+
+    def initialize(raw, connection)
+      @hash = raw
+      @hash.each_key do |key|
+        class_eval "def #{key.underscore};@hash['#{key}'];end"
+        class_eval "def #{key.gsub('repository', '').underscore};@hash['#{key}'];end" if key =~ /^repository/
+      end
+
+      @connection = connection
+    end
+
+    def new_document
+      Document.new({}, self)
+    end
+
+    def new_folder
+      Folder.new({}, self)
+    end
+
+    def new_relationship
+      Relationship.new({}, self)
+    end
+
+    def new_item
+      Item.new({}, self)
+    end
+
+    def new_policy
+      Policy.new({}, self)
+    end
+
+    def root
+      result = connection.execute!({ cmisselector: 'object',
+                                     repositoryId: id,
+                                     objectId: root_folder_id })
+
+      ObjectFactory.create(result, self)
+    end
+
+    def object(cmis_object_id)
+      result = connection.execute!({ cmisselector: 'object',
+                                     repositoryId: id,
+                                     objectId: cmis_object_id })
+
+      ObjectFactory.create(result, self)
+    end
+
+    def types
+      result = connection.execute!({ cmisselector: 'typeDescendants',
+                                     repositoryId: id,
+                                     includePropertyDefinitions: true })
+
+      construct_types(result)
+    end
+
+    def type(type_id)
+      result = connection.execute!({ cmisselector: 'typeDefinition',
+                                     repositoryId: id,
+                                     typeId: type_id })
+
+      Type.new(result, self)
+    end
+
+    def has_type?(type_id)
+      types.map(&:id).include?(type_id)
+    end
+
+    def create_type(type)
+      result = connection.execute!({ cmisaction: 'createType',
+                                     repositoryId: id,
+                                     type: MultiJson.dump(type.to_hash) })
+
+      Type.new(result, self)
+    end
+
+    def create_relationship(object)
+      raise 'Object is not a Relationship' unless object.is_a?(Relationship)
+
+      result = connection.execute!({ cmisaction: 'createRelationship',
+                                     repositoryId: id,
+                                     properties: object.properties })
+
+      ObjectFactory.create(result, self)
+    end
+
+    def content_changes(change_log_token)
+      connection.execute!({ cmisselector: 'contentChanges',
+                            repositoryId: id,
+                            changeLogToken: change_log_token })
+    end
+
+    def query(statement, options = {})
+      Query.new(self, statement, options)
+    end
+
+    private
+
+    def construct_types(a)
+      types = []
+      a.each do |t|
+        types << Type.new(t['type'], self)
+        types << construct_types(t['children']) if t.has_key?('children')
+      end
+      types.flatten
+    end
+
+  end
+end

data/lib/cmis/server.rb

@@ -0,0 +1,43 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module CMIS
+  class Server
+
+    attr_reader :connection
+
+    def initialize(options = {})
+      options.stringify_keys!
+
+      service_url = options['service_url'] || ENV['CMIS_BROWSER_URL']
+      username    = options['username']    || ENV['CMIS_USER']
+      password    = options['password']    || ENV['CMIS_PASSWORD']
+      headers     = options['headers']
+
+      raise "'service_url' must be set" unless service_url
+
+      @connection = Connection.new(service_url, username, password, headers)
+    end
+
+    def repositories
+      result = connection.execute!
+
+      result.values.map do |r|
+        Repository.new(r, connection)
+      end
+    end
+
+    def repository(repository_id)
+      result = connection.execute!({ cmisselector: 'repositoryInfo',
+                                     repositoryId: repository_id })
+
+      Repository.new(result[repository_id], connection)
+    end
+
+    def has_repository?(repository_id)
+      result = connection.execute!
+
+      result.keys.include?(repository_id)
+    end
+
+  end
+end

data/lib/cmis/type.rb

@@ -0,0 +1,106 @@
+require 'active_support/core_ext'
+
+module CMIS
+  class Type
+
+    attr_accessor :connection
+    attr_accessor :repository
+
+    def initialize(hash = {}, repository = nil)
+      @repository = repository
+      @connection = repository.connection if repository
+
+      @hash = hash.with_indifferent_access
+
+      properties = %w( id localName localNamespace queryName displayName baseId
+                       parentId description creatable fileable queryable
+                       controllablePolicy controllableACL fulltextIndexed
+                       includedInSupertypeQuery propertyDefinitions versionable
+                       contentStreamAllowed allowedSourceTypes allowedTargetTypes )
+
+      properties.each do |key|
+        class_eval "def #{key.underscore};@hash['#{key}'];end"
+        class_eval "def #{key.underscore}=(value);@hash['#{key}']=value;end"
+      end
+
+      @hash['propertyDefinitions'] ||= ActiveSupport::HashWithIndifferentAccess.new
+      @hash['propertyDefinitions'].each do |key, value|
+        @hash['propertyDefinitions'][key] = PropertyDefinition.new(value)
+      end
+    end
+
+    def add_property_definition(property)
+      property_definitions[property[:id]] = property
+    end
+
+    def create
+      repository.create_type(self)
+    end
+
+    def update(changed_property_defs)
+      new_defs = changed_property_defs.map(&:to_hash).reduce({}) do |result, element|
+        result[element[:id]] = element
+        result
+      end
+
+      hash = to_hash
+      hash['propertyDefinitions'] = new_defs
+
+      result = connection.execute! ({ cmisaction: 'updateType',
+                                      repositoryId: repository.id,
+                                      type: MultiJson.dump(hash) })
+
+      Type.new(result, repository)
+    end
+
+    def delete
+      connection.execute!({ cmisaction: 'deleteType',
+                            repositoryId: repository.id,
+                            typeId: id })
+    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 new_object
+      object = case base_id
+      when 'cmis:document'
+        Document.new({}, repository)
+      when 'cmis:folder'
+        Folder.new({}, repository)
+      when 'cmis:relationship'
+        Relationship.new({}, repository)
+      when 'cmis:policy'
+        Policy.new({}, repository)
+      when 'cmis:item'
+        Item.new({}, repository)
+      else
+        raise "Unsupported base type: #{base_id}"
+      end
+      object.object_type_id = id
+      object
+    end
+
+    def to_hash
+      @hash
+    end
+
+  end
+end

data/lib/cmis/version.rb

@@ -0,0 +1,3 @@
+module CMIS
+  VERSION = '0.2'
+end

data/readme.md

@@ -0,0 +1,23 @@
+# cmis-ruby
+
+**cmis-ruby** is a [CMIS](http://chemistry.apache.org/project/cmis.html) client library, using the the CMIS browser binding ([CMIS 1.1](http://docs.oasis-open.org/cmis/CMIS/v1.1/CMIS-v1.1.html)) for Ruby.
+
+## Running Test
+
+Running the tests requires a running CMIS server.
+
+    rake
+
+## TODO
+
+* query properties, not *
+* string / symbol consistency
+* better exceptions and handling
+* headers / params in low level (options)
+* facilitate copy between servers (make a flow)
+* improve exists for repo / type
+* caching
+
+## Contributing
+
+Write some code. Run tests. Open a pull request.

data/spec/document_spec.rb

@@ -0,0 +1,45 @@
+require_relative './helper'
+
+describe CMIS::Document do
+
+  before :all do
+    @repo = create_repository('test')
+  end
+
+  after :all do
+    delete_repository('test')
+  end
+
+  it 'create_in_folder with content' do
+    new_object = @repo.new_document
+    new_object.name = 'doc1'
+    new_object.object_type_id = 'cmis:document'
+    new_object.set_content(StringIO.new('content1'), 'text/plain', 'doc1.txt') # set content on detached doc
+    doc = new_object.create_in_folder(@repo.root)
+    doc.name.should eq 'doc1'
+    doc.content_stream_mime_type.should eq 'text/plain'
+    doc.content_stream_file_name.should eq 'doc1.txt'
+    doc.content.should eq 'content1'
+    doc.delete
+  end
+
+  it 'create_in_folder without content' do
+    new_object = @repo.new_document
+    new_object.name = 'doc2'
+    new_object.object_type_id = 'cmis:document'
+    doc = new_object.create_in_folder(@repo.root)
+    doc.name.should eq 'doc2'
+    doc.content.should be nil
+    doc.delete
+  end
+
+  # it 'set content - attached' do
+  #   new_object = @repo.new_document
+  #   new_object.name = 'doc3'
+  #   new_object.object_type_id = 'cmis:document'
+  #   doc = @repo.root.create(new_object)
+  #   doc.set_content(StringIO.new('content3'), 'text/plain', 'doc3.txt') # set content on attached doc
+  #   doc.content.should eq 'content3'
+  #   doc.delete
+  # end
+end

data/spec/folder_spec.rb

@@ -0,0 +1,75 @@
+require_relative './helper'
+
+describe CMIS::Folder do
+
+  before :all do
+    @repo = create_repository('test')
+  end
+
+  after :all do
+    delete_repository('test')
+  end
+
+  it 'parent - root' do
+    @repo.root.parent.should be_nil
+  end
+
+  it 'parent - root child' do
+    new_object = @repo.new_folder
+    new_object.name = 'folder1'
+    new_object.object_type_id = 'cmis:folder'
+    folder = @repo.root.create(new_object)
+    folder.parent.cmis_object_id.should eq @repo.root_folder_id
+    folder.delete
+  end
+
+  it 'create document' do
+    new_object = @repo.new_document
+    new_object.name = 'doc1'
+    new_object.object_type_id = 'cmis:document'
+    new_object.set_content(StringIO.new('apple is a fruit'), 'text/plain', 'apple.txt')
+    object = @repo.root.create(new_object)
+    object.should be_a_kind_of CMIS::Document
+    object.name.should eq 'doc1'
+    object.content_stream_mime_type.should eq 'text/plain'
+    object.content_stream_file_name.should eq 'apple.txt'
+    object.content.should eq 'apple is a fruit'
+    object.delete
+  end
+
+  it 'create folder' do
+    new_object = @repo.new_folder
+    new_object.name = 'folder1'
+    new_object.object_type_id = 'cmis:folder'
+    object = @repo.root.create(new_object)
+    object.should be_a_kind_of CMIS::Folder
+    object.name.should eq 'folder1'
+    object.delete
+  end
+
+  it 'create relationship' do
+    new_object = @repo.new_relationship
+    new_object.name = 'rel1'
+    new_object.object_type_id = 'cmis:relationship'
+    lambda { @repo.root.create(new_object) }.should raise_exception
+  end
+
+  it 'create item' do
+    begin
+      new_object = @repo.new_item
+      new_object.name = 'item1'
+      new_object.object_type_id = 'cmis:item'
+      object = @repo.root.create(new_object)
+      object.should be_a_kind_of CMIS::Item
+      object.name.should eq 'item1'
+      object.delete
+    end unless @repo.cmis_version_supported < '1.1'
+  end
+
+  it 'create object' do
+    new_object = CMIS::Object.new({}, @repo)
+    new_object.name = 'object1'
+    new_object.object_type_id = 'cmis:folder'
+    lambda { @repo.root.create(new_object) }.should raise_exception
+  end
+end