calligraphy 0.2.1 → 0.3.1

data/lib/calligraphy/rails/web_dav_preconditions.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Calligraphy
+  module Rails
+    # Provides methods to handle checking and validating WebDAV request
+    # preconditions.
+    module WebDavPreconditions
+      private
+
+      def check_preconditions
+        return true unless request.headers['If'].present?
+
+        evaluate_if_header
+      end
+
+      def evaluate_if_header
+        conditions_met = false
+        condition_lists = if_conditions
+
+        condition_lists.each do |list|
+          conditions = parse_preconditions list
+
+          conditions_met = evaluate_preconditions conditions
+          break if conditions_met
+        end
+
+        conditions_met
+      end
+
+      def if_conditions
+        if request.headers['If'][0] == '<'
+          request.headers['If'].split Calligraphy::TAGGED_LIST_REGEX
+        else
+          request.headers['If'].split Calligraphy::UNTAGGAGED_LIST_REGEX
+        end
+      end
+
+      def parse_preconditions(list)
+        conditions = conditions_hash
+        conditions[:dav_no_lock] = match_dav_no_lock list
+        conditions[:resource] = scan_for_resource list
+        conditions[:lock_token] = scan_for_lock_token list
+        conditions[:etag] = scan_for_etag list
+        conditions
+      end
+
+      def conditions_hash
+        {
+          dav_no_lock: nil,
+          etag: nil,
+          lock_token: nil,
+          resource: nil
+        }
+      end
+
+      def match_dav_no_lock(list)
+        return nil unless list =~ Calligraphy::DAV_NO_LOCK_REGEX
+
+        list =~ Calligraphy::DAV_NOT_NO_LOCK_REGEX ? nil : true
+      end
+
+      def scan_for_resource(list)
+        return nil unless list =~ Calligraphy::RESOURCE_REGEX
+
+        list.scan(Calligraphy::RESOURCE_REGEX).flatten[0]
+      end
+
+      def scan_for_lock_token(list)
+        return nil unless list =~ Calligraphy::LOCK_TOKEN_REGEX
+
+        list.scan(Calligraphy::LOCK_TOKEN_REGEX).flatten[0]
+      end
+
+      def scan_for_etag(list)
+        return nil unless list =~ Calligraphy::ETAG_IF_REGEX
+
+        list.scan(Calligraphy::ETAG_IF_REGEX).flatten[0]
+      end
+
+      def evaluate_preconditions(conditions)
+        conditions_met = true
+
+        if conditions[:etag]
+          conditions_met = false unless evaluate_etag_condition conditions
+        end
+
+        conditions_met = false if conditions[:dav_no_lock]
+        conditions_met
+      end
+
+      def target_resource(conditions)
+        if conditions[:resource]
+          @resource_class.new(
+            resource: conditions[:resource],
+            mount: @resource.mount_point
+          )
+        else
+          @resource
+        end
+      end
+
+      def evaluate_etag_condition(conditions)
+        validators = [@resource.etag, '']
+        validate_etag validators, conditions[:etag]
+      end
+
+      def validate_etag(etag_validators, validate_against)
+        cache_key = ActiveSupport::Cache.expand_cache_key etag_validators
+
+        validate_against == "W/\"#{Digest::MD5.hexdigest(cache_key)}\""
+      end
+    end
+  end
+end

data/lib/calligraphy/rails/web_dav_requests_controller.rb

@@ -1,213 +1,105 @@
-module Calligraphy::Rails
-  class WebDavRequestsController < ActionController::Base
-    before_action :verify_resource_scope
-    before_action :authenticate_with_digest_authentiation
-    before_action :set_resource
-
-    # Entry-point for all WebDAV requests. Handles checking and validating
-    # preconditions, directing of requests to the proper WebDAV action
-    # method, and composing responses to send back to the client.
-    def invoke_method
-      method = request.request_method.downcase
-
-      if check_preconditions
-        if method == 'head'
-          status = get head: true
-        elsif Calligraphy.allowed_http_methods.include? method
-          set_resource_client_nonce(method) if Calligraphy.enable_digest_authentication
-
-          status, body = send method
-        else
-          status = :method_not_allowed
+# frozen_string_literal: true
+
+module Calligraphy
+  module Rails
+    # Controller for all WebDAV requests.
+    class WebDavRequestsController < ActionController::Base
+      include Calligraphy::Rails::WebDavMethods
+      include Calligraphy::Rails::WebDavPreconditions
+
+      before_action :verify_resource_scope
+      before_action :authenticate_with_digest_authentiation
+      before_action :set_resource
+
+      # Entry-point for all WebDAV requests. Handles checking and validating
+      # preconditions, directing of requests to the proper WebDAV action
+      # method, and composing responses to send back to the client.
+      def invoke_method
+        unless check_preconditions
+          return send_response(status: :precondition_failed)
         end
 
+        method = request.request_method.downcase
+        status, body = make_request method
+
         send_response status: status, body: body
-      else
-        send_response status: :precondition_failed
       end
-    end
 
-    private
+      private
 
-    def verify_resource_scope
-      head :forbidden if %w(. ..).any? { |seg| params[:resource].include? seg }
-    end
+      def verify_resource_scope
+        # Prevent any request with `.` or `..` as part of the resource.
+        head :forbidden if %w[. ..].any? do |seg|
+          params[:resource].include? seg
+        end
+      end
 
-    def authenticate_with_digest_authentiation
-      return unless Calligraphy.enable_digest_authentication
+      def authenticate_with_digest_authentiation
+        return unless digest_enabled?
 
-      realm = Calligraphy.http_authentication_realm
+        realm = Calligraphy.http_authentication_realm
 
-      authenticate_or_request_with_http_digest(realm) do |username|
-        Calligraphy.digest_password_procedure.call(username)
+        authenticate_or_request_with_http_digest(realm) do |username|
+          Calligraphy.digest_password_procedure.call(username)
+        end
       end
-    end
 
-    def set_resource
-      resource_id = if params[:format]
-        [params[:resource], params[:format]].join '.'
-      else
-        params[:resource]
+      def digest_enabled?
+        Calligraphy.enable_digest_authentication
       end
 
-      @resource_class = params[:resource_class]
-      @resource_root_path = params[:resource_root_path]
-      @resource = @resource_class.new resource: resource_id, req: request, root_dir: @resource_root_path
-    end
-
-    def check_preconditions
-      return true unless request.headers['If'].present?
-
-      evaluate_if_header
-    end
-
-    def evaluate_if_header
-      conditions_met = false
-      condition_lists = get_if_conditions
-
-      condition_lists.each do |list|
-        conditions = parse_preconditions list
+      def set_resource
+        @resource_class = params[:resource_class] || Calligraphy::Resource
+        @resource_root_path = params[:resource_root_path]
 
-        conditions_met = evaluate_preconditions conditions
-        break if conditions_met
+        @resource = @resource_class.new(
+          resource: resource_id,
+          req: request,
+          root_dir: @resource_root_path
+        )
       end
 
-      conditions_met
-    end
-
-    def get_if_conditions
-      lists = if request.headers['If'][0] == '<'
-        request.headers['If'].split Calligraphy::TAGGED_LIST_REGEX
-      else
-        request.headers['If'].split Calligraphy::UNTAGGAGED_LIST_REGEX
+      def resource_id
+        if params[:format]
+          [params[:resource], params[:format]].join '.'
+        else
+          params[:resource]
+        end
       end
 
-      lists
-    end
-
-    def parse_preconditions(list)
-      conditions = { dav_no_lock: nil, etag: nil, lock_token: nil, resource: nil }
-
-      conditions[:dav_no_lock] = if list =~ Calligraphy::DAV_NO_LOCK_REGEX
-        list =~ Calligraphy::DAV_NOT_NO_LOCK_REGEX ? nil : true
-      end
+      def make_request(method)
+        if method == 'head'
+          status = get head: true
+        elsif Calligraphy.allowed_http_methods.include? method
+          resource_client_nonce(method) if digest_enabled?
 
-      if list =~ Calligraphy::RESOURCE_REGEX
-        conditions[:resource] = list.scan(Calligraphy::RESOURCE_REGEX).flatten[0]
-      end
+          status, body = send method
+        else
+          status = :method_not_allowed
+        end
 
-      if list =~ Calligraphy::LOCK_TOKEN_REGEX
-        conditions[:lock_token] = list.scan(Calligraphy::LOCK_TOKEN_REGEX).flatten[0]
+        [status, body]
       end
 
-      if list =~ Calligraphy::ETAG_IF_REGEX
-        conditions[:etag] = list.scan(Calligraphy::ETAG_IF_REGEX).flatten[0]
+      def resource_client_nonce(_method)
+        @resource.client_nonce = client_nonce
       end
 
-      conditions
-    end
+      def client_nonce
+        auth_header = request.headers['HTTP_AUTHORIZATION']
+        digest = ::ActionController::HttpAuthentication::Digest
 
-    def evaluate_preconditions(conditions)
-      conditions_met = true
-      target = if conditions[:resource]
-        @resource_class.new(
-          resource: conditions[:resource],
-          mount: @resource.mount_point
-        )
-      else
-        @resource
+        auth = digest.decode_credentials auth_header
+        auth[:cnonce]
       end
 
-      if conditions[:lock_token]
-        if target.locked?
-          conditions_met = false unless target.lock_tokens&.include? conditions[:lock_token]
+      def send_response(status:, body: nil)
+        if body.nil?
+          head status
         else
-          conditions_met = false if target.locked_to_user? request.headers
+          render body: body, status: status
         end
       end
-
-      if conditions[:etag]
-        validators = [@resource.etag, ""]
-        conditions_met = false unless validate_etag validators, conditions[:etag]
-      end
-
-      conditions_met = false if conditions[:dav_no_lock]
-      conditions_met
-    end
-
-    def validate_etag(etag_validators, validate_against)
-      cache_key = ActiveSupport::Cache.expand_cache_key etag_validators
-      "W/\"#{Digest::MD5.hexdigest(cache_key)}\"" == validate_against
-    end
-
-    def web_dav_request
-      { headers: request.headers, request: request, resource: @resource, response: response }
-    end
-
-    def options
-      response.headers['DAV'] = '1, 2, 3'
-      :ok
-    end
-
-    def get(head: false)
-      fresh_when(@resource, etag: @resource.etag) if @resource.readable?
-
-      Calligraphy::Get.new(web_dav_request).request(head: head)
-    end
-
-    def put
-      Calligraphy::Put.new(web_dav_request).request
-    end
-
-    def delete
-      Calligraphy::Delete.new(web_dav_request).request
-    end
-
-    def copy
-      Calligraphy::Copy.new(web_dav_request).request
-    end
-
-    def move
-      Calligraphy::Move.new(web_dav_request).request
-    end
-
-    def mkcol
-      Calligraphy::Mkcol.new(web_dav_request).request
-    end
-
-    def propfind
-      Calligraphy::Propfind.new(web_dav_request).request
-    end
-
-    def proppatch
-      Calligraphy::Proppatch.new(web_dav_request).request
-    end
-
-    def lock
-      Calligraphy::Lock.new(web_dav_request).request
-    end
-
-    def unlock
-      Calligraphy::Unlock.new(web_dav_request).request
-    end
-
-    def send_response(status:, body: nil)
-      if body.nil?
-        head status
-      else
-        render body: body, status: status
-      end
-    end
-
-    def set_resource_client_nonce(method)
-      @resource.client_nonce = get_client_nonce
-    end
-
-    def get_client_nonce
-      auth_header = request.headers["HTTP_AUTHORIZATION"]
-
-      auth = ::ActionController::HttpAuthentication::Digest.decode_credentials auth_header
-      auth[:cnonce]
     end
   end
 end

data/lib/calligraphy/resource/file_resource.rb

@@ -1,13 +1,22 @@
+# frozen_string_literal: true
+
 require 'pstore'
 
 module Calligraphy
+  # Resource responsible for writing and deleting directories and files to disk.
   class FileResource < Resource
+    DAV_PROPERTY_METHODS = %w[
+      creationdate displayname getcontentlanguage getcontentlength
+      getcontenttype getetag getlastmodified lockdiscovery resourcetype
+      supportedlock
+    ].freeze
+
     include Calligraphy::Utils
 
+    #:nodoc:
     def initialize(resource: nil, req: nil, mount: nil, root_dir: Dir.pwd)
       super
 
-      @root_dir = root_dir || Dir.pwd
       @src_path = join_paths @root_dir, @request_path
 
       if exists?
@@ -19,90 +28,97 @@ module Calligraphy
       set_ancestors
     end
 
+    # Responsible for returning a boolean value indicating if an ancestor
+    # exists for the resource.
+    #
+    # Used in COPY and MKCOL requests.
     def ancestor_exist?
       File.exist? @ancestor_path
     end
 
-    def can_copy?(options)
-      copy_options = { can_copy: false, ancestor_exist: false, locked: false }
+    # Responsible for returning a boolean value indicating if the resource
+    # is a collection.
+    #
+    # Used in DELETE, MKCOL, MOVE, and PUT requests.
+    def collection?
+      File.directory? @src_path
+    end
 
-      overwrite = is_true? options[:overwrite]
-      destination = options[:destination].tap { |s| s.slice! @mount_point }
-      copy_options[:ancestor_exist] = File.exist? parent_path(destination)
+    # Responsible for returning a hash with keys indicating if the resource
+    # can be copied, if an ancestor exists, or if the copy destinatin is
+    # locked.
+    #
+    # Return hash should contain `can_copy`, `ancestor_exist`, and `locked`
+    # keys with boolean values.
+    #
+    # Used in COPY and MOVE (which inherits from COPY) requests.
+    def copy_options(options)
+      copy_options = { can_copy: false, ancestor_exist: false, locked: false }
 
+      destination = copy_destination options
       to_path = join_paths @root_dir, destination
-      to_path_exist = File.exist? to_path
-
-      copy_options[:locked] = if to_path_exist
-        if destination_locked? to_path
-          true
-        else
-          to_path_parent = split_and_pop(path: to_path).join '/'
-          common_ancestor = common_path_ancestors(to_path, @ancestors).first
-          to_path_ancestors = ancestors_from_path_to_ancestor to_path, common_ancestor
-
-          locking_ancestor? to_path_parent, to_path_ancestors
-        end
-      else
-        false
-      end
-
-      if copy_options[:ancestor_exist]
-        if !overwrite && to_path_exist
-          copy_options[:can_copy] = false
-        else
-          copy_options[:can_copy] = true
-        end
-      end
+      to_path_exists = File.exist? to_path
 
+      copy_options[:ancestor_exist] = File.exist? parent_path destination
+      copy_options[:locked] = can_copy_locked_option to_path, to_path_exists
+      copy_options = can_copy_option copy_options, options, to_path_exists
       copy_options
     end
 
-    def collection?
-      File.directory? @src_path
-    end
-
+    # Responsible for creating a duplicate of the resource in
+    # `options[:destination]` (see section 9.8 of RFC4918).
+    #
+    # Used in COPY and MOVE (which inherits from COPY) requests.
     def copy(options)
-      destination = options[:destination].tap { |s| s.slice! @mount_point }
-      preserve_existing = is_false? options[:overwrite]
-
+      destination = copy_destination options
       to_path = join_paths @root_dir, destination
       to_path_exists = File.exist? to_path
 
-      if collection?
-        FileUtils.cp_r @src_path, to_path, preserve: preserve_existing
-      else
-        FileUtils.cp @src_path, to_path, preserve: preserve_existing
-      end
-
-      if store_exist? && preserve_existing
-        dest_store_path = collection? ? "#{to_path}/#{@name}" : to_path
-        dest_store_path += ".pstore"
+      preserve_existing = false? options[:overwrite]
 
-        FileUtils.cp @store_path, dest_store_path, preserve: preserve_existing
-      end
+      copy_resource_to_path to_path, preserve_existing
+      copy_pstore_to_path to_path, preserve_existing
 
       to_path_exists
     end
 
+    # Responsible for creating a new collection based on the resource (see
+    # section 9.3 of RFC4918).
+    #
+    # Used in MKCOL requests.
     def create_collection
       Dir.mkdir @src_path
     end
 
+    # Responsible for deleting a resource collection (see section 9.6 of
+    # RFC4918).
+    #
+    # Used in DELETE and MOVE requests.
     def delete_collection
       FileUtils.rm_r @src_path
       FileUtils.rm_r @store_path if store_exist?
     end
 
+    # Responsible for returning unique identifier used to create an etag.
+    #
+    # Used in precondition validation, as well as GET, HEAD, and PROPFIND
+    # requests.
     def etag
       [@updated_at.to_i, @stats[:inode], @stats[:size]].join('-').to_s
     end
 
+    # Responsible for indicating if the resource already exists.
+    #
+    # Used in DELETE, LOCK, MKCOL, and MOVE requests.
     def exists?
       File.exist? @src_path
     end
 
-    def lock(nodes, depth=INFINITY)
+    # Responsible for creating a lock on the resource (see section 9.10 of
+    # RFC4918).
+    #
+    # Used in LOCK requests.
+    def lock(nodes, depth = 'infinity')
       properties = {}
 
       nodes.each do |node|
@@ -110,30 +126,32 @@ module Calligraphy
         properties[node.name.to_sym] = node
       end
 
-      unless exists?
-        write ''
-        @name = File.basename @src_path
-        init_pstore
-      end
+      create_blank_file unless exists?
 
       create_lock properties, depth
+      fetch_lock_info
     end
 
+    # Responsible for indicating if a resource lock is exclusive.
+    #
+    # Used in LOCK requests.
     def lock_is_exclusive?
       lockscope == 'exclusive'
     end
 
-    def lock_tokens
-      get_lock_info
-      @lock_info&.each { |x| x }&.map { |k, v| k[:locktoken].children[0].text }
-    end
-
+    # Responsible for indicating if a resource is current locked.
+    #
+    # Used in LOCK requests.
     def locked?
-      get_lock_info
+      fetch_lock_info
+
       obj_exists_and_is_not_type? obj: @lock_info, type: []
     end
 
-    def locked_to_user?(headers=nil)
+    # Responsible for indicating if a resource is locked to the current user.
+    #
+    # Used in DELETE, LOCK, MOVE, PROPPATCH, and PUT requests.
+    def locked_to_user?(headers = nil)
       if locked?
         !can_unlock? headers
       else
@@ -141,6 +159,10 @@ module Calligraphy
       end
     end
 
+    # Responsible for handling the retrieval of properties defined on the
+    # resource (see section 9.1 of RFC4918).
+    #
+    # Used in PROPFIND requests.
     def propfind(nodes)
       properties = { found: [], not_found: [] }
 
@@ -150,96 +172,73 @@ module Calligraphy
 
           value = get_property prop
 
-          if value.nil?
-            properties[:not_found].push prop
-          elsif value.is_a? Hash
-            value.each_key do |key|
-              properties[:found].push value[key]
-            end
-          else
-            properties[:found].push value
-          end
+          update_found_properties properties, prop, value
         end
       end
 
       properties
     end
 
+    # Responsible for handling the addition and/or removal of properties
+    # defined on the resource through a PROPPATCH request (see section 9.2 of
+    # RFC4918).
+    #
+    # Used in PROPPATCH requests.
     def proppatch(nodes)
       actions = { set: [], remove: [] }
 
       @store.transaction do
         @store[:properties] = {} unless @store[:properties].is_a? Hash
 
-        nodes.each do |node|
-          if node.name == 'set'
-            node.children.each do |prop|
-              prop.children.each do |property|
-                prop_sym = property.name.to_sym
-                node = Calligraphy::XML::Node.new property
-
-                if @store[:properties][prop_sym]
-                  if @store[:properties][prop_sym].is_a? Array
-                    unless matching_namespace? @store[:properties][prop_sym], node
-                      @store[:properties][prop_sym].push node
-                    end
-                  else
-                    if !same_namespace? @store[:properties][prop_sym], node
-                      @store[:properties][prop_sym] = [@store[:properties][prop_sym]]
-                      @store[:properties][prop_sym].push node
-                    else
-                      @store[:properties][prop_sym] = node
-                    end
-                  end
-                else
-                  @store[:properties][prop_sym] = node
-                end
-
-                actions[:set].push property
-              end
-            end
-          elsif node.name == 'remove'
-            node.children.each do |prop|
-              prop.children.each do |property|
-                @store[:properties].delete property.name.to_sym
-
-                actions[:remove].push property
-              end
-            end
-          end
-        end
+        add_remove_properties nodes, actions
       end
 
       get_custom_property nil
       actions
     end
 
+    # Responsible for setting and returning the contents of a resource
+    # if it is readable (see section 9.4 of RFC4918).
+    #
+    # Used in GET requests.
     def read
       @contents ||= File.read @src_path if readable?
     end
 
+    # Responsible for refreshing locks (see section 9.10.2 of RFC4918).
+    #
+    # Used in LOCK requests.
     def refresh_lock
       if locked?
         @store.transaction do
           @store[:lockdiscovery][-1][:timeout] = timeout_node
         end
 
-        get_lock_info
+        fetch_lock_info
       else
         refresh_ancestor_locks @ancestor_path, @ancestors.dup
       end
     end
 
+    # Responsible for unlocking a resource lock (see section 9.11 of RFC4918).
+    #
+    # Used in UNLOCK requests.
     def unlock(token)
       if lock_tokens.include? token
         remove_lock token
+        @lock_info = nil
+
         :no_content
       else
         :forbidden
       end
     end
 
-    def write(contents=@request_body.to_s)
+    # Responsible for writing contents to a resource (see section 9.7 of
+    # RFC4918).
+    #
+    # Used in PUT requests.
+    def write(contents = @request_body.to_s)
       @contents = contents
 
       File.open(@src_path, 'w') do |file|
@@ -261,7 +260,7 @@ module Calligraphy
       @stats = {
         created_at: file_stats.ctime,
         inode: file_stats.ino,
-        size: file_stats.size,
+        size: file_stats.size
       }
       @updated_at = file_stats.mtime
     end
@@ -275,6 +274,34 @@ module Calligraphy
       join_paths @root_dir, split_and_pop(path: path)
     end
 
+    def copy_destination(options)
+      options[:destination].tap { |s| s.slice! @mount_point }
+    end
+
+    def can_copy_locked_option(to_path, to_path_exists)
+      return false unless to_path_exists
+      return true if destination_locked? to_path
+
+      to_path_parent = split_and_pop(path: to_path).join '/'
+      common_ancestor = common_path_ancestors(to_path, @ancestors).first
+      to_path_ancestors = ancestors_from_path_to_ancestor(to_path,
+                                                          common_ancestor)
+
+      locking_ancestor? to_path_parent, to_path_ancestors
+    end
+
+    def can_copy_option(copy_options, options, to_path_exists)
+      return copy_options unless copy_options[:ancestor_exist]
+
+      copy_options[:can_copy] = if false?(options[:overwrite]) && to_path_exists
+                                  false
+                                else
+                                  true
+                                end
+
+      copy_options
+    end
+
     def destination_locked?(path)
       store = PStore.new "#{path}.pstore"
       lock = store.transaction(true) { store[:lockdiscovery] }
@@ -295,36 +322,51 @@ module Calligraphy
       path = split_and_pop path: path
       ancestors = []
 
-      until path.last == stop_at_ancestor
-        ancestors.push path.pop
-      end
-
+      ancestors.push path.pop until path.last == stop_at_ancestor
       ancestors.push stop_at_ancestor
       ancestors.reverse
     end
 
+    def copy_resource_to_path(to_path, preserve_existing)
+      if collection?
+        FileUtils.cp_r @src_path, to_path, preserve: preserve_existing
+      else
+        FileUtils.cp @src_path, to_path, preserve: preserve_existing
+      end
+    end
+
+    def copy_pstore_to_path(to_path, preserve_existing)
+      return unless store_exist? && preserve_existing
+
+      dest_store_path = collection? ? "#{to_path}/#{@name}" : to_path
+      dest_store_path += '.pstore'
+
+      FileUtils.cp @store_path, dest_store_path, preserve: preserve_existing
+    end
+
     def store_exist?
       File.exist? @store_path
     end
 
+    def create_blank_file
+      write ''
+      @name = File.basename @src_path
+      init_pstore
+    end
+
     def create_lock(properties, depth)
       @store.transaction do
         @store[:lockcreator] = client_nonce
-        @store[:lockdiscovery] = [] unless @store[:lockdiscovery].is_a? Array
         @store[:lockdepth] = depth
+        @store[:lockdiscovery] = [] unless @store[:lockdiscovery].is_a? Array
 
-        activelock = {}
-        activelock[:locktoken] = create_lock_token
-        activelock[:timeout] = timeout_node
-
-        properties.each_key do |prop|
-          activelock[prop] = Calligraphy::XML::Node.new properties[prop]
-        end
+        @store[:lockdiscovery].push({}.tap do |activelock|
+          activelock[:locktoken] = create_lock_token
+          activelock[:timeout] = timeout_node
 
-        @store[:lockdiscovery].push activelock
+          add_lock_properties activelock, properties
+        end)
       end
-
-      get_lock_info
     end
 
     def create_lock_token
@@ -346,7 +388,13 @@ module Calligraphy
       end
     end
 
-    def get_lock_info
+    def add_lock_properties(activelock, properties)
+      properties.each_key do |prop|
+        activelock[prop] = Calligraphy::XML::Node.new properties[prop]
+      end
+    end
+
+    def fetch_lock_info
       return nil if @store.nil?
 
       @lock_info = @store.transaction(true) { @store[:lockdiscovery] }
@@ -357,94 +405,153 @@ module Calligraphy
       @lock_info[-1][:lockscope].children[0].name
     end
 
-    def can_unlock?(headers=nil)
+    def can_unlock?(headers = nil)
       token = unless headers.nil?
-        extract_lock_token(headers['If']) if headers['If']
-      end
+                extract_lock_token(headers['If']) if headers['If']
+              end
 
       lock_tokens.include? token
     end
 
-    def locking_ancestor?(ancestor_path, ancestors, headers=nil)
+    def lock_tokens
+      fetch_lock_info
+      @lock_info&.each { |x| x }&.map { |k| k[:locktoken].children[0].text }
+    end
+
+    def locking_ancestor?(ancestor_path, ancestors, headers = nil)
+      ancestor_info = ancestor_lock_info headers
       ancestor_store_path = "#{ancestor_path}/#{ancestors[-1]}.pstore"
-      check_lock_creator = Calligraphy.enable_digest_authentication
-      blocking_lock = false
-      unlockable = true
 
       ancestors.pop
 
-      if File.exist? ancestor_store_path
-        ancestor_store = PStore.new ancestor_store_path
+      check_for_ancestor ancestor_info, ancestor_store_path
 
-        ancestor_lock = nil
-        ancestor_lock_creator = nil
-        ancestor_lock_depth = nil
+      if ancestor_info[:blocking] || ancestors.empty?
+        assign_locking_ancestor ancestor_info
 
-        ancestor_store.transaction(true) do
-          ancestor_lock = ancestor_store[:lockdiscovery]
-          ancestor_lock_depth = ancestor_store[:lockdepth]
+        return ancestor_info[:unlockable] ? false : true
+      end
 
-          if check_lock_creator
-            ancestor_lock_creator = ancestor_store[:lockcreator]
-          end
-        end
+      next_ancestor = split_and_pop(path: ancestor_path).join '/'
+      locking_ancestor? next_ancestor, ancestors, ancestor_info[:headers]
+    end
+
+    def ancestor_lock_info(headers)
+      {
+        blocking: false,
+        check_creator: Calligraphy.enable_digest_authentication,
+        creator: nil,
+        depth: nil,
+        headers: headers || nil,
+        lock: nil,
+        unlockable: true
+      }
+    end
 
-        blocking_lock = obj_exists_and_is_not_type? obj: ancestor_lock, type: []
+    def check_for_ancestor(ancestor_info, store_path)
+      return unless File.exist? store_path
+      ancestor_lock_from_store ancestor_info, store_path
 
-        if blocking_lock
-          token = unless headers.nil?
-            extract_lock_token(headers['If']) if headers['If']
-          end
+      ancestor_info[:blocking] = obj_exists_and_is_not_type?(
+        obj: ancestor_info[:lock],
+        type: []
+      )
 
-          ancestor_lock_tokens = ancestor_lock
-            .each { |x| x }
-            .map { |k, v| k[:locktoken].children[0].text }
+      blocking_lock_unlockable? ancestor_info if ancestor_info[:blocking]
+    end
+
+    def ancestor_lock_from_store(lock_info, store_path)
+      ancestor_store = PStore.new store_path
+
+      ancestor_store.transaction(true) do
+        lock_info[:lock] = ancestor_store[:lockdiscovery]
+        lock_info[:depth] = ancestor_store[:lockdepth]
 
-          unlockable = ancestor_lock_tokens.include?(token) ||
-            (check_lock_creator && (ancestor_lock_creator == client_nonce))
+        if lock_info[:check_creator]
+          lock_info[:creator] = ancestor_store[:lockcreator]
         end
       end
+    end
 
-      if blocking_lock || ancestors.empty?
-        @locking_ancestor = {
-          depth: ancestor_lock_depth,
-          info: ancestor_lock
-        }
+    def blocking_lock_unlockable?(lock_info)
+      headers = lock_info[:headers]
 
-        return unlockable ? false : true
-      end
+      token = unless headers.nil?
+                extract_lock_token(headers['If']) if headers['If']
+              end
 
-      next_ancestor = split_and_pop(path: ancestor_path).join '/'
-      locking_ancestor? next_ancestor, ancestors, headers
+      ancestor_tokens = lock_info[:lock]
+
+      lock_info[:unlockable] =
+        ancestor_tokens.include?(token) ||
+        (lock_info[:check_creator] && (lock_info[:creator] == client_nonce))
+    end
+
+    def ancestor_lock_tokens(lock_info)
+      lock_info[:lock].each { |x| x }.map { |k| k[:locktoken].children[0].text }
+    end
+
+    def assign_locking_ancestor(ancestor_info)
+      @locking_ancestor = {
+        depth: ancestor_info[:depth],
+        info: ancestor_info[:lock]
+      }
     end
 
     def get_property(prop)
       case prop.name
-      when 'creationdate'
-        prop.content = @stats[:created_at]
-      when 'displayname'
-        prop.content = @name
-      when 'getcontentlanguage'
-        prop.content = nil
-      when 'getcontentlength'
-        prop.content = @stats[:size]
-      when 'getcontenttype'
-        prop.content = nil
-      when 'getetag'
-        prop.content = nil
-      when 'getlastmodified'
-        prop.content = @updated_at
       when 'lockdiscovery'
-        return get_lock_info
-      when 'resourcetype'
-        prop.content = 'collection'
-      when 'supportedlock'
-        prop.content = nil
+        fetch_lock_info
+      when *DAV_PROPERTY_METHODS
+        prop.content = send prop.name
+        prop
       else
-        return get_custom_property prop.name
+        get_custom_property prop.name
       end
+    end
+
+    def creationdate
+      @stats[:created_at]
+    end
+
+    def displayname
+      get_custom_property(:displayname) || @name
+    end
+
+    def getcontentlanguage
+      get_custom_property :contentlanguage
+    end
+
+    def getcontentlength
+      @stats[:size]
+    end
+
+    def getcontenttype
+      get_custom_property :contenttype
+    end
+
+    def getetag
+      cache_key = ActiveSupport::Cache.expand_cache_key [@resource.etag, '']
+      "W/\"#{Digest::MD5.hexdigest(cache_key)}\""
+    end
+
+    def getlastmodified
+      @updated_at
+    end
+
+    def lockdiscovery
+      fetch_lock_info
+    end
 
-      prop
+    def resourcetype
+      'collection' if collection?
+    end
+
+    def supportedlock
+      exclusive_write = lockentry_hash('exclusive', 'write')
+      shared_write = lockentry_hash('shared', 'write')
+
+      JSON.generate [exclusive_write, shared_write]
     end
 
     def get_custom_property(prop)
@@ -452,12 +559,85 @@ module Calligraphy
       @store_properties[prop.to_sym] unless @store_properties.nil? || prop.nil?
     end
 
-    def matching_namespace?(node_arr, node)
-      node_arr.select { |x| x.namespace.href == node.namespace.href }.length > 0
+    def update_found_properties(properties, prop, value)
+      if value.nil?
+        properties[:not_found].push prop
+      elsif value.is_a? Hash
+        value.each_key do |key|
+          properties[:found].push value[key]
+        end
+      else
+        properties[:found].push value
+      end
+    end
+
+    def add_remove_properties(nodes, actions)
+      nodes.each do |node|
+        if node.name == 'set'
+          add_properties node, actions
+        elsif node.name == 'remove'
+          remove_properties node, actions
+        end
+      end
+    end
+
+    def add_properties(node, actions)
+      node.children.each do |prop|
+        prop.children.each do |property|
+          node = Calligraphy::XML::Node.new property
+          prop_sym = property.name.to_sym
+
+          store_property_node node, prop_sym
+
+          actions[:set].push property
+        end
+      end
+    end
+
+    def store_property_node(node, prop)
+      # Property does not exist yet so we can just store the property node.
+      return @store[:properties][prop] = node unless @store[:properties][prop]
+
+      if @store[:properties][prop].is_a? Array
+        store_mismatch_namespace_property_node node, prop
+      elsif same_namespace? @store[:properties][prop], node
+        # If stored property and node have the same namespace, we can just
+        # overwrite the previously stored property node.
+        @store[:properties][prop] = node
+      else
+        # If stored property and node DO NOT have the same namespace, create
+        # an array for the stored property and push the new property node.
+        store_mismatch_namespace_property_nodes node, prop
+      end
+    end
+
+    def store_mismatch_namespace_property_node(node, prop)
+      node_arr = @store[:properties][prop]
+
+      namespace_mismatch = node_arr.select do |x|
+        x.namespace.href == node.namespace.href
+      end.length.positive?
+
+      @store[:properties][prop].push node unless namespace_mismatch
     end
 
     def same_namespace?(node1, node2)
-      node1.namespace.href == node2.namespace.href
+      node1.namespace&.href == node2.namespace&.href
+    end
+
+    def store_mismatch_namespace_property_nodes(node, prop)
+      @store[:properties][prop] = [@store[:properties][prop]]
+      @store[:properties][prop].push node
+    end
+
+    def remove_properties(node, actions)
+      node.children.each do |prop|
+        prop.children.each do |property|
+          @store[:properties].delete property.name.to_sym
+
+          actions[:remove].push property
+        end
+      end
     end
 
     def refresh_ancestor_locks(ancestor_path, ancestors)
@@ -465,11 +645,7 @@ module Calligraphy
       ancestors.pop
 
       if File.exist? ancestor_store_path
-        ancestor_store = PStore.new ancestor_store_path
-        ancestor_lock = ancestor_store.transaction do
-          ancestor_store[:lockdiscovery][-1][:timeout] = timeout_node
-          ancestor_store[:lockdiscovery]
-        end
+        ancestor_lock = refresh_ancestor_lock ancestor_store_path
 
         return map_array_of_hashes ancestor_lock
       end
@@ -478,6 +654,15 @@ module Calligraphy
       refresh_ancestor_locks next_ancestor, ancestors
     end
 
+    def refresh_ancestor_lock(ancestor_store_path)
+      ancestor_store = PStore.new ancestor_store_path
+
+      ancestor_store.transaction do
+        ancestor_store[:lockdiscovery][-1][:timeout] = timeout_node
+        ancestor_store[:lockdiscovery]
+      end
+    end
+
     def remove_lock(token)
       @store.transaction do
         @store.delete :lockcreator
@@ -490,8 +675,6 @@ module Calligraphy
           end
         end
       end
-
-      @lock_info = nil
     end
   end
 end