tilia-dav 3.1.0.pre.alpha2

data/lib/tilia/dav/xml/property/supported_method_set.rb

@@ -0,0 +1,101 @@
+module Tilia
+  module Dav
+    module Xml
+      module Property
+        # supported-method-set property.
+        #
+        # This property is defined in RFC3253, but since it's
+        # so common in other webdav-related specs, it is part of the core server.
+        #
+        # This property is defined here:
+        # http://tools.ietf.org/html/rfc3253#section-3.1.3
+        class SupportedMethodSet
+          include Tilia::Xml::XmlSerializable
+          include Browser::HtmlOutput
+
+          # List of methods
+          #
+          # @var string[]
+          # RUBY: attr_accessor :methods
+
+          # Creates the property
+          #
+          # Any reports passed in the constructor
+          # should be valid report-types in clark-notation.
+          #
+          # Either a string or an array of strings must be passed.
+          #
+          # @param string|string[] methods
+          def initialize(methods = nil)
+            if methods.nil?
+              methods = []
+            elsif !methods.is_a?(Array)
+              methods = [methods]
+            end
+
+            @methods = methods
+          end
+
+          # Returns the list of supported http methods.
+          #
+          # @return string[]
+          def value
+            @methods
+          end
+
+          # Returns true or false if the property contains a specific method.
+          #
+          # @param string method_name
+          # @return bool
+          def has(method_name)
+            @methods.include?(method_name)
+          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)
+            value.each do |val|
+              writer.start_element('{DAV:}supported-method')
+              writer.write_attribute('name', val)
+              writer.end_element
+            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)
+            tmp = value.map do |value|
+              html.h(value)
+            end
+            tmp.join(', ')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/xml/property/supported_report_set.rb

@@ -0,0 +1,118 @@
+module Tilia
+  module Dav
+    module Xml
+      module Property
+        # supported-report-set property.
+        #
+        # This property is defined in RFC3253, but since it's
+        # so common in other webdav-related specs, it is part of the core server.
+        #
+        # This property is defined here:
+        # http://tools.ietf.org/html/rfc3253#section-3.1.5
+        class SupportedReportSet
+          include Tilia::Xml::XmlSerializable
+          include Browser::HtmlOutput
+
+          # List of reports
+          #
+          # @var array
+          # RUBY: attr_accessor :reports
+
+          # Creates the property
+          #
+          # Any reports passed in the constructor
+          # should be valid report-types in clark-notation.
+          #
+          # Either a string or an array of strings must be passed.
+          #
+          # @param string|string[] reports
+          def initialize(reports = nil)
+            @reports = []
+
+            add_report(reports) if reports
+          end
+
+          # Adds a report to this property
+          #
+          # The report must be a string in clark-notation.
+          # Multiple reports can be specified as an array.
+          #
+          # @param mixed report
+          # @return void
+          def add_report(report)
+            report = [report] unless report.is_a?(Array)
+
+            report.each do |r|
+              unless r =~ /^{([^}]*)}(.*)$/
+                fail Dav::Exception, 'Reportname must be in clark-notation'
+              end
+
+              @reports << r
+            end
+          end
+
+          # Returns the list of supported reports
+          #
+          # @return string[]
+          def value
+            @reports
+          end
+
+          # Returns true or false if the property contains a specific report.
+          #
+          # @param string report_name
+          # @return bool
+          def has(report_name)
+            @reports.include?(report_name)
+          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)
+            value.each do |val|
+              writer.start_element('{DAV:}supported-report')
+              writer.start_element('{DAV:}report')
+              writer.write_element(val)
+              writer.end_element
+              writer.end_element
+            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)
+            tmp = value.map do |value|
+              html.xml_name(value)
+            end
+            tmp.join(', ')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Tilia
+  module Dav
+    module Xml
+      module Request
+        require 'tilia/dav/xml/request/lock'
+        require 'tilia/dav/xml/request/mk_col'
+        require 'tilia/dav/xml/request/prop_find'
+        require 'tilia/dav/xml/request/prop_patch'
+        require 'tilia/dav/xml/request/sync_collection_report'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Tilia
+  module Dav
+    module Xml
+      module Request
+        # WebDAV LOCK request parser.
+        #
+        # This class parses the {DAV:}lockinfo request, as defined in:
+        #
+        # http://tools.ietf.org/html/rfc4918#section-9.10
+        class Lock
+          include Tilia::Xml::XmlDeserializable
+
+          # Owner of the lock
+          #
+          # @var string
+          attr_accessor :owner
+
+          # Scope of the lock.
+          #
+          # Either LockInfo::SHARED or LockInfo::EXCLUSIVE
+          # @var int
+          attr_accessor :scope
+
+          # 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)
+            reader.push_context
+            reader.element_map['{DAV:}owner'] = Tilia::Xml::Element::XmlFragment
+
+            values = Tilia::Xml::Element::KeyValue.xml_deserialize(reader)
+
+            reader.pop_context
+
+            instance = new
+            instance.owner = values['{DAV:}owner'] ? values['{DAV:}owner'].xml : nil
+            instance.scope = Locks::LockInfo::SHARED
+
+            if values.key?('{DAV:}lockscope')
+              values['{DAV:}lockscope'].each do |elem|
+                instance.scope = Locks::LockInfo::EXCLUSIVE if elem['name'] == '{DAV:}exclusive'
+              end
+            end
+
+            instance
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module Tilia
+  module Dav
+    module Xml
+      module Request
+        # WebDAV Extended MKCOL request parser.
+        #
+        # This class parses the {DAV:}mkol request, as defined in:
+        #
+        # https://tools.ietf.org/html/rfc5689#section-5.1
+        class MkCol
+          include Tilia::Xml::XmlDeserializable
+
+          # The list of properties that will be set.
+          #
+          # @var array
+          attr_accessor :properties
+
+          # Returns a key=>value array with properties that are supposed to get set
+          # during creation of the new collection.
+          #
+          # @return array
+          attr_reader :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
+
+            element_map = reader.element_map
+            element_map['{DAV:}prop']   = Element::Prop
+            element_map['{DAV:}set']    = Tilia::Xml::Element::KeyValue
+            element_map['{DAV:}remove'] = Tilia::Xml::Element::KeyValue
+
+            elems = reader.parse_inner_tree(element_map)
+
+            elems.each do |elem|
+              if elem['name'] == '{DAV:}set'
+                instance.properties.merge!(elem['value']['{DAV:}prop'])
+              end
+            end
+
+            instance
+          end
+
+          def initialize
+            @properties = {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Tilia
+  module Dav
+    module Xml
+      module Request
+        # WebDAV PROPFIND request parser.
+        #
+        # This class parses the {DAV:}propfind request, as defined in:
+        #
+        # https://tools.ietf.org/html/rfc4918#section-14.20
+        class PropFind
+          include Tilia::Xml::XmlDeserializable
+
+          # If this is set to true, this was an 'allprop' request.
+          #
+          # @var bool
+          attr_accessor :all_prop
+
+          # The property list
+          #
+          # @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
+
+            Tilia::Xml::Element::KeyValue.xml_deserialize(reader).each do |k, v|
+              case k
+              when '{DAV:}prop'
+                instance.properties = v
+              when '{DAV:}allprop'
+                instance.all_prop = true
+              end
+            end
+
+            reader.pop_context
+
+            instance
+          end
+
+          # TODO: document
+          def initialize
+            @all_prop = false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module Tilia
+  module Dav
+    module Xml
+      module Request
+        # WebDAV PROPPATCH request parser.
+        #
+        # This class parses the {DAV:}propertyupdate request, as defined in:
+        #
+        # https://tools.ietf.org/html/rfc4918#section-14.20
+        class PropPatch
+          include Tilia::Xml::Element
+
+          # The list of properties that will be updated and removed.
+          #
+          # If a property will be removed, it's value will be set to null.
+          #
+          # @var array
+          attr_accessor :properties
+
+          # 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)
+            properties.each do |property_name, property_value|
+              if property_value.nil?
+                writer.start_element('{DAV:}remove')
+                writer.write('{DAV:}prop' => { property_name => property_value })
+                writer.end_element
+              else
+                writer.start_element('{DAV:}set')
+                writer.write('{DAV:}prop' => { property_name => property_value })
+                writer.end_element
+              end
+            end
+          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)
+            instance = new
+
+            element_map = reader.element_map
+            element_map['{DAV:}prop']   = Tilia::Dav::Xml::Element::Prop
+            element_map['{DAV:}set']    = Tilia::Xml::Element::KeyValue
+            element_map['{DAV:}remove'] = Tilia::Xml::Element::KeyValue
+
+            elems = reader.parse_inner_tree(element_map)
+
+            elems.each do |elem|
+              if elem['name'] == '{DAV:}set'
+                instance.properties.merge! elem['value']['{DAV:}prop']
+              elsif elem['name'] == '{DAV:}remove'
+                # Ensuring there are no values.
+                elem['value']['{DAV:}prop'].each do |remove, _value|
+                  instance.properties[remove] = nil
+                end
+              end
+            end
+
+            instance
+          end
+
+          def initialize
+            @properties = {}
+          end
+        end
+      end
+    end
+  end
+end