heel 0.6.0 → 1.0.0

data/tasks/distribution.rake

@@ -0,0 +1,52 @@
+#--
+# Copyright (c) 2007, 2008 Jeremy Hinegardner
+# All rights reserved.  Licensed under the BSD license.  See LICENSE for details
+#++
+
+require 'tasks/config'
+
+#-------------------------------------------------------------------------------
+# Distribution and Packaging
+#-------------------------------------------------------------------------------
+if pkg_config = Configuration.for_if_exist?("packaging") then
+
+  require 'gemspec'
+  require 'rake/gempackagetask'
+  require 'rake/contrib/sshpublisher'
+
+  namespace :dist do
+
+    Rake::GemPackageTask.new(Heel::GEM_SPEC) do |pkg|
+      pkg.need_tar = pkg_config.formats.tgz
+      pkg.need_zip = pkg_config.formats.zip
+    end
+
+    desc "Install as a gem"
+    task :install => [:clobber, :package] do
+      sh "sudo gem install -y pkg/#{Heel::GEM_SPEC.full_name}.gem"
+    end
+
+    desc "Uninstall gem"
+    task :uninstall do 
+      sh "sudo gem uninstall -i #{Heel::GEM_SPEC.name} -x"
+    end
+
+    desc "dump gemspec"
+    task :gemspec do
+      puts Heel::GEM_SPEC.to_ruby
+    end
+
+    desc "reinstall gem"
+    task :reinstall => [:uninstall, :repackage, :install]
+
+    desc "distribute copiously"
+    task :copious => [:package] do
+        Rake::SshFilePublisher.new('jeremy@copiousfreetime.org',
+                               '/var/www/vhosts/www.copiousfreetime.org/htdocs/gems/gems',
+                               'pkg',"#{Heel::GEM_SPEC.full_name}.gem").upload
+        sh "ssh jeremy@copiousfreetime.org rake -f /var/www/vhosts/www.copiousfreetime.org/htdocs/gems/Rakefile"
+    end
+
+
+  end
+end

data/tasks/documentation.rake

@@ -0,0 +1,35 @@
+#--
+# Copyright (c) 2007, 2008 Jeremy Hinegardner
+# All rights reserved.  Licensed under the BSD license.  See LICENSE for details
+#++
+
+require 'tasks/config'
+
+#-----------------------------------------------------------------------
+# Documentation
+#-----------------------------------------------------------------------
+
+if rdoc_config = Configuration.for_if_exist?('rdoc') then
+
+  namespace :doc do
+
+    require 'rake/rdoctask'
+
+    # generating documentation locally
+    Rake::RDocTask.new do |rdoc|
+      rdoc.rdoc_dir   = rdoc_config.output_dir
+      rdoc.options    = rdoc_config.options
+      rdoc.rdoc_files = rdoc_config.files
+      rdoc.title      = rdoc_config.title
+      rdoc.main       = rdoc_config.main
+    end
+
+    if rubyforge_config = Configuration.for_if_exist?('rubyforge') then
+      desc "Deploy the RDoc documentation to #{rubyforge_config.rdoc_location}"
+      task :deploy => :rerdoc do
+        sh "rsync -zav --delete #{rdoc_config.output_dir}/ #{rubyforge_config.rdoc_location}"
+      end
+    end
+
+  end
+end

data/tasks/rspec.rb

@@ -0,0 +1,33 @@
+#--
+# Copyright (c) 2007, 2008 Jeremy Hinegardner
+# All rights reserved.  Licensed under the BSD license.  See LICENSE for details
+#++
+
+require 'tasks/config'
+
+#-------------------------------------------------------------------------------
+# configuration for running rspec.  This shows up as the test:default task
+#-------------------------------------------------------------------------------
+
+if spec_config = Configuration.for_if_exist?('test') then
+
+  namespace :test do
+
+    task :default => :spec
+
+    require 'spec/rake/spectask'
+    Spec::Rake::SpecTask.new do |r| 
+      r.rcov        = spec_config.ruby_opts
+      r.libs        = [ Heel::Configuration.lib_path,
+        Heel::Configuration.root_dir ]
+      r.spec_files  = spec_config.files
+      r.spec_opts   = spec_config.options
+
+      if rcov_config = Configuration.for_if_exist?('rcov') then
+        r.rcov      = true
+        r.rcov_dir  = rcov_config.output_dir
+        r.rcov_opts = rcov_config.rcov_opts
+      end
+    end
+  end
+end

data/tasks/rubyforge.rb

@@ -0,0 +1,52 @@
+#--
+# Copyright (c) 2007, 2008 Jeremy Hinegardner
+# All rights reserved.  Licensed under the BSD license.  See LICENSE for details
+#++
+
+require 'tasks/config'
+
+#-----------------------------------------------------------------------
+# Rubyforge additions to the task library
+#-----------------------------------------------------------------------
+if rf_conf = Configuration.for_if_exist?('rubyforge') then
+  require 'rubyforge'
+  
+  proj_conf = Configuration.for('project')
+
+  namespace :dist do
+    desc "Release files to rubyforge"
+    task :rubyforge => [:clean, :package] do
+
+      rubyforge = ::RubyForge.new
+
+      # make sure this release doesn't already exist
+      releases = rubyforge.autoconfig['release_ids']
+      if releases.has_key?(proj_conf.name) and releases[proj_conf.name][Heel::VERSION] then
+        abort("Release #{Heel::VERSION} already exists! Unable to release.")
+      end
+
+      config = rubyforge.userconfig
+      config["release_notes"]     = proj_conf.description
+      config["release_changes"]   = Utils.release_notes_from(proj_conf.history)[Heel::VERSION]
+      config["Prefomatted"]       = true
+
+      puts "Uploading to rubyforge..."
+      files = FileList[File.join("pkg","#{proj_conf.name}-#{Heel::VERSION}*.*")].to_a
+      rubyforge.login
+      rubyforge.add_release(rf_conf.project, proj_conf.name, Heel::VERSION, *files)
+      puts "done."
+    end
+  end
+
+  namespace :announce do
+    desc "Post news of #{proj_conf.name} to #{rf_conf.project} on rubyforge"
+    task :rubyforge do
+      subject, title, body, urls = announcement
+      rubyforge = RubyForge.new
+      rubyforge.login
+      rubyforge.post_news(rf_conf.project, subject, "#{title}\n\n#{urls}\n\n#{body}")
+      puts "Posted to rubyforge"
+    end
+
+  end
+end

data/tasks/utils.rb

@@ -0,0 +1,85 @@
+#--
+# Copyright (c) 2007, 2008 Jeremy Hinegardner
+# All rights reserved.  Licensed under the BSD license.  See LICENSE for details
+#++
+
+require 'heel/version'
+
+#-------------------------------------------------------------------------------
+# Additions to the Configuration class that are useful
+#-------------------------------------------------------------------------------
+class Configuration
+  class << self
+    def exist?( name )
+      Configuration::Table.has_key?( name )
+    end
+
+    def for_if_exist?( name )
+      if self.exist?( name ) then
+        self.for( name )
+      end
+    end
+  end
+end
+
+#-------------------------------------------------------------------------------
+# some useful utilitiy methods for the tasks
+#-------------------------------------------------------------------------------
+module Utils
+  class << self
+
+    # Try to load the given _library_ using the built-in require, but do not
+    # raise a LoadError if unsuccessful. Returns +true+ if the _library_ was
+    # successfully loaded; returns +false+ otherwise.
+    #
+    def try_require( lib ) 
+      require lib
+      true 
+    rescue LoadError 
+      false 
+    end 
+
+    # partition an rdoc file into sections, and return the text of the section
+    # given.  
+    def section_of(file, section_name) 
+      File.read(file).split(/^(?==)/).each do |section|
+        lines = section.split("\n")
+        return lines[1..-1].join("\n").strip if lines.first =~ /#{section_name}/i
+      end
+      nil
+    end
+
+    # Get an array of all the changes in the application for a particular
+    # release.  This is done by looking in the history file and grabbing the
+    # information for the most recent release.  The history file is assumed to
+    # be in RDoc format and version release are 2nd tier sections separated by
+    # '== Version X.Y.Z'
+    #
+    # returns:: A hash of notes keyed by version number
+    #
+    def release_notes_from(history_file)
+      releases = {}
+      File.read(history_file).split(/^(?==)/).each do |section|
+        lines = section.split("\n")
+        md = %r{Version ((\w+\.)+\w+)}.match(lines.first)
+        next unless md
+        releases[md[1]] = lines[1..-1].join("\n").strip
+      end
+      return releases
+    end
+
+    # return a hash of useful information for the latest release
+    # urls, subject, title, description and latest release notes
+    #
+    def announcement
+      cfg = Configuration.for("project") 
+      { 
+        :subject        => "#{cfg.name} #{Heel::VERSION} Released",
+        :title          => "#{cfg.name} version #{Heel::VERSION} has been released.",
+        :urls           => "#{cfg.homepage}",
+        :description    => "#{cfg.description.rstrip}",
+        :release_notes  => Utils.release_notes_from(cfg.history)[Heel::VERSION].rstrip 
+      }
+    end
+  end
+end # << self

metadata

@@ -1,34 +1,25 @@
 --- !ruby/object:Gem::Specification 
 name: heel
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
-platform: ""
+  version: 1.0.0
+platform: ruby
 authors: 
 - Jeremy Hinegardner
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2007-11-21 00:00:00 -07:00
-default_executable: heel
+date: 2008-04-21 00:00:00 -06:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: mongrel
+  name: thin
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.0.1
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: launchy
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.3.0
+        version: 0.7.0
     version: 
 - !ruby/object:Gem::Dependency 
   name: mime-types
@@ -40,48 +31,60 @@ dependencies:
         version: "1.15"
     version: 
 - !ruby/object:Gem::Dependency 
-  name: coderay
+  name: launchy
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.7.4.215
+        version: 0.3.1
     version: 
 - !ruby/object:Gem::Dependency 
-  name: rake
+  name: coderay
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.7.3
+        version: 0.7.4.215
     version: 
-description: Heel is a mongrel based web server to quickly and easily serve up the contents of a directory as webpages.  Beyond just serving up webpages heel uses an ERB template and famfamfam icons to create useful index pages.  And to make things even easier it launches your browser for you so no cut and paste necessary.
-email: jeremy@hinegardner.org
+description: Heel is a small static web server for use when you need a quick web server for 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.  Heel is built using {Rack}[http://rack.rubyforge.org] and {Thin}[http://code.macournoyer.com/thin/]  % heel         >> Thin web server (v0.8.1 codename Rebel Porpoise) >> Threaded mode OFF >> Maximum connections set to 1024 >> Listening on 0.0.0.0:4331, CTRL+C to stop Launching your browser...  Or run it in the background  % heel --daemonize Created /Users/jeremy/.heel heel's PID (/Users/jeremy/.heel/heel.pid) and log file (/Users/jeremy/.heel/heel.log) are stored here Launching your browser at http://0.0.0.0:4331/  % heel --kill Sending TERM to process 3304 Done.
+email: jeremy at hinegardner dot org
 executables: 
 - heel
 extensions: []
 
 extra_rdoc_files: 
-- CHANGES
-- LICENSE
 - README
-files: 
-- spec/dir_handler_spec.rb
-- spec/error_handler_spec.rb
-- spec/server_spec.rb
-- spec/spec_helper.rb
-- CHANGES
+- HISTORY
 - LICENSE
-- README
-- lib/heel/dir_handler.rb
-- lib/heel/error_handler.rb
-- lib/heel/gemspec.rb
+- lib/heel/configuration.rb
+- lib/heel/directory_indexer.rb
+- lib/heel/error_response.rb
+- lib/heel/logger.rb
+- lib/heel/mime_map.rb
+- lib/heel/rackapp.rb
+- lib/heel/request.rb
+- lib/heel/server.rb
+- lib/heel/version.rb
+- lib/heel.rb
+files: 
+- bin/heel
+- lib/heel/configuration.rb
+- lib/heel/directory_indexer.rb
+- lib/heel/error_response.rb
+- lib/heel/logger.rb
+- lib/heel/mime_map.rb
+- lib/heel/rackapp.rb
+- lib/heel/request.rb
 - lib/heel/server.rb
-- lib/heel/specification.rb
 - lib/heel/version.rb
 - lib/heel.rb
+- spec/configuration_spec.rb
+- spec/directory_indexer_spec.rb
+- spec/rackapp_spec.rb
+- spec/server_spec.rb
+- spec/spec_helper.rb
 - data/css
 - data/css/coderay-cycnus.css
 - data/css/coderay-murphy.css
@@ -106,7 +109,17 @@ files:
 - data/famfamfam/readme.html
 - data/famfamfam/readme.txt
 - data/listing.rhtml
-- bin/heel
+- README
+- HISTORY
+- LICENSE
+- tasks/announce.rake
+- tasks/distribution.rake
+- tasks/documentation.rake
+- tasks/config.rb
+- tasks/rspec.rb
+- tasks/rubyforge.rb
+- tasks/utils.rb
+- gemspec.rb
 has_rdoc: true
 homepage: http://copiousfreetime.rubyforge.org/heel/
 post_install_message: 
@@ -115,15 +128,13 @@ rdoc_options:
 - --inline-source
 - --main
 - README
-- --title
-- "'heel -- A mongrel based static file webserver.'"
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: 1.8.5
+      version: "0"
   version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
@@ -137,9 +148,6 @@ rubyforge_project: copiousfreetime
 rubygems_version: 0.9.5
 signing_key: 
 specification_version: 2
-summary: A mongrel based static file webserver.
-test_files: 
-- spec/dir_handler_spec.rb
-- spec/error_handler_spec.rb
-- spec/server_spec.rb
-- spec/spec_helper.rb
+summary: Heel is a small static web server for use when you need a quick web server for a directory
+test_files: []
+

data/lib/heel/dir_handler.rb

@@ -1,310 +0,0 @@
-require 'heel'
-require 'mime/types'
-require 'erb'
-require 'coderay'
-require 'coderay/helpers/file_type'
-
-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   :highlighting
-        attr_reader   :ignore_globs
-        attr_reader   :reload_template_changes
-        attr_reader   :template
-        attr_reader   :template_mtime
-        attr_accessor :listener
-        attr_reader   :request_notify
-
-        # 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] || "/heel_icons"
-            @reload_template_changes    = options[:reload_template_changes] || false
-            @highlighting               = options[:highlighting] || 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_DATA_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))
-            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,query_params = {})
-            return 403 unless req_path.index(document_root) == 0
-            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
-                    elsif highlighting and (stat.size > 0) and not %w(false off).include? query_params['highlighting'].to_s.downcase
-                        ft = ::FileType[req_path,true]
-                        return :highlighted_file if ft and ft != :html
-                    end
-                    return req_path
-                else
-                    log "ERROR: #{req_path} is not a directory or a readable file"
-                    return 403
-                end
-
-            rescue => error
-                if error.kind_of?(Errno::ENOENT) then
-                    return 404
-                end
-                log "ERROR: Unknown, check out the backtrace"
-                log error.backtrace.join("\n")
-                return 500
-            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 }
-            res_bytes = 0
-            response.start(200) do |head,out|
-                head['Content-Type'] = 'text/html'
-                res_bytes = out.write(template.result(binding))
-            end
-            return res_bytes
-        end
-
-        
-        # send the file back with the appropriate mimetype
-        def respond_with_send_file(path,method,request,response)
-            stat    = File.stat(path)
-            header  = response.header
-            
-            header[::Mongrel::Const::LAST_MODIFIED] = stat.mtime
-            header[::Mongrel::Const::CONTENT_TYPE]  = (MIME::Types.of(path).first || default_mime_type).to_s
-            
-            response.status = 200
-            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
-            
-            return stat.size
-        end
-        
-        #
-        # send back the file marked up by code ray
-        def respond_with_highlighted_file(path,request,response)
-            res_bytes = 0
-            response.start(200) do |head,out|
-                head[::Mongrel::Const::CONTENT_TYPE] = 'text/html'
-                bytes = CodeRay.scan_file(path,:auto).html
-                res_bytes = out.write(<<-EOM)
-                <html>
-                  <head>
-                    <title>#{path}</title>
-                    <!-- CodeRay syntax highlighting CSS -->
-                    <link rel="stylesheet" href="/heel_css/coderay-cycnus.css" type="text/css" />
-                  </head>
-                  <body>
-                    <div class="CodeRay">
-                    <pre>
-#{CodeRay.scan_file(path,:auto).html({:line_numbers => :inline})}
-                     </pre>
-                    </div>
-                  </body>
-                </html>
-                EOM
-            end
-            return res_bytes
-        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,::Mongrel::HttpRequest.query_parse(request.params['QUERY_STRING']))
-                res_size = 0
-                case res_type 
-                when :directory_listing
-                    res_size = respond_with_directory_listing(req_path,request,response)
-                when :highlighted_file
-                    res_size = respond_with_highlighted_file(req_path,request,response)
-                when String
-                    res_size = 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
-            log_line = [ request.params[Mongrel::Const::REMOTE_ADDR], "-", "-", "[#{Time.now.strftime("%d/%b/%Y:%H:%M:%S %Z")}]" ]
-            log_line << "\"#{method}"
-            log_line << request.params['REQUEST_URI']
-            log_line << "#{request.params['HTTP_VERSION']}\""
-            log_line << response.status
-            log_line << res_size
-            
-            log log_line.join(' ')            
-        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