dav4rack 0.0.1

data/lib/dav4rack/file_resource.rb

@@ -0,0 +1,176 @@
+require 'webrick/httputils'
+
+module DAV4Rack
+
+  class FileResource < Resource
+    
+    include WEBrick::HTTPUtils
+    
+    def authenticate(user, pass)
+      if(options[:username])
+        options[:username] == user && options[:password] == pass
+      else
+        true
+      end
+    end
+    
+    # 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.size.to_s
+      else
+        file = Rack::File.new(nil)
+        file.path = file_path
+        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?
+        Dir.rmdir(file_path)
+      else
+        File.unlink(file_path)
+      end
+      NoContent
+    end
+    
+    # HTTP COPY request.
+    #
+    # Copy this resource to given destination resource.
+    def copy(dest)
+      if stat.directory?
+        dest.make_collection
+      else
+        open(file_path, "rb") do |file|
+          dest.write(file)
+        end
+      end
+      OK
+    end
+  
+    # HTTP MOVE request.
+    #
+    # Move this resource to given destination resource.
+    def move(dest)
+      copy(dest)
+      delete
+      OK
+    end
+    
+    # HTTP MKCOL request.
+    #
+    # Create this resource as collection.
+    def make_collection
+      Dir.mkdir(file_path)
+      NoContent
+    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
+    
+    private
+
+    def root
+      @options[:root]
+    end
+
+    def file_path
+      root + '/' + path
+    end
+
+    def stat
+      @stat ||= File.stat(file_path)
+    end
+
+  end
+
+end

data/lib/dav4rack/handler.rb

@@ -0,0 +1,44 @@
+module DAV4Rack
+  
+  class Handler
+    include DAV4Rack::HTTPStatus    
+    def initialize(options={})
+      @options = options.dup
+      unless(@options[:resource_class])
+        require 'dav4rack/file_resource'
+        @options[:resource_class] = FileResource
+        @options[:root] ||= Dir.pwd
+      end
+    end
+
+    def call(env)
+      
+      request = Rack::Request.new(env)
+      response = Rack::Response.new
+
+      begin
+        controller = Controller.new(request, response, @options.dup)
+        res = controller.send(request.request_method.downcase)
+        response.status = res.code if res.respond_to?(:code)
+      rescue HTTPStatus::Status => status
+        response.status = status.code
+      end
+
+      # 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.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
+
+      response.finish
+    end
+    
+  end
+
+end

data/lib/dav4rack/http_status.rb

@@ -0,0 +1,108 @@
+module DAV4Rack
+
+  module HTTPStatus
+    
+    class Status < Exception
+      
+      class << self
+        attr_accessor :code, :reason_phrase
+        alias_method :to_i, :code
+        
+        def status_line
+          "#{code} #{reason_phrase}"
+        end
+        
+      end
+      
+      def code
+        self.class.code
+      end
+
+      def reason_phrase
+        self.class.reason_phrase
+      end
+      
+      def status_line
+        self.class.status_line
+      end
+      
+      def to_i
+        self.class.to_i
+      end
+      
+    end
+    
+    StatusMessage = {
+      100 => 'Continue',
+      101 => 'Switching Protocols',
+      102 => 'Processing',
+      200 => 'OK',
+      201 => 'Created',
+      202 => 'Accepted',
+      203 => 'Non-Authoritative Information',
+      204 => 'No Content',
+      205 => 'Reset Content',
+      206 => 'Partial Content',
+      207 => 'Multi-Status',
+      300 => 'Multiple Choices',
+      301 => 'Moved Permanently',
+      302 => 'Found',
+      303 => 'See Other',
+      304 => 'Not Modified',
+      305 => 'Use Proxy',
+      307 => 'Temporary Redirect',
+      400 => 'Bad Request',
+      401 => 'Unauthorized',
+      402 => 'Payment Required',
+      403 => 'Forbidden',
+      404 => 'Not Found',
+      405 => 'Method Not Allowed',
+      406 => 'Not Acceptable',
+      407 => 'Proxy Authentication Required',
+      408 => 'Request Timeout',
+      409 => 'Conflict',
+      410 => 'Gone',
+      411 => 'Length Required',
+      412 => 'Precondition Failed',
+      413 => 'Request Entity Too Large',
+      414 => 'Request-URI Too Large',
+      415 => 'Unsupported Media Type',
+      416 => 'Request Range Not Satisfiable',
+      417 => 'Expectation Failed',
+      422 => 'Unprocessable Entity',
+      423 => 'Locked',
+      424 => 'Failed Dependency',      
+      500 => 'Internal Server Error',
+      501 => 'Not Implemented',
+      502 => 'Bad Gateway',
+      503 => 'Service Unavailable',
+      504 => 'Gateway Timeout',
+      505 => 'HTTP Version Not Supported',
+      507 => 'Insufficient Storage'
+    }
+
+    StatusMessage.each do |code, reason_phrase|
+      klass = Class.new(Status)
+      klass.code = code
+      klass.reason_phrase = reason_phrase
+      klass_name = reason_phrase.gsub(/[ \-]/,'')
+      const_set(klass_name, klass)
+    end
+
+  end
+
+end
+
+
+module Rack
+  class Response
+    module Helpers
+      DAV4Rack::HTTPStatus::StatusMessage.each do |code, reason_phrase|
+        name = reason_phrase.gsub(/[ \-]/,'_').downcase
+        define_method(name + '?') do
+          @status == code
+        end
+      end
+    end
+  end
+end

data/lib/dav4rack/interceptor.rb

@@ -0,0 +1,20 @@
+require 'dav4rack/interceptor_resource'
+module DAV4Rack
+  class Interceptor
+    def initialize(app, args={})
+      @roots = args[:mappings].keys
+      @args = args
+      @app = app
+    end
+
+    def call(env)
+      path = env['PATH_INFO'].downcase
+      method = env['REQUEST_METHOD'].upcase
+      app = nil
+      if(@roots.detect{|x| path =~ /^#{Regexp.escape(x.downcase)}\/?/}.nil? && %w(OPTIONS PUT PROPFIND PROPPATCH MKCOL COPY MOVE LOCK UNLOCK).include?(method))
+        app = DAV4Rack::Handler.new(:resource_class => InterceptorResource, :mappings => @args[:mappings])
+      end
+      app ? app.call(env) : @app.call(env)
+    end
+  end
+end

data/lib/dav4rack/interceptor_resource.rb

@@ -0,0 +1,119 @@
+require 'digest/sha1'
+
+module DAV4Rack
+
+  class InterceptorResource < Resource
+    attr_reader :path, :options
+    
+    def initialize(*args)
+      super
+      @root_paths = @options[:mappings].keys
+      @mappings = @options[:mappings]
+    end
+        
+    def children
+      childs = @root_paths.find_all{|x|x =~ /^#{Regexp.escape(@path)}/}
+      childs = childs.map{|a| child a.gsub(/^#{Regexp.escape(@path)}/, '').split('/').delete_if{|x|x.empty?}.first }.flatten
+    end
+
+    def collection?
+      true if exist?
+    end
+
+    def exist?
+      !@root_paths.find_all{|x| x =~ /^#{Regexp.escape(@path)}/}.empty?
+    end
+    
+    def creation_date
+      Time.now
+    end
+
+    def last_modified
+      Time.now
+    end
+    
+    def last_modified=(time)
+      Time.now
+    end
+
+    def etag
+      Digest::SHA1.hexdigest(@path)
+    end
+
+    def content_type
+      'text/html'
+    end
+
+    def content_length
+      0
+    end
+
+    def get(request, response)
+      raise Forbidden
+    end
+
+    def put(request, response)
+      raise Forbidden
+    end
+    
+    def post(request, response)
+      raise Forbidden
+    end
+    
+    def delete
+      raise Forbidden
+    end
+    
+    def copy(dest)
+      raise Forbidden
+    end
+  
+    def move(dest)
+      raise Forbidden
+    end
+    
+    def make_collection
+      raise Forbidden
+    end
+
+    def ==(other)
+      path == other.path
+    end
+
+    def name
+      File.basename(path)
+    end
+
+    def display_name
+      File.basename(path.to_s)
+    end
+    
+    def child(name, option={})
+      new_path = path.dup
+      new_path = '/' + new_path unless new_path[0,1] == '/'
+      new_path.slice!(-1) if new_path[-1,1] == '/'
+      name = '/' + name unless name[-1,1] == '/'
+      new_path = "#{new_path}#{name}"
+      new_public = public_path.dup
+      new_public = '/' + new_public unless new_public[0,1] == '/'
+      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))
+      else
+        self.class.new(new_public, new_path, request, options)
+      end
+    end
+    
+    def descendants
+      list = []
+      children.each do |child|
+        list << child
+        list.concat(child.descendants)
+      end
+      list
+    end
+
+  end
+
+end