tilia-dav 3.1.0.pre.alpha2

data/lib/tilia/dav/browser/prop_find_all.rb

@@ -0,0 +1,95 @@
+module Tilia
+  module Dav
+    module Browser
+      # This class is used by the browser plugin to trick the system in returning
+      # every defined property.
+      class PropFindAll < PropFind
+        # Creates the PROPFIND object
+        #
+        # @param string path
+        def initialize(path)
+          super(path, [])
+        end
+
+        # Handles a specific property.
+        #
+        # This method checks wether the specified property was requested in this
+        # PROPFIND request, and if so, it will call the callback and use the
+        # return value for it's value.
+        #
+        # Example:
+        #
+        # prop_find.handle('{DAV:}displayname', function {
+        #      return 'hello'
+        # })
+        #
+        # Note that handle will only work the first time. If null is returned, the
+        # value is ignored.
+        #
+        # It's also possible to not pass a callback, but immediately pass a value
+        #
+        # @param string property_name
+        # @param mixed value_or_call_back
+        # @return void
+        def handle(property_name, value_or_call_back)
+          if value_or_call_back.is_a?(Proc) || value_or_call_back.is_a?(Method)
+            value = value_or_call_back.call
+          else
+            value = value_or_call_back
+          end
+
+          result[property_name] = [200, value] unless value.nil?
+        end
+
+        # Sets the value of the property
+        #
+        # If status is not supplied, the status will default to 200 for non-null
+        # properties, and 404 for null properties.
+        #
+        # @param string property_name
+        # @param mixed value
+        # @param int status
+        # @return void
+        def set(property_name, value, status = nil)
+          status = value.nil? ? 404 : 200 if status.nil?
+          result[property_name] = [status, value]
+        end
+
+        # Returns the current value for a property.
+        #
+        # @param string property_name
+        # @return mixed
+        def get(property_name)
+          result.key?(property_name) ? result[property_name][1] : nil
+        end
+
+        # Returns the current status code for a property name.
+        #
+        # If the property does not appear in the list of requested properties,
+        # null will be returned.
+        #
+        # @param string property_name
+        # @return int|null
+        def status(property_name)
+          result.key?(property_name) ? result[property_name][0] : 404
+        end
+
+        # Returns all propertynames that have a 404 status, and thus don't have a
+        # value yet.
+        #
+        # @return array
+        def get404_properties
+          result = []
+          self.result.each do |property_name, stuff|
+            result << property_name if stuff[0] == 404
+          end
+
+          # If there's nothing in this list, we're adding one fictional item.
+          result << '{http://sabredav.org/ns}idk' if result.empty?
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/tilia/dav/client.rb

@@ -0,0 +1,341 @@
+module Tilia
+  module Dav
+    # SabreDAV DAV client
+    #
+    # This client wraps around Curl to provide a convenient API to a WebDAV
+    # server.
+    #
+    # NOTE: This class is experimental, it's api will likely change in the future.
+    class Client < Http::Client
+      # The xml service.
+      #
+      # Uset this service to configure the property and namespace maps.
+      #
+      # @var mixed
+      attr_accessor :xml
+
+      # The elementMap
+      #
+      # This property is linked via reference to @xml.element_map.
+      # It's deprecated as of version 3.0.0, and should no longer be used.
+      #
+      # @deprecated
+      # @var array
+      attr_accessor :property_map
+
+      # Base URI
+      #
+      # This URI will be used to resolve relative urls.
+      #
+      # @var string
+      # RUBY: attr_accessor :base_uri
+
+      # Basic authentication
+      AUTH_BASIC = 1
+
+      # Digest authentication
+      AUTH_DIGEST = 2
+
+      # NTLM authentication
+      AUTH_NTLM = 4
+
+      # Identity encoding, which basically does not nothing.
+      ENCODING_IDENTITY = 1
+
+      # Deflate encoding
+      ENCODING_DEFLATE = 2
+
+      # Gzip encoding
+      ENCODING_GZIP = 4
+
+      # Sends all encoding headers.
+      ENCODING_ALL = 7
+
+      # Content-encoding
+      #
+      # @var int
+      # RUBY: attr_accessor :encoding
+
+      # Constructor
+      #
+      # Settings are provided through the 'settings' argument. The following
+      # settings are supported:
+      #
+      #   * baseUri
+      #   * userName (optional)
+      #   * password (optional)
+      #   * proxy (optional)
+      #   * authType (optional)
+      #   * encoding (optional)
+      #
+      #  authType must be a bitmap, using AUTH_BASIC, AUTH_DIGEST
+      #  and AUTH_NTLM. If you know which authentication method will be
+      #  used, it's recommended to set it, as it will save a great deal of
+      #  requests to 'discover' this information.
+      #
+      #  Encoding is a bitmap with one of the ENCODING constants.
+      #
+      # @param array settings
+      def initialize(settings)
+        @property_map = {}
+        @encoding = ENCODING_IDENTITY
+
+        unless settings.key?('baseUri')
+          fail ArgumentError, 'A baseUri must be provided'
+        end
+
+        super()
+
+        @base_uri = settings['baseUri']
+
+        add_curl_setting(:proxy, settings['proxy']) if settings.key?('proxy')
+
+        if settings.key?('userName')
+          user_name = settings['userName']
+          password = settings['password'] || ''
+
+          if settings.key?('authType')
+            curl_type = []
+            curl_type << :basic if settings['authType'] & AUTH_BASIC > 0
+            curl_type << :digest if settings['authType'] & AUTH_DIGEST > 0
+            curl_type << :ntlm if settings['authType'] & AUTH_NTLM > 0
+          else
+            curl_type = [:basic, :digest]
+          end
+
+          add_curl_setting(:httpauth, curl_type)
+          add_curl_setting(:userpwd, "#{user_name}:#{password}")
+        end
+
+        if settings.key?('encoding')
+          encoding = settings['encoding']
+
+          encodings = []
+          encodings << 'identity' if encoding & ENCODING_IDENTITY > 0
+          encodings << 'deflate' if encoding & ENCODING_DEFLATE > 0
+          encodings << 'gzip' if encoding & ENCODING_GZIP > 0
+
+          add_curl_setting(:encoding, encodings.join(','))
+        end
+
+        @xml = Xml::Service.new
+        # BC
+        @property_map = @xml.element_map
+      end
+
+      # Does a PROPFIND request
+      #
+      # The list of requested properties must be specified as an array, in clark
+      # notation.
+      #
+      # The returned array will contain a list of filenames as keys, and
+      # properties as values.
+      #
+      # The properties array will contain the list of properties. Only properties
+      # that are actually returned from the server (without error) will be
+      # returned, anything else is discarded.
+      #
+      # Depth should be either 0 or 1. A depth of 1 will cause a request to be
+      # made to the server to also return all child resources.
+      #
+      # @param string url
+      # @param array properties
+      # @param int depth
+      # @return array
+      def prop_find(url, properties, depth = 0)
+        dom = LibXML::XML::Document.new
+
+        root = LibXML::XML::Node.new('d:propfind')
+        LibXML::XML::Namespace.new(root, 'd', 'DAV:')
+        prop = LibXML::XML::Node.new('d:prop')
+
+        properties.each do |property|
+          (namespace, element_name) = Tilia::Xml::Service.parse_clark_notation(property)
+
+          if namespace == 'DAV:'
+            element = LibXML::XML::Node.new("d:#{element_name}")
+          else
+            element = LibXML::XML::Node.new("x:#{element_name}")
+            LibXML::XML::Namespace.new(element, 'x', namespace)
+          end
+
+          prop << element
+        end
+
+        dom.root = root
+        root << prop
+
+        body = dom.to_s
+
+        url = absolute_url(url)
+
+        request = Http::Request.new(
+          'PROPFIND',
+          url,
+          {
+            'Depth'        => depth,
+            'Content-Type' => 'application/xml'
+          },
+          body
+        )
+
+        response = send_request(request)
+
+        fail Exception, "HTTP error: #{response.status}" if response.status.to_i >= 400
+
+        result = parse_multi_status(response.body_as_string)
+
+        # If depth was 0, we only return the top item
+        if depth == 0
+          result = result.first.second # value of first key/value pair
+          return result.key?('200') ? result['200'] : {}
+        end
+
+        new_result = {}
+        result.each do |href, status_list|
+          new_result[href] = status_list.key?('200') ? status_list['200'] : {}
+        end
+
+        new_result
+      end
+
+      # Updates a list of properties on the server
+      #
+      # The list of properties must have clark-notation properties for the keys,
+      # and the actual (string) value for the value. If the value is null, an
+      # attempt is made to delete the property.
+      #
+      # @param string url
+      # @param array properties
+      # @return void
+      def prop_patch(url, properties)
+        prop_patch = Xml::Request::PropPatch.new
+        prop_patch.properties = properties
+        xml = @xml.write('{DAV:}propertyupdate', prop_patch)
+
+        url = absolute_url(url)
+        request = Http::Request.new(
+          'PROPPATCH',
+          url,
+          { 'Content-Type' => 'application/xml' },
+          xml
+        )
+        send_request(request)
+      end
+
+      # Performs an HTTP options request
+      #
+      # This method returns all the features from the 'DAV:' header as an array.
+      # If there was no DAV header, or no contents this method will return an
+      # empty array.
+      #
+      # @return array
+      def options
+        request = Http::Request.new('OPTIONS', absolute_url(''))
+        response = send_request(request)
+
+        dav = response.header('Dav')
+        return [] unless dav
+
+        features = dav.split(',')
+        features.map(&:strip)
+      end
+
+      # Performs an actual HTTP request, and returns the result.
+      #
+      # If the specified url is relative, it will be expanded based on the base
+      # url.
+      #
+      # The returned array contains 3 keys:
+      #   * body - the response body
+      #   * httpCode - a HTTP code (200, 404, etc)
+      #   * headers - a list of response http headers. The header names have
+      #     been lowercased.
+      #
+      # For large uploads, it's highly recommended to specify body as a stream
+      # resource. You can easily do this by simply passing the result of
+      # fopen(..., 'r').
+      #
+      # This method will throw an exception if an HTTP error was received. Any
+      # HTTP status code above 399 is considered an error.
+      #
+      # Note that it is no longer recommended to use this method, use the send
+      # method instead.
+      #
+      # @param string method
+      # @param string url
+      # @param string|resource|null body
+      # @param array headers
+      # @throws ClientException, in case a curl error occurred.
+      # @return array
+      def request(method, url = '', body = nil, headers = {})
+        url = absolute_url(url)
+
+        headers = {}
+        response.headers.each { |k, v| headers[k.downcase] = v }
+
+        response = send_request(Http::Request.new(method, url, headers, body))
+        {
+          'body'       => response.body_as_string,
+          'statusCode' => response.status.to_i,
+          'headers'    => headers
+        }
+      end
+
+      # Returns the full url based on the given url (which may be relative). All
+      # urls are expanded based on the base url as given by the server.
+      #
+      # @param string url
+      # @return string
+      def absolute_url(url)
+        # If the url starts with http:// or https://, the url is already absolute.
+        return url if url =~ /^http(s?):\/\//
+
+        # If the url starts with a slash, we must calculate the url based off
+        # the root of the base url.
+        if url.index('/') == 0
+          parts = Tilia::Uri.parse(@base_uri)
+          return "#{parts['scheme']}://#{parts['host']}#{parts['port'] ? ":#{parts['port']}" : ''}#{url}"
+        end
+
+        # Otherwise...
+        @base_uri + url
+      end
+
+      # Parses a WebDAV multistatus response body
+      #
+      # This method returns an array with the following structure
+      #
+      # [
+      #   'url/to/resource' => [
+      #     '200' => [
+      #        '{DAV:}property1' => 'value1',
+      #        '{DAV:}property2' => 'value2',
+      #     ],
+      #     '404' => [
+      #        '{DAV:}property1' => null,
+      #        '{DAV:}property2' => null,
+      #     ],
+      #   ],
+      #   'url/to/resource2' => [
+      #      .. etc ..
+      #   ]
+      # ]
+      #
+      #
+      # @param string body xml body
+      # @return array
+      def parse_multi_status(body)
+        multistatus = @xml.expect('{DAV:}multistatus', body)
+
+        result = {}
+
+        multistatus.responses.each do |response|
+          result[response.href] = response.response_properties
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/tilia/dav/collection.rb

@@ -0,0 +1,79 @@
+module Tilia
+  module Dav
+    # Collection class
+    #
+    # This is a helper class, that should aid in getting collections classes setup.
+    # Most of its methods are implemented, and throw permission denied exceptions
+    class Collection < Node
+      include ICollection
+
+      # Returns a child object, by its name.
+      #
+      # This method makes use of the children method to grab all the child
+      # nodes, and compares the name.
+      # Generally its wise to override this, as this can usually be optimized
+      #
+      # This method must throw Sabre\DAV\Exception\NotFound if the node does not
+      # exist.
+      #
+      # @param string name
+      # @throws Exception\NotFound
+      # @return INode
+      def child(name)
+        children.each do |child|
+          return child if child.name == name
+        end
+
+        fail Exception::NotFound, "File not found: #{name}"
+      end
+
+      # Checks is a child-node exists.
+      #
+      # It is generally a good idea to try and override this. Usually it can be optimized.
+      #
+      # @param string name
+      # @return bool
+      def child_exists(name)
+        child(name)
+        true
+      rescue Exception::NotFound => e
+        false
+      end
+
+      # Creates a new file in the directory
+      #
+      # Data will either be supplied as a stream resource, or in certain cases
+      # as a string. Keep in mind that you may have to support either.
+      #
+      # After succesful creation of the file, you may choose to return the ETag
+      # of the new file here.
+      #
+      # The returned ETag must be surrounded by double-quotes (The quotes should
+      # be part of the actual string).
+      #
+      # If you cannot accurately determine the ETag, you should not return it.
+      # If you don't store the file exactly as-is (you're transforming it
+      # somehow) you should also not return an ETag.
+      #
+      # This means that if a subsequent GET to this new file does not exactly
+      # return the same contents of what was submitted here, you are strongly
+      # recommended to omit the ETag.
+      #
+      # @param string name Name of the file
+      # @param resource|string data Initial payload
+      # @return null|string
+      def create_file(name, _data = nil)
+        fail Exception::Forbidden, "Permission denied to create file (filename #{name})"
+      end
+
+      # Creates a new subdirectory
+      #
+      # @param string name
+      # @throws Exception\Forbidden
+      # @return void
+      def create_directory(_name)
+        fail Exception::Forbidden, 'Permission denied to create directory'
+      end
+    end
+  end
+end