heel 0.2.0

data/CHANGES

@@ -0,0 +1,17 @@
+= Changelog
+
+=== Version 0.2.0 - 2007-08-11
+
+* Initial public release
+* Added daemonizing of server
+* Added launching of browser to server URL
+
+=== Version 0.1.0
+
+* rename project to 'heel'
+* gem packaging
+
+=== Version 0.0.1 - 2007-05-03
+
+* initial development release 
+

data/LICENSE

@@ -0,0 +1,31 @@
+Copyright (c) 2007, Jeremy Hinegardner
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+ 
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the
+      distribution.  
+      
+    * Neither the name of Jeremy Hinegardner nor the
+      names of its contributors may be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,84 @@
+== Heel
+
+* Homepage[http://copiousfreetime.rubyforge.org/heel/]
+* {Rubyforge Project}[http://rubyforge.org/projects/copiousfreetime/]
+* email jeremy at hinegardner dot org
+
+== DESCRIPTION:
+
+Heel is a small static file web server based on {mongrel}[http://mongrel.rubyforge.org] 
+for use when you need a quick web server fo a directory.  Once the server is running heel will use
+{launchy}[http://copiousfreetime.rubyforge.org/launchy/] to open your browser at the URL of your document root.
+
+== SYNOPSIS:
+
+	Usage: heel [options]
+
+	    -a, --address ADDRESS            Address to bind to
+	                                     (default: 0.0.0.0)
+	    -d, --daemonize                  Run daemonized in the background
+	    -h, --help                       Display this text
+	    -k, --kill                       Kill an existing daemonized heel process
+	    -p, --port PORT                  Port to bind to
+	                                     (default: 4331)
+	    -r, --root ROOT                  Set the document root
+	                                      (default: current working directory)
+	    -v, --version                    Show version
+
+
+== REQUIREMENTS:
+
+=== For running: 
+
+* mongrel
+* {launchy}[http://copiousfreetime.rubyforge.org/launchy/] >= 0.1.1
+* mime-types
+
+=== For development:
+
+* rake >= 0.7.1
+* rcov >= 0.7.0.1
+* rspec  >= 0.7.3
+
+== INSTALL:
+
+* gem install heel
+
+== CREDITS:
+
+* Zed Shaw for {mongrel}[http://mongrel.rubyforge.org]
+* http://www.famfamfam.com/ for amazing icons
+
+== LICENSE:
+
+Copyright (c) 2007, Jeremy Hinegardner
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+ 
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the
+      distribution.  
+      
+    * Neither the name of Jeremy Hinegardner nor the
+      names of its contributors may be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/bin/heel

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+
+require 'rubygems'
+require 'mongrel'
+require 'heel'
+
+Heel::Server.new(ARGV).run
+

data/lib/heel.rb

@@ -0,0 +1,16 @@
+module Heel
+    APP_ROOT_DIR     = File.dirname(File.expand_path(File.join(__FILE__,".."))).freeze
+    APP_LIB_DIR      = File.join(APP_ROOT_DIR,"lib")
+    APP_RESOURCE_DIR = File.join(APP_ROOT_DIR,"resources")
+end
+
+require 'rubygems'
+require 'mongrel'
+
+require 'heel/version'
+require 'heel/specification'
+require 'heel/gemspec'
+require 'heel/server'
+require 'heel/dir_handler'
+require 'heel/error_handler'
+

data/lib/heel/dir_handler.rb

@@ -0,0 +1,284 @@
+require 'heel'
+require 'mime/types'
+require 'erb'
+
+module Heel
+
+    # A refactored version of Mongrel::DirHandler using the mime-types
+    # gem and a prettier directory listing.
+    class DirHandler < ::Mongrel::HttpHandler
+        attr_reader :document_root
+        attr_reader :directory_index_html
+        attr_reader :icon_url
+        attr_reader :default_mime_type
+        attr_reader :ignore_globs
+        attr_reader :reload_template_changes
+        attr_reader :template
+        attr_reader :template_mtime
+
+        # if any other mime types are needed, add them directly via the
+        # mime-types calls.
+        ADDITIONAL_MIME_TYPES = [
+            # [ content-type , [ array, of, filename, extentions] ]
+            ["images/svg+xml", ["svg"]],
+            ["video/x-flv", ["flv"]],
+            ["application/x-shockwave-flash", ["swf"]],
+            ["text/plain", ["rb", "rhtml"]],
+        ]
+
+        ICONS_BY_MIME_TYPE = {
+            "text/plain"                => "page_white_text.png",
+            "image"                     => "picture.png",
+            "pdf"                       => "page_white_acrobat.png",
+            "xml"                       => "page_white_code.png",
+            "compress"                  => "compress.png",
+            "gzip"                      => "compress.png",
+            "zip"                       => "compress.png",
+            "application/xhtml+xml"     => "xhtml.png",
+            "application/word"          => "page_word.png",
+            "application/excel"         => "page_excel.png",
+            "application/powerpoint"    => "page_white_powerpoint.png",
+            "text/html"                 => "html.png",
+            "application"               => "application.png",
+            "text"                      => "page_white_text.png",
+            :directory                  => "folder.png",
+            :default                    => "page_white.png",
+        }
+
+        def initialize(options = {})
+            @ignore_globs               = options[:ignore_globs] || %w( *~ .htaccess . )
+            @document_root              = options[:document_root] || Dir.pwd
+            @directory_listing_allowed  = options[:directory_listing_allowed] || true
+            @directory_index_html       = options[:directory_index_html] || "index.html"
+            @using_icons                = options[:using_icons] || true
+            @icon_url                   = options[:icon_url] || "/icons"
+            @reload_template_changes    = options[:reload_template_changes] || false
+            reload_template
+
+            ADDITIONAL_MIME_TYPES.each do |mt|
+                if MIME::Types[mt.first].size == 0 then
+                    type = MIME::Type.from_array(mt)
+                    MIME::Types.add(type)
+                else
+                    type = MIME::Types[mt.first].first
+                    mt[1].each do |ext|
+                        type.extensions << ext unless type.extensions.include?(ext)
+                    end
+                    # have to reindex if new extensions added
+                    MIME::Types.index_extensions(type)
+                end
+            end
+
+            @default_mime_type = MIME::Types["application/octet-stream"].first
+        end
+
+        def directory_listing_allowed?
+            return !!@directory_listing_allowed
+        end
+
+        def using_icons?
+            return !!@using_icons
+        end
+
+        def icon_for(mime_type)
+            icon = nil
+            [:content_type, :sub_type, :media_type].each do |t| 
+                icon = ICONS_BY_MIME_TYPE[mime_type.send(t)]
+                return icon if icon
+            end
+            icon = ICONS_BY_MIME_TYPE[:default]
+        end
+
+        def reload_template_changes?
+            return @reload_template_changes
+        end
+
+        def reload_template
+            fname = File.join(APP_RESOURCE_DIR,"listing.rhtml")
+            fstat = File.stat(fname)
+            @template_mtime ||= fstat.mtime
+            if @template.nil? or fstat.mtime > @template_mtime then
+                @template = ::ERB.new(File.read(fname))
+                # log "Reloaded #{fname}"
+            end
+        end
+
+        # determine how to respond to the request, it will either be a
+        # directory listing, a file return, or an error return.
+        def how_to_respond(req_path)
+            if req_path.index(document_root) == 0 then
+                begin
+                    stat = File.stat(req_path)
+
+                    # if it is a directory, we either return the
+                    # directory index file, or a directory listing
+                    if stat.directory? then
+                       dir_index = File.join(req_path,directory_index_html)
+                       if File.exists?(dir_index) then
+                           return dir_index
+                       elsif directory_listing_allowed?
+                           return :directory_listing
+                       end
+
+                    # if it is a file and readable, make sure that the
+                    # path is a legal path
+                    elsif stat.file? and stat.readable? then
+                        if should_ignore?(File.basename(req_path)) then
+                            return 403
+                        end
+                        return req_path
+                    else
+                        # TODO: debug log
+                        return 403
+                    end
+
+                rescue => error
+                    if error.kind_of?(Errno::ENOENT) then
+                        return 404
+                    end
+                    # TODO: debug log
+                    return 500
+                end
+            else
+               return 403
+            end
+        end
+
+        def should_ignore?(fname)
+            ignore_globs.each do |glob|
+                return true if File.fnmatch(glob,fname)
+            end
+            false 
+        end
+
+        # send a directory listing back to the client
+        def respond_with_directory_listing(req_path,request,response)
+            base_uri = ::Mongrel::HttpRequest.unescape(request.params[Mongrel::Const::REQUEST_URI])
+            entries = []
+            Dir.entries(req_path).each do |entry|
+                next if should_ignore?(entry)
+                next if req_path == document_root and entry == ".."
+
+                stat            = File.stat(File.join(req_path,entry))
+                entry_data      = OpenStruct.new 
+
+                entry_data.name          = entry == ".." ? "Parent Directory" : entry
+                entry_data.link          = entry
+                entry_data.size          = num_to_bytes(stat.size)
+                entry_data.last_modified = stat.mtime.strftime("%Y-%m-%d %H:%M:%S")
+
+                if stat.directory? then
+                    entry_data.content_type = "Directory"
+                    entry_data.size         = "-"
+                    entry_data.name         += "/"
+                    if using_icons? then
+                        entry_data.icon_url = File.join(icon_url, ICONS_BY_MIME_TYPE[:directory])
+                    end
+                else
+                    entry_data.mime_type = MIME::Types.of(entry).first || default_mime_type
+                    entry_data.content_type = entry_data.mime_type.content_type
+                    if using_icons? then
+                        entry_data.icon_url = File.join(icon_url, icon_for(entry_data.mime_type))
+                    end
+                end
+                entries << entry_data
+            end
+
+            entries = entries.sort_by { |e| e.link }
+
+            response.start(200) do |head,out|
+                head['Content-Type'] = 'text/html'
+                out.write(template.result(binding))
+            end
+        end
+
+        # this method is essentially the send_file method from
+        # Mongrel::DirHandler
+        def respond_with_send_file(path,method,request,response)
+            stat    = File.stat(path)
+            mtime   = stat.mtime
+            etag    = ::Mongrel::Const::ETAG_FORMAT % [mtime.to_i, stat.size, stat.ino]
+
+            modified_since  = request.params[::Mongrel::Const::HTTP_IF_MODIFIED_SINCE]
+            none_match      = request.params[::Mongrel::Const::HTTP_IF_NONE_MATCH]
+
+            last_response_time = Time.httpddate(modified_since) rescue nil
+
+            same_response = case
+                            when modified_since && !last_response_time                               : false
+                            when modified_since && last_response_time > Time.now                     : false
+                            when modified_since && mtime > last_response_time                        : false
+                            when none_match     && none_match == "*"                                 : false
+                            when none_match     && !none_match.strip.split(/\s*,\s*/).include?(etag) : false
+                            else modified_since || none_match
+                            end
+            header = response.header
+            header[::Mongrel::Const::ETAG] = etag
+
+            if same_response then
+                response.start(304) {}
+            else
+                response.status = 200
+                header[::Mongrel::Const::LAST_MODIFIED] = mtime.httpdate
+                header[::Mongrel::Const::CONTENT_TYPE] = (MIME::Types.of(path).first || default_mime_type).to_s
+            end
+
+            response.send_status(stat.size)
+            response.send_header
+
+            if method == ::Mongrel::Const::GET then
+                response.send_file(path,stat.size < ::Mongrel::Const::CHUNK_SIZE * 2)
+            end
+        end
+
+        # process the request, returning either the file, a directory
+        # listing (if allowed) or an appropriate error
+        def process(request, response)
+            method   = request.params[Mongrel::Const::REQUEST_METHOD] || Mongrel::Const::GET
+            if ( method == Mongrel::Const::GET ) or ( method == Mongrel::Const::HEAD ) then
+
+                reload_template if reload_template_changes
+                
+                req_path = File.expand_path(File.join(@document_root,
+                                                      ::Mongrel::HttpRequest.unescape(request.params[Mongrel::Const::PATH_INFO])),
+                                            @document_root)
+                res_type = how_to_respond(req_path)
+
+                case res_type 
+                when :directory_listing
+                    respond_with_directory_listing(req_path,request,response)
+                when String
+                    respond_with_send_file(res_type,method,request,response)
+                when Integer
+                    response.status = res_type
+                end
+
+            # invalid method
+            else
+                response.start(403) { |head,out| out.write("Only HEAD and GET requests are honored.") }
+            end
+        end
+
+        # essentially this is strfbytes from facets
+        def num_to_bytes(num,fmt="%.2f")
+           case
+            when num < 1024
+              "#{num} bytes"
+            when num < 1024**2
+              "#{fmt % (num.to_f / 1024)} KB"
+            when num < 1024**3
+              "#{fmt % (num.to_f / 1024**2)} MB"
+            when num < 1024**4
+              "#{fmt % (num.to_f / 1024**3)} GB"
+            when num < 1024**5
+              "#{fmt % (num.to_f / 1024**4)} TB"
+            else
+              "#{num} bytes"
+            end
+        end
+
+        def log(msg)
+            STDERR.print "-->  ", msg, "\n"
+        end
+    end
+end