cmis_active 0.3.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2a25854af50aa7abf1f0e00ec2e3b2ffe5b48b4e1f9160a34c6458d226da96e1
+  data.tar.gz: 71e14c04c76e672b209d758ffbe67efc1ac573a8b9de5164cbc2138bf52bf1f7
+SHA512:
+  metadata.gz: 1b6b5bc2449f05a07e1a1eaa34ce50cc0d7812a5fe496b4527b7cdf4686e44c57c0c04293bea5ab4d86ddbfa267f0c7886e215ec4fb1064a8e2b8a4e574e9265
+  data.tar.gz: e26c32c51ae979d950d00254cde08a875609153baf4f3838edb545d6ea2467e101839120434e808ac675aee38209af48b0dc3eb39a4291dbd95435b0e7ba437c

data/AUTHORS

@@ -0,0 +1,9 @@
+Joeri Samson
+Michel Benevento
+Tim Felgentreff
+Stijn Van Vreckem
+linzhixing
+Jean-Denis Vauguet
+Kenneth Geerts
+Ryan Murphy
+Guillaume Hain

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2010 XAOP bvba
+
+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.

data/README.md

@@ -0,0 +1,55 @@
+# ActiveCMIS Release 0.3.4 #
+**Git**:       <http://github.com/xaop/activecmis>  
+**Documentation**: <http://rdoc.info/github/xaop/activecmis/master/frames>  
+**Author**:    XAOP bvba  
+**Copyright**: 2011  
+**License**:   MIT License  
+## Synopsis ##
+ActiveCMIS is Ruby library aimed at easing the interaction with various CMIS providers. It creates Ruby objects for CMIS objects, and creates Ruby classes that correspond to CMIS types.
+## Features ##
+- Read support for all CMIS object types
+- Write support and the ability to create new objects.
+- Support for paging
+
+## Changes since 0.3.5 ##
+- implement the possibility to set the timeout to be used by the Net::HTTP object (thanks to zedtux)
+
+## Changes since 0.3.4 ##
+- Fix a bug with checkin
+
+## Changes since 0.3.3 ##
+- added #set_versioning_state for documents (thanks to @zedtux)
+- improve checking method to make more parameters optional (and use set_versioning_state when possible)
+
+## Changes since 0.3.2 ##
+- Fix for header of PUT request (thanks to @linzhixing)
+- Improvement for integer conversion (thanks to @kennethgeerts)
+- Correctly set the default namespace (reported by @brunospy)
+
+## Changes since 0.3.1 ##
+- Does not require ntlm-http unless needed for authentication
+- Fix some issues with authentication (thanks to @beno)
+- Follow redirects for renditions (thanks to @timfel)
+
+
+## Changes since 0.2.6 ##
+The way authentication works has changed. If you previously used ActiveCMIS.connect then you're fine, otherwise the authentication changes will affect you: the authenticate methods on ActiveCMIS::Server and ActiveCMIS::Repository now return a new object, and don't change the authentication on the object itself. You can also specify optional authentication when connecting to a Server, or when calling the repository method.
+
+## Installation ##
+If you haven't installed Nokogiri yet it will be installed automatically, you will need a C compiler and the development files for libxml2.
+
+    > gem install active_cmis
+
+ActiveCMIS also depends on ntlm-http for ntlm authentication, unfortunately ntlm-http is broken on ruby 1.9.x
+This isn't a problem as long as you don't actually try to connect with NTLM authentication.
+If you actually need NTLM authentication you can use https://github.com/xaop/ntlm-http (or any other fixed version of the library), although you may need to use bundler for this to work.
+
+## Usage ##
+    require 'active_cmis'
+    repository = ActiveCMIS.load_config('configuration', 'optional_filename_for_config')
+    f = repository.root_folder
+    p f.items.map do |i| i.cmis.name end
+
+And so on ...
+
+Full documentation of the API can be found at [rdoc.info](http://rdoc.info/projects/xaop/activecmis)

data/Rakefile

@@ -0,0 +1,34 @@
+require 'rubygems'
+
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new do |t|
+    t.files   = ['lib/**/*.rb', '-', 'TODO']   # optional
+    t.options = ["--default-return", "::Object", "--query", "!@private", "--hide-void-return"]
+  end
+rescue LoadError
+  puts "Yard, or a dependency, not available. Install it with gem install yard"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "active_cmis"
+    gemspec.summary = "A library to interact with CMIS repositories through the AtomPub/REST binding"
+    gemspec.description = "A CMIS library implementing both reading and updating capabilities through the AtomPub/REST binding to CMIS."
+    gemspec.email = "joeri@xaop.com"
+    gemspec.homepage = "http://xaop.com/labs/activecmis/"
+    gemspec.authors = ["Joeri Samson"]
+
+    gemspec.add_runtime_dependency 'nokogiri', '>= 1.4.1'
+    gemspec.add_runtime_dependency 'ntlm-http', '~> 0.1', '>= 0.1.1'
+    gemspec.add_runtime_dependency 'require_relative', '~> 1.0', '>= 1.0.2'
+
+    gemspec.required_ruby_version = '>= 1.8.6'
+    gemspec.files.exclude '.gitignore'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/TODO

@@ -0,0 +1,7 @@
+- For {ActiveCMIS::Rendition#get_file Rendition#get_file}:
+  * filename should be optional, a temporary file should be created (e.g. in /tmp) if no filename is given
+- For {ActiveCMIS::Type::ClassMethods#attributes Type::ClassMethods#attributes}: inherited parameter is misleading (+ default is wrong, some other code depends on it being true by default if it would work)
+- improve use of correct Exceptions:
+  * don't throw RuntimeError anymore (except perhaps where the library code is the only code that could cause the exception)
+  * try to use correct exceptions when receiving errors from server (may need some wrapper with repository specific code)
+- improve support for queries (i.e. allow interface such as the with_ATTR_NAME way of ActiveDCTM, allow select to return only a few attributes, ...)

data/VERSION.yml

@@ -0,0 +1,5 @@
+---
+:major: 0
+:minor: 3
+:patch: 6
+:build: 

data/active_cmis.gemspec

@@ -0,0 +1,79 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: active_cmis 0.3.6 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "cmis_active"
+  s.version = "0.3.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Joeri Samson"]
+  s.date = "2015-04-09"
+  s.description = "A CMIS library implementing both reading and updating capabilities through the AtomPub/REST binding to CMIS."
+  s.email = "joeri@xaop.com"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md",
+    "TODO"
+  ]
+  s.files = [
+    "AUTHORS",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "TODO",
+    "VERSION.yml",
+    "active_cmis.gemspec",
+    "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/query_result.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",
+    "lib/active_cmis/version.rb"
+  ]
+  s.homepage = "http://xaop.com/labs/activecmis/"
+  s.required_ruby_version = Gem::Requirement.new(">= 1.8.6")
+  s.rubygems_version = "2.4.5"
+  s.summary = "A library to interact with CMIS repositories through the AtomPub/REST binding"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<nokogiri>, [">= 1.4.1"])
+      s.add_runtime_dependency(%q<ntlm-http>, [">= 0.1.1", "~> 0.1"])
+      s.add_runtime_dependency(%q<require_relative>, [">= 1.0.2", "~> 1.0"])
+    else
+      s.add_dependency(%q<nokogiri>, [">= 1.4.1"])
+      s.add_dependency(%q<ntlm-http>, [">= 0.1.1", "~> 0.1"])
+      s.add_dependency(%q<require_relative>, [">= 1.0.2", "~> 1.0"])
+    end
+  else
+    s.add_dependency(%q<nokogiri>, [">= 1.4.1"])
+    s.add_dependency(%q<ntlm-http>, [">= 0.1.1", "~> 0.1"])
+    s.add_dependency(%q<require_relative>, [">= 1.0.2", "~> 1.0"])
+  end
+end
+

data/lib/active_cmis.rb

@@ -0,0 +1,30 @@
+require 'nokogiri'
+require 'net/http'
+require 'net/https'
+require 'yaml'
+require 'logger'
+require 'require_relative'
+require_relative 'active_cmis/version'
+require_relative 'active_cmis/internal/caching'
+require_relative 'active_cmis/internal/connection'
+require_relative 'active_cmis/exceptions'
+require_relative 'active_cmis/server'
+require_relative 'active_cmis/repository'
+require_relative 'active_cmis/object'
+require_relative 'active_cmis/document'
+require_relative 'active_cmis/folder'
+require_relative 'active_cmis/policy'
+require_relative 'active_cmis/relationship'
+require_relative 'active_cmis/type'
+require_relative 'active_cmis/atomic_types'
+require_relative 'active_cmis/property_definition'
+require_relative 'active_cmis/collection.rb'
+require_relative 'active_cmis/rendition.rb'
+require_relative 'active_cmis/acl.rb'
+require_relative 'active_cmis/acl_entry.rb'
+require_relative 'active_cmis/ns'
+require_relative 'active_cmis/active_cmis'
+require_relative 'active_cmis/internal/utils'
+require_relative 'active_cmis/rel'
+require_relative 'active_cmis/attribute_prefix'
+require_relative 'active_cmis/query_result'

data/lib/active_cmis/acl.rb

@@ -0,0 +1,181 @@
+module ActiveCMIS
+  # ACLs belong to a document and have no identity of their own
+  #
+  # = Updating:
+  # The effect on documents other than the one this ACL belongs to depends
+  # on the repository.
+  #
+
+  class Acl
+    include Internal::Caching
+
+    # @return [Object] The document or object from which we got this ACL
+    attr_reader :document
+    # @return [Repository]
+    attr_reader :repository
+
+    # @private
+    def initialize(repository, document, link, _data = nil)
+      @repository = repository
+      @document   = document
+      @self_link  = case link
+                    when URI; link
+                    else URI(link)
+                    end
+      @data = _data if _data
+    end
+
+    # Returns an array with all Acl entries.
+    # @return [Array<AclEntry>]
+    def permissions
+      data.xpath("c:permission", NS::COMBINED).map do |permit|
+        principal      = nil
+        permissions    = []
+        direct         = false
+        permit.children.each do |child|
+          next unless child.namespace && child.namespace.href == NS::CMIS_CORE
+
+          case child.name
+          when "principal"
+            child.children.map do |n|
+              next unless n.namespace && n.namespace.href == NS::CMIS_CORE
+
+              if n.name == "principalId" && principal.nil?
+                principal = convert_principal(n.text)
+              end
+            end
+          when "permission"
+            permissions << child.text
+          when "direct"
+            direct = AtomicType::Boolean.xml_to_bool(child.text)
+          end
+        end
+        AclEntry.new(principal, permissions, direct)
+      end
+    end
+    cache :permissions
+
+    # An indicator that the ACL fully describes the permissions for this object.
+    # This means that there are no other security constraints.
+    def exact?
+      @exact ||= begin
+                   value = data.xpath("c:exact", NS::COMBINED)
+                   if value.empty?
+                     false
+                   elsif value.length == 1
+                     AtomicType::Boolean.xml_to_bool(value.first.text)
+                   else
+                     raise "Unexpected multiplicity of exactness ACL"
+                   end
+                 end
+    end
+
+    # @param [String, :anonymous, :world] user Can be "cmis:user" to indicate the currently logged in user.
+    # For :anonymous and :world you can use both the the active_cmis symbol or the name used by the CMIS repository
+    # @param permissions (see ActiveCMIS::AclEntry#initialize)
+    # @return [void]
+    def grant_permission(user, *permissions)
+      principal = convert_principal(user)
+
+      relevant = self.permissions.select {|p| p.principal == principal && p.direct?}
+      if relevant = relevant.first
+        self.permissions.delete relevant
+        permissions.concat(relevant.permissions)
+      end
+
+      @updated = true
+      self.permissions << AclEntry.new(principal, permissions, true)
+    end
+
+    # @param (see ActiveCMIS::Acl#grant_permission)
+    # @return [void]
+    def revoke_permission(user, *permissions)
+      principal = convert_principal(user)
+
+      keep = self.permissions.reject {|p| p.principal == principal && p.permissions.any? {|t| permissions.include? t} }
+
+      relevant = self.permissions.select {|p| p.principal == principal && p.permissions.any? {|t| permissions.include? t} }
+      changed  = relevant.map {|p| AclEntry.new(principal, p.permissions - permissions, p.direct?) }
+
+      @updated = true
+      @permissions = keep + changed
+    end
+
+    # @param user (see ActiveCMIS::Acl#grant_permission)
+    # @return [void]
+    def revoke_all_permissions(user)
+      principal = convert_principal(user)
+      @updated = true
+      permissions.reject! {|p| p.principal == principal}
+    end
+
+    # Needed to actually execute changes on the server, this method is also executed when you save an object with a modified ACL
+    # @return [void]
+    def apply
+      body = Nokogiri::XML::Builder.new do |xml|
+        xml.acl("xmlns" => NS::CMIS_CORE) do
+          permissions.each do |permission|
+            xml.permission do
+              xml.principal { xml.principalId { convert_principal(permission.principal) }}
+              xml.direct    { permission.direct? }
+              permission.each do |permit|
+                xml.permission { permit }
+              end
+            end
+          end
+        end
+      end
+      conn.put(self_link("onlyBasicPermissions" => false), body)
+      reload
+    end
+
+    # True if there are local changes to the ACL
+    def updated?
+      @updated
+    end
+
+    # @return [void]
+    def reload
+      @updated = false
+      @exact = nil
+      __reload
+    end
+
+    private
+    def self_link(options = {})
+      Internal::Utils.append_parameters(@self_link, options)
+    end
+
+    def conn
+      repository.conn
+    end
+
+    def data
+      conn.get_xml(self_link).xpath("c:acl", NS::COMBINED)
+    end
+    cache :data
+
+    def anonymous_user
+      repository.anonymous_user
+    end
+    def world_user
+      repository.world_user
+    end
+
+    def convert_principal(principal)
+      case principal
+      when :anonymous
+        anonymous_user
+      when :world
+        world
+      when anonymous_user
+        :anonymous
+      when world_user
+        :world
+      else
+        principal
+      end
+    end
+
+  end
+end

data/lib/active_cmis/acl_entry.rb

@@ -0,0 +1,26 @@
+module ActiveCMIS
+  class AclEntry
+    # @param [<String>] permissions A list of permissions, valid values depend on the repository
+    # @private
+    def initialize(principal, permissions, direct)
+      @principal = principal.freeze
+      @permissions = permissions.freeze
+      @permissions.each {|p| p.freeze}
+      @direct = direct
+    end
+
+
+    # Normal users are represented with a string, a non-logged in user is known
+    # as :anonymous, the principal :world represents the group of all logged in
+    # users.
+    # @return [String, :world, :anonymous]
+    attr_reader :principal
+    # @return [<String>] A frozen array of strings with the permissions
+    attr_reader :permissions
+
+    # True if this is the direct representation of the ACL from the repositories point of view. This means there are no hidden differences that can't be expressed within the limitations of CMIS
+    def direct?
+      @direct
+    end
+  end
+end