rack_dav 0.4.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 849a36645773dd942cbf87d7e41a685ff5814157
-  data.tar.gz: 5269572bc9f41e2c6fa73eb23f1e31a7ac17aa58
+SHA256:
+  metadata.gz: 3f5efaaf9d78cffb9459cce4b8ff84610ae9a480303d23e0266cbd8ec351603b
+  data.tar.gz: 817e1db4fcb91c2fa26e8be1e32074c466c8aa6c7631237b73bd9e61c6316804
 SHA512:
-  metadata.gz: b6e6183c272dbd1c9c292c2de86fda4afef9282db0e190cc9fa31f1d7d0af7d3d175e917442f83d11c53231bf07f676fa4990bf722781a385f29d2dfcbdab299
-  data.tar.gz: c591239bce9cff7162639b6bf1b24b28b4e1d193a87eafda61c1aa0477085f491683270622cdd78eaeaa9855fb2c1a039b0816bfa0da7b66e986b11c0c15b25c
+  metadata.gz: b827c9616a9c8a106bdd0bb2dce19e944f9a21932f0686b6ce51a58307094c88d449e1673d611769c1dce28e1fdb460770eeff4351b235aa30718bf7d0cad665
+  data.tar.gz: 33c156ccecb968a88d8d38435b9d95a65245de4abce448dc0d987f83cf5f355ec4289c823be5340bf5e333bcf99622bd908be9f9dee1fafab79e82cd0cf21289

data/Dockerfile

@@ -0,0 +1,13 @@
+FROM ruby:latest
+
+RUN mkdir /app
+WORKDIR /app
+
+ADD Gemfile /app
+ADD rack_dav.gemspec /app
+ADD lib/rack_dav/version.rb /app/lib/rack_dav/version.rb
+
+RUN bundle install
+
+ADD . /app
+

data/README.md

@@ -2,30 +2,17 @@
 RackDAV - Web Authoring for Rack
 ---
 
-RackDAV is Handler for [Rack][1], which allows content authoring over
-HTTP. RackDAV brings its own file backend, but other backends are
-possible by subclassing RackDAV::Resource.
-
-## Install
-
-Just install the gem from RubyGems:
-
-    $ gem install rack_dav
+RackDAV is a Ruby gem that allows you to use the WebDAV protocol to edit and manage files over HTTP. It comes with its own file backend, but you can also create your own backend by subclassing RackDAV::Resource.
 
 ## Quickstart
 
-If you just want to share a folder over WebDAV, you can just start a
-simple server with:
-
-    $ rack_dav
+To install the gem, run `gem install rack_dav`.
 
-This will start a WEBrick server on port 3000, which you can connect
-to without authentication.
+To quickly test out RackDAV, copy the config.ru file from this repository and run `bundle exec rackup`. This will start a web server on a default port that you can connect to without any authentication.
 
 ## Rack Handler
 
-Using RackDAV inside a rack application is quite easy. A simple rackup
-script looks like this:
+To use RackDAV in your own rack application, include the following in your config.ru file:
 
     require 'rubygems'
     require 'rack_dav'
@@ -36,18 +23,7 @@ script looks like this:
 
 ## Implementing your own WebDAV resource
 
-RackDAV::Resource is an abstract base class and defines an interface
-for accessing resources.
-
-Each resource will be initialized with a path, which should be used to
-find the real resource.
-
-RackDAV::Handler needs to be initialized with the actual resource class:
-
-    RackDAV::Handler.new(:resource_class => MyResource)
-
-RackDAV needs some information about the resources, so you have to
-implement following methods:
+If you want to create your own WebDAV resource, you will need to subclass RackDAV::Resource and implement the following methods:
 
 * __children__: If this is a collection, return the child resources.
 
@@ -67,10 +43,6 @@ implement following methods:
 
 * __content\_length__: Return the size in bytes for this resource.
 
-
-Most importantly you have to implement the actions, which are called
-to retrieve and change the resources:
-
 * __get(request, response)__: Write the content of the resource to the response.body.
 
 * __put(request, response)__: Save the content of the request.body.
@@ -94,18 +66,6 @@ to retrieve and change the resources:
 
 * __unlock(token)__: Unlock this resource
 
-Note, that it is generally possible, that a resource object is
-instantiated for a not yet existing resource.
-
-For inspiration you should have a look at the FileResource
-implementation. Please let me now, if you are going to implement a new
-type of resource.
-
-
-### RackDAV on GitHub
-
-Download or fork the project on its [Github page][2]
-
+Note that it is possible that a resource object may be instantiated for a resource that does not yet exist.
 
-[1]: http://github.com/chneukirchen/rack
-[2]: http://github.com/georgi/rack_dav
+For more examples and inspiration, you can look at the FileResource implementation.

data/config.ru

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'rack_dav'
+
+app = Rack::Builder.new do
+  use Rack::ShowExceptions
+  use Rack::CommonLogger
+  use Rack::Reloader
+  # use Rack::Lint
+
+  run RackDAV::Handler.new(:root => ".")
+
+end.to_app
+
+run app

data/lib/rack_dav/controller.rb

@@ -9,6 +9,8 @@ module RackDAV
 
     attr_reader :request, :response, :resource
 
+    @@uri = URI::RFC2396_Parser.new
+
     def initialize(request, response, options)
       @request  = request
       @response = response
@@ -18,11 +20,11 @@ module RackDAV
     end
 
     def url_escape(s)
-      URI.escape(s)
+      @@uri.escape(s)
     end
 
     def url_unescape(s)
-      URI.unescape(s).force_valid_encoding
+      @@uri.unescape(s).force_valid_encoding
     end
 
     def options
@@ -61,7 +63,7 @@ module RackDAV
       map_exceptions do
         resource.put
       end
-      response.status = Created
+      response.status = Created.to_i
     end
 
     def post
@@ -76,7 +78,7 @@ module RackDAV
       delete_recursive(resource, errors = [])
 
       if errors.empty?
-        response.status = NoContent
+        response.status = NoContent.to_i
       else
         multistatus do |xml|
           response_errors(xml, errors)
@@ -92,14 +94,14 @@ module RackDAV
       map_exceptions do
         resource.make_collection
       end
-      response.status = Created
+      response.status = Created.to_i
     end
 
     def copy
       raise NotFound if not resource.exist?
 
       dest_uri = URI.parse(env['HTTP_DESTINATION'])
-      destination = url_unescape(dest_uri.path)
+      destination = parse_destination(dest_uri)
 
       raise BadGateway if dest_uri.host and dest_uri.host != request.host
       raise Forbidden if destination == resource.path
@@ -114,7 +116,7 @@ module RackDAV
       copy_recursive(resource, dest, depth, errors = [])
 
       if errors.empty?
-        response.status = dest_existed ? NoContent : Created
+        response.status = dest_existed ? NoContent.to_i : Created.to_i
       else
         multistatus do |xml|
           response_errors(xml, errors)
@@ -128,7 +130,7 @@ module RackDAV
       raise NotFound if not resource.exist?
 
       dest_uri = URI.parse(env['HTTP_DESTINATION'])
-      destination = url_unescape(dest_uri.path)
+      destination = parse_destination(dest_uri)
 
       raise BadGateway if dest_uri.host and dest_uri.host != request.host
       raise Forbidden if destination == resource.path
@@ -145,7 +147,7 @@ module RackDAV
       delete_recursive(resource, errors)
 
       if errors.empty?
-        response.status = dest_existed ? NoContent : Created
+        response.status = dest_existed ? NoContent.to_i : Created.to_i
       else
         multistatus do |xml|
           response_errors(xml, errors)
@@ -185,7 +187,7 @@ module RackDAV
         for resource in find_resources
           resource.path.gsub!(/\/\//, '/')
           xml.response do
-            xml.href "http://#{host}#{url_escape resource.path}"
+            xml.href "http://#{host}#{@request.script_name}#{url_escape resource.path}"
             propstats xml, get_properties(resource, nodes)
           end
         end
@@ -212,7 +214,7 @@ module RackDAV
       multistatus do |xml|
         for resource in find_resources
           xml.response do
-            xml.href "http://#{host}#{resource.path}"
+            xml.href "http://#{host}#{@request.script_name}#{resource.path}"
             propstats xml, set_properties(resource, nodes)
           end
         end
@@ -241,7 +243,7 @@ module RackDAV
       locktoken = request_locktoken('LOCK_TOKEN')
       raise BadRequest if locktoken.nil?
 
-      response.status = resource.unlock(locktoken) ? NoContent : Forbidden
+      response.status = resource.unlock(locktoken) ? NoContent.to_i : Forbidden.to_i
     end
 
     private
@@ -251,7 +253,7 @@ module RackDAV
       end
 
       def host
-        env['HTTP_HOST']
+        @request.host
       end
 
       def resource_class
@@ -552,6 +554,12 @@ module RackDAV
         end
       end
 
+      def parse_destination dest_uri
+        destination = url_unescape(dest_uri.path)
+        destination.slice!(1..@request.script_name.length) if @request.script_name.length > 0
+        destination
+      end
+
   end
 
 end

data/lib/rack_dav/file_resource.rb

@@ -1,5 +1,5 @@
 require 'digest'
-require 'ffi-xattr'
+require 'webrick/httputils'
 
 module RackDAV
 
@@ -66,26 +66,8 @@ module RackDAV
       stat.size
     end
 
-    def set_custom_property(name, value)
-      if value.nil? || value.empty?
-        begin
-          xattr.remove("rack_dav:#{name}")
-        rescue Errno::ENOATTR
-          # If the attribute being deleted doesn't exist, just do nothing
-        end
-      else
-        xattr["rack_dav:#{name}"] = value
-      end
-    end
-
-    def get_custom_property(name)
-      value = xattr["rack_dav:#{name}"]
-      raise HTTPStatus::NotFound if value.nil?
-      value
-    end
-
     def list_custom_properties
-      xattr.list.select { |a| a.start_with?('rack_dav') }.map { |a| a.sub(/^rack_dav:/, '') }
+      []
     end
 
     # HTTP GET request.
@@ -194,10 +176,6 @@ module RackDAV
         @stat ||= File.stat(file_path)
       end
 
-      def xattr
-        @xattr ||= Xattr.new(file_path)
-      end
-
       def content_md5_pass?(env)
         expected = env['HTTP_CONTENT_MD5'] or return true
 

data/lib/rack_dav/handler.rb

@@ -6,6 +6,9 @@ module RackDAV
     attr_reader :options
 
 
+    ALLOWED_METHODS = %w(GET PUT POST DELETE PROPFIND PROPPATCH MKCOL COPY MOVE OPTIONS HEAD LOCK UNLOCK)
+
+
     # Initializes a new instance with given options.
     #
     # @param  [Hash] options Hash of options to customize the handler behavior.
@@ -27,7 +30,12 @@ module RackDAV
 
       begin
         controller = Controller.new(request, response, @options)
-        controller.send(request.request_method.downcase)
+        if ALLOWED_METHODS.include?(request.request_method)
+          controller.send(request.request_method.downcase)
+        else
+          response.status = 405
+          response['Allow'] = ALLOWED_METHODS.join(', ')
+        end
 
       rescue HTTPStatus::Status => status
         response.status = status.code

data/lib/rack_dav/version.rb

@@ -3,7 +3,7 @@ module RackDAV
   # Holds information about library version.
   module Version
     MAJOR = 0
-    MINOR = 4
+    MINOR = 5
     PATCH = 1
     BUILD = nil
 

data/lib/rack_dav.rb

@@ -3,7 +3,6 @@ require 'time'
 require 'uri'
 require 'rexml/document'
 require 'nokogiri'
-require 'webrick/httputils'
 
 require 'rack'
 require 'rack_dav/http_status'

data/rack_dav.gemspec

@@ -13,14 +13,16 @@ Gem::Specification.new do |s|
   s.license       = "MIT"
 
   s.files         = `git ls-files`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
   s.extra_rdoc_files = ["README.md"]
 
-  s.add_dependency("rack", "~> 1.4")
+  s.add_dependency("rack", "~> 3.0.0")
+  s.add_dependency("rackup", "~> 0.2.3")
+  s.add_dependency("rexml", "~> 3.2.4")
   s.add_dependency('nokogiri', "~> 1.5")
-  s.add_dependency("ffi-xattr", "~> 0.1")
+  s.add_dependency('webrick', "~> 1.3")
+  s.add_dependency('puma', "~> 6.0")
   s.add_development_dependency("rspec", "~> 2.11")
-  s.add_development_dependency("rake","~> 0.9")
+  s.add_development_dependency("rake","~> 13.0")
 end

data/spec/controller_spec.rb

@@ -40,30 +40,25 @@ describe RackDAV::Handler do
   CLASS_1 = CLASS_2 - %w(LOCK UNLOCK)
 
   before do
-    FileUtils.mkdir(DOC_ROOT) unless File.exists?(DOC_ROOT)
+    FileUtils.mkdir(DOC_ROOT) unless File.exist?(DOC_ROOT)
   end
 
   after do
-    FileUtils.rm_rf(DOC_ROOT) if File.exists?(DOC_ROOT)
+    FileUtils.rm_rf(DOC_ROOT) if File.exist?(DOC_ROOT)
   end
 
   attr_reader :response
 
-  context "Given a Lockable resource" do
-    before do
-      @controller = RackDAV::Handler.new(
-        :root           => DOC_ROOT,
-        :resource_class => RackDAV::LockableFileResource
-      )
-    end
+  shared_examples :lockable_resource do
+
 
     describe "OPTIONS" do
       it "is successful" do
-        options('/').should be_ok
+        options(url_root).should be_ok
       end
 
       it "sets the allow header with class 2 methods" do
-        options('/')
+        options(url_root)
         CLASS_2.each do |method|
           response.headers['allow'].should include(method)
         end
@@ -72,8 +67,8 @@ describe RackDAV::Handler do
 
     describe "LOCK" do
       before(:each) do
-        put("/test", :input => "body").should be_created
-        lock("/test", :input => File.read(fixture("requests/lock.xml")))
+        put(url_root + 'test', :input => "body").should be_created
+        lock(url_root + 'test', :input => File.read(fixture("requests/lock.xml")))
       end
 
       describe "creation" do
@@ -96,26 +91,26 @@ describe RackDAV::Handler do
         context "a valid locktoken" do
           it "prints the lockdiscovery" do
             token = response_locktoken
-            lock("/test", 'HTTP_IF' => "(#{token})").should be_ok
+            lock(url_root + 'test', 'HTTP_IF' => "(#{token})").should be_ok
             lockdiscovery_response token
           end
 
           it "accepts it without parenthesis" do
             token = response_locktoken
-            lock("/test", 'HTTP_IF' => token).should be_ok
+            lock(url_root + 'test', 'HTTP_IF' => token).should be_ok
             lockdiscovery_response token
           end
 
           it "accepts it with excess angular braces (office 2003)" do
             token = response_locktoken
-            lock("/test", 'HTTP_IF' => "(<#{token}>)").should be_ok
+            lock(url_root + 'test', 'HTTP_IF' => "(<#{token}>)").should be_ok
             lockdiscovery_response token
           end
         end
 
         context "an invalid locktoken" do
           it "bails out" do
-            lock("/test", 'HTTP_IF' => '123')
+            lock(url_root + 'test', 'HTTP_IF' => '123')
             response.should be_forbidden
             response.body.should be_empty
           end
@@ -123,7 +118,7 @@ describe RackDAV::Handler do
 
         context "no locktoken" do
           it "bails out" do
-            lock("/test")
+            lock(url_root + 'test')
             response.should be_bad_request
             response.body.should be_empty
           end
@@ -134,14 +129,14 @@ describe RackDAV::Handler do
 
     describe "UNLOCK" do
       before(:each) do
-        put("/test", :input => "body").should be_created
-        lock("/test", :input => File.read(fixture("requests/lock.xml"))).should be_ok
+        put(url_root + 'test', :input => "body").should be_created
+        lock(url_root + 'test', :input => File.read(fixture("requests/lock.xml"))).should be_ok
       end
 
       context "given a valid token" do
         before(:each) do
           token = response_locktoken
-          unlock("/test", 'HTTP_LOCK_TOKEN' => "(#{token})")
+          unlock(url_root + 'test', 'HTTP_LOCK_TOKEN' => "(#{token})")
         end
 
         it "unlocks the resource" do
@@ -151,7 +146,7 @@ describe RackDAV::Handler do
 
       context "given an invalid token" do
         before(:each) do
-          unlock("/test", 'HTTP_LOCK_TOKEN' => '(123)')
+          unlock(url_root + 'test', 'HTTP_LOCK_TOKEN' => '(123)')
         end
 
         it "bails out" do
@@ -161,7 +156,7 @@ describe RackDAV::Handler do
 
       context "given no token" do
         before(:each) do
-          unlock("/test")
+          unlock(url_root + 'test')
         end
 
         it "bails out" do
@@ -172,33 +167,55 @@ describe RackDAV::Handler do
     end
   end
 
-  context "Given a not lockable resource" do
-    before do
-      @controller = RackDAV::Handler.new(
-        :root           => DOC_ROOT,
-        :resource_class => RackDAV::FileResource
-      )
+
+  context "Given a Lockable resource" do
+    context "when mounted directly" do
+      before do
+        @controller = RackDAV::Handler.new(
+          :root           => DOC_ROOT,
+          :resource_class => RackDAV::LockableFileResource
+        )
+      end
+
+      let(:url_root){ '/' }
+      include_examples :lockable_resource
     end
 
+    context "When mounted via a URLMap" do
+      before do
+        @controller = Rack::URLMap.new(
+          "/dav" => RackDAV::Handler.new(
+            :root           => DOC_ROOT,
+            :resource_class => RackDAV::LockableFileResource
+          )
+        )
+      end
+
+      let(:url_root){ '/dav/' }
+      include_examples :lockable_resource
+    end
+  end
+
+  shared_examples :not_lockable_resource do
     describe "uri escaping" do
       it "allows url escaped utf-8" do
-        put('/D%C3%B6ner').should be_created
-        get('/D%C3%B6ner').should be_ok
+        put(url_root + 'D%C3%B6ner').should be_created
+        get(url_root + 'D%C3%B6ner').should be_ok
       end
 
       it "allows url escaped iso-8859" do
-        put('/D%F6ner').should be_created
-        get('/D%F6ner').should be_ok
+        put(url_root + 'D%F6ner').should be_created
+        get(url_root + 'D%F6ner').should be_ok
       end
     end
 
     describe "OPTIONS" do
       it "is successful" do
-        options('/').should be_ok
+        options(url_root).should be_ok
       end
 
       it "sets the allow header with class 2 methods" do
-        options('/')
+        options(url_root)
         CLASS_1.each do |method|
           response.headers['allow'].should include(method)
         end
@@ -208,8 +225,8 @@ describe RackDAV::Handler do
     describe "CONTENT-MD5 header exists" do
       context "doesn't match with body's checksum" do
         before do
-          put('/foo', :input => 'bar',
-                      'HTTP_CONTENT_MD5' => 'baz')
+          put(url_root + 'foo', :input => 'bar',
+                                'HTTP_CONTENT_MD5' => 'baz')
         end
 
         it 'should return a Bad Request response' do
@@ -217,14 +234,14 @@ describe RackDAV::Handler do
         end
 
         it 'should not create the resource' do
-          get('/foo').should be_not_found
+          get(url_root + 'foo').should be_not_found
         end
       end
 
       context "matches with body's checksum" do
         before do
-          put('/foo', :input => 'bar',
-                      'HTTP_CONTENT_MD5' => 'N7UdGUp1E+RbVvZSTy1R8g==')
+          put(url_root + 'foo', :input => 'bar',
+                                'HTTP_CONTENT_MD5' => 'N7UdGUp1E+RbVvZSTy1R8g==')
         end
 
         it 'should be successful' do
@@ -232,15 +249,15 @@ describe RackDAV::Handler do
         end
 
         it 'should create the resource' do
-          get('/foo').should be_ok
+          get(url_root + 'foo').should be_ok
           response.body.should == 'bar'
         end
       end
     end
 
     it 'should return headers' do
-      put('/test.html', :input => '<html/>').should be_created
-      head('/test.html').should be_ok
+      put(url_root + 'test.html', :input => '<html/>').should be_created
+      head(url_root + 'test.html').should be_ok
 
       response.headers['etag'].should_not be_nil
       response.headers['content-type'].should match(/html/)
@@ -249,147 +266,148 @@ describe RackDAV::Handler do
 
 
     it 'should not find a nonexistent resource' do
-      get('/not_found').should be_not_found
+      get(url_root + 'not_found').should be_not_found
     end
 
     it 'should not allow directory traversal' do
-      get('/../htdocs').should be_forbidden
+      get(url_root + '../htdocs').should be_forbidden
     end
 
     it 'should create a resource and allow its retrieval' do
-      put('/test', :input => 'body').should be_created
-      get('/test').should be_ok
+      put(url_root + 'test', :input => 'body').should be_created
+      get(url_root + 'test').should be_ok
       response.body.should == 'body'
     end
+
     it 'should create and find a url with escaped characters' do
-      put(url_escape('/a b'), :input => 'body').should be_created
-      get(url_escape('/a b')).should be_ok
+      put(url_root + url_escape('/a b'), :input => 'body').should be_created
+      get(url_root + url_escape('/a b')).should be_ok
       response.body.should == 'body'
     end
 
     it 'should delete a single resource' do
-      put('/test', :input => 'body').should be_created
-      delete('/test').should be_no_content
+      put(url_root + 'test', :input => 'body').should be_created
+      delete(url_root + 'test').should be_no_content
     end
 
     it 'should delete recursively' do
-      mkcol('/folder').should be_created
-      put('/folder/a', :input => 'body').should be_created
-      put('/folder/b', :input => 'body').should be_created
+      mkcol(url_root + 'folder').should be_created
+      put(url_root + 'folder/a', :input => 'body').should be_created
+      put(url_root + 'folder/b', :input => 'body').should be_created
 
-      delete('/folder').should be_no_content
-      get('/folder').should be_not_found
-      get('/folder/a').should be_not_found
-      get('/folder/b').should be_not_found
+      delete(url_root + 'folder').should be_no_content
+      get(url_root + 'folder').should be_not_found
+      get(url_root + 'folder/a').should be_not_found
+      get(url_root + 'folder/b').should be_not_found
     end
 
     it 'should return not found when deleting a non-existent resource' do
-      delete('/not_found').should be_not_found
+      delete(url_root + 'not_found').should be_not_found
     end
 
     it 'should not allow copy to another domain' do
-      put('/test', :input => 'body').should be_created
-      copy('http://localhost/', 'HTTP_DESTINATION' => 'http://another/').should be_bad_gateway
+      put(url_root + 'test', :input => 'body').should be_created
+      copy('http://example.org' + url_root, 'HTTP_DESTINATION' => 'http://another/').should be_bad_gateway
     end
 
     it 'should not allow copy to the same resource' do
-      put('/test', :input => 'body').should be_created
-      copy('/test', 'HTTP_DESTINATION' => '/test').should be_forbidden
+      put(url_root + 'test', :input => 'body').should be_created
+      copy(url_root + 'test', 'HTTP_DESTINATION' => url_root + 'test').should be_forbidden
     end
 
     it 'should not allow an invalid destination uri' do
-      put('/test', :input => 'body').should be_created
-      copy('/test', 'HTTP_DESTINATION' => '%').should be_bad_request
+      put(url_root + 'test', :input => 'body').should be_created
+      copy(url_root + 'test', 'HTTP_DESTINATION' => '%').should be_bad_request
     end
 
     it 'should copy a single resource' do
-      put('/test', :input => 'body').should be_created
-      copy('/test', 'HTTP_DESTINATION' => '/copy').should be_created
-      get('/copy').body.should == 'body'
+      put(url_root + 'test', :input => 'body').should be_created
+      copy(url_root + 'test', 'HTTP_DESTINATION' => url_root + 'copy').should be_created
+      get(url_root + 'copy').body.should == 'body'
     end
 
     it 'should copy a resource with escaped characters' do
-      put(url_escape('/a b'), :input => 'body').should be_created
-      copy(url_escape('/a b'), 'HTTP_DESTINATION' => url_escape('/a c')).should be_created
-      get(url_escape('/a c')).should be_ok
+      put(url_root + url_escape('/a b'), :input => 'body').should be_created
+      copy(url_root + url_escape('/a b'), 'HTTP_DESTINATION' => url_root + url_escape('/a c')).should be_created
+      get(url_root + url_escape('/a c')).should be_ok
       response.body.should == 'body'
     end
 
     it 'should deny a copy without overwrite' do
-      put('/test', :input => 'body').should be_created
-      put('/copy', :input => 'copy').should be_created
-      copy('/test', 'HTTP_DESTINATION' => '/copy', 'HTTP_OVERWRITE' => 'F').should be_precondition_failed
+      put(url_root + 'test', :input => 'body').should be_created
+      put(url_root + 'copy', :input => 'copy').should be_created
+      copy(url_root + 'test', 'HTTP_DESTINATION' => url_root + 'copy', 'HTTP_OVERWRITE' => 'F').should be_precondition_failed
 
-      get('/copy').body.should == 'copy'
+      get(url_root + 'copy').body.should == 'copy'
     end
 
     it 'should allow a copy with overwrite' do
-      put('/test', :input => 'body').should be_created
-      put('/copy', :input => 'copy').should be_created
-      copy('/test', 'HTTP_DESTINATION' => '/copy', 'HTTP_OVERWRITE' => 'T').should be_no_content
-      get('/copy').body.should == 'body'
+      put(url_root + 'test', :input => 'body').should be_created
+      put(url_root + 'copy', :input => 'copy').should be_created
+      copy(url_root + 'test', 'HTTP_DESTINATION' => url_root + 'copy', 'HTTP_OVERWRITE' => 'T').should be_no_content
+      get(url_root + 'copy').body.should == 'body'
     end
 
     it 'should deny a move to an existing resource without overwrite' do
-      put('/test', :input => 'body').should be_created
-      put('/copy', :input => 'copy').should be_created
-      move('/test', 'HTTP_DESTINATION' => '/copy', 'HTTP_OVERWRITE' => 'F').should be_precondition_failed
+      put(url_root + 'test', :input => 'body').should be_created
+      put(url_root + 'copy', :input => 'copy').should be_created
+      move(url_root + 'test', 'HTTP_DESTINATION' => url_root + 'copy', 'HTTP_OVERWRITE' => 'F').should be_precondition_failed
     end
 
     it 'should copy a collection' do
-      mkcol('/folder').should be_created
-      copy('/folder', 'HTTP_DESTINATION' => '/copy').should be_created
-      propfind('/copy', :input => propfind_xml(:resourcetype))
+      mkcol(url_root + 'folder').should be_created
+      copy(url_root + 'folder', 'HTTP_DESTINATION' => url_root + 'copy').should be_created
+      propfind(url_root + 'copy', :input => propfind_xml(:resourcetype))
       multistatus_response('/d:propstat/d:prop/d:resourcetype/d:collection').should_not be_empty
     end
 
     it 'should copy a collection resursively' do
-      mkcol('/folder').should be_created
-      put('/folder/a', :input => 'A').should be_created
-      put('/folder/b', :input => 'B').should be_created
+      mkcol(url_root + 'folder').should be_created
+      put(url_root + 'folder/a', :input => 'A').should be_created
+      put(url_root + 'folder/b', :input => 'B').should be_created
 
-      copy('/folder', 'HTTP_DESTINATION' => '/copy').should be_created
-      propfind('/copy', :input => propfind_xml(:resourcetype))
+      copy(url_root + 'folder', 'HTTP_DESTINATION' => url_root + 'copy').should be_created
+      propfind(url_root + 'copy', :input => propfind_xml(:resourcetype))
       multistatus_response('/d:propstat/d:prop/d:resourcetype/d:collection').should_not be_empty
 
-      get('/copy/a').body.should == 'A'
-      get('/copy/b').body.should == 'B'
+      get(url_root + 'copy/a').body.should == 'A'
+      get(url_root + 'copy/b').body.should == 'B'
     end
 
     it 'should move a collection recursively' do
-      mkcol('/folder').should be_created
-      put('/folder/a', :input => 'A').should be_created
-      put('/folder/b', :input => 'B').should be_created
+      mkcol(url_root + 'folder').should be_created
+      put(url_root + 'folder/a', :input => 'A').should be_created
+      put(url_root + 'folder/b', :input => 'B').should be_created
 
-      move('/folder', 'HTTP_DESTINATION' => '/move').should be_created
-      propfind('/move', :input => propfind_xml(:resourcetype))
+      move(url_root + 'folder', 'HTTP_DESTINATION' => url_root + 'move').should be_created
+      propfind(url_root + 'move', :input => propfind_xml(:resourcetype))
       multistatus_response('/d:propstat/d:prop/d:resourcetype/d:collection').should_not be_empty
 
-      get('/move/a').body.should == 'A'
-      get('/move/b').body.should == 'B'
-      get('/folder/a').should be_not_found
-      get('/folder/b').should be_not_found
+      get(url_root + 'move/a').body.should == 'A'
+      get(url_root + 'move/b').body.should == 'B'
+      get(url_root + 'folder/a').should be_not_found
+      get(url_root + 'folder/b').should be_not_found
     end
 
     it 'should not move a collection onto an existing collection without overwrite' do
-      mkcol('/folder').should be_created
-      mkcol('/dest').should be_created
+      mkcol(url_root + 'folder').should be_created
+      mkcol(url_root + 'dest').should be_created
 
-      move('/folder', 'HTTP_DESTINATION' => '/dest', 'HTTP_OVERWRITE' => 'F').should be_precondition_failed
+      move(url_root + 'folder', 'HTTP_DESTINATION' => url_root + 'dest', 'HTTP_OVERWRITE' => 'F').should be_precondition_failed
     end
 
     it 'should create a collection' do
-      mkcol('/folder').should be_created
-      propfind('/folder', :input => propfind_xml(:resourcetype))
+      mkcol(url_root + 'folder').should be_created
+      propfind(url_root + 'folder', :input => propfind_xml(:resourcetype))
       multistatus_response('/d:propstat/d:prop/d:resourcetype/d:collection').should_not be_empty
     end
 
     it 'should not create a collection with a body' do
-      mkcol('/folder', :input => 'body').should be_unsupported_media_type
+      mkcol(url_root + 'folder', :input => 'body').should be_unsupported_media_type
     end
 
     it 'should not find properties for nonexistent resources' do
-      propfind('/non').should be_not_found
+      propfind(url_root + 'non').should be_not_found
     end
 
     it 'should find all properties' do
@@ -399,9 +417,9 @@ describe RackDAV::Handler do
         end
       end
 
-      propfind('http://localhost/', :input => xml)
+      propfind('http://example.org' + url_root, :input => xml)
 
-      multistatus_response('/d:href').first.text.strip.should == 'http://localhost/'
+      multistatus_response('/d:href').first.text.strip.should == 'http://example.org' + url_root
 
       props = %w(creationdate displayname getlastmodified getetag resourcetype getcontenttype getcontentlength)
       props.each do |prop|
@@ -410,61 +428,31 @@ describe RackDAV::Handler do
     end
 
     it 'should find named properties' do
-      put('/test.html', :input => '<html/>').should be_created
-      propfind('/test.html', :input => propfind_xml(:getcontenttype, :getcontentlength))
+      put(url_root + 'test.html', :input => '<html/>').should be_created
+      propfind(url_root + 'test.html', :input => propfind_xml(:getcontenttype, :getcontentlength))
 
       multistatus_response('/d:propstat/d:prop/d:getcontenttype').first.text.should == 'text/html'
       multistatus_response('/d:propstat/d:prop/d:getcontentlength').first.text.should == '7'
     end
 
-    it 'should set custom properties in the dav namespace', :has_xattr_support => true do
-      put('/prop', :input => 'A').should be_created
-      proppatch('/prop', :input => propset_xml([:foo, 'testing']))
-      multistatus_response('/d:propstat/d:prop/d:foo').should_not be_empty
-
-      propfind('/prop', :input => propfind_xml(:foo))
-      multistatus_response('/d:propstat/d:prop/d:foo').first.text.should == 'testing'
-    end
-
-    it 'should set custom properties in custom namespaces', :has_xattr_support => true do
-      xmlns = { 'xmlns:s' => 'SPEC:' }
-      put('/prop', :input => 'A').should be_created
-      proppatch('/prop', :input => propset_xml(['s:foo'.to_sym, 'testing', xmlns]))
-      multistatus_response('/d:propstat/d:prop/s:foo', xmlns).should_not be_empty
-
-      propfind('/prop', :input => propfind_xml(['s:foo'.to_sym, xmlns]))
-      multistatus_response('/d:propstat/d:prop/s:foo', xmlns).first.text.should == 'testing'
-    end
-
-    it 'should copy custom properties', :has_xattr_support => true do
-      xmlns = { 'xmlns:s' => 'SPEC:' }
-      put('/prop', :input => 'A').should be_created
-      proppatch('/prop', :input => propset_xml(['s:foo'.to_sym, 'testing', xmlns]))
-      multistatus_response('/d:propstat/d:prop/s:foo', xmlns).should_not be_empty
-
-      copy('/prop', 'HTTP_DESTINATION' => '/propcopy').should be_created
-      propfind('/propcopy', :input => propfind_xml(['s:foo'.to_sym, xmlns]))
-      multistatus_response('/d:propstat/d:prop/s:foo', xmlns).first.text.should == 'testing'
-    end
-
     it 'should not set properties for a non-existent resource' do
-      proppatch('/not_found', :input => propset_xml([:foo, 'testing'])).should be_not_found
+      proppatch(url_root + 'not_found', :input => propset_xml([:foo, 'testing'])).should be_not_found
     end
 
     it 'should not return properties for non-existent resource' do
-      propfind('/prop', :input => propfind_xml(:foo)).should be_not_found
+      propfind(url_root + 'prop', :input => propfind_xml(:foo)).should be_not_found
     end
 
     it 'should return the correct charset (utf-8)' do
-      put('/test.html', :input => '<html/>').should be_created
-      propfind('/test.html', :input => propfind_xml(:getcontenttype, :getcontentlength))
+      put(url_root + 'test.html', :input => '<html/>').should be_created
+      propfind(url_root + 'test.html', :input => propfind_xml(:getcontenttype, :getcontentlength))
 
       charset = @response.media_type_params['charset']
       charset.should eql 'utf-8'
     end
 
     it 'should not support LOCK' do
-      put('/test', :input => 'body').should be_created
+      put(url_root + 'test', :input => 'body').should be_created
 
       xml = render do |xml|
         xml.lockinfo('xmlns:d' => "DAV:") do
@@ -474,22 +462,49 @@ describe RackDAV::Handler do
         end
       end
 
-      lock('/test', :input => xml).should be_method_not_allowed
+      lock(url_root + 'test', :input => xml).should be_method_not_allowed
     end
 
     it 'should not support UNLOCK' do
-      put('/test', :input => 'body').should be_created
-      unlock('/test', :input => '').should be_method_not_allowed
+      put(url_root + 'test', :input => 'body').should be_created
+      unlock(url_root + 'test', :input => '').should be_method_not_allowed
     end
 
   end
 
+  context "Given a not lockable resource" do
+    context "when mounted directly" do
+      before do
+        @controller = RackDAV::Handler.new(
+          :root           => DOC_ROOT,
+          :resource_class => RackDAV::FileResource
+        )
+      end
+
+      let(:url_root){ '/' }
+      include_examples :not_lockable_resource
+    end
+
+    context "When mounted via a URLMap" do
+      let(:url_root){ '/dav/' }
+
+      before do
+        @controller = Rack::URLMap.new(
+          "/dav" => RackDAV::Handler.new(
+            :root           => DOC_ROOT,
+            :resource_class => RackDAV::FileResource
+          )
+        )
+      end
+
+      include_examples :not_lockable_resource
+    end
+  end
 
   private
 
     def request(method, uri, options={})
       options = {
-        'HTTP_HOST' => 'localhost',
         'REMOTE_USER' => 'manni'
       }.merge(options)
       request = Rack::MockRequest.new(@controller)

metadata

@@ -1,102 +1,143 @@
 --- !ruby/object:Gem::Specification
 name: rack_dav
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.1
 platform: ruby
 authors:
 - Matthias Georgi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-27 00:00:00.000000000 Z
+date: 2023-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rackup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.4
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
-  name: ffi-xattr
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: puma
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.11'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '13.0'
 description: WebDAV handler for Rack.
 email: matti.georgi@gmail.com
-executables:
-- rack_dav
+executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - CHANGELOG.md
+- Dockerfile
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
-- bin/rack_dav
+- config.ru
 - lib/rack_dav.rb
 - lib/rack_dav/controller.rb
 - lib/rack_dav/file_resource.rb
@@ -124,17 +165,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 3.4.1
 signing_key: 
 specification_version: 4
 summary: WebDAV handler for Rack.

data/Gemfile.lock

@@ -1,39 +0,0 @@
-PATH
-  remote: .
-  specs:
-    rack_dav (0.4.0)
-      ffi-xattr (~> 0.1)
-      nokogiri (~> 1.5)
-      rack (~> 1.4)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    diff-lcs (1.2.5)
-    ffi (1.9.10)
-    ffi (1.9.10-java)
-    ffi-xattr (0.1.2)
-      ffi
-    mini_portile (0.6.2)
-    nokogiri (1.6.6.2)
-      mini_portile (~> 0.6.0)
-    nokogiri (1.6.6.2-java)
-    rack (1.6.4)
-    rake (0.9.6)
-    rspec (2.99.0)
-      rspec-core (~> 2.99.0)
-      rspec-expectations (~> 2.99.0)
-      rspec-mocks (~> 2.99.0)
-    rspec-core (2.99.2)
-    rspec-expectations (2.99.2)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.99.3)
-
-PLATFORMS
-  java
-  ruby
-
-DEPENDENCIES
-  rack_dav!
-  rake (~> 0.9)
-  rspec (~> 2.11)

data/bin/rack_dav

@@ -1,24 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift(File.expand_path("../../lib", __FILE__))
-
-require 'rack_dav'
-
-root=ARGV[1] || Dir.pwd
-port = ARGV[0] || 3000
-
-app = Rack::Builder.new do 
-  use Rack::ShowExceptions
-  use Rack::CommonLogger
-  use Rack::Reloader
-  use Rack::Lint
-
-  run RackDAV::Handler.new(:root => root)
-
-end.to_app
-
-begin
-  Rack::Handler::Mongrel.run(app, :Port => port)
-rescue LoadError
-  Rack::Handler::WEBrick.run(app, :Port => port)
-end