tilia-dav 3.1.0.pre.alpha2

data/lib/tilia/dav/xml/request/sync_collection_report.rb

@@ -0,0 +1,102 @@
+module Tilia
+  module Dav
+    module Xml
+      module Request
+        # SyncCollection request parser.
+        #
+        # This class parses the {DAV:}sync-collection reprot, as defined in:
+        #
+        # http://tools.ietf.org/html/rfc6578#section-3.2
+        class SyncCollectionReport
+          include Tilia::Xml::XmlDeserializable
+
+          # The sync-token the client supplied for the report.
+          #
+          # @var string|null
+          attr_accessor :sync_token
+
+          # The 'depth' of the sync the client is interested in.
+          #
+          # @var int
+          attr_accessor :sync_level
+
+          # Maximum amount of items returned.
+          #
+          # @var int|null
+          attr_accessor :limit
+
+          # The list of properties that are being requested for every change.
+          #
+          # @var null|array
+          attr_accessor :properties
+
+          # The deserialize method is called during xml parsing.
+          #
+          # This method is called statictly, this is because in theory this method
+          # may be used as a type of constructor, or factory method.
+          #
+          # Often you want to return an instance of the current class, but you are
+          # free to return other data as well.
+          #
+          # You are responsible for advancing the reader to the next element. Not
+          # doing anything will result in a never-ending loop.
+          #
+          # If you just want to skip parsing for this element altogether, you can
+          # just call reader.next
+          #
+          # reader.parse_inner_tree will parse the entire sub-tree, and advance to
+          # the next element.
+          #
+          # @param Reader reader
+          # @return mixed
+          def self.xml_deserialize(reader)
+            instance = new
+
+            reader.push_context
+
+            reader.element_map['{DAV:}prop'] = Tilia::Xml::Element::Elements
+            elems = Tilia::Xml::Element::KeyValue.xml_deserialize(reader)
+
+            reader.pop_context
+
+            required = [
+              '{DAV:}sync-token',
+              '{DAV:}prop'
+            ]
+
+            required.each do |elem|
+              unless elems.include?(elem)
+                fail Exception::BadRequest, "The #{elem} element in the {DAV:}sync-collection report is required"
+              end
+            end
+
+            instance.properties = elems['{DAV:}prop']
+            instance.sync_token = elems['{DAV:}sync-token']
+
+            if elems.key?('{DAV:}limit')
+              nresults = nil
+              elems['{DAV:}limit'].each do |child|
+                if child['name'] == '{DAV:}nresults'
+                  nresults = child['value'].to_i
+                end
+              end
+              instance.limit = nresults
+            end
+
+            if elems.key?('{DAV:}sync-level')
+              value = elems['{DAV:}sync-level']
+              if value == 'infinity'
+                value = Server::DEPTH_INFINITY
+              else
+                value = value.to_i
+              end
+              instance.sync_level = value
+            end
+
+            instance
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/xml/response.rb

@@ -0,0 +1,9 @@
+module Tilia
+  module Dav
+    module Xml
+      module Response
+        require 'tilia/dav/xml/response/multi_status'
+      end
+    end
+  end
+end

data/lib/tilia/dav/xml/response/multi_status.rb

@@ -0,0 +1,108 @@
+module Tilia
+  module Dav
+    module Xml
+      module Response
+        # WebDAV MultiStatus parser
+        #
+        # This class parses the {DAV:}multistatus response, as defined in:
+        # https://tools.ietf.org/html/rfc4918#section-14.16
+        #
+        # And it also adds the {DAV:}synctoken change from:
+        # http://tools.ietf.org/html/rfc6578#section-6.4
+        class MultiStatus
+          include Tilia::Xml::Element
+
+          # The responses
+          #
+          # @var \Sabre\DAV\Xml\Element\Response[]
+          # RUBY: attr_accessor :responses
+
+          # A sync token (from RFC6578).
+          #
+          # @var string
+          # RUBY: attr_accessor :sync_token
+
+          # Constructor
+          #
+          # @param \Sabre\DAV\Xml\Element\Response[] responses
+          # @param string sync_token
+          def initialize(responses, sync_token = nil)
+            @responses = responses
+            @sync_token = sync_token
+          end
+
+          # Returns the response list.
+          #
+          # @return \Sabre\DAV\Xml\Element\Response[]
+          attr_reader :responses
+
+          # Returns the sync-token, if available.
+          #
+          # @return string|null
+          attr_reader :sync_token
+
+          # The serialize method is called during xml writing.
+          #
+          # It should use the writer argument to encode this object into XML.
+          #
+          # Important note: it is not needed to create the parent element. The
+          # parent element is already created, and we only have to worry about
+          # attributes, child elements and text (if any).
+          #
+          # Important note 2: If you are writing any new elements, you are also
+          # responsible for closing them.
+          #
+          # @param Writer writer
+          # @return void
+          def xml_serialize(writer)
+            responses.each do |response|
+              writer.write_element('{DAV:}response', response)
+            end
+
+            writer.write_element('{DAV:}sync-token', @sync_token) if @sync_token
+          end
+
+          # The deserialize method is called during xml parsing.
+          #
+          # This method is called statictly, this is because in theory this method
+          # may be used as a type of constructor, or factory method.
+          #
+          # Often you want to return an instance of the current class, but you are
+          # free to return other data as well.
+          #
+          # You are responsible for advancing the reader to the next element. Not
+          # doing anything will result in a never-ending loop.
+          #
+          # If you just want to skip parsing for this element altogether, you can
+          # just call reader.next
+          #
+          # reader.parse_inner_tree will parse the entire sub-tree, and advance to
+          # the next element.
+          #
+          # @param Reader reader
+          # @return mixed
+          def self.xml_deserialize(reader)
+            element_map = reader.element_map
+            element_map['{DAV:}prop'] = Element::Prop
+            elements = reader.parse_inner_tree(element_map)
+
+            responses = []
+            sync_token = nil
+
+            if elements && elements.any?
+              elements.each do |elem|
+                if elem['name'] == '{DAV:}response'
+                  responses << elem['value']
+                elsif elem['name'] == '{DAV:}sync-token'
+                  sync_token = elem['value']
+                end
+              end
+            end
+
+            new(responses, sync_token)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/xml/service.rb

@@ -0,0 +1,42 @@
+module Tilia
+  module Dav
+    module Xml
+      # XML service for WebDAV
+      class Service < Tilia::Xml::Service
+        # This is a list of XML elements that we automatically map to PHP classes.
+        #
+        # For instance, this list may contain an entry `{DAV:}propfind` that would
+        # be mapped to Sabre\DAV\Xml\Request\PropFind
+        attr_accessor :element_map
+
+        # This is a default list of namespaces.
+        #
+        # If you are defining your own custom namespace, add it here to reduce
+        # bandwidth and improve legibility of xml bodies.
+        #
+        # @var array
+        attr_accessor :namespace_map
+
+        def initialize
+          super
+          @element_map = {
+            '{DAV:}multistatus' => Tilia::Dav::Xml::Response::MultiStatus,
+            '{DAV:}response'    => Tilia::Dav::Xml::Element::Response,
+
+            # Requests
+            '{DAV:}propfind'       => Tilia::Dav::Xml::Request::PropFind,
+            '{DAV:}propertyupdate' => Tilia::Dav::Xml::Request::PropPatch,
+            '{DAV:}mkcol'          => Tilia::Dav::Xml::Request::MkCol,
+
+            # Properties
+            '{DAV:}resourcetype' => Tilia::Dav::Xml::Property::ResourceType
+          }
+          @namespace_map = {
+            'DAV:'                   => 'd',
+            'http://sabredav.org/ns' => 's'
+          }
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav_acl.rb

@@ -0,0 +1,16 @@
+module Tilia
+  module DavAcl
+    require 'tilia/dav_acl/i_principal'
+    require 'tilia/dav_acl/i_acl'
+    require 'tilia/dav_acl/i_principal_collection'
+
+    require 'tilia/dav_acl/abstract_principal_collection'
+    require 'tilia/dav_acl/exception'
+    require 'tilia/dav_acl/fs'
+    require 'tilia/dav_acl/plugin'
+    require 'tilia/dav_acl/principal_backend'
+    require 'tilia/dav_acl/principal_collection'
+    require 'tilia/dav_acl/principal'
+    require 'tilia/dav_acl/xml'
+  end
+end

data/lib/tilia/dav_acl/abstract_principal_collection.rb

@@ -0,0 +1,143 @@
+module Tilia
+  module DavAcl
+    # Principals Collection
+    #
+    # This is a helper class that easily allows you to create a collection that
+    # has a childnode for every principal.
+    #
+    # To use this class, simply implement the getChildForPrincipal method.
+    class AbstractPrincipalCollection < Dav::Collection
+      include IPrincipalCollection
+
+      protected
+
+      # Principal backend
+      #
+      # @var PrincipalBackend\BackendInterface
+      attr_accessor :principal_backend
+
+      # The path to the principals we're listing from.
+      #
+      # @var string
+      attr_accessor :principal_prefix
+
+      public
+
+      # If this value is set to true, it effectively disables listing of users
+      # it still allows user to find other users if they have an exact url.
+      #
+      # @var bool
+      attr_accessor :disable_listing
+
+      # Creates the object
+      #
+      # This object must be passed the principal backend. This object will
+      # filter all principals from a specified prefix (principal_prefix). The
+      # default is 'principals', if your principals are stored in a different
+      # collection, override principal_prefix
+      #
+      #
+      # @param PrincipalBackend\BackendInterface principal_backend
+      # @param string principal_prefix
+      def initialize(principal_backend, principal_prefix = 'principals')
+        @disable_listing = false
+        @principal_prefix = principal_prefix
+        @principal_backend = principal_backend
+      end
+
+      # This method returns a node for a principal.
+      #
+      # The passed array contains principal information, and is guaranteed to
+      # at least contain a uri item. Other properties may or may not be
+      # supplied by the authentication backend.
+      #
+      # @param array principal_info
+      # @return IPrincipal
+      def child_for_principal(principal_info)
+      end
+
+      # Returns the name of this collection.
+      #
+      # @return string
+      def name
+        name = Http::UrlUtil.split_path(@principal_prefix)[1]
+        name
+      end
+
+      # Return the list of users
+      #
+      # @return array
+      def children
+        fail Dav::Exception::MethodNotAllowed, 'Listing members of this collection is disabled' if @disable_listing
+
+        children = []
+        @principal_backend.principals_by_prefix(@principal_prefix).each do |principal_info|
+          children << child_for_principal(principal_info)
+        end
+
+        children
+      end
+
+      # Returns a child object, by its name.
+      #
+      # @param string name
+      # @throws DAV\Exception\NotFound
+      # @return IPrincipal
+      def child(name)
+        principal_info = @principal_backend.principal_by_path("#{@principal_prefix}/#{name}")
+        fail Dav::Exception::NotFound, "Principal with name #{name} not found" unless principal_info
+        child_for_principal(principal_info)
+      end
+
+      # This method is used to search for principals matching a set of
+      # properties.
+      #
+      # This search is specifically used by RFC3744's principal-property-search
+      # REPORT. You should at least allow searching on
+      # http://sabredav.org/ns}email-address.
+      #
+      # The actual search should be a unicode-non-case-sensitive search. The
+      # keys in searchProperties are the WebDAV property names, while the values
+      # are the property values to search on.
+      #
+      # By default, if multiple properties are submitted to this method, the
+      # various properties should be combined with 'AND'. If test is set to
+      # 'anyof', it should be combined using 'OR'.
+      #
+      # This method should simply return a list of 'child names', which may be
+      # used to call self.child in the future.
+      #
+      # @param array search_properties
+      # @param string test
+      # @return array
+      def search_principals(search_properties, test = 'allof')
+        result = @principal_backend.search_principals(@principal_prefix, search_properties, test)
+        r = []
+
+        result.each do |row|
+          r << Http::UrlUtil.split_path(row)[1]
+        end
+
+        r
+      end
+
+      # Finds a principal by its URI.
+      #
+      # This method may receive any type of uri, but mailto: addresses will be
+      # the most common.
+      #
+      # Implementation of this API is optional. It is currently used by the
+      # CalDAV system to find principals based on their email addresses. If this
+      # API is not implemented, some features may not work correctly.
+      #
+      # This method must return a relative principal path, or null, if the
+      # principal was not found or you refuse to find it.
+      #
+      # @param string uri
+      # @return string
+      def find_by_uri(uri)
+        @principal_backend.find_by_uri(uri, @principal_prefix)
+      end
+    end
+  end
+end

data/lib/tilia/dav_acl/exception.rb

@@ -0,0 +1,11 @@
+module Tilia
+  module DavAcl
+    module Exception
+      require 'tilia/dav_acl/exception/ace_conflict'
+      require 'tilia/dav_acl/exception/need_privileges'
+      require 'tilia/dav_acl/exception/no_abstract'
+      require 'tilia/dav_acl/exception/not_recognized_principal'
+      require 'tilia/dav_acl/exception/not_supported_privilege'
+    end
+  end
+end

data/lib/tilia/dav_acl/exception/ace_conflict.rb

@@ -0,0 +1,21 @@
+module Tilia
+  module DavAcl
+    module Exception
+      # This exception is thrown when a client attempts to set conflicting
+      # permissions.
+      class AceConflict < Dav::Exception::Conflict
+        # Adds in extra information in the xml response.
+        #
+        # This method adds the {DAV:}no-ace-conflict element as defined in rfc3744
+        #
+        # @param DAV\Server server
+        # @param \DOMElement error_node
+        # @return void
+        def serialize(_server, error_node)
+          error = LibXML::XML::Node.new('d:no-ace-conflict')
+          error_node << error
+        end
+      end
+    end
+  end
+end