railsdav 0.0.5

data/README.md

@@ -0,0 +1,185 @@
+# RailsDAV
+
+Make your Rails 3 resources accessible via WebDAV
+
+ProvidesThis gem provides basic Rails 3 extensions for making your business resources accessible via WebDAV. This gem does by no means by no means implement the full WebDAV semantics, but it suffices to access your app with client(-libs) such as Konqueror, cadaver, davfs2 or NetDrive.
+
+## Compatibility
+
+Definitely works with Rails 3.0.9 and 3.2.13, but should also work with versions in between.
+This is due to some hacking done "under the hood" in the Rails routing implementation as well as a simple method override in ActionController.
+
+f you encounter any problems with other Rails versions, please feel free to report an issue or send me a pull request on github.
+
+## Installation
+
+Just at the following to your Gemfile
+
+    gem 'railsdav', :git => 'https://github.com/wvk/railsdav.git'
+
+and then run
+
+    bundle install
+
+
+## Usage
+
+TODO: Context
+
+### Controller
+
+#### Doing the Set-Up
+
+Tell your controller which actions should be available as WebDAV resources, what media types should be advertised and whether or not they should be also available as collection resources (i.e. "folders"):
+
+    class FoosController < ApplicationController
+      enable_webdav_for :index,
+          :accept => :json
+
+      enable_webdav_for :show,
+          :accept     => [:xml, :json],
+          :collection => false
+
+      # ...
+
+This stores some metadata about your actions that can be accessed from another controller, in case this one acts as a subresource of another resource. You may provide an arbitrary list of media types ("formats") with the :accept options. This causes RailsDAV to advertise that resource as separate files, one for each provided media type.
+By default, RailsDAV also advertises each resource as a collection ("folder"), containing a resource's subresources. You may choose not to let it do so by setting the :collection option to false (nil won't do, it really must be /false/).
+
+# Handling PROPFIND Requests
+
+As for the actions themselves they, too, need some attention. Collection resources usually contain subresources (otherwise, why bother?) that are specified in the format.webdav responder block:
+
+      # ...
+
+      def index
+        @foos = Foo.limit(100)
+        respond_to do |format|
+          # you already know this...
+          format.html
+          format.xml  { render :json => @foos }
+          format.json { render :xml  => @foos }
+
+          # and this one is new...
+          format.webdav do |dav|
+            @foos.each |foo|
+              dav.subresource foo_path(foo)
+            end
+            dav.format :xml,  :size => @foos.to_json.size, :updated_at => @foos.maximum(:updated_at)
+            dav.format :json, :size => @foos.to_xml.size, :updated_at => @foos.maximum(:updated_at)
+          end
+        end
+      end
+
+      # ...
+
+The webdav responder block is called when a PROPFIND request comes in. Within the block, we define a metadata set for each possible mime type that will be served via WebDAV. If the index resource is accessed as a collection (PROPFIND /foos), a multi-status response is rendered with the foos collection containting up to 100 foo entries as separate XML and JSON files:
+
+    PROPFIND /foos
+
+will return a directory layout similar to:
+
+    /foos
+      -> /foos/1.xml
+      -> /foos/1.json
+      -> /foos/2.xml
+      -> /foos/2.json
+      ...
+
+If the index resource is accessed as XML (PROPFIND /foos.xml) or JSON (PROPFIND /foos.json), size and last-update of the XML/JSON "file" are included in the response. You can include that metatdata for each subresource, too:
+
+          format.webdav do |dav|
+            @foos.each do |foo|
+              dav.subresource foo_path(foo), :updated_at => foo.updated_at
+            end
+          end
+
+the "dav.format" statements are entirely optional if you do not wish to include any metadata such as updated-at, created-at, or size. There's no need to be redundant here, since you already specified the most important metadata with "enable_webdav_for".
+
+The show action looks similar.
+
+      def show
+        @foo = Foo.find(params[:id])
+        respond_to do |format|
+          format.html
+          format.json { render :json => @foo }
+          format.xml  { render :xml  => @foo }
+
+          format.webdav do |dav|
+            dav.format :xml,  :size => @foo.to_xml.size,  :updated_at => @foo.updated_at
+            dav.format :json, :size => @foo.to_json.size, :updated_at => @foo.updated_at
+          end
+        end
+      end
+
+TODO: explain why respond_to is always needed
+
+TODO: explain difference between PROPFIND /foos/1 and PROPFIND /foos/1.:format and medadata defined on class level and in responder block
+
+### Routing
+
+To make the rails routing mechanism webdav aware, RailsDAV extends it by means of some new DSL methods. Let's take the above example again and what the default routing would look like:
+
+    MyAwesomeApp::Application.routes.draw do
+      resources :foos
+    end
+
+In order to accept PROPFIND and other WebDAV requests, you'll have to change it to look rather this way:
+
+    MyAwesomeApp::Application.routes.draw do
+      webdav_resources :foos
+    end
+
+Easy enough. As you may have guessed, there exists also a "webdav_resource" counterpart for singleton resources and some more. By the way: the above also produces a route for OPTIONS requests that matches the capabilities of the resource. In case you only want the show and update action to be present, the following would also adapt the OPTIONS responder to only contain PROPFIND, GET and PUT:
+
+      webdav_resource :bar,
+          :only => %w(show update)
+
+To enable propfind for a single action somewhere, use:
+      dav_propfind '/my-foo', :to => 'my_foos#show'
+
+the other available helpers are: dav_copy, dav_move, dav_mkcol, dav_lock, dav_unlock, dav_proppatch.
+
+### Authentication
+
+RailsDAV does not do any authentication whatsoever, nor is there any sugar to go nicely with $your_favourite_authentication_gem. However, since cookie/session based authentication does not like to be friends with WebDAV, it's up to you to ensure Basic or Digest Authentication is used when a request from a WebDAV client comes in.
+
+Assuming you have an application where resources are normally accessed as text/html but never so for WebDAV, a simple means of providing access control using HTTP Basic might look like this:
+
+    class ApplicationController < ActionController::Base
+      before_filter :authenticate_unless_session
+
+      protected
+
+      def authenticate_unless_session
+        # Always use Basic Authentication if the request method is one of WebDAV's
+        if is_webdav_request?
+          basic_auth
+        elsif request.format == Mime::HTML
+          # skip Basic Authentication and use anoher way
+        else
+          basic_auth # or whatever...
+        end
+      end
+
+      def basic_auth
+        session = authenticate_with_http_basic {|usr, pwd| Session.new :login => usr, :password => pwd }
+        if session and session.valid?
+          @current_user = session.user
+        else
+          request_http_basic_authentication 'My Awesome App'
+        end
+      end
+    end
+
+is_webdav_request? checks whether an Incoming request is issued by a WebDAV client using any specific HTTP verbs (such as PROPFIND, MKCOL, COPY, MOVE, etc.) or a media type other than text/html is requested.
+
+## Changelog
+
+* 0.0.5: Rails 3.1.x compatibility, add encoding hints, fix ResourceDescriptor load error
+* 0.0.4: Basic support for allprop in PROPFIND
+* 0.0.3: Change the API within the responder block to a more concise one
+* 0.0.2: More or less a complete rewrite: Use more sensible API, modularize the renderer code, get rid of controller monkey patching
+* 0.0.1: Initial Release: Basic support for PROPFIND and webdav_resource(s) based routing
+
+Copyright (c) 2012 Willem van Kerkhof <wvk@consolving.de>, released under the MIT license
+

data/lib/railsdav/controller_extensions.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Railsdav
+  module ControllerExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :webdav_metadata
+
+      alias_method_chain :respond_to, :webdav
+      alias_method_chain :respond_with, :webdav
+    end
+
+    module ClassMethods
+      def enable_webdav_for(*names_and_options, &block)
+        options = names_and_options.extract_options!
+        names   = names_and_options
+        self.webdav_metadata ||= {}
+
+        options[:collection] = true unless options.has_key?(:collection)
+
+        names.each do |name|
+          self.webdav_metadata[name] = options
+        end
+      end
+
+      def webdav_metadata_for_action(action)
+        webdav_metadata[action.to_sym]
+      end
+    end
+
+    # decorate behaviour defined in ActionController::MimeResponds
+    def respond_to_with_webdav(*mimes, &block)
+      if request.propfind?
+        render :webdav => :propstat, :respond_to_block => block
+      else
+        respond_to_without_webdav *mimes, &block
+      end
+    end
+
+    # decorate behaviour defined in ActionController::MimeResponds
+    def respond_with_with_webdav(*resources, &block)
+      if request.propfind?
+        render :webdav => :propstat, :respond_to_block => block
+      else
+        respond_with_without_webdav *resources, &block
+      end
+    end
+
+    def webdav_metadata_for_current_action
+      self.class.webdav_metadata_for_action params[:action]
+    end
+
+  end
+end

data/lib/railsdav/renderer/response_collector.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Railsdav
+  class Renderer
+    class ResponseCollector
+      attr_writer :controller
+
+      delegate :subresources,
+          :to => :@selector
+
+      def initialize(controller, request_format)
+        @controller, @request_format = controller, request_format
+        @selector = ResponseTypeSelector.new(controller, request_format)
+      end
+
+      def resource
+        @resource ||= Renderer::ResourceDescriptor.new(@controller.request.url, @selector.resource_options)
+      end
+
+      # responds to calls like html, xml, json by ignoring them
+      def method_missing(name, *args)
+        super unless Mime::EXTENSION_LOOKUP[name.to_s]
+      end
+
+      def webdav
+        if block_given?
+          yield @selector
+        end
+      end
+    end
+  end
+end

data/lib/railsdav/renderer/response_type_selector.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Railsdav
+  class Renderer
+    class ResponseTypeSelector
+      attr_reader :subresources, :resource_options
+
+      def initialize(controller, request_format)
+        @controller, @request_format = controller, request_format
+        @subresources = []
+
+        # TODO: somehow allow passing more options to current resource
+        @resource_options = {:format => @request_format.to_sym}
+      end
+
+      def format(name, options)
+        if Mime::EXTENSION_LOOKUP[name.to_s]
+          if @request_format.to_sym == name
+            # TODO: somehow get the attributes (size, updated-at, ...) from the actual Mime responder block here
+            @resource_options.merge! options
+          end
+        else
+          raise UnknownMimeTypeExtension, "#{name} is not a valid MIME type file extension."
+        end
+      end
+
+      # loop over all urls marked as subresources in webdav responder block
+      # and add them with all their acceptable mime types
+      def subresource(*subresources)
+        return unless @request_format == :collection
+
+        options = subresources.extract_options!
+        subresources.each do |resource_url|
+          route = Rails.application.routes.recognize_path(resource_url)
+
+          if meta = Renderer.webdav_metadata_for_url(route)
+            # show the resource as a collection unless disabled
+            if meta[:collection]
+              @subresources << Renderer::ResourceDescriptor.new(resource_url, options.merge(:format => :collection))
+            elsif meta[:accept].blank?
+              # show the resource without .:format suffix, but not as a collection
+              @subresources << Renderer::ResourceDescriptor.new(resource_url, options)
+            end
+
+            # show the resource with all the specified format suffixes
+            if meta[:accept]
+              [meta[:accept]].flatten.each do |type_name|
+                mime_type = Mime::Type.lookup_by_extension(type_name)
+                subresource_url = @controller.url_for(route.merge(:format => type_name))
+                @subresources << Renderer::ResourceDescriptor.new(subresource_url, options.merge(:format => mime_type))
+              end
+            end
+          else
+            raise MissingWebDAVMetadata, "no WebDAV metadata found for #{resource_url}, please specify it using #enable_webdav_for"
+          end
+        end
+
+        @resource_options[:size] = @subresources.size
+      end
+    end
+  end
+end

data/lib/railsdav/renderer.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+
+require 'builder'
+
+module Railsdav
+  class Renderer
+    autoload :ResourceDescriptor,   'railsdav/renderer/resource_descriptor'
+    autoload :ResponseCollector,    'railsdav/renderer/response_collector'
+    autoload :ResponseTypeSelector, 'railsdav/renderer/response_type_selector'
+
+    # Return the webdav metadata for a given URL/path
+    #
+    # If the given route is recognized, a controller and action can be identified.
+    # To get the properties for that URI, we lookup the metadata
+    # specified in the target controller (see #enable_webdav_for)
+    #
+    def self.webdav_metadata_for_url(routing_data)
+      controller = "#{routing_data[:controller]}_controller".camelize.constantize
+      controller ? controller.webdav_metadata_for_action(routing_data[:action]) : nil
+    end
+
+    attr_accessor :depth
+
+    # Create a new Renderer instance that will render an XML multistatus response.
+    # 
+    # Arguments:
+    #   controller: the current controller instance
+    #
+    def initialize(controller)
+      @controller = controller
+      @request    = controller.request
+      @depth      = (@request.headers['Depth'].to_i > 0) ? 1 : 0 # depth "infinite" is not yet supported
+    end
+
+    # Render the requested response_type.
+    #
+    # Arguments:
+    #   response_type: currently either :propstat or :response.
+    #   options:
+    #     - for response: :href, :status, :error (see #response)
+    #     - for propstat: :size, :format, :created_at, :updated_at, :resource_layout, ... (see #propstat)
+    def respond_with(response_type, options = {})
+      self.send response_type, options
+    end
+
+    protected
+
+    def request_format
+      if @controller.params[:format].blank?
+        if @controller.webdav_metadata_for_current_action[:collection]
+          return :collection
+        else
+          return @controller.request_format
+        end
+      else
+        return @controller.params[:format]
+      end
+    end
+
+    def render
+      @dav = Builder::XmlMarkup.new :indent => 2
+      @dav.instruct!
+      @dav.multistatus :xmlns => 'DAV:' do
+        yield @dav
+      end
+      @dav.target!
+    end
+
+    # Render a WebDAV multistatus response with a single "response" element.
+    # This is primarily intended vor responding to single resource errors.
+    #
+    # Arguments:
+    #   options:
+    #     - href: the requested resource URL, usually request.url
+    #     - status: the response status, something like :unprocessable_entity or 204.
+    #     - error: an Error description, if any.
+    #
+    def response(options = {})
+      elements = options.slice(:error)
+
+      render do
+        response_for options[:href] do |dav|
+          elements.each do |name, value|
+            status_for options[:status]
+            dav.__send__ name, value
+          end
+        end
+      end
+    end
+
+    def status_for(status)
+      code   = Rack::Utils.status_code(status || :ok)
+      status = "HTTP/1.1 #{code} #{Rack::Utils::HTTP_STATUS_CODES[code]}"
+      @dav.status status
+    end
+
+    # Render a WebDAV multistatus response with a "response" element per resource
+    # TODO: explain the magic implemented here
+    # Arguments:
+    #    TODO: describe valid arguments
+    #
+    def propstat(options = {})
+      response_collector = ResponseCollector.new(@controller, self.request_format)
+      # retrieve properties for this resource and all subresources if this is a collection
+      if options[:respond_to_block]
+        options[:respond_to_block].call(response_collector)
+      end
+
+      render do |dav|
+        propstat_for response_collector.resource
+        propstat_for response_collector.subresources if @depth > 0
+      end
+    end
+
+    private
+
+    def propstat_for(*resources)
+      params = @controller.params
+      params[:propfind] ||= {:prop => []}
+
+      if params[:propfind].has_key? 'allprop'
+        requested_properties = nil # fill it later, see below.
+      else
+        requested_properties = params[:propfind][:prop]
+      end
+
+      resources.flatten.each do |resource|
+        hash = resource.props
+
+        case hash[:updated_at]
+        when Time, DateTime
+          updated_at = hash[:updated_at]
+        when String
+          updated_at = Time.parse(hash[:updated_at])
+        else
+          updated_at = Time.now
+        end
+
+        response_hash = {
+          :quota_used_bytes      => 0,
+          :quota_available_bytes => 10.gigabytes,
+          :creationdate          => updated_at.rfc2822,
+          :getlastmodified       => updated_at.rfc2822,
+          :getcontentlength      => hash[:size],
+          :getcontenttype        => hash[:format].to_s
+        }
+
+        if resource.collection?
+          response_hash[:resourcetype]   = proc { @dav.tag! :collection } # must be block to render <collection></collection> instead of "collection"
+          response_hash[:getcontenttype] = nil
+        end
+
+        requested_properties ||= response_hash.keys
+
+        response_for(resource.url) do |dav|
+          dav.propstat do
+            status_for hash[:status]
+            dav.prop do
+              requested_properties.each do |prop_name, opts|
+                if prop_val = response_hash[prop_name.to_sym]
+                  if prop_val.respond_to? :call
+                    if opts
+                      dav.tag! prop_name, opts, &prop_val
+                    else
+                      dav.tag! prop_name, &prop_val
+                    end
+                  else
+                    dav.tag! prop_name, prop_val, opts
+                  end
+                elsif opts
+                  dav.tag! prop_name, opts
+                else
+                  dav.tag! prop_name
+                end
+              end # requested_properties.each
+            end # dav.prop
+          end # dav.propstat
+        end # dav.response_for
+      end # resource_layout.keys.each
+    end # def propstat_for
+
+    def response_for(href)
+      @dav.response do
+        @dav.href href
+        yield @dav
+      end
+    end
+
+  end # class Railsdav
+end # module Railsdav
+

data/lib/railsdav/request_extensions.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Railsdav
+  module RequestExtensions
+
+    def self.included(base)
+      base.class_eval do
+        Railsdav::WEBDAV_HTTP_VERBS.each do |verb|
+          method_name = "#{verb.underscore}?"
+
+          # just to make sure we don't accidentally break things...
+          raise "#{method_name} is already defined in #{self.class}!" if respond_to? method_name
+
+          define_method method_name do
+            ActionDispatch::Request::HTTP_METHOD_LOOKUP[request_method] == verb.underscore.to_sym
+          end
+        end
+      end
+    end
+
+    def webdav?
+      Railsdav::WEBDAV_HTTP_VERBS.include? request_method
+    end
+
+  end # module RequestExtensions
+end # module Railsdav

data/lib/railsdav/routing_extensions.rb

@@ -0,0 +1,213 @@
+# encoding: utf-8
+
+# Allow usage of WebDAV specific HTTP verbs
+# userinfo is not a standard webdav verb, bur davfs2 uses it
+# and we want to be prepared to ignore it gracefully (e.g.
+# by sending a :not_implemented response)
+verbs = %w(propfind proppatch mkcol copy move lock unlock userinfo)
+verbs.each do |method|
+  ActionDispatch::Request::HTTP_METHODS << method.upcase
+  ActionDispatch::Request::HTTP_METHOD_LOOKUP[method.upcase] = method.to_sym
+end
+
+# Extend routing s.t. webdav_resource and webdav_resources can be used,
+# enabling things like PROPFIND /foo/index.(:format) and such.
+#
+# ATTENTION: adapt this to newer rails version if upgrading the framework!
+class ActionDispatch::Routing::Mapper
+  module HttpHelpers
+    def dav_propfind(*args, &block)
+      map_method(:propfind, *args, &block)
+    end
+
+    def dav_options(*args, &block)
+      map_method(:options, *args, &block)
+    end
+
+    def dav_copy(*args, &block)
+      map_method(:copy, *args, &block)
+    end
+
+    def dav_move(*args, &block)
+      map_method(:move, *args, &block)
+    end
+
+    def dav_mkcol(*args, &block)
+      map_method(:mkcol, *args, &block)
+    end
+
+    def dav_lock(*args, &block)
+      map_method(:lock, *args, &block)
+    end
+
+    def dav_unlock(*args, &block)
+      map_method(:unlock, *args, &block)
+    end
+
+    def dav_proppatch(*args, &block)
+      map_method(:proppatch, *args, &block)
+    end
+  end
+
+  module Resources
+    CANONICAL_ACTIONS << :update_all
+
+    class WebDAVResource < Resource
+      DEFAULT_ACTIONS = [:index, :create, :new, :show, :update, :destroy, :edit, :update_all]
+    end
+
+    class WebDAVSingletonResource < SingletonResource
+      DEFAULT_ACTIONS = [:show, :create, :update, :destroy, :new, :edit]
+    end
+
+    def resource_scope?
+      [:webdav_resource, :webdav_resources, :resource, :resources].include?(@scope[:scope_level])
+    end
+
+    if Rails.version <= '3.1.0'
+      # Rails versions after 3.1 expect two arguments here, the first being :resource, :resources,
+      # :webdav_resource etc.so we don't need the inferring logic anymore in newer versions.
+      def resource_scope(resource)
+        case resource
+        when WebDAVSingletonResource
+          scope_level = :webdav_resource
+        when WebDAVResource
+          scope_level = :webdav_resources
+        when SingletonResource
+          scope_level = :resource
+        when Resource
+          scope_level = :resources
+        end
+        with_scope_level(scope_level, resource) do
+          scope(parent_resource.resource_scope) do
+            yield
+          end
+        end
+      end
+    end
+
+    def dav_options_response(*allowed_http_verbs)
+      lambda { [200, {'Allow' => allowed_http_verbs.flatten.map{|s| s.to_s.upcase}.join(' '), 'DAV' => '1'}, ''] }
+    end
+
+    def dav_match(*args)
+      get *args
+      dav_propfind *args
+    end
+
+    def webdav_resource(*resources, &block)
+      options = resources.extract_options!
+
+      if apply_common_behavior_for(:webdav_resource, resources, options, &block)
+        return self
+      end
+
+      sub_block = lambda do
+        yield if block_given?
+
+        if parent_resource.actions.include?(:create)
+          collection do
+            post :create
+          end
+        end
+
+        if parent_resource.actions.include?(:new)
+          new do
+            get :new
+          end
+        end
+
+        member do
+          if parent_resource.actions.include?(:show)
+            dav_match :show
+          end
+          get    :edit    if parent_resource.actions.include?(:edit)
+          put    :update  if parent_resource.actions.include?(:update)
+          delete :destroy if parent_resource.actions.include?(:destroy)
+        end
+      end
+
+      if Rails.version <= '3.1'
+        resource_scope(WebDAVSingletonResource.new(resources.pop, options), &sub_block)
+      else
+        resource_scope(:webdav_resource, WebDAVSingletonResource.new(resources.pop, options), &sub_block)
+      end
+
+      self
+    end
+
+    def webdav_resources(*resources, &block)
+      options = resources.extract_options!
+
+      if apply_common_behavior_for(:webdav_resources, resources, options, &block)
+        return self
+      end
+
+      sub_block = lambda do
+        yield if block_given?
+
+        opts = []
+        collection do
+          if parent_resource.actions.include?(:index)
+            dav_match :index
+            opts << [:get, :propfind]
+          end
+
+          if parent_resource.actions.include?(:create)
+            post :create
+            opts << :post
+          end
+
+          if parent_resource.actions.include?(:update_all)
+            put :index, :action => :update_all
+            opts << :put
+          end
+          dav_options :index, :to => dav_options_response(opts)
+        end
+
+        if parent_resource.actions.include?(:new)
+          new do
+            dav_match :new
+            put :new, :action => :create
+            dav_options :new, :to => dav_options_response(:get, :put, :propfind, :options)
+          end
+        end
+
+        member do
+          opts = []
+          if parent_resource.actions.include?(:show)
+            dav_match :show
+            opts << :get
+            opts << :propfind
+          end
+
+          if parent_resource.actions.include?(:update)
+            put :update
+            opts << :put
+          end
+
+          if parent_resource.actions.include?(:destroy)
+            delete :destroy
+            opts << :delete
+          end
+
+          dav_options :show, :to => dav_options_response(opts)
+
+          if parent_resource.actions.include?(:edit)
+            dav_match :edit
+            dav_options :edit, :to => dav_options_response(:get, :propfind)
+          end
+        end
+      end
+
+      if Rails.version <= '3.1'
+        resource_scope(WebDAVResource.new(resources.pop, options), &sub_block)
+      else
+        resource_scope(:webdav_resources, WebDAVResource.new(resources.pop, options), &sub_block)
+      end
+
+      self
+    end
+
+  end
+end

data/lib/railsdav.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Railsdav
+  autoload :ControllerExtensions, 'railsdav/controller_extensions'
+  autoload :RoutingExtensions,    'railsdav/routing_extensions'
+  autoload :RequestExtensions,    'railsdav/request_extensions'
+  autoload :Renderer,             'railsdav/renderer'
+
+  class MissingWebDAVMetadata < StandardError; end
+
+  WEBDAV_HTTP_VERBS = ActionDispatch::Request::RFC2518
+
+  Mime::Type.register_alias 'application/xml', :webdav
+
+  ActionController::Renderers.add :webdav do |response_type, options|
+    renderer = Railsdav::Renderer.new(self)
+    xml_str  = renderer.respond_with response_type, options
+
+    Rails.logger.debug "WebDAV response:\n#{xml_str}"
+
+    response.headers['Depth'] = renderer.depth.to_s
+    response.headers['DAV']   = '1'
+
+    send_data xml_str,
+        :content_type => Mime::XML,
+        :status => :multi_status
+  end
+
+  ActionController::Base.send :include, Railsdav::ControllerExtensions
+  ActionDispatch::Request.send :include, Railsdav::RequestExtensions
+
+end # module Railsdav

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: railsdav
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+  prerelease: 
+platform: ruby
+authors:
+- Willem van Kerkhof
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-18 00:00:00.000000000 Z
+dependencies: []
+description: Provides basic Rails 3/Rails 4 extensions for making your business resources
+  accessible via WebDAV. This gem does by no means by no means implement the full
+  WebDAV semantics, but it suffices to access your app with client(-libs) such as
+  Konqueror, cadaver, davfs2 or NetDrive
+email: wvk@consolving.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- init.rb
+- lib/railsdav.rb
+- lib/railsdav/routing_extensions.rb
+- lib/railsdav/request_extensions.rb
+- lib/railsdav/renderer/response_collector.rb
+- lib/railsdav/renderer/response_type_selector.rb
+- lib/railsdav/controller_extensions.rb
+- lib/railsdav/renderer.rb
+homepage: http://github.com/wvk/railsdav
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Make your Rails 3/4 resources accessible via WebDAV
+test_files: []
+has_rdoc: