tilia-dav 3.1.0.pre.alpha2

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

@@ -0,0 +1,79 @@
+module Tilia
+  module Dav
+    module Xml
+      module Property
+        # This property represents the {DAV:}getlastmodified property.
+        #
+        # Defined in:
+        # http://tools.ietf.org/html/rfc4918#section-15.7
+        class GetLastModified
+          include Tilia::Xml::Element
+
+          # time
+          #
+          # @var DateTime
+          attr_accessor :time
+
+          # Constructor
+          #
+          # @param int|DateTime time
+          def initialize(time)
+            tz = ActiveSupport::TimeZone.new('UTC')
+            if time.is_a?(Time)
+              @time = time.in_time_zone(tz)
+            else
+              @time = tz.at time
+            end
+          end
+
+          # getTime
+          #
+          # @return DateTime
+          attr_reader :time
+
+          # 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)
+            writer.write(
+              Tilia::Http::Util.to_http_date(@time)
+            )
+          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.
+          #
+          # 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)
+            new(Time.zone.parse(reader.parse_inner_tree))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+module Tilia
+  module Dav
+    module Xml
+      module Property
+        # Href property
+        #
+        # This class represents any WebDAV property that contains a {DAV:}href
+        # element, and there are many.
+        #
+        # It can support either 1 or more hrefs. If while unserializing no valid
+        # {DAV:}href elements were found, this property will unserialize itself as
+        # null.
+        class Href
+          include Tilia::Xml::Element
+          include Browser::HtmlOutput
+
+          # List of uris
+          #
+          # @var array
+          # RUBY: attr_accessor :hrefs
+
+          # Automatically prefix the url with the server base directory
+          #
+          # @var bool
+          # RUBY: attr_accessor :auto_prefix
+
+          # Constructor
+          #
+          # You must either pass a string for a single href, or an array of hrefs.
+          #
+          # If auto-prefix is set to false, the hrefs will be treated as absolute
+          # and not relative to the servers base uri.
+          #
+          # @param string|string[] href
+          # @param bool auto_prefix
+          def initialize(hrefs, auto_prefix = true)
+            hrefs = [] if hrefs.nil?
+            hrefs = [hrefs] unless hrefs.is_a?(Array)
+            @hrefs = hrefs
+            @auto_prefix = auto_prefix
+          end
+
+          # Returns the first Href.
+          #
+          # @return string
+          def href
+            @hrefs[0]
+          end
+
+          # Returns the hrefs as an array
+          #
+          # @return array
+          attr_reader :hrefs
+
+          # 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)
+            hrefs.each do |href|
+              href = writer.context_uri + href if @auto_prefix
+              writer.write_element('{DAV:}href', href)
+            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)
+            links = []
+            hrefs.each do |href|
+              links << html.link(href)
+            end
+            links.join('<br />')
+          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)
+            hrefs = []
+
+            list = reader.parse_inner_tree
+            list = [] if list.nil?
+            list = [list] unless list.is_a?(Array)
+
+            list.each do |elem|
+              next if elem['name'] != '{DAV:}href'
+
+              hrefs << elem['value']
+            end
+
+            new(hrefs, false) if hrefs.any?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Tilia
+  module Dav
+    module Xml
+      module Property
+        # Represents {DAV:}lockdiscovery property.
+        #
+        # This property is defined here:
+        # http://tools.ietf.org/html/rfc4918#section-15.8
+        #
+        # This property contains all the open locks on a given resource
+        class LockDiscovery
+          include Tilia::Xml::XmlSerializable
+
+          # locks
+          #
+          # @var LockInfo[]
+          attr_accessor :locks
+
+          # Hides the {DAV:}lockroot element from the response.
+          #
+          # It was reported that showing the lockroot in the response can break
+          # Office 2000 compatibility.
+          #
+          # @var bool
+          @hide_lock_root = false
+
+          class << self
+            attr_accessor :hide_lock_root
+          end
+
+          # __construct
+          #
+          # @param LockInfo[] locks
+          def initialize(locks)
+            @locks = locks
+          end
+
+          # 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)
+            @locks.each do |lock|
+              writer.start_element('{DAV:}activelock')
+
+              writer.start_element('{DAV:}lockscope')
+              if lock.scope == Locks::LockInfo::SHARED
+                writer.write_element('{DAV:}shared')
+              else
+                writer.write_element('{DAV:}exclusive')
+              end
+
+              writer.end_element # {DAV:}lockscope
+
+              writer.start_element('{DAV:}locktype')
+              writer.write_element('{DAV:}write')
+              writer.end_element # {DAV:}locktype
+
+              unless self.class.hide_lock_root
+                writer.start_element('{DAV:}lockroot')
+                writer.write_element('{DAV:}href', "#{writer.context_uri}#{lock.uri}")
+                writer.end_element # {DAV:}lockroot
+              end
+
+              writer.write_element('{DAV:}depth', (lock.depth == Dav::Server::DEPTH_INFINITY ? 'infinity' : lock.depth))
+              writer.write_element('{DAV:}timeout', "Second-#{lock.timeout}")
+
+              writer.start_element('{DAV:}locktoken')
+              writer.write_element('{DAV:}href', "opaquelocktoken:#{lock.token}")
+              writer.end_element #  {DAV:}locktoken
+
+              writer.write_element('{DAV:}owner', Tilia::Xml::Element::XmlFragment.new(lock.owner))
+              writer.end_element # {DAV:}activelock
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+module Tilia
+  module Dav
+    module Xml
+      module Property
+        # {DAV:}resourcetype property
+        #
+        # This class represents the {DAV:}resourcetype property, as defined in:
+        #
+        # https://tools.ietf.org/html/rfc4918#section-15.9
+        class ResourceType < Tilia::Xml::Element::Elements
+          include Browser::HtmlOutput
+
+          # Constructor
+          #
+          # You can either pass null (for no resourcetype), a string (for a single
+          # resourcetype) or an array (for multiple).
+          #
+          # The resourcetype must be specified in clark-notation
+          #
+          # @param array|string|null resource_type
+          def initialize(resource_types = nil)
+            resource_types = [] if resource_types.nil?
+            resource_types = [resource_types] unless resource_types.is_a?(Array)
+            super(resource_types)
+          end
+
+          # Returns the values in clark-notation
+          #
+          # For example array('{DAV:}collection')
+          #
+          # @return array
+          attr_reader :value
+
+          # Checks if the principal contains a certain value
+          #
+          # @param string type
+          # @return bool
+          def is(type)
+            @value.include?(type)
+          end
+
+          # Adds a resourcetype value to this property
+          #
+          # @param string type
+          # @return void
+          def add(type)
+            @value << type
+            @value = @value.uniq
+          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.
+          #
+          # 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)
+            new(super(reader))
+          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/property/supported_lock.rb

@@ -0,0 +1,48 @@
+module Tilia
+  module Dav
+    module Xml
+      module Property
+        # This class represents the {DAV:}supportedlock property.
+        #
+        # This property is defined here:
+        # http://tools.ietf.org/html/rfc4918#section-15.10
+        #
+        # This property contains information about what kind of locks
+        # this server supports.
+        class SupportedLock
+          include Tilia::Xml::XmlSerializable
+
+          # 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)
+            writer.write_element(
+              '{DAV:}lockentry',
+              '{DAV:}lockscope' => { '{DAV:}exclusive' => nil },
+              '{DAV:}locktype'  => { '{DAV:}write'     => nil }
+            )
+            writer.write_element(
+              '{DAV:}lockentry',
+              '{DAV:}lockscope' => { '{DAV:}shared' => nil },
+              '{DAV:}locktype'  => { '{DAV:}write'  => nil }
+            )
+          end
+        end
+      end
+    end
+  end
+end