tilia-dav 3.1.0.pre.alpha2

data/lib/tilia/dav_acl/xml/property/principal.rb

@@ -0,0 +1,149 @@
+module Tilia
+  module DavAcl
+    module Xml
+      module Property
+        # Principal property
+        #
+        # The principal property represents a principal from RFC3744 (ACL).
+        # The property can be used to specify a principal or pseudo principals.
+        class Principal < Dav::Xml::Property::Href
+          # To specify a not-logged-in user, use the UNAUTHENTICATED principal
+          UNAUTHENTICATED = 1
+
+          # To specify any principal that is logged in, use AUTHENTICATED
+          AUTHENTICATED = 2
+
+          # Specific principals can be specified with the HREF
+          HREF = 3
+
+          # Everybody, basically
+          ALL = 4
+
+          protected
+
+          # Principal-type
+          #
+          # Must be one of the UNAUTHENTICATED, AUTHENTICATED or HREF constants.
+          #
+          # @var int
+          attr_accessor :type
+
+          public
+
+          # Creates the property.
+          #
+          # The 'type' argument must be one of the type constants defined in this class.
+          #
+          # 'href' is only required for the HREF type.
+          #
+          # @param int type
+          # @param string|null href
+          def initialize(type, href = nil)
+            @type = type
+
+            fail Dav::Exception, 'The href argument must be specified for the HREF principal type.' if type == HREF && href.nil?
+
+            href = href.gsub(%r{/+$}, '') + '/' if href
+            super(href)
+          end
+
+          # Returns the principal type
+          #
+          # @return int
+          attr_reader :type
+
+          # The xmlSerialize metod is called during xml writing.
+          #
+          # Use the writer argument to write its own xml serialization.
+          #
+          # An important note: do _not_ create a parent element. Any element
+          # implementing XmlSerializble should only ever write what's considered
+          # its 'inner xml'.
+          #
+          # The parent of the current element is responsible for writing a
+          # containing element.
+          #
+          # This allows serializers to be re-used for different element names.
+          #
+          # If you are opening new elements, you must also close them again.
+          #
+          # @param Writer writer
+          # @return void
+          def xml_serialize(writer)
+            case @type
+            when UNAUTHENTICATED
+              writer.write_element('{DAV:}unauthenticated')
+            when AUTHENTICATED
+              writer.write_element('{DAV:}authenticated')
+            when HREF
+              super(writer)
+            when ALL
+              writer.write_element('{DAV:}all')
+            end
+          end
+
+          # Generate html representation for this value.
+          #
+          # The html output is 100% trusted, and no effort is being made to sanitize
+          # it. It's up to the implementor to sanitize user provided values.
+          #
+          # The output must be in UTF-8.
+          #
+          # The baseUri parameter is a url to the root of the application, and can
+          # be used to construct local links.
+          #
+          # @param HtmlOutputHelper html
+          # @return string
+          def to_html(html)
+            case @type
+            when UNAUTHENTICATED
+              return '<em>unauthenticated</em>'
+            when AUTHENTICATED
+              return '<em>authenticated</em>'
+            when HREF
+              return super(html)
+            when ALL
+              return '<em>all</em>'
+            end
+          end
+
+          # The deserialize method is called during xml parsing.
+          #
+          # This method is called staticly, 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.
+          #
+          # Important note 2: 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)
+            tree = reader.parse_inner_tree[0]
+
+            case tree['name']
+            when '{DAV:}unauthenticated'
+              return new(UNAUTHENTICATED)
+            when '{DAV:}authenticated'
+              return new(AUTHENTICATED)
+            when '{DAV:}href'
+              return new(HREF, tree['value'])
+            when '{DAV:}all'
+              return new(ALL)
+            else
+              fail Dav::Exception::BadRequest, "Unknown or unsupported principal type: #{tree['name']}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav_acl/xml/property/supported_privilege_set.rb

@@ -0,0 +1,135 @@
+module Tilia
+  module DavAcl
+    module Xml
+      module Property
+        # SupportedPrivilegeSet property
+        #
+        # This property encodes the {DAV:}supported-privilege-set property, as defined
+        # in rfc3744. Please consult the rfc for details about it's structure.
+        #
+        # This class expects a structure like the one given from
+        # Tilia::DavAcl::Plugin::getSupportedPrivilegeSet as the argument in its
+        # constructor.
+        #
+        # @copyright Copyright (C) 2007-2015 fruux GmbH (https://fruux.com/).
+        # @author Evert Pot (http://evertpot.com/)
+        # @license http://sabre.io/license/ Modified BSD License
+        class SupportedPrivilegeSet
+          include Tilia::Xml::XmlSerializable
+          include Dav::Browser::HtmlOutput
+
+          protected
+
+          # privileges
+          #
+          # @var array
+          attr_accessor :privileges
+
+          public
+
+          # Constructor
+          #
+          # @param array privileges
+          def initialize(privileges)
+            @privileges = privileges
+          end
+
+          # Returns the privilege value.
+          #
+          # @return array
+          def value
+            @privileges
+          end
+
+          # The xmlSerialize metod is called during xml writing.
+          #
+          # Use the writer argument to write its own xml serialization.
+          #
+          # An important note: do _not_ create a parent element. Any element
+          # implementing XmlSerializble should only ever write what's considered
+          # its 'inner xml'.
+          #
+          # The parent of the current element is responsible for writing a
+          # containing element.
+          #
+          # This allows serializers to be re-used for different element names.
+          #
+          # If you are opening new elements, you must also close them again.
+          #
+          # @param Writer writer
+          # @return void
+          def xml_serialize(writer)
+            serialize_priv(writer, @privileges)
+          end
+
+          # Generate html representation for this value.
+          #
+          # The html output is 100% trusted, and no effort is being made to sanitize
+          # it. It's up to the implementor to sanitize user provided values.
+          #
+          # The output must be in UTF-8.
+          #
+          # The baseUri parameter is a url to the root of the application, and can
+          # be used to construct local links.
+          #
+          # @param HtmlOutputHelper html
+          # @return string
+          def to_html(html)
+            traverse = lambda do |priv|
+              output = '<li>'
+              output << html.xml_name(priv['privilege'])
+              output << ' <i>(abstract)</i>' unless priv['abstract'].blank?
+              output << " #{html.h(priv['description'])}" if priv.key?('description')
+
+              if priv.key?('aggregates')
+                output << "\n<ul>\n"
+                priv['aggregates'].each do |sub_priv|
+                  output << traverse.call(sub_priv)
+                end
+                output << '</ul>'
+              end
+              output << "</li>\n"
+
+              output
+            end
+
+            output = "<ul class=\"tree\">"
+            output << traverse.call(@privileges)
+            output << "</ul>\n"
+
+            output
+          end
+
+          private
+
+          # Serializes a property
+          #
+          # This is a recursive function.
+          #
+          # @param Writer writer
+          # @param array privilege
+          # @return void
+          def serialize_priv(writer, privilege)
+            writer.start_element('{DAV:}supported-privilege')
+
+            writer.start_element('{DAV:}privilege')
+            writer.write_element(privilege['privilege'])
+            writer.end_element; # privilege
+
+            writer.write_element('{DAV:}abstract') unless privilege['abstract'].blank?
+
+            writer.write_element('{DAV:}description', privilege['description']) unless privilege['description'].blank?
+
+            if privilege.key?('aggregates')
+              privilege['aggregates'].each do |sub_privilege|
+                serialize_priv(writer, sub_privilege)
+              end
+            end
+
+            writer.end_element; # supported-privilege
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav_acl/xml/request.rb

@@ -0,0 +1,11 @@
+module Tilia
+  module DavAcl
+    module Xml
+      module Request
+        require 'tilia/dav_acl/xml/request/expand_property_report'
+        require 'tilia/dav_acl/xml/request/principal_property_search_report'
+        require 'tilia/dav_acl/xml/request/principal_search_property_set_report'
+      end
+    end
+  end
+end

data/lib/tilia/dav_acl/xml/request/expand_property_report.rb

@@ -0,0 +1,86 @@
+module Tilia
+  module DavAcl
+    module Xml
+      module Request
+        # ExpandProperty request parser.
+        #
+        # This class parses the {DAV:}expand-property REPORT, as defined in:
+        #
+        # http://tools.ietf.org/html/rfc3253#section-3.8
+        #
+        # @copyright Copyright (C) 2007-2015 fruux GmbH (https://fruux.com/).
+        # @author Evert Pot (http://evertpot.com/)
+        # @license http://sabre.io/license/ Modified BSD License
+        class ExpandPropertyReport
+          include Tilia::Xml::XmlDeserializable
+
+          # An array with requested properties.
+          #
+          # The requested properties will be used as keys in this array. The value
+          # is normally null.
+          #
+          # If the value is an array though, it means the property must be expanded.
+          # Within the array, the sub-properties, which themselves may be null or
+          # arrays.
+          #
+          # @var 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)
+            elems = reader.parse_inner_tree
+
+            obj = new
+            obj.properties = traverse(elems)
+
+            obj
+          end
+
+          # This method is used by deserializeXml, to recursively parse the
+          # {DAV:}property elements.
+          #
+          # @param array elems
+          # @return void
+          def self.traverse(elems)
+            result = {}
+
+            elems.each do |elem|
+              next unless elem['name'] == '{DAV:}property'
+
+              namespace = elem['attributes'].key?('namespace') ?
+                  elem['attributes']['namespace'] :
+                  'DAV:'
+
+              prop_name = "{#{namespace}}#{elem['attributes']['name']}"
+
+              value = nil
+              value = traverse(elem['value']) if elem['value'].is_a?(Array)
+
+              result[prop_name] = value
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav_acl/xml/request/principal_property_search_report.rb

@@ -0,0 +1,111 @@
+module Tilia
+  module DavAcl
+    module Xml
+      module Request
+        # PrincipalSearchPropertySetReport request parser.
+        #
+        # This class parses the {DAV:}principal-property-search REPORT, as defined
+        # in:
+        #
+        # https://tools.ietf.org/html/rfc3744#section-9.4
+        #
+        # @copyright Copyright (C) 2007-2015 fruux GmbH (https://fruux.com/).
+        # @author Evert Pot (http://evertpot.com/)
+        # @license http://sabre.io/license/ Modified BSD License
+        class PrincipalPropertySearchReport
+          include Tilia::Xml::XmlDeserializable
+
+          # The requested properties.
+          #
+          # @var array|null
+          attr_accessor :properties
+
+          # searchProperties
+          #
+          # @var array
+          attr_accessor :search_properties
+
+          # By default the property search will be conducted on the url of the http
+          # request. If this is set to true, it will be applied to the principal
+          # collection set instead.
+          #
+          # @var bool
+          attr_accessor :apply_to_principal_collection_set
+
+          # Search for principals matching ANY of the properties (OR) or a ALL of
+          # the properties (AND).
+          #
+          # This property is either "anyof" or "allof".
+          #
+          # @var string
+          attr_accessor :test
+
+          # 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
+
+            found_search_prop = false
+            instance.test = 'allof'
+            instance.test = 'anyof' if reader.get_attribute('test') == 'anyof'
+
+            elem_map = {
+              '{DAV:}property-search' => Tilia::Xml::Element::KeyValue,
+              '{DAV:}prop'            => Tilia::Xml::Element::KeyValue
+            }
+
+            reader.parse_inner_tree(elem_map).each do |elem|
+              case elem['name']
+              when '{DAV:}prop'
+                instance.properties = elem['value'].keys
+              when '{DAV:}property-search'
+                found_search_prop = true
+                # This property has two sub-elements:
+                #   {DAV:}prop - The property to be searched on. This may
+                #                also be more than one
+                #   {DAV:}match - The value to match with
+                if !elem['value'].key?('{DAV:}prop') || !elem['value'].key?('{DAV:}match')
+                  fail Dav::Exception::BadRequest, 'The {DAV:}property-search element must contain one {DAV:}match and one {DAV:}prop element'
+                end
+                elem['value']['{DAV:}prop'].each do |prop_name, _discard|
+                  instance.search_properties[prop_name] = elem['value']['{DAV:}match']
+                end
+              when '{DAV:}apply-to-principal-collection-set'
+                instance.apply_to_principal_collection_set = true
+              end
+            end
+
+            unless found_search_prop
+              fail Dav::Exception::BadRequest, 'The {DAV:}principal-property-search report must contain at least 1 {DAV:}property-search element'
+            end
+
+            instance
+          end
+
+          # TODO: document
+          def initialize
+            @search_properties = {}
+            @apply_to_principal_collection_set = false
+          end
+        end
+      end
+    end
+  end
+end