calligraphy 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ca4ef1090301769811a4e4e9582826338ebcc7d
+  data.tar.gz: 6453585dca9f697419f6f5e8b4c73e2f664d5b10
+SHA512:
+  metadata.gz: 5055f8ed11cda5dcc4bdaf6d1e821b989fd57f2e2869e9e316a8a9ed49e40a6da5962614dac6a8f6448d155a5de743f9ca3360aaa8700af736c7e989a8a66f91
+  data.tar.gz: 7de86141b36bd5bef0bd915a8eed30c524568c1e409bf0ecdc1bf5d7f41a22fa887cbbc69964ef404f8f5f0de094474cb4d5eea10e68278d20d1e573e8dc90f5

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Brandon Robins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# Calligraphy
+
+Calligraphy is a Web Distributed Authoring and Versioning (WebDAV) solution for Rails that:
+
+* Provides a framework for handling WebDAV requests (e.g. `PROPFIND`, `PROPPATCH`)
+* Allows you to extend WedDAV functionality to any type of resource
+* Passes all of the [Litmus](https://github.com/eanlain/litmus) tests (using `Calligraphy::FileResource` and digest authentication)
+
+## Getting Started
+
+Add the following line to your Gemfile:
+
+```ruby
+gem 'calligraphy', :git => 'https://github.com/eanlain/calligraphy'
+```
+
+Then run `bundle install`
+
+Next, set up a `calligraphy_resource` route in `config/routes.rb` with a `resource_class`.
+
+```ruby
+calligraphy_resource :webdav, resource_class: Calligraphy::FileResource
+```
+
+The above will create a route, `/webdav` that will be able to handle the following HTTP request methods:
+
+* `OPTIONS`
+* `GET`
+* `PUT`
+* `DELETE`
+* `COPY`
+* `MOVE`
+* `MKCOL`
+* `PROPFIND`
+* `PROPPATCH`
+* `LOCK`
+* `UNLOCK`
+
+The routes will also use the `Calligraphy::FileResource`, enabling Rails to carry out WebDAV actions on files.
+
+## Extensibility
+
+The `Calligraphy::Resource` class exposes all the methods used in the various `Calligraphy::WebDavRequest` classes.
+To create a custom resource, simply inherit from `Calligraphy::Resource` and redefine the public methods you'd like to customize.
+
+For example, to create a `CalendarResource`:
+
+```ruby
+module Calligraphy
+  class CalendarResource < Resource
+
+    def propfind(nodes)
+      # custom implementation of propfind for CalendarResource
+    end
+
+    ...
+  end
+end
+```
+
+## License
+
+Calligraphy is Copyright © 2017 Brandon Robins.
+It is free software, and may be redistributed under the terms specified in the [LICENSE](/LICENSE) file.

data/lib/calligraphy.rb

@@ -0,0 +1,58 @@
+require 'calligraphy/rails/mapper'
+require 'calligraphy/rails/web_dav_requests_controller'
+
+require 'calligraphy/xml/builder'
+require 'calligraphy/xml/namespace'
+require 'calligraphy/xml/node'
+require 'calligraphy/xml/utils'
+
+require 'calligraphy/utils'
+require 'calligraphy/resource'
+require 'calligraphy/file_resource'
+
+require 'calligraphy/web_dav_request'
+require 'calligraphy/copy'
+require 'calligraphy/delete'
+require 'calligraphy/get'
+require 'calligraphy/lock'
+require 'calligraphy/mkcol'
+require 'calligraphy/move'
+require 'calligraphy/propfind'
+require 'calligraphy/proppatch'
+require 'calligraphy/put'
+require 'calligraphy/unlock'
+
+module Calligraphy
+  DAV_NS = 'DAV:'
+  DAV_NO_LOCK_REGEX = /DAV:no-lock/i
+  DAV_NOT_NO_LOCK_REGEX = /Not\s+<DAV:no-lock>/i
+  ETAG_IF_REGEX = /\[(.+?)\]/
+  LOCK_TOKEN_ANGLE_REGEX = /[<>]/
+  LOCK_TOKEN_REGEX = /<(urn:uuid:.+?)>/
+  RESOURCE_REGEX = /^<+(.+?)>\s/
+  TAGGED_LIST_REGEX = /\)\s</
+  UNTAGGAGED_LIST_REGEX = /\)\s\(/
+
+  mattr_accessor :allowed_methods
+  @@allowed_methods = %w(
+    options head get put delete copy move mkcol propfind proppatch lock unlock
+  )
+
+  mattr_accessor :digest_password_procedure
+  @@digest_password_procedure = Proc.new { |x| 'changeme!' }
+
+  mattr_accessor :enable_digest_authentication
+  @@enable_digest_authentication = false
+
+  mattr_accessor :lock_timeout_period
+  @@lock_timeout_period = 24 * 60 * 60
+
+  mattr_accessor :web_dav_actions
+  @@web_dav_actions = %i(
+    options get put delete copy move mkcol propfind proppatch lock unlock
+  )
+
+  def self.configure
+    yield self
+  end
+end

data/lib/calligraphy/copy.rb

@@ -0,0 +1,37 @@
+module Calligraphy
+  class Copy < WebDavRequest
+    def request
+      options = copy_move_options
+      can_copy = @resource.can_copy? options
+
+      if can_copy[:ancestor_exist]
+        return :precondition_failed
+      else
+        return :conflict
+      end unless can_copy[:can_copy]
+
+      return :locked if can_copy[:locked]
+
+      overwritten = @resource.copy options
+      return overwritten ? :no_content : :created
+    end
+
+    private
+
+    def copy_move_options
+      {
+        depth: @headers['Depth'],
+        destination: remove_trailing_slash(destination_header),
+        overwrite: @headers['Overwrite'] || true
+      }
+    end
+
+    def destination_header
+      @headers['Destination'].split(@headers['Host'])[-1]
+    end
+
+    def remove_trailing_slash(input)
+      input[-1] == '/' ? input[0..-2] : input
+    end
+  end
+end

data/lib/calligraphy/delete.rb

@@ -0,0 +1,17 @@
+module Calligraphy
+  class Delete < WebDavRequest
+    def request
+      return :locked if @resource.locked_to_user? @headers
+
+      if @resource.collection?
+        @resource.delete_collection
+
+        return :no_content
+      else
+        return :not_found unless @resource.exists?
+      end
+
+      return :no_content
+    end
+  end
+end

data/lib/calligraphy/file_resource.rb

@@ -0,0 +1,487 @@
+require 'pstore'
+
+module Calligraphy
+  class FileResource < Resource
+    include Calligraphy::Utils
+
+    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?
+        @name = File.basename @src_path
+        init_pstore
+        set_file_stats
+      end
+
+      set_ancestors
+    end
+
+    def ancestor_exist?
+      File.exist? @ancestor_path
+    end
+
+    def can_copy?(options)
+      copy_options = { can_copy: false, ancestor_exist: false, locked: false }
+
+      overwrite = is_true? options[:overwrite]
+      destination = options[:destination].tap { |s| s.slice! @mount_point }
+      copy_options[:ancestor_exist] = File.exist? parent_path(destination)
+
+      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
+
+      copy_options
+    end
+
+    def collection?
+      File.directory? @src_path
+    end
+
+    def copy(options)
+      destination = options[:destination].tap { |s| s.slice! @mount_point }
+      preserve_existing = is_false? options[:overwrite]
+
+      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"
+
+        FileUtils.cp @store_path, dest_store_path, preserve: preserve_existing
+      end
+
+      to_path_exists
+    end
+
+    def create_collection
+      Dir.mkdir @src_path
+    end
+
+    def delete_collection
+      FileUtils.rm_r @src_path
+      FileUtils.rm_r @store_path if store_exist?
+    end
+
+    def etag
+      [@updated_at.to_i, @stats[:inode], @stats[:size]].join('-').to_s
+    end
+
+    def exists?
+      File.exist? @src_path
+    end
+
+    def lock(nodes, depth='infinity')
+      properties = {}
+
+      nodes.each do |node|
+        next unless node.is_a? Nokogiri::XML::Element
+        properties[node.name.to_sym] = node
+      end
+
+      unless exists?
+        write ''
+        @name = File.basename @src_path
+        init_pstore
+      end
+
+      create_lock properties, depth
+    end
+
+    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
+
+    def locked?
+      get_lock_info
+      obj_exists_and_is_not_type? obj: @lock_info, type: []
+    end
+
+    def locked_to_user?(headers=nil)
+      if locked?
+        !can_unlock? headers
+      else
+        locking_ancestor? @ancestor_path, @ancestors.dup, headers
+      end
+    end
+
+    def propfind(nodes)
+      properties = { found: [], not_found: [] }
+
+      nodes.each do |node|
+        node.children.each do |prop|
+          next unless prop.is_a? Nokogiri::XML::Element
+
+          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
+        end
+      end
+
+      properties
+    end
+
+    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
+      end
+
+      get_custom_property nil
+      actions
+    end
+
+    def read
+      @contents ||= File.read @src_path if readable?
+    end
+
+    def refresh_lock
+      if locked?
+        @store.transaction do
+          @store[:lockdiscovery][-1][:timeout] = timeout_node
+        end
+
+        get_lock_info
+      else
+        refresh_ancestor_locks @ancestor_path, @ancestors.dup
+      end
+    end
+
+    def unlock(token)
+      if lock_tokens.include? token
+        remove_lock token
+        :no_content
+      else
+        :forbidden
+      end
+    end
+
+    def write(contents=@request_body.to_s)
+      @contents = contents
+
+      File.open(@src_path, 'w') do |file|
+        file.write @contents
+      end
+    end
+
+    private
+
+    def init_pstore
+      pstore_path = collection? ? "#{@src_path}/#{@name}" : @src_path
+      @store = PStore.new "#{pstore_path}.pstore"
+      @store_path = @store.instance_variable_get :@filename
+    end
+
+    def set_file_stats
+      file_stats = File.stat @src_path
+
+      @stats = {
+        created_at: file_stats.ctime,
+        inode: file_stats.ino,
+        size: file_stats.size,
+      }
+      @updated_at = file_stats.mtime
+    end
+
+    def set_ancestors
+      @ancestors = split_and_pop path: @request_path
+      @ancestor_path = join_paths @root_dir, @ancestors.join('/')
+    end
+
+    def parent_path(path)
+      join_paths @root_dir, split_and_pop(path: path)
+    end
+
+    def destination_locked?(path)
+      store = PStore.new "#{path}.pstore"
+      lock = store.transaction(true) { store[:lockdiscovery] }
+
+      obj_exists_and_is_not_type? obj: lock, type: {}
+    end
+
+    def common_path_ancestors(path, ancestors)
+      [].tap do |common|
+        ancestors.each do |ancestor|
+          split_path = path.split ancestor
+          common.push ancestor if split_path.length > 1
+        end
+      end
+    end
+
+    def ancestors_from_path_to_ancestor(path, stop_at_ancestor)
+      path = split_and_pop path: path
+      ancestors = []
+
+      until path.last == stop_at_ancestor
+        ancestors.push path.pop
+      end
+
+      ancestors.push stop_at_ancestor
+      ancestors.reverse
+    end
+
+    def store_exist?
+      File.exist? @store_path
+    end
+
+    def create_lock(properties, depth)
+      @store.transaction do
+        @store[:lockcreator] = client_nonce
+        @store[:lockdiscovery] = [] unless @store[:lockdiscovery].is_a? Array
+        @store[:lockdepth] = depth
+
+        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 activelock
+      end
+
+      get_lock_info
+    end
+
+    def create_lock_token
+      token = Calligraphy::XML::Node.new
+      token.name = 'locktoken'
+
+      href = Calligraphy::XML::Node.new
+      href.name = 'href'
+      href.text = ['urn', 'uuid', SecureRandom.uuid].join ':'
+
+      token.children = [href]
+      token
+    end
+
+    def timeout_node
+      Calligraphy::XML::Node.new.tap do |node|
+        node.name = 'timeout'
+        node.text = ['Second', Calligraphy.lock_timeout_period].join '-'
+      end
+    end
+
+    def get_lock_info
+      return nil if @store.nil?
+
+      @lock_info = @store.transaction(true) { @store[:lockdiscovery] }
+      @lock_info.nil? ? nil : map_array_of_hashes(@lock_info)
+    end
+
+    def lockscope
+      @lock_info[-1][:lockscope].children[0].name
+    end
+
+    def can_unlock?(headers=nil)
+      token = unless headers.nil?
+        extract_lock_token(headers['If']) if headers['If']
+      end
+
+      lock_tokens.include? token
+    end
+
+    def locking_ancestor?(ancestor_path, ancestors, headers=nil)
+      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
+        ancestor_lock_depth = ancestor_store.transaction(true) do
+          ancestor_store[:lockdepth]
+        end
+
+        ancestor_lock = ancestor_store.transaction(true) do
+          ancestor_store[:lockdiscovery]
+        end
+
+        ancestor_lock_creator = ancestor_store.transaction(true) do
+          ancestor_store[:lockcreator]
+        end if check_lock_creator
+
+        blocking_lock = obj_exists_and_is_not_type? obj: ancestor_lock, type: []
+
+        if blocking_lock
+          token = unless headers.nil?
+            extract_lock_token(headers['If']) if headers['If']
+          end
+
+          ancestor_lock_tokens = ancestor_lock
+            .each { |x| x }
+            .map { |k, v| k[:locktoken].children[0].text }
+
+          unlockable = ancestor_lock_tokens.include?(token) ||
+            (check_lock_creator && (ancestor_lock_creator == client_nonce))
+        end
+      end
+
+      if blocking_lock || ancestors.empty?
+        @locking_ancestor = {
+          depth: ancestor_lock_depth,
+          info: ancestor_lock
+        }
+
+        return unlockable ? false : true
+      end
+
+      next_ancestor = split_and_pop(path: ancestor_path).join '/'
+      locking_ancestor? next_ancestor, ancestors, headers
+    end
+
+    def get_property(prop)
+      case prop.name
+      when 'creationdate'
+        prop.content = @stats[:created_at]
+      when 'displayname'
+        prop.content = @name
+      when 'getcontentlength'
+        prop.content = @stats[:size]
+      when 'getlastmodified'
+        prop.content = @updated_at
+      when 'resourcetype'
+        prop.content = 'collection'
+      when 'lockdiscovery'
+        return get_lock_info
+      else
+        return get_custom_property prop.name
+      end
+
+      prop
+    end
+
+    def get_custom_property(prop)
+      @store_properties ||= @store.transaction(true) { @store[:properties] }
+      @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
+    end
+
+    def same_namespace?(node1, node2)
+      node1.namespace.href == node2.namespace.href
+    end
+
+    def refresh_ancestor_locks(ancestor_path, ancestors)
+      ancestor_store_path = "#{ancestor_path}/#{ancestors[-1]}.pstore"
+      ancestors.pop
+
+      if File.exist? ancestor_store_path
+        ancestor_store = PStore.new ancestor_store_path
+        ancestor_lock = ancestor_store.transaction(true) do
+          ancestor_store[:lockdiscovery][-1][:timeout] = timeout_node
+          ancestor_store[:lockdiscovery]
+        end
+
+        return map_array_of_hashes ancestor_lock
+      end
+
+      next_ancestor = split_and_pop(path: ancestor_path).join '/'
+      refresh_ancestor_locks next_ancestor, ancestors
+    end
+
+    def remove_lock(token)
+      @store.transaction do
+        @store.delete :lockcreator
+
+        if @store[:lockdiscovery].length == 1
+          @store.delete :lockdiscovery
+        else
+          @store[:lockdiscovery] = @store[:lockdiscovery].reject do |activelock|
+            activelock[:locktoken].children[0].text == token
+          end
+        end
+      end
+
+      @lock_info = nil
+    end
+  end
+end