tilia-dav 3.1.0.pre.alpha2

data/lib/tilia/dav/uuid_util.rb

@@ -0,0 +1,45 @@
+module Tilia
+  module Dav
+    # UUID Utility
+    #
+    # This class has static methods to generate and validate UUID's.
+    # UUIDs are used a decent amount within various *DAV standards, so it made
+    # sense to include it.
+    class UuidUtil
+      # Returns a pseudo-random v4 UUID
+      #
+      # This function is based on a comment by Andrew Moore on php.net
+      #
+      # @see http://www.php.net/manual/en/function.uniqid.php#94959
+      # @return string
+      def self.uuid
+        format('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
+               # 32 bits for "time_low"
+               rand(0..0xffff), rand(0..0xffff),
+
+               # 16 bits for "time_mid"
+               rand(0..0xffff),
+
+               # 16 bits for "time_hi_and_version",
+               # four most significant bits holds version number 4
+               rand(0..0x0fff) | 0x4000,
+
+               # 16 bits, 8 bits for "clk_seq_hi_res",
+               # 8 bits for "clk_seq_low",
+               # two most significant bits holds zero and one for variant DCE1.1
+               rand(0..0x3fff) | 0x8000,
+
+               # 48 bits for "node"
+               rand(0..0xffff), rand(0..0xffff), rand(0..0xffff))
+      end
+
+      # Checks if a string is a valid UUID.
+      #
+      # @param string $uuid
+      # @return bool
+      def self.validate_uuid(uuid)
+        uuid =~ /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i
+      end
+    end
+  end
+end

data/lib/tilia/dav/version.rb

@@ -0,0 +1,9 @@
+module Tilia
+  module Dav
+    # This class contains the SabreDAV version constants.
+    class Version
+      # Full version number
+      VERSION = '3.1.0-alpha2'
+    end
+  end
+end

data/lib/tilia/dav/xml.rb

@@ -0,0 +1,11 @@
+module Tilia
+  module Dav
+    module Xml
+      require 'tilia/dav/xml/element'
+      require 'tilia/dav/xml/property'
+      require 'tilia/dav/xml/request'
+      require 'tilia/dav/xml/response'
+      require 'tilia/dav/xml/service'
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Tilia
+  module Dav
+    module Xml
+      module Element
+        require 'tilia/dav/xml/element/prop'
+        require 'tilia/dav/xml/element/response'
+      end
+    end
+  end
+end

data/lib/tilia/dav/xml/element/prop.rb

@@ -0,0 +1,92 @@
+module Tilia
+  module Dav
+    module Xml
+      module Element
+        # This class is responsible for decoding the {DAV:}prop element as it appears
+        # in {DAV:}property-update.
+        #
+        # This class doesn't return an instance of itself. It just returns a
+        # key.value array.
+        class Prop
+          include Tilia::Xml::XmlDeserializable
+
+          # 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)
+            # If there's no children, we don't do anything.
+            if reader.empty_element?
+              reader.next
+              return {}
+            end
+
+            values = {}
+
+            reader.read
+            loop do
+              if reader.node_type == ::LibXML::XML::Reader::TYPE_ELEMENT
+                clark = reader.clark
+                values[clark] = parse_current_element(reader)['value']
+              else
+                reader.read
+              end
+              break unless reader.node_type != ::LibXML::XML::Reader::TYPE_END_ELEMENT
+            end
+
+            reader.read
+            values
+          end
+
+          private
+
+          # This function behaves similar to Sabre\Xml\Reader::parseCurrentElement,
+          # but instead of creating deep xml array structures, it will turn any
+          # top-level element it doesn't recognize into either a string, or an
+          # XmlFragment class.
+          #
+          # This method returns arn array with 2 properties:
+          #   * name - A clark-notation XML element name.
+          #   * value - The parsed value.
+          #
+          # @param Reader reader
+          # @return array
+          def self.parse_current_element(reader)
+            name = reader.clark
+
+            if reader.element_map.key?(name)
+              deserializer = reader.element_map[name]
+              if deserializer.is_a?(Class) && deserializer.include?(Tilia::Xml::XmlDeserializable)
+                value = deserializer.xml_deserialize(reader)
+              elsif deserializer.is_a? Proc
+                value = deserializer.call(reader)
+              else
+                # Omit php stuff for error creation
+                fail "Could not use this type as a deserializer: #{deserializer.inspect}"
+              end
+            else
+              value = Property::Complex.xml_deserialize(reader)
+            end
+
+            { 'name' => name, 'value' => value }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,188 @@
+module Tilia
+  module Dav
+    module Xml
+      module Element
+        # WebDAV {DAV:}response parser
+        #
+        # This class parses the {DAV:}response element, as defined in:
+        #
+        # https://tools.ietf.org/html/rfc4918#section-14.24
+        class Response
+          include Tilia::Xml::Element
+
+          # Url for the response
+          #
+          # @var string
+          # RUBY: attr_accessor :href
+
+          # Propertylist, ordered by HTTP status code
+          #
+          # @var array
+          # RUBY: attr_accessor :response_properties
+
+          # The HTTP status for an entire response.
+          #
+          # This is currently only used in WebDAV-Sync
+          #
+          # @var string
+          # RUBY: attr_accessor :http_status
+
+          # The href argument is a url relative to the root of the server. This
+          # class will calculate the full path.
+          #
+          # The responseProperties argument is a list of properties
+          # within an array with keys representing HTTP status codes
+          #
+          # Besides specific properties, the entire {DAV:}response element may also
+          # have a http status code.
+          # In most cases you don't need it.
+          #
+          # This is currently used by the Sync extension to indicate that a node is
+          # deleted.
+          #
+          # @param string href
+          # @param array response_properties
+          # @param string http_status
+          def initialize(href, response_properties, http_status = nil)
+            @href = href
+            @response_properties = response_properties
+            @http_status = http_status
+          end
+
+          # Returns the url
+          #
+          # @return string
+          attr_reader :href
+
+          # Returns the httpStatus value
+          #
+          # @return string
+          attr_reader :http_status
+
+          # Returns the property list
+          #
+          # @return array
+          attr_reader :response_properties
+
+          # 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)
+            if @http_status
+              writer.write_element('{DAV:}status', "HTTP/1.1 #{@http_status} #{Tilia::Http::Response.status_codes[@http_status]}")
+            end
+            writer.write_element('{DAV:}href', writer.context_uri + href)
+
+            @response_properties.each do |status, properties|
+              # Skipping empty lists
+              # TODO: this code is slightly extended, wait for Evert if the original PHP code was correct
+              next if properties.is_a?(Hash) && properties.empty?
+              next if properties.blank?
+              next if status.to_i.to_s != status.to_s
+
+              writer.start_element('{DAV:}propstat')
+              writer.write_element('{DAV:}prop', properties)
+              writer.write_element('{DAV:}status', "HTTP/1.1 #{status} #{Tilia::Http::Response.status_codes[status]}")
+              writer.end_element # {DAV:}propstat
+            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)
+            reader.push_context
+
+            reader.element_map['{DAV:}propstat'] = Tilia::Xml::Element::KeyValue
+
+            # We are overriding the parser for {DAV:}prop. This deserializer is
+            # almost identical to the one for Sabre\Xml\Element\KeyValue.
+            #
+            # The difference is that if there are any child-elements inside of
+            # {DAV:}prop, that have no value, normally any deserializers are
+            # called. But we don't want this, because a singular element without
+            # child-elements implies 'no value' in {DAV:}prop, so we want to skip
+            # deserializers and just set null for those.
+            reader.element_map['{DAV:}prop'] = lambda do |reader|
+              if reader.empty_element?
+                reader.next
+                return {}
+              end
+
+              values = {}
+
+              reader.read
+              loop do
+                if reader.node_type == ::LibXML::XML::Reader::TYPE_ELEMENT
+                  clark = reader.clark
+                  if reader.empty_element?
+                    values[clark] = nil
+                    reader.next
+                  else
+                    values[clark] = reader.parse_current_element['value']
+                  end
+                else
+                  reader.read
+                end
+                break unless reader.node_type != ::LibXML::XML::Reader::TYPE_END_ELEMENT
+              end
+
+              reader.read
+
+              values
+            end
+
+            elems = reader.parse_inner_tree
+            reader.pop_context
+
+            href = nil
+            property_lists = {}
+            status_code = nil
+
+            elems.each do |elem|
+              case elem['name']
+              when '{DAV:}href'
+                href = elem['value']
+              when '{DAV:}propstat'
+                status = elem['value']['{DAV:}status']
+                status = status.split(' ')[1]
+                properties = elem['value'].key?('{DAV:}prop') ? elem['value']['{DAV:}prop'] : []
+                property_lists[status] = properties
+              when '{DAV:}status'
+                status_code = elem['value'].split(' ')[1]
+              end
+            end
+
+            new(href, property_lists, status_code)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Tilia
+  module Dav
+    module Xml
+      module Property
+        require 'tilia/dav/xml/property/complex'
+        require 'tilia/dav/xml/property/get_last_modified'
+        require 'tilia/dav/xml/property/href'
+        require 'tilia/dav/xml/property/lock_discovery'
+        require 'tilia/dav/xml/property/resource_type'
+        require 'tilia/dav/xml/property/supported_lock'
+        require 'tilia/dav/xml/property/supported_method_set'
+        require 'tilia/dav/xml/property/supported_report_set'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Tilia
+  module Dav
+    module Xml
+      module Property
+        # This class represents a 'complex' property that didn't have a default
+        # decoder.
+        #
+        # It's basically a container for an xml snippet.
+        class Complex < Tilia::Xml::Element::XmlFragment
+          # 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)
+            xml = reader.read_inner_xml
+
+            if reader.node_type == ::LibXML::XML::Reader::TYPE_ELEMENT && reader.empty_element?
+              # Easy!
+              reader.next
+              return nil
+            end
+
+            # Now we have a copy of the inner xml, we need to traverse it to get
+            # all the strings. If there's no non-string data, we just return the
+            # string, otherwise we return an instance of this class.
+            reader.read
+
+            non_text = false
+            text = ''
+
+            loop do
+              case reader.node_type
+              when ::LibXML::XML::Reader::TYPE_ELEMENT
+                non_text = true
+                reader.next
+                next
+              when ::LibXML::XML::Reader::TYPE_TEXT,
+                  ::LibXML::XML::Reader::TYPE_CDATA
+                text += reader.value
+              when ::LibXML::XML::Reader::TYPE_END_ELEMENT
+                break
+              end
+
+              reader.read
+            end
+
+            # Make sure we advance the cursor one step further.
+            reader.read
+
+            if non_text
+              instance = new(xml)
+              return instance
+            else
+              return text
+            end
+          end
+        end
+      end
+    end
+  end
+end