dav4rack 0.0.1 → 0.1.0

data/README.rdoc

@@ -19,9 +19,10 @@ simple server with:
 
     dav4rack
 
-This will start a WEBrick server on port 3000, which you can connect
-to without authentication. The simple file resource allows very basic authentication
-which is used for an example. To enable it:
+This will start a Unicorn, Mongrel or WEBrick server on port 3000, which you can connect
+to without authentication. Unicorn and Mongrel will be much more responsive than WEBrick,
+so if you are having slowness issues, install one of them and restart the dav4rack process.
+The simple file resource allows very basic authentication which is used for an example. To enable it:
 
     dav4rack --username=user --password=pass
 
@@ -43,8 +44,8 @@ an example of how to use a custom resource:
   run DAV4Rack::Handler.new(:resource_class => CustomResource, :custom => 'options', :passed => 'to resource')
   
 Next, lets venture into mapping a path for our WebDAV access. In this example, we 
-will use default FileResource like in the first example, but instead of connecting
-directly to the host, we will have to connect to: http://host/webdav/share/
+will use default FileResource like in the first example, but instead of the WebDAV content
+being available at the root directory, we will map it to a specific directory: /webdav/share/
 
   require 'rubygems'
   require 'dav4rack'
@@ -58,7 +59,7 @@ directly to the host, we will have to connect to: http://host/webdav/share/
   }.to_app
   run app
   
-Aside from the #map block, notice the new option passed to the Handler's initialization, :root_uri_path. When
+Aside from the Builder#map block, notice the new option passed to the Handler's initialization, :root_uri_path. When
 DAV4Rack receives a request, it will automatically convert the request to the proper path and pass it to
 the resource.
 
@@ -107,14 +108,13 @@ virtualized resources.
 
 There are some helpers worth mentioning that make things a little easier. DAV4Rack::Resource#accept_redirect? method is available to Resources.
 If true, the currently connected client will accept and properly use a 302 redirect for a GET request. Most clients do not properly
-support this, which can be a real pain when working with virtualized files that may located some where else, like S3. To deal with
+support this, which can be a real pain when working with virtualized files that may be located some where else, like S3. To deal with
 those clients that don't support redirects, a helper has been provided so resources don't have to deal with proxying themselves. The 
-DAV4Rack::RemoteFile allows the resource to simple tell Rack to download and send the file from the provided resource and go away, allowing the 
+DAV4Rack::RemoteFile allows the resource to simply tell Rack to download and send the file from the provided resource and go away, allowing the 
 process to be freed up to deal with other waiters. A very simple example:
 
   class MyResource < DAV4Rack::Resource
-    def initialize(*args)
-      super(*args)
+    def setup
       @item = method_to_fill_this_properly
     end
     
@@ -128,8 +128,96 @@ process to be freed up to deal with other waiters. A very simple example:
     end
   end
   
+
+== Authentication
+
+Authentication is performed on a per Resource basis. The Controller object will check the Resource for a Resource#authenticate method. If it exists,
+any authentication information will be passed to the method. Depending on the result, the Controller will either continue on with the request, or send
+a 401 Unauthorized response. 
+
+As a nicety, Resource#authentication_realm will be checked for existence and the returning string will be used as the Realm. Resource#authentication_error_msg
+will also be checked for existence and the returning string will be passed in the response upon authentication failure.
+
+Authentication can also be implemented using callbacks, as discussed below.
+  
+== Callbacks
+
+Resources can make use of callbacks to easily apply permissions, authentication or any other action that needs to be performed before or after any or all
+actions. Callbacks are applied to all publicly available methods. This is important for methods used internally within the resource. Methods not meant
+to be called by the Controller, or anyone else, should be scoped protected or private to reduce the interaction with callbacks.
+
+Callbacks can be called before or after a method call. For example:
+
+  class MyResource < DAV4Rack::Resource
+    before do |resource, method_name|
+      my_authentication_method
+    end
+    
+    after do |resource, method_name|
+      puts "#{Time.now} -> Completed: #{resource}##{method_name}"
+    end
+    
+    private
+    
+    def my_authentication_method
+      true
+    end
+  end
+  
+In this example MyResource#my_authentication_method will be called before any public method is called. After any method has been called a status
+line will be printed to STDOUT. Running callbacks before/after every method call is a bit much in most cases, so callbacks can be applied to specific
+methods:
+
+  class MyResource < DAV4Rack::Resource
+    before_get do |resource|
+      puts "#{Time.now} -> Received GET request from resource: #{resource}"
+    end
+  end
+  
+In this example, a simple status line will be printed to STDOUT before the MyResource#get method is called. The current resource object is always
+provided to callbacks. The method name is only provided to the generic before/after callbacks.
+
+Something very handy for dealing with the mess of files OS X leaves on the system:
+
+  class MyResource < DAV4Rack::Resource
+    after_unlock do |resource|
+      resource.delete if resource.name[0,1] == '.'
+    end
+  end
+  
+Because OS X implements locking correctly, we can wait until it releases the lock on the file, and remove it if it's a hidden file. 
+
+Callbacks are called in the order they are defined, so you can easily build callbacks off each other. Like this example:
+
+  class MyResource < DAV4Rack::Resource
+    before do |resource, method_name|
+      resource.DAV_authenticate unless resource.user.is_a?(User)
+      raise Unauthorized unless resource.user.is_a?(User)
+    end
+    before do |resource, method_name|
+      resource.user.allowed?(method_name)
+    end
+  end
+  
+In this example, the second block checking User#allowed? can count on Resource#user being defined because the blocks are called in
+order, and if the Resource#user is not a User type, an exception is raised.
+
+=== Avoiding callbacks
+
+Something special to notice in the last example is the DAV_ prefix on authenticate. Providing the DAV_ prefix will prevent
+any callbacks being applied to the given method. This allows us to provide a public method that the callback can access on the resource
+without getting stuck in a loop.
+
 == Issues/Bugs/Questions
 
+=== Known Issues
+
+* OS X Finder PUT fails when using NGINX (this is due to NGINX's lack of chunked transfer encoding)
+* Windows WebDAV mini-redirector fails (this client is very broken. patches welcome.)
+* Lots of unimplemented parts of the webdav spec (patches always welcome)
+
+=== Unknown Issues
+
 Please use the issues at github: http://github.com/chrisroberts/dav4rack
 
 == License

data/bin/dav4rack

@@ -62,4 +62,14 @@ app = Rack::Builder.new do
 
 end.to_app
 
-Rack::Handler::WEBrick.run(app, :Port => 3000)
+begin
+  puts 'Attempting to start unicorn...'
+  require 'unicorn'
+  Unicorn.run(app, :listeners => ["0.0.0.0:3000"])
+rescue => e
+  puts "Failed to start unicorn (#{e}). Starting mongrel..."
+  Rack::Handler::Mongrel.run(app, :Port => 3000)
+rescue => e
+  puts "Failed to start mongrel (#{e}). Falling back to WEBrick."
+  Rack::Handler::WEBrick.run(app, :Port => 3000)
+end

data/dav4rack.gemspec

@@ -1,16 +1,19 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
 require 'dav4rack'
 Gem::Specification.new do |s|
   s.name = 'dav4rack'
   s.version = DAV4Rack::VERSION
   s.summary = 'WebDAV handler for Rack'
   s.author = 'Chris Roberts'
-  s.email = 'chris@chrisroberts.org'
-  s.homepage = 'http://github.com/dav4rack'
+  s.email = 'chrisroberts.code@gmail.com'
+  s.homepage = 'http://github.com/chrisroberts/dav4rack'
   s.description = 'WebDAV handler for Rack'
   s.require_path = 'lib'
   s.executables << 'dav4rack'
   s.has_rdoc = true
-  s.extra_rdoc_files = ['README.rdoc']  
+  s.extra_rdoc_files = ['README.rdoc']
+  s.add_dependency 'nokogiri', '~> 1.4.2'
+  s.add_dependency 'uuidtools', '~> 2.1.1'
   s.files = %w{
 .gitignore
 LICENSE
@@ -24,6 +27,8 @@ lib/dav4rack/resource.rb
 lib/dav4rack/interceptor.rb
 lib/dav4rack/interceptor_resource.rb
 lib/dav4rack/remote_file.rb
+lib/dav4rack/lock.rb
+lib/dav4rack/lock_store.rb
 bin/dav4rack
 spec/handler_spec.rb
 README.rdoc

data/lib/dav4rack.rb

@@ -9,5 +9,5 @@ require 'dav4rack/handler'
 require 'dav4rack/controller'
 
 module DAV4Rack
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/lib/dav4rack/controller.rb

@@ -11,12 +11,11 @@
     # Create a new Controller.
     # NOTE: options will be passed to Resource
     def initialize(request, response, options={})
+      raise Forbidden if request.path_info.include?('../')
       @request = request
       @response = response
       @options = options
-      @resource = resource_class.new(actual_path, implied_path, @request, @options)
-      authenticate
-      raise Forbidden if request.path_info.include?('../')
+      @resource = resource_class.new(actual_path, implied_path, @request, @response, @options)
     end
     
     # s:: string
@@ -56,7 +55,7 @@
     def get
       raise NotFound unless resource.exist?
       res = resource.get(request, response)
-      if(response.status == 200 && !resource.collection?)
+      if(res == OK && !resource.collection?)
         response['Etag'] = resource.etag
         response['Content-Type'] = resource.content_type
         response['Content-Length'] = resource.content_length.to_s
@@ -68,7 +67,14 @@
     # Return response to PUT
     def put
       raise Forbidden if resource.collection?
-      resource.put(request, response)
+      resource.lock_check
+      status = resource.put(request, response)
+      multistatus do |xml|
+        xml.response do
+          xml.href resource.path
+          xml.status "#{http_version} #{status.status_line}"
+        end
+      end
     end
 
     # Return response to POST
@@ -79,12 +85,20 @@
     # Return response to DELETE
     def delete
       raise NotFound unless resource.exist?
+      resource.lock_check
       resource.delete
     end
     
     # Return response to MKCOL
     def mkcol
-      resource.make_collection
+      resource.lock_check
+      status = resource.make_collection
+      multistatus do |xml|
+        xml.response do
+          xml.href resource.path
+          xml.status "#{http_version} #{status.status_line}"
+        end
+      end
     end
     
     # Return response to COPY
@@ -97,16 +111,25 @@
     # Resource will be copied (implementation ease)
     def move(*args)
       raise NotFound unless resource.exist?
+      resource.lock_check unless args.include?(:copy)
       dest_uri = URI.parse(env['HTTP_DESTINATION'])
       destination = url_unescape(dest_uri.path)
       raise BadGateway if dest_uri.host and dest_uri.host != request.host
       raise Forbidden if destination == resource.public_path
-      dest = resource_class.new(destination, clean_path(destination), @request, @options)
+      dest = resource_class.new(destination, clean_path(destination), @request, @response, @options.merge(:user => resource.user))
+      status = nil
       if(args.include?(:copy))
-        resource.copy(dest, overwrite)
+        status = resource.copy(dest, overwrite)
       else
         raise Conflict unless depth.is_a?(Symbol) || depth > 1
-        resource.move(dest)
+        status = resource.move(dest)
+      end
+      response['Location'] = "#{scheme}://#{host}:#{port}#{dest.public_path}" if status == Created
+      multistatus do |xml|
+        xml.response do
+          xml.href "#{scheme}://#{host}:#{port}#{dest.public_path}"
+          xml.status = "#{http_version} #{status.status_line}"
+        end
       end
     end
     
@@ -132,6 +155,7 @@
     # Return response to PROPPATCH
     def proppatch
       raise NotFound unless resource.exist?
+      resource.lock_check
       prop_rem = request_match('/propertyupdate/remove/prop').children.map{|n| [n.name] }
       prop_set = request_match('/propertyupdate/set/prop').children.map{|n| [n.name, n.text] }
       multistatus do |xml|
@@ -191,7 +215,6 @@
             end
           end
         end
-        response.status = MultiStatus
       end
     end
 
@@ -200,6 +223,23 @@
       resource.unlock(lock_token)
     end
 
+    # Perform authentication
+    # NOTE: Authentication will only be performed if the Resource
+    # has defined an #authenticate method
+    def authenticate
+      authed = true
+      if(resource.respond_to?(:authenticate))
+        authed = false
+        if(request.env['HTTP_AUTHORIZATION'])
+          auth = Rack::Auth::Basic::Request.new(request.env)
+          if(auth.basic? && auth.credentials)
+            authed = resource.authenticate(auth.credentials[0], auth.credentials[1])
+          end
+        end
+      end
+      raise Unauthorized unless authed
+    end
+    
     # ************************************************************
     # private methods
     
@@ -363,6 +403,8 @@
         begin
           val = resource.get_property(name)
           stats[OK].push [name, val] if val
+        rescue Unauthorized => u
+          raise u
         rescue Status
           stats[$!] << name
         end
@@ -378,6 +420,8 @@
       for name, value in pairs
         begin
           stats[OK] << [name, resource.set_property(name, value)]
+        rescue Unauthorized => u
+          raise u
         rescue Status
           stats[$!] << name
         end
@@ -431,27 +475,6 @@
       end
     end
 
-    # Perform authentication
-    # NOTE: Authentication will only be performed if the Resource
-    # has defined an #authenticate method
-    def authenticate
-      authed = true
-      if(resource.respond_to?(:authenticate))
-        authed = false
-        if(request.env['HTTP_AUTHORIZATION'])
-          auth = Rack::Auth::Basic::Request.new(request.env)
-          if(auth.basic? && auth.credentials)
-            authed = resource.authenticate(auth.credentials[0], auth.credentials[1])
-          end
-        end
-      end
-      unless(authed)
-        response.body = resource.respond_to?(:authentication_error_msg) ? resource.authentication_error_msg : 'Not Authorized'
-        response['WWW-Authenticate'] = "Basic realm=\"#{resource.respond_to?(:authentication_realm) ? resource.authentication_realm : 'Locked content'}\""
-        raise Unauthorized.new unless authed
-      end
-    end
-
   end
 
 end 

data/lib/dav4rack/handler.rb

@@ -16,10 +16,16 @@ module DAV4Rack
       request = Rack::Request.new(env)
       response = Rack::Response.new
 
+      controller = nil
       begin
         controller = Controller.new(request, response, @options.dup)
+        controller.authenticate
         res = controller.send(request.request_method.downcase)
         response.status = res.code if res.respond_to?(:code)
+      rescue HTTPStatus::Unauthorized => status
+        response.body = controller.resource.respond_to?(:authentication_error_msg) ? controller.resource.authentication_error_msg : 'Not Authorized'
+        response['WWW-Authenticate'] = "Basic realm=\"#{controller.resource.respond_to?(:authentication_realm) ? controller.resource.authentication_realm : 'Locked content'}\""
+        response.status = status.code
       rescue HTTPStatus::Status => status
         response.status = status.code
       end
@@ -27,11 +33,11 @@ module DAV4Rack
       # Strings in Ruby 1.9 are no longer enumerable.  Rack still expects the response.body to be
       # enumerable, however.
       
-      response['Content-Length'] = response.body.to_s.length unless response['Content-Length'] || response.body.empty?
+      response['Content-Length'] = response.body.to_s.length unless response['Content-Length'] || !response.body.is_a?(String)
       response.body = [response.body] if not response.body.respond_to? :each
       response.status = response.status ? response.status.to_i : 200
       response.headers.each_pair{|k,v| response[k] = v.to_s}
-
+      
       # Apache wants the body dealt with, so just read it and junk it
       buf = true
       buf = request.body.read(8192) while buf

data/lib/dav4rack/interceptor_resource.rb

@@ -99,9 +99,9 @@ module DAV4Rack
       new_public.slice!(-1) if new_public[-1,1] == '/'
       new_public = "#{new_public}#{name}"
       if(key = @root_paths.find{|x| new_path =~ /^#{Regexp.escape(x.downcase)}\/?/})
-        @mappings[key][:resource_class].new(new_public, new_path.gsub(key, ''), request, {:root_uri_path => key}.merge(@mappings[key][:options] ? @mappings[key][:options] : options))
+        @mappings[key][:resource_class].new(new_public, new_path.gsub(key, ''), request, response, {:root_uri_path => key, :user => @user}.merge(@mappings[key][:options] ? @mappings[key][:options] : options))
       else
-        self.class.new(new_public, new_path, request, options)
+        self.class.new(new_public, new_path, request, response, {:user => @user}.merge(options))
       end
     end
     

data/lib/dav4rack/lock.rb

@@ -0,0 +1,40 @@
+module DAV4Rack
+  class Lock
+    
+    def initialize(args={})
+      @args = args
+      @store = nil
+      @args[:created_at] = Time.now
+      @args[:updated_at] = Time.now
+    end
+    
+    def store
+      @store
+    end
+    
+    def store=(s)
+      raise TypeError.new 'Expecting LockStore' unless s.respond_to? :remove
+      @store = s
+    end
+    
+    def destroy
+      if(@store)
+        @store.remove(self)
+      end
+    end
+    
+    def remaining_timeout
+      @args[:timeout].to_i - (Time.now.to_i - @args[:created_at].to_i)
+    end
+    
+    def method_missing(*args)
+      if(@args.has_key?(args.first.to_sym))
+        @args[args.first.to_sym]
+      elsif(args.first.to_s[-1,1] == '=')
+        @args[args.first.to_s[0, args.first.to_s.length - 1].to_sym] = args[1]
+      else
+        raise NoMethodError.new "Undefined method #{args.first} for #{self}"
+      end
+    end
+  end
+end

data/lib/dav4rack/lock_store.rb

@@ -0,0 +1,61 @@
+require 'dav4rack/lock'
+module DAV4Rack
+  class LockStore
+    class << self
+      def create
+        @locks_by_path = {}
+        @locks_by_token = {}
+      end
+      def add(lock)
+        @locks_by_path[lock.path] = lock
+        @locks_by_token[lock.token] = lock
+      end
+      
+      def remove(lock)
+        @locks_by_path.delete(lock.path)
+        @locks_by_token.delete(lock.token)
+      end
+    
+      def find_by_path(path)
+        @locks_by_path.map do |lpath, lock|
+          lpath == path && lock.remaining_timeout > 0 ? lock : nil
+        end.compact.first
+      end
+      
+      def find_by_token(token)
+        @locks_by_token.map do |ltoken, lock|
+          ltoken == token && lock.remaining_timeout > 0 ? lock : nil
+        end.compact.first
+      end
+      
+      def explicit_locks(path)
+        @locks_by_path.map do |lpath, lock|
+          lpath == path && lock.remaining_timeout > 0 ? lock : nil
+        end.compact
+      end
+      
+      def implicit_locks(path)
+        @locks_by_path.map do |lpath, lock|
+          lpath =~ /^#{Regexp.escape(path)}/ && lock.remaining_timeout > 0 && lock.depth > 0 ? lock : nil
+        end.compact
+      end
+      
+      def explicitly_locked?(path)
+        self.explicit_locks(path).size > 0
+      end
+      
+      def implicitly_locked?(path)
+        self.implicit_locks(path).size > 0
+      end
+      
+      def generate(path, user, token)
+        l = Lock.new(:path => path, :user => user, :token => token)
+        l.store = self
+        add(l)
+        l
+      end
+    end
+  end
+end
+
+DAV4Rack::LockStore.create

data/lib/dav4rack/remote_file.rb

@@ -1,9 +1,11 @@
 require 'net/http'
 require 'uri'
+require 'digest/sha1'
+require 'rack/file'
 
 module DAV4Rack
   
-  class RemoteFile
+  class RemoteFile < Rack::File
     
     attr_accessor :path
     
@@ -14,49 +16,81 @@ module DAV4Rack
     # Create a reference to a remote file. 
     # NOTE: HTTPError will be raised if path does not return 200 result
     def initialize(path, args={})
-      @path = path
+      @fpath = args[:url]
       @size = args[:size] || nil
       @mime_type = args[:mime_type] || 'text/plain'
       @modified = args[:last_modified] || nil
-      @uri = URI.parse(@path)
-      @con = Net::HTTP.new(@uri.host, @uri.port)
-      @call_path = @uri.path + (@uri.query ? "?#{@uri.query}" : '')
-      res = @con.request_get(@call_path)
-      @heads = res.to_hash
-      res.value
-      @store = nil
-    end
-    
-    def size
-      @heads['content-length'] || @size
+      @cache = args[:cache_directory] || nil
+      cached_file = @cache + '/' + Digest::SHA1.hexdigest(@fpath)
+      if(File.exists?(cached_file))
+        @root = ''
+        @path_info = cached_file
+        @path = @path_info
+      else
+        begin
+          @cf = File.open(cached_file, 'w+')
+        rescue
+          @cf = nil
+        end
+        @uri = URI.parse(path)
+        @con = Net::HTTP.new(@uri.host, @uri.port)
+        @call_path = @uri.path + (@uri.query ? "?#{@uri.query}" : '')
+        res = @con.request_get(@call_path)
+        @heads = res.to_hash
+        res.value
+        @store = nil
+        self.public_methods.each do |method|
+          m = method.to_s.dup
+          next unless m.slice!(0,7) == 'remote_'
+          self.class.class_eval "undef :'#{m}'"
+          self.class.class_eval "alias :'#{m}' :'#{method}'"
+        end
+      end
     end
-    
-    def content_type
-      @mime_type || @heads['content-type']
+
+    def remote_serving
+      [200, {
+             "Last-Modified"  => last_modified,
+             "Content-Type"   => content_type,
+             "Content-Length" => size
+            }, self]
     end
     
-    def last_modified
-      @heads['last-modified'] || @modified
-    end
     
-    def call(env)
+    def remote_call(env)
       dup._call(env)
     end
-
-    def _call(env)
+    
+    def remote__call(env)
       serving
     end
     
-    def each
+    def remote_each
       if(@store)
         yield @store
       else
         @con.request_get(@call_path) do |res|
           res.read_body(@store) do |part|
+            @cf.write part if @cf
             yield part
           end
         end
       end
     end
+    
+    def size
+      @heads['content-length'] || @size
+    end
+    
+    private
+    
+    def content_type
+      @mime_type || @heads['content-type']
+    end
+    
+    def last_modified
+      @heads['last-modified'] || @modified
+    end
+
   end
 end

data/lib/dav4rack/resource.rb

@@ -1,3 +1,5 @@
+require 'uuidtools'
+
 module DAV4Rack
   
   class LockFailure < RuntimeError
@@ -13,7 +15,36 @@ module DAV4Rack
   end
   
   class Resource
-    attr_reader :path, :options, :public_path, :request
+    attr_reader :path, :options, :public_path, :request, :response
+    attr_accessor :user
+    @@blocks = {}
+    
+    class << self
+      
+      # This lets us define a bunch of before and after blocks that are
+      # either called before all methods on the resource, or only specific
+      # methods on the resource
+      def method_missing(*args, &block)
+        class_sym = self.name.to_sym
+        @@blocks[class_sym] ||= {:before => {}, :after => {}}
+        m = args.shift
+        parts = m.to_s.split('_')
+        type = parts.shift.to_s.to_sym
+        method = parts.empty? ? nil : parts.join('_').to_sym
+        if(@@blocks[class_sym][type] && block_given?)
+          if(method)
+            @@blocks[class_sym][type][method] ||= []
+            @@blocks[class_sym][type][method] << block
+          else
+            @@blocks[class_sym][type][:'__all__'] ||= []
+            @@blocks[class_sym][type][:'__all__'] << block
+          end
+        else
+          raise NoMethodError.new("Undefined method #{m} for class #{self}")
+        end
+      end
+      
+    end
     
     include DAV4Rack::HTTPStatus
     
@@ -28,13 +59,56 @@ module DAV4Rack
     #       request -> /my/webdav/directory/actual/path
     #       public_path -> /my/webdav/directory/actual/path
     #       path -> /actual/path
-    def initialize(public_path, path, request, options)
+    # NOTE: Customized Resources should not use initialize for setup. Instead
+    #       use the #setup method
+    def initialize(public_path, path, request, response, options)
+      @skip_alias = [:authenticate, :authentication_error_msg, :authentication_realm, :path, :options, :public_path, :request, :response, :user, :user=]
       @public_path = public_path.dup
       @path = path.dup
       @request = request
+      @response = response
+      unless(options.has_key?(:lock_class))
+        require 'dav4rack/lock_store'
+        @lock_class = LockStore
+      else
+        @lock_class = options[:lock_class]
+        raise NameError.new("Unknown lock type constant provided: #{@lock_class}") unless @lock_class.nil? || defined?(@lock_class)
+      end
       @options = options.dup
+      @max_timeout = options[:max_timeout] || 86400
+      @default_timeout = options[:default_timeout] || 60
+      @user = @options[:user] || request.ip
+      setup if respond_to?(:setup)
+      public_methods(false).each do |method|
+        next if @skip_alias.include?(method.to_sym) || method[0,4] == 'DAV_' || method[0,5] == '_DAV_'
+        self.class.class_eval "alias :'_DAV_#{method}' :'#{method}'"
+        self.class.class_eval "undef :'#{method}'"
+      end
+      @runner = lambda do |class_sym, kind, method_name|
+        [:'__all__', method_name.to_sym].each do |sym|
+          if(@@blocks[class_sym] && @@blocks[class_sym][kind] && @@blocks[class_sym][kind][sym])
+            @@blocks[class_sym][kind][sym].each do |b|
+              args = [self, sym == :'__all__' ? method_name : nil].compact
+              b.call(*args)
+            end
+          end
+        end
+      end
     end
-        
+    
+    # This allows us to call before and after blocks
+    def method_missing(*args)
+      result = nil
+      orig = args.shift
+      class_sym = self.class.name.to_sym
+      m = orig.to_s[0,5] == '_DAV_' ? orig : "_DAV_#{orig}" # If hell is doing the same thing over and over and expecting a different result this is a hell preventer
+      raise NoMethodError.new("Undefined method: #{orig} for class #{self}.") unless respond_to?(m)
+      @runner.call(class_sym, :before, orig)
+      result = send m, *args
+      @runner.call(class_sym, :after, orig)
+      result
+    end
+    
     # If this is a collection, return the child resources.
     def children
       raise NotImplementedError
@@ -45,11 +119,16 @@ module DAV4Rack
       raise NotImplementedError
     end
 
-    # Does this recource exist?
+    # Does this resource exist?
     def exist?
       raise NotImplementedError
     end
     
+    # Does the parent resource exist?
+    def parent_exists?
+      parent.exist?
+    end
+    
     # Return the creation time.
     def creation_date
       raise NotImplementedError
@@ -142,14 +221,77 @@ module DAV4Rack
     # NOTE: See section 9.10 of RFC 4918 for guidance about
     # how locks should be generated and the expected responses
     # (http://www.webdav.org/specs/rfc4918.html#rfc.section.9.10)
+    
     def lock(args)
-      raise NotImplemented
+      raise NotImplemented if @lock_class.nil?
+      raise Conflict unless parent_exists?
+      lock_check(args[:scope])
+      lock = @lock_class.explicit_locks(@path).find{|l| l.scope == args[:scope] && l.kind == args[:type] && l.user == @user}
+      unless(lock)
+        token = UUIDTools::UUID.random_create.to_s
+        lock = @lock_class.generate(@path, @user, token)
+        lock.scope = args[:scope]
+        lock.kind = args[:type]
+        lock.owner = args[:owner]
+        lock.depth = args[:depth].to_i
+        if(args[:timeout])
+          lock.timeout = args[:timeout] <= @max_timeout && args[:timeout] > 0 ? args[:timeout] : @max_timeout
+        else
+          lock.timeout = @default_timeout
+        end
+        lock.save if lock.respond_to? :save
+      end
+      begin
+        lock_check(args[:type])
+      rescue DAV4Rack::LockFailure => e
+        lock.destroy
+        raise e
+      end
+      [lock.remaining_timeout, lock.token]
+    end
+
+    # lock_scope:: scope of lock
+    # Check if resource is locked. Raise DAV4Rack::LockFailure if locks are in place.
+    def lock_check(lock_scope=nil)
+      return unless @lock_class
+      if(@lock_class.explicitly_locked?(@path))
+        raise Locked if @lock_class.explicit_locks(@path).find_all{|l|l.scope == 'exclusive' && l.user != @user}.size > 0
+      elsif(@lock_class.implicitly_locked?(@path))
+        if(lock_scope.to_s == 'exclusive')
+          locks = @lock_class.implicit_locks(@path)
+          failure = DAV4Rack::LockFailure.new("Failed to lock: #{@path}")
+          locks.each do |lock|
+            failure.add_failure(@path, Locked)
+          end
+          raise failure
+        else
+          locks = @lock_class.implict_locks(@path).find_all{|l| l.scope == 'exclusive' && l.user != @user}
+          if(locks.size > 0)
+            failure = LockFailure.new("Failed to lock: #{@path}")
+            locks.each do |lock|
+              failure.add_failure(@path, Locked)
+            end
+            raise failure
+          end
+        end
+      end
     end
     
+    # token:: Lock token
+    # Remove the given lock
     def unlock(token)
-      raise NotImplemented
+      raise NotImplemented if @lock_class.nil?
+      token = token.slice(1, token.length - 2)
+      raise BadRequest if token.nil? || token.empty?
+      lock = @lock_class.find_by_token(token)
+      raise Forbidden unless lock && lock.user == @user
+      raise Conflict unless lock.path =~ /^#{Regexp.escape(@path)}.*$/
+      lock.destroy
+      delete if name[0,1] == '.' && @options[:delete_dotfiles]
+      NoContent
     end
-
+    
+    
     # Create this resource as collection.
     def make_collection
       raise NotImplementedError
@@ -220,14 +362,14 @@ module DAV4Rack
       new_path = path.dup
       new_path = new_path + '/' unless new_path[-1,1] == '/'
       new_path = '/' + new_path unless new_path[0,1] == '/'
-      self.class.new("#{new_public}#{name}", "#{new_path}#{name}", request, options)
+      self.class.new("#{new_public}#{name}", "#{new_path}#{name}", request, response, options.merge(:user => @user))
     end
     
     # Return parent of this resource
     def parent
       elements = @path.scan(/[^\/]+/)
       return nil if elements.empty?
-      self.class.new(('/' + @public_path.scan(/[^\/]+/)[0..-2].join('/')), ('/' + elements[0..-2].to_a.join('/')), @request, @options)
+      self.class.new(('/' + @public_path.scan(/[^\/]+/)[0..-2].join('/')), ('/' + elements[0..-2].to_a.join('/')), @request, @response, @options.merge(:user => @user))
     end
     
     # Return list of descendants
@@ -239,10 +381,28 @@ module DAV4Rack
       end
       list
     end
+    
+    protected
+    
+    # Index page template for GETs on collection
+    def index_page
+      '<html><head> <title>%s</title>
+      <meta http-equiv="content-type" content="text/html; charset=utf-8" /></head>
+      <body> <h1>%s</h1> <hr /> <table> <tr> <th class="name">Name</th>
+      <th class="size">Size</th> <th class="type">Type</th> 
+      <th class="mtime">Last Modified</th> </tr> %s </table> <hr /> </body></html>'
+    end
 
     # Does client allow GET redirection
     def allows_redirect?
-      %w(webdrive cyberduck konqueror).any?{|x| (request.respond_to?(:user_agent) ? request.user_agent.downcase : request.env['HTTP_USER_AGENT'].downcase) =~ /#{Regexp.escape(x)}/}
+      %w(cyberduck konqueror).any?{|x| (request.respond_to?(:user_agent) ? request.user_agent.to_s.downcase : request.env['HTTP_USER_AGENT'].to_s.downcase) =~ /#{Regexp.escape(x)}/}
+    end
+    
+    # Returns authentication credentials if available in form of [username,password]
+    # TODO: Add support for digest
+    def auth_credentials
+      auth = Rack::Auth::Basic::Request.new(request.env)
+      auth.basic? && auth.credentials ? auth.credentials : [nil,nil]
     end
     
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dav4rack
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Chris Roberts
@@ -15,12 +15,43 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-03 00:00:00 -07:00
+date: 2010-08-10 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 4
+        - 2
+        version: 1.4.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: uuidtools
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 1
+        - 1
+        version: 2.1.1
+  type: :runtime
+  version_requirements: *id002
 description: WebDAV handler for Rack
-email: chris@chrisroberts.org
+email: chrisroberts.code@gmail.com
 executables: 
 - dav4rack
 extensions: []
@@ -40,11 +71,13 @@ files:
 - lib/dav4rack/interceptor.rb
 - lib/dav4rack/interceptor_resource.rb
 - lib/dav4rack/remote_file.rb
+- lib/dav4rack/lock.rb
+- lib/dav4rack/lock_store.rb
 - bin/dav4rack
 - spec/handler_spec.rb
 - README.rdoc
 has_rdoc: true
-homepage: http://github.com/dav4rack
+homepage: http://github.com/chrisroberts/dav4rack
 licenses: []
 
 post_install_message: