dav4rack 0.2.11 → 0.3.0

data/.gitignore

@@ -1,7 +0,0 @@
-.*
-!.gitignore
-*.gem
-*~
-doc/*
-pkg/*
-test/repo

data/lib/dav4rack/file_resource.rb

@@ -1,257 +0,0 @@
-require 'webrick/httputils'
-
-module DAV4Rack
-
-  class FileResource < Resource
-    
-    include WEBrick::HTTPUtils
-    
-    # If this is a collection, return the child resources.
-    def children
-      Dir[file_path + '/*'].map do |path|
-        child File.basename(path)
-      end
-    end
-
-    # Is this resource a collection?
-    def collection?
-      File.directory?(file_path)
-    end
-
-    # Does this recource exist?
-    def exist?
-      File.exist?(file_path)
-    end
-    
-    # Return the creation time.
-    def creation_date
-      stat.ctime
-    end
-
-    # Return the time of last modification.
-    def last_modified
-      stat.mtime
-    end
-    
-    # Set the time of last modification.
-    def last_modified=(time)
-      File.utime(Time.now, time, file_path)
-    end
-
-    # Return an Etag, an unique hash value for this resource.
-    def etag
-      sprintf('%x-%x-%x', stat.ino, stat.size, stat.mtime.to_i)
-    end
-
-    # Return the mime type of this resource.
-    def content_type
-      if stat.directory?
-        "text/html"
-      else 
-        mime_type(file_path, DefaultMimeTypes)
-      end
-    end
-
-    # Return the size in bytes for this resource.
-    def content_length
-      stat.size
-    end
-
-    # HTTP GET request.
-    #
-    # Write the content of the resource to the response.body.
-    def get(request, response)
-      raise NotFound unless exist?
-      if stat.directory?
-        response.body = ""
-        Rack::Directory.new(root).call(request.env)[2].each do |line|
-          response.body << line
-        end
-        response['Content-Length'] = response.body.bytesize.to_s
-      else
-        file = Rack::File.new(root)
-        response.body = file
-      end
-      OK
-    end
-
-    # HTTP PUT request.
-    #
-    # Save the content of the request.body.
-    def put(request, response)
-      write(request.body)
-      Created
-    end
-    
-    # HTTP POST request.
-    #
-    # Usually forbidden.
-    def post(request, response)
-      raise HTTPStatus::Forbidden
-    end
-    
-    # HTTP DELETE request.
-    #
-    # Delete this resource.
-    def delete
-      if stat.directory?
-        FileUtils.rm_rf(file_path)
-      else
-        File.unlink(file_path)
-      end
-      NoContent
-    end
-    
-    # HTTP COPY request.
-    #
-    # Copy this resource to given destination resource.
-    # Copy this resource to given destination resource.
-    def copy(dest, overwrite)
-      if(collection?)
-        if(dest.exist?)
-          if(dest.collection? && overwrite)
-            FileUtils.cp_r(file_path, dest.send(:file_path))
-            Created
-          else
-            if(overwrite)
-              FileUtils.rm(dest.send(:file_path))
-              FileUtils.cp_r(file_path, dest.send(:file_path))
-              NoContent
-            else
-              PreconditionFailed
-            end
-          end
-        else
-          FileUtils.cp_r(file_path, dest.send(:file_path))
-          Created
-        end
-      else
-        if(dest.exist? && !overwrite)
-          PreconditionFailed
-        else
-          if(File.directory?(File.dirname(dest.send(:file_path))))
-            new = !dest.exist?
-            if(dest.collection? && dest.exist?)
-              FileUtils.rm_rf(dest.send(:file_path))
-            end
-            FileUtils.cp(file_path, dest.send(:file_path).sub(/\/$/, ''))
-            new ? Created : NoContent
-          else
-            Conflict
-          end
-        end
-      end
-    end
-    
-    # HTTP MOVE request.
-    #
-    # Move this resource to given destination resource.
-    def move(*args)
-      result = copy(*args)
-      delete if [Created, NoContent].include?(result)
-      result
-    end
-    
-    # HTTP MKCOL request.
-    #
-    # Create this resource as collection.
-    def make_collection
-      if(request.body.read.to_s == '')
-        if(File.directory?(file_path))
-          MethodNotAllowed
-        else
-          if(File.directory?(File.dirname(file_path)))
-            Dir.mkdir(file_path)
-            Created
-          else
-            Conflict
-          end
-        end
-      else
-        UnsupportedMediaType
-      end
-    end
-  
-    # Write to this resource from given IO.
-    def write(io)
-      tempfile = "#{file_path}.#{Process.pid}.#{object_id}"
-      
-      open(tempfile, "wb") do |file|
-        while part = io.read(8192)
-          file << part
-        end
-      end
-
-      File.rename(tempfile, file_path)      
-    ensure
-      File.unlink(tempfile) rescue nil
-    end
-    
-    # name:: String - Property name
-    # Returns the value of the given property
-    def get_property(name)
-      super || custom_props(name)
-    end
-
-    # name:: String - Property name
-    # value:: New value
-    # Set the property to the given value
-    def set_property(name, value)
-      super || set_custom_props(name,value)
-    end
-
-    protected
-
-    def set_custom_props(key,val)
-      prop_hash[key.to_sym] = val
-      File.open(prop_path, 'w') do |file|
-        file.write(YAML.dump(prop_hash))
-      end
-    end
-
-    def custom_props(key)
-      prop_hash[key.to_sym]
-    end
-
-    def prop_path
-      path = File.join(root, '.props', File.dirname(file_path), File.basename(file_path))
-      unless(File.directory?(File.dirname(path)))
-        FileUtils.mkdir_p(File.dirname(path))
-      end
-      path
-    end
-
-    def prop_hash
-      unless(@_prop_hash)
-        if(File.exists?(prop_path))
-          @_prop_hash = YAML.load(File.read(prop_path))
-        else
-          @_prop_hash = {}
-        end
-      end
-      @_prop_hash
-    end
-
-    def authenticate(user, pass)
-      if(options[:username])
-        options[:username] == user && options[:password] == pass
-      else
-        true
-      end
-    end
-    
-    def root
-      @options[:root]
-    end
-
-    def file_path
-      File.join(root, path)
-    end
-
-    def stat
-      @stat ||= File.stat(file_path)
-    end
-
-  end
-
-end

data/spec/handler_spec.rb

@@ -1,301 +0,0 @@
-$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
-
-require 'rubygems'
-require 'dav4rack'
-require 'fileutils'
-require 'nokogiri'
-require 'rspec'
-
-describe DAV4Rack::Handler do
-  DOC_ROOT = File.expand_path(File.dirname(__FILE__) + '/htdocs')
-  METHODS = %w(GET PUT POST DELETE PROPFIND PROPPATCH MKCOL COPY MOVE OPTIONS HEAD LOCK UNLOCK)  
-  
-  before do
-    FileUtils.mkdir(DOC_ROOT) unless File.exists?(DOC_ROOT)
-    @controller = DAV4Rack::Handler.new(:root => DOC_ROOT)
-  end
-
-  after do
-    FileUtils.rm_rf(DOC_ROOT) if File.exists?(DOC_ROOT)
-  end
-  
-  attr_reader :response
-  
-  def request(method, uri, options={})
-    options = {
-      'HTTP_HOST' => 'localhost',
-      'REMOTE_USER' => 'user'
-    }.merge(options)
-    request = Rack::MockRequest.new(@controller)
-    @response = request.request(method, uri, options)
-  end
-
-  METHODS.each do |method|
-    define_method(method.downcase) do |*args|
-      request(method, *args)
-    end
-  end  
-  
-  def render(root_type)
-    raise ArgumentError.new 'Expecting block' unless block_given?
-    doc = Nokogiri::XML::Builder.new do |xml_base|
-      xml_base.send(root_type.to_s, 'xmlns:D' => 'D:') do
-        xml_base.parent.namespace = xml_base.parent.namespace_definitions.first
-        xml = xml_base['D']
-        yield xml
-      end
-    end
-    doc.to_xml
-  end
- 
-  def url_escape(string)
-    URI.escape(string)
-  end
-  
-  def response_xml
-    Nokogiri.XML(@response.body)
-  end
-  
-  def multistatus_response(pattern)
-    @response.should be_multi_status
-    response_xml.xpath('//D:multistatus/D:response', response_xml.root.namespaces).should_not be_empty
-    response_xml.xpath("//D:multistatus/D:response#{pattern}", response_xml.root.namespaces)
-  end
-
-  def multi_status_created
-    response_xml.xpath('//D:multistatus/D:response/D:status').should_not be_empty
-    response_xml.xpath('//D:multistatus/D:response/D:status').text.should =~ /Created/
-  end
-  
-  def multi_status_ok
-    response_xml.xpath('//D:multistatus/D:response/D:status').should_not be_empty
-    response_xml.xpath('//D:multistatus/D:response/D:status').text.should =~ /OK/
-  end
-  
-  def multi_status_no_content
-    response_xml.xpath('//D:multistatus/D:response/D:status').should_not be_empty
-    response_xml.xpath('//D:multistatus/D:response/D:status').text.should =~ /No Content/
-  end
-  
-  def propfind_xml(*props)
-    render(:propfind) do |xml|
-      xml.prop do
-        props.each do |prop|
-        xml.send(prop.to_sym)
-        end
-      end
-    end
-  end
-  
-  it 'should return all options' do
-    options('/').should be_ok
-    
-    METHODS.each do |method|
-      response.headers['allow'].should include(method)
-    end
-  end
-  
-  it 'should return headers' do
-    put('/test.html', :input => '<html/>').should be_created
-    head('/test.html').should be_ok
-    
-    response.headers['etag'].should_not be_nil
-    response.headers['content-type'].should match(/html/)
-    response.headers['last-modified'].should_not be_nil
-  end
-  
-  it 'should not find a nonexistent resource' do
-    get('/not_found').should be_not_found
-  end
-  
-  it 'should not allow directory traversal' do
-    get('/../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
-    response.body.should == 'body'
-  end
-
-  it 'should return an absolute url after a put request' do
-    put('/test', :input => 'body').should be_created
-    response['location'].should =~ /http:\/\/localhost(:\d+)?\/test/
-  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
-    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
-  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
-    
-    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
-  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
-  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
-  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'
-  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
-    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
-    get('/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'
-  end
-  
-  it 'should copy a collection' do  
-    mkcol('/folder').should be_created
-    copy('/folder', 'HTTP_DESTINATION' => '/copy')
-    multi_status_created.should eq true
-    propfind('/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
-    
-    copy('/folder', 'HTTP_DESTINATION' => '/copy')
-    multi_status_created.should eq true
-    propfind('/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'
-  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
-    
-    move('/folder', 'HTTP_DESTINATION' => '/move')
-    multi_status_created.should eq true
-    propfind('/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
-  end
-  
-  it 'should create a collection' do
-    mkcol('/folder').should be_created
-    propfind('/folder', :input => propfind_xml(:resourcetype))
-    multistatus_response('/D:propstat/D:prop/D:resourcetype/D:collection').should_not be_empty
-  end
-  
-  it 'should return full urls after creating a collection' do
-    mkcol('/folder').should be_created
-    propfind('/folder', :input => propfind_xml(:resourcetype))
-    multistatus_response('/D:propstat/D:prop/D:resourcetype/D:collection').should_not be_empty
-    multistatus_response('/D:href').first.text.should =~ /http:\/\/localhost(:\d+)?\/folder/
-  end
-  
-  it 'should not find properties for nonexistent resources' do
-    propfind('/non').should be_not_found
-  end
-  
-  it 'should find all properties' do
-    xml = render(:propfind) do |xml|
-      xml.allprop
-    end
-    
-    propfind('http://localhost/', :input => xml)
-    
-    multistatus_response('/D:href').first.text.strip.should =~ /http:\/\/localhost(:\d+)?\//
-
-    props = %w(creationdate displayname getlastmodified getetag resourcetype getcontenttype getcontentlength)
-    props.each do |prop|
-      multistatus_response("/D:propstat/D:prop/D:#{prop}").should_not be_empty
-    end
-  end
-  
-  it 'should find named properties' do
-    put('/test.html', :input => '<html/>').should be_created
-    propfind('/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 lock a resource' do
-    put('/test', :input => 'body').should be_created
-    
-    xml = render(:lockinfo) do |xml|
-      xml.lockscope { xml.exclusive }
-      xml.locktype { xml.write }
-      xml.owner { xml.href "http://test.de/" }
-    end
-
-    lock('/test', :input => xml)
-    
-    response.should be_ok
-    
-    match = lambda do |pattern|
-      response_xml.xpath "/D:prop/D:lockdiscovery/D:activelock#{pattern}"
-    end
-    
-    match[''].should_not be_empty
-
-    match['/D:locktype'].should_not be_empty
-    match['/D:lockscope'].should_not be_empty
-    match['/D:depth'].should_not be_empty
-    match['/D:timeout'].should_not be_empty
-    match['/D:locktoken'].should_not be_empty
-    match['/D:owner'].should_not be_empty
-  end
-  
-  context "when mapping a path" do
-    
-    before do
-      @controller = DAV4Rack::Handler.new(:root => DOC_ROOT, :root_uri_path => '/webdav/')
-    end
-    
-    it "should return correct urls" do
-      # FIXME: a put to '/test' works, too -- should it?
-      put('/webdav/test', :input => 'body').should be_created
-      response.headers['location'].should =~ /http:\/\/localhost(:\d+)?\/webdav\/test/
-    end
-  end
-end