shotgun 0.6 → 0.7

data/Rakefile

@@ -2,42 +2,35 @@ require 'rake/clean'
 require 'rake/testtask'
 
 task :default => [:test]
-task :spec => :test
 
 Rake::TestTask.new(:test) do |t|
-  t.test_files = FileList['test/*_test.rb']
+  t.test_files = FileList['test/test_shotgun_*.rb']
   t.ruby_opts = ['-rubygems'] if defined? Gem
 end
 
-if defined? Gem
-  $spec = eval(File.read('shotgun.gemspec'))
-
-  def package(ext='')
-    "pkg/#{$spec.name}-#{$spec.version}#{ext}"
-  end
-
-  desc 'Build packages'
-  task :package => %w[.gem .tar.gz].map { |ext| package(ext) }
-
-  desc 'Build and install as local gem'
-  task :install => package('.gem') do
-    sh "gem install #{package('.gem')}"
-  end
-
-  directory 'pkg/'
-  CLOBBER.include('pkg')
-
-  file package('.gem') => %w[pkg/ shotgun.gemspec] + $spec.files do |f|
-    sh "gem build shotgun.gemspec"
-    mv File.basename(f.name), f.name
-  end
-
-  file package('.tar.gz') => %w[pkg/] + $spec.files do |f|
-    sh <<-SH
-      git archive \
-        --prefix=shotgun-#{$spec.version}/ \
-        --format=tar \
-        HEAD | gzip > #{f.name}
-    SH
-  end
+desc "build manual"
+task :man do
+  ENV['RONN_ORGANIZATION'] = "Shotgun #{SPEC.version}"
+  sh "ronn -5r -stoc man/*.ronn"
+end
+
+require 'rubygems'
+SPEC = eval(File.read('shotgun.gemspec'))
+PACK = "#{SPEC.name}-#{SPEC.version}"
+
+desc 'build packages'
+task :package => %W[pkg/#{PACK}.gem pkg/#{PACK}.tar.gz]
+
+directory 'pkg/'
+
+file "pkg/#{PACK}.gem" => %w[pkg/ shotgun.gemspec] + SPEC.files do |f|
+  sh "gem build shotgun.gemspec"
+  mv File.basename(f.name), f.name
+end
+
+file "pkg/#{PACK}.tar.gz" => %w[pkg/] + SPEC.files do |f|
+  sh <<-SH
+    git archive --prefix=shotgun-#{SPEC.version}/ --format=tar HEAD |
+    gzip > '#{f.name}'
+  SH
 end

data/bin/shotgun

@@ -2,16 +2,10 @@
 
 require 'optparse'
 
-begin
-  require 'thin'
-  server = 'thin'
-rescue LoadError
-  server = nil
-end
-
 env = ENV['RACK_ENV'] || 'development'
 browse = false
-options = {:Port => 9393, :Host => 'localhost', :AccessLog => [], :Path => '/'}
+public_dir = 'public' if File.directory?('public')
+options = {:Port => 9393, :Host => '127.0.0.1', :AccessLog => [], :Path => '/'}
 
 opts = OptionParser.new("", 24, '  ') { |opts|
   opts.banner = "Usage: shotgun [ruby options] [rack options] [rackup config]"
@@ -48,7 +42,7 @@ opts = OptionParser.new("", 24, '  ') { |opts|
     server = s
   }
 
-  opts.on("-o", "--host HOST", "listen on HOST (default: 0.0.0.0)") { |host|
+  opts.on("-o", "--host HOST", "listen on HOST (default: 127.0.0.1)") { |host|
     options[:Host] = host
   }
 
@@ -63,12 +57,16 @@ opts = OptionParser.new("", 24, '  ') { |opts|
   opts.separator ""
   opts.separator "Shotgun options:"
 
+  opts.on("-O", "--browse", "open browser immediately after starting") { |browse|
+    browse = true
+  }
+
   opts.on("-u", "--url URL", "specify url path (default: /)") { |url|
     options[:Path] = url
   }
 
-  opts.on("-O", "--browse", "open browser immediately after starting") { |browse|
-    browse = true
+  opts.on("-P", "--public PATH", "serve static files under PATH") { |path|
+    public_dir = path
   }
 
   opts.on_tail("-h", "--help", "show this message") do
@@ -86,12 +84,22 @@ opts = OptionParser.new("", 24, '  ') { |opts|
 }
 
 config = ARGV[0] || "config.ru"
-abort "configuration #{config} not found"  unless File.exist? config
+abort "configuration #{config} not found" unless File.exist? config
 
-if config =~ /\.ru$/ && File.read(config)[/^#\\(.*)/]
+# extract additional arguments from first #\ line in config file.
+if File.read(config)[/^#\\(.*)/]
   opts.parse! $1.split(/\s+/)
 end
 
+# use the BROWSER environment variable or fall back to a more or less standard
+# set of commands
+ENV['BROWSER'] ||=
+  %w[open xdg-open x-www-browser firefox opera mozilla netscape].find do |comm|
+    next if comm == 'open' && `uname` !~ /Darwin/
+    ENV['PATH'].split(':').any? { |dir| File.executable?("#{dir}/#{comm}") }
+  end
+ENV['RACK_ENV'] = env
+
 require 'rack'
 require 'rack/utils'
 require 'rack/request'
@@ -100,53 +108,49 @@ require 'rack/lint'
 require 'rack/commonlogger'
 require 'rack/showexceptions'
 
-unless server = Rack::Handler.get(server)
-  begin
-    server = Rack::Handler::Mongrel
-  rescue LoadError => e
-    server = Rack::Handler::WEBrick
-  end
-end
+require 'shotgun'
 
-app_wrapper =
-  lambda do |inner_app|
-    case env
-    when 'development'
-      Rack::Builder.new {
+server = Rack::Handler.get(server) || Rack::Handler.default
+app =
+  Rack::Builder.new do
+    # these middleware run in the master process.
+    use Shotgun::Static, public_dir if public_dir
+    use Shotgun::SkipFavicon
+
+    # loader forks the child and runs the embedded config followed by the
+    # application config.
+    run Shotgun::Loader.new(config) {
+      case env
+      when 'development'
         use Rack::CommonLogger, STDERR  unless server.name =~ /CGI/
         use Rack::ShowExceptions
         use Rack::Lint
-        run inner_app
-      }.to_app
-    when 'deployment', 'production'
-      Rack::Builder.new {
+      when 'deployment', 'production'
         use Rack::CommonLogger, STDERR  unless server.name =~ /CGI/
-        run inner_app
-      }.to_app
-    else
-      inner_app
-    end
+      end
+    }
   end
 
-ENV['RACK_ENV'] = env
-
-# use the BROWSER environment variable or fall back to a more or less standard
-# set of commands
-ENV['BROWSER'] ||=
-  %w[open xdg-open x-www-browser firefox opera mozilla netscape].find do |comm|
-    next if comm == 'open' && `uname` !~ /Darwin/
-    ENV['PATH'].split(':').any? { |dir| File.executable?("#{dir}/#{comm}") }
+Shotgun.enable_copy_on_write
+
+# trap exit signals
+downward = false
+['INT', 'TERM', 'QUIT'].each do |signal|
+  trap(signal) do
+    exit! if downward
+    downward = true
+    server.shutdown if server.respond_to?(:shutdown)
+    Process.wait rescue nil
+    exit!
   end
+end
 
-require 'shotgun'
-app = Shotgun.new(config, app_wrapper)
-
-base_url = "http://#{options[:Host]}:#{options[:Port]}"
-puts "== Shotgun starting #{server.to_s} at #{base_url}"
+base_url = "http://#{options[:Host]}:#{options[:Port]}#{options[:Path]}"
+puts "== Shotgun/#{server.to_s.sub(/Rack::Handler::/, '')} on #{base_url}"
 server.run app, options do |inst|
   if browse
     if ENV['BROWSER']
-      system "#{ENV['BROWSER']} '#{base_url}#{options[:Path]}'"
+      system "#{ENV['BROWSER']} '#{base_url}'"
     else
       abort "BROWSER environment variable not set and no browser detected"
     end

data/lib/shotgun.rb

@@ -1,98 +1,15 @@
 require 'rack'
-require 'rack/utils'
-require 'thread'
 
-class Shotgun
-  include Rack::Utils
-  attr_reader :rackup_file
+module Shotgun
+  autoload :Loader,      'shotgun/loader'
+  autoload :SkipFavicon, 'shotgun/favicon'
+  autoload :Static,      'shotgun/static'
 
-  def initialize(rackup_file, wrapper=nil)
-    @rackup_file = rackup_file
-    @wrapper = wrapper || lambda { |inner_app| inner_app }
-    enable_copy_on_write
+  def self.new(rackup_file, &block)
+    Loader.new(rackup_file, &block)
   end
 
-  def call(env)
-    dup.call!(env)
-  end
-
-  def call!(env)
-    @env = env
-    @reader, @writer = IO.pipe
-
-    if @child = fork
-      proceed_as_parent
-    else
-      proceed_as_child
-    end
-  end
-
-  # ==== Stuff that happens in the parent process
-
-  def proceed_as_parent
-    rand # Reseeds 
-    @writer.close
-    result = Marshal.load(@reader)
-    @reader.close
-    Process.wait(@child)
-    if result.length == 3
-      result
-    else
-      [500, {'Content-Type'=>'text/html;charset=utf-8'}, [format_error(result)]]
-    end
-  end
-
-  def format_error(result)
-    message, backtrace = result
-    "<h1>FAIL</h1><h3>#{escape_html(message)}</h3>" +
-    "<pre>#{escape_html(backtrace.join("\n"))}</pre>"
-  end
-
-  # ==== Stuff that happens in the forked child process.
-
-  def proceed_as_child
-    @reader.close
-    app = assemble_app
-    status, headers, body = app.call(@env)
-    Marshal.dump([status, headers.to_hash, slurp(body)], @writer)
-    @writer.close
-  rescue Object => boom
-    Marshal.dump(["#{boom.class.name}: #{boom.to_s}", boom.backtrace], @writer)
-  ensure
-    exit! 0
-  end
-
-  def assemble_app
-    @wrapper.call(inner_app)
-  end
-
-  def inner_app
-    if rackup_file =~ /\.ru$/
-      config = File.read(rackup_file)
-      eval "Rack::Builder.new {( #{config}\n )}.to_app", nil, rackup_file
-    else
-      require rackup_file
-      if defined? Sinatra::Application
-        Sinatra::Application.set :reload, false
-        Sinatra::Application.set :logging, false
-        Sinatra::Application.set :raise_errors, true
-        Sinatra::Application
-      else
-        Object.const_get(File.basename(rackup_file, '.rb').capitalize)
-      end
-    end
-  end
-
-  def slurp(body)
-    return body    if body.respond_to? :to_ary
-    return [body]  if body.respond_to? :to_str
-
-    buf = []
-    body.each { |part| buf << part }
-    buf
-  end
-
-  def enable_copy_on_write
+  def self.enable_copy_on_write
     GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=)
   end
 end

data/lib/shotgun/favicon.rb

@@ -0,0 +1,16 @@
+module Shotgun
+  # Responds to requests for /favicon.ico with a content free 404 and caching
+  # headers.
+  class SkipFavicon < Struct.new(:app)
+    def call(env)
+      if env['PATH_INFO'] == '/favicon.ico'
+        [404, {
+          'Content-Type'  => 'image/png',
+          'Cache-Control' => 'public, max-age=100000000000'
+        }, []]
+      else
+        app.call(env)
+      end
+    end
+  end
+end

data/lib/shotgun/loader.rb

@@ -0,0 +1,133 @@
+require 'rack/utils'
+require 'thread'
+
+module Shotgun
+  # Rack app that forks, loads the rackup config in the child process,
+  # processes a single request, and exits. The response is communicated over
+  # a unidirectional pipe.
+  class Loader
+    include Rack::Utils
+    attr_reader :rackup_file
+
+    def initialize(rackup_file, &block)
+      @rackup_file = rackup_file
+      @config = block || lambda { }
+    end
+
+    def call(env)
+      dup.call!(env)
+    end
+
+    def call!(env)
+      @env = env
+      @reader, @writer = IO.pipe
+
+      if @child = fork
+        proceed_as_parent
+      else
+        proceed_as_child
+      end
+    end
+
+    ##
+    # Stuff that happens in the parent process
+
+    def proceed_as_parent
+      @writer.close
+      rand
+      result, status, headers = Marshal.load(@reader)
+      body = Body.new(@child, @reader)
+      case result
+      when :ok
+        [status, headers, body]
+      when :error
+        error, backtrace = status, headers
+        body.close
+        [
+          500,
+          {'Content-Type'=>'text/html;charset=utf-8'},
+          [format_error(error, backtrace)]
+        ]
+      else
+        fail "unexpected response: #{result.inspect}"
+      end
+    end
+
+    class Body < Struct.new(:pid, :fd)
+      def each
+        while chunk = fd.read(1024)
+          yield chunk
+        end
+      end
+
+      def close
+        fd.close
+      ensure
+        Process.wait(pid)
+      end
+    end
+
+    def format_error(error, backtrace)
+      "<h1>Boot Error</h1>" +
+      "<p>Something went wrong while loading <tt>#{escape_html(rackup_file)}</tt></p>" +
+      "<h3>#{escape_html(error)}</h3>" +
+      "<pre>#{escape_html(backtrace.join("\n"))}</pre>"
+    end
+
+    ##
+    # Stuff that happens in the child process
+
+    def proceed_as_child
+      boom = false
+      @reader.close
+      status, headers, body = assemble_app.call(@env)
+      Marshal.dump([:ok, status, headers.to_hash], @writer)
+      spec_body(body).each { |chunk| @writer.write(chunk) }
+    rescue Object => boom
+      Marshal.dump([
+        :error,
+        "#{boom.class.name}: #{boom.to_s}",
+        boom.backtrace
+      ], @writer)
+    ensure
+      @writer.close
+      exit! boom ? 1 : 0
+    end
+
+    def assemble_app
+      config = @config
+      inner_app = self.inner_app
+      Rack::Builder.new {
+        instance_eval(&config)
+        run inner_app
+      }.to_app
+    end
+
+    def inner_app
+      if rackup_file =~ /\.ru$/
+        config = File.read(rackup_file)
+        eval "Rack::Builder.new {( #{config}\n )}.to_app", nil, rackup_file
+      else
+        require rackup_file
+        if defined? Sinatra::Application
+          Sinatra::Application.set :reload, false
+          Sinatra::Application.set :logging, false
+          Sinatra::Application.set :raise_errors, true
+          Sinatra::Application
+        else
+          Object.const_get(File.basename(rackup_file, '.rb').capitalize)
+        end
+      end
+    end
+
+    def spec_body(body)
+      if body.respond_to? :to_str
+        [body]
+      elsif body.respond_to?(:each)
+        body
+      else
+        fail "body must respond to #each"
+      end
+    end
+  end
+end

data/lib/shotgun/static.rb

@@ -0,0 +1,20 @@
+require 'rack/file'
+
+module Shotgun
+  # Serves static files out of the specified directory.
+  class Static
+    def initialize(app, public_dir='./public')
+      @file = Rack::File.new(public_dir)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @file.call(env)
+      if status > 400
+        @app.call(env)
+      else
+        [status, headers, body]
+      end
+    end
+  end
+end

data/man/index.txt

@@ -0,0 +1,6 @@
+ruby(1)    http://man.cx/ruby
+
+# other resources
+rack       http://rack.rubyforge.org/doc/README.html
+rack-spec  http://rack.rubyforge.org/doc/SPEC.html
+sinatra    http://www.sinatrarb.com/

data/man/shotgun.1.ronn

@@ -0,0 +1,134 @@
+shotgun(1) -- reloading rack development server
+===============================================
+
+## SYNOPSIS
+
+`shotgun` [<options>] [<rackup-file>]
+
+## DESCRIPTION
+
+**Shotgun** is a simple process-per-request [Rack][] server designed for use in
+development environments. Each time a request is received, `shotgun` forks,
+loads the <rackup-file>, processes a single request and exits.  The result is
+application-wide reloading of all configuration, source files, and templates
+without the need for complex application-level reloading logic.
+
+When no <rackup-file> is given, `shotgun` uses the `config.ru` file in the
+current working directory.
+
+## OPTIONS
+
+Shotgun runs at `http://127.0.0.1:9393` by default. The following options
+control server behavior:
+
+ * `-E`, `--env`=<environment>:
+   Sets the `RACK_ENV` environment variable to <environment> and selects
+   the default set of utility middleware. When <environment> is 'development',
+   shotgun inserts the `Rack::Lint` and `Rack::CommonLogger` middleware
+   components; when <environment> is 'production' or 'deployed',
+   `Rack::CommonLogger` is inserted; otherwise, no utility middleware are
+   inserted.
+
+ * `-P`, `--public`=<path>:
+   Serve requests for static files that exist under <path> from the shotgun
+   master process without forking a worker process. This option is
+   automatically enabled when a `./public` directory is detected, but can be
+   configured explicitly for non-conventional static file directory locations.
+
+   Setting this option appropriately can severely improve overall page load
+   times for applications with many static assets.
+
+ * `-s`, `--server`=<mongrel>|<webrick>|<thin>|<other>:
+   The Rack server handler implementation used to serve requests. Supported
+   values include: `mongrel`, `webrick`, and `thin`. By default, shotgun first
+   tries to use `mongrel` and falls back to `webrick` if mongrel is not
+   available.
+
+ * `-o`, `--host`=<addr>:
+   The hostname or address of the interface the HTTP server should bind to.
+   Default: `127.0.0.1`.
+
+ * `-p`, `--port`=<port>:
+   The port the HTTP server should bind to. Default: `9393`.
+
+ * `-O`, `--browse`:
+   Open browser at http://<host>:<port>/ immediately after the server
+   is started.
+
+Ruby environment related options:
+
+ * `-e`, `--eval` <command>:
+   Evaluate arbitrary <command> within the Ruby interpreter. <command> is
+   evaluated as program arguments are parsed. Multiple `-e` arguments are
+   allowed.
+
+ * `-d`, `--debug`:
+   Turns on debug mode. `$DEBUG` will be set `true`.
+
+ * `-w`, `--warn`:
+   Enable verbose mode without printing version message at the beginning. It
+   sets the `$VERBOSE` variable to true.
+
+ * `-I`, `--include` <path>:
+   Add <path> to the Ruby load path (`$LOAD_PATH`). May be used more than once.
+
+ * `-r`, `--require` <library>:
+   Require <library> before loading the application and starting the server.
+
+Miscellaneous:
+
+ * `-h`, `--help`:
+   Show usage message and exit.
+
+ * `--version`:
+   Show the Rack version and exit.
+
+## INSTALLING
+
+Shotgun is distributed as a gem package at rubygems.org:
+
+<http://rubygems.org/gems/shotgun><br>
+`gem install shotgun`
+
+The `rack` package is required. The `mongrel` package is recommended.
+
+## CONTRIBUTING
+
+Fork and report issues at github.com:
+
+<http://github.com/rtomayko/shotgun/><br>
+`git clone git://github.com/rtomayko/shotgun.git`
+
+## VERSION HISTORY
+
+### Version 0.7 (unreleased)
+
+ * <http://github.com/rtomayko/shotgun/compare/0.6...master>
+
+ * Static files now served from the shotgun master process, making
+   shotgun tolerable for apps with many/unbundled static assets.
+
+ * Added `--public` (`-P`) for specifying a non-standard root / public
+   directory.
+
+ * Response bodies are now streamed over the master &lt; worker pipe
+   instead of being marshalled. Improves performance with large response
+   bodies, and reduces shotgun master process RES usage.
+
+ * GET /favicon.ico requests are served an empty response by the shotgun
+   master process. Prevents the need to fork a worker process.
+
+ * `INT`, `TERM`, `QUIT` now properly trigger server shutdown. The second
+   `INT`, `TERM`, `QUIT` causes the master process to exit hard.
+
+ * Non `.ru` config files (e.g., sinatra app files) may now define command
+   line options in the same way as `.ru` files: by including a
+   `#\ -p 5555 ...` line.
+
+### Versions &lt; 0.7 (2009-2010)
+
+ * <http://github.com/rtomayko/shotgun/commits/0.6>
+
+## SEE ALSO
+
+ruby(1)

data/shotgun.gemspec

@@ -1,34 +1,40 @@
 Gem::Specification.new do |s|
-  s.specification_version = 2 if s.respond_to? :specification_version=
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-
   s.name = 'shotgun'
-  s.version = '0.6'
-  s.date = '2010-01-28'
+  s.version = '0.7'
+  s.date = '2010-06-22'
 
-  s.description = "Because reloading sucks."
+  s.description = "reloading rack development server"
   s.summary     = s.description
 
   s.authors = ["Ryan Tomayko"]
-  s.email = "r@tomayko.com"
+  s.email = "rtomayko@gmail.com"
 
   s.files = %w[
-    README
     COPYING
+    README
     Rakefile
-    shotgun.gemspec
-    lib/shotgun.rb
     bin/shotgun
-    test/shotgun_test.rb
+    lib/shotgun.rb
+    lib/shotgun/favicon.rb
+    lib/shotgun/loader.rb
+    lib/shotgun/static.rb
+    man/index.txt
+    man/shotgun.1.ronn
+    shotgun.gemspec
+    test/big.ru
+    test/boom.ru
+    test/slow.ru
+    test/test-sinatra.ru
     test/test.ru
+    test/test_shotgun_loader.rb
+    test/test_shotgun_static.rb
   ]
   s.executables = ['shotgun']
-  s.test_files = ['test/shotgun_test.rb']
+  s.test_files = s.files.select { |f| f =~ /test_shotgun.*rb/ }
 
   s.extra_rdoc_files = %w[README]
-  s.add_dependency 'rack',    '>= 0.9.1'
+  s.add_dependency 'rack',    '>= 1.0'
 
-  s.homepage = "http://github.com/rtomayko/shotgun/"
+  s.homepage = "http://rtomayko.github.com/shotgun/"
   s.require_paths = %w[lib]
-  s.rubygems_version = '1.1.1'
 end

data/test/big.ru

@@ -0,0 +1,15 @@
+class BigResponse
+  def call(env)
+    [200, {'Content-Type'=>'text/html'}, self]
+  end
+
+  def each
+    yield "<pre>"
+    1024.times do
+      yield(('.' * 1023) + "\n")
+    end
+    yield "</pre>"
+  end
+end
+
+run BigResponse.new

data/test/boom.ru

@@ -0,0 +1,4 @@
+require 'rack'
+
+use Rack::Lock
+run lambda { |env| fail 'boom' }

data/test/slow.ru

@@ -0,0 +1,16 @@
+class SlowResponse
+  def call(env)
+    [200, {'Content-Type'=>'text/html'}, self]
+  end
+
+  def each
+    yield "<pre>"
+    10.times do
+      yield('.' * 10) + "\n")
+      sleep 0.5
+    end
+    yield "</pre>"
+  end
+end
+
+run SlowResponse.new

data/test/test-sinatra.ru

@@ -0,0 +1,14 @@
+require 'sinatra'
+
+set :logging, false
+
+get '/' do
+  puts 'hello world'
+  "Hello World"
+end
+
+get '/boom' do
+  fail 'boom'
+end
+
+run Sinatra::Application

data/test/test_shotgun_loader.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'rack/mock'
+require 'shotgun'
+
+class ShotgunLoaderTest < Test::Unit::TestCase
+  def rackup_file(name)
+    "#{File.dirname(__FILE__)}/#{name}"
+  end
+
+  def test_knows_the_rackup_file
+    file = rackup_file('test.ru')
+    shotgun = Shotgun::Loader.new(file)
+    assert_equal file, shotgun.rackup_file
+  end
+
+  def test_processes_requests
+    file = rackup_file('test.ru')
+    shotgun = Shotgun::Loader.new(file)
+    request = Rack::MockRequest.new(shotgun)
+    res = request.get("/")
+    assert_equal 200, res.status
+    assert_equal "BANG!", res.body
+    assert_equal "text/plain", res.headers['Content-Type']
+  end
+
+  def test_processes_large_requests
+    file = rackup_file('big.ru')
+    shotgun = Shotgun::Loader.new(file)
+    request = Rack::MockRequest.new(shotgun)
+    res = request.get("/")
+    assert_equal 200, res.status
+    assert res.body =~ %r|<pre>(?:.{1023}\n){1024}</pre>|,
+      "body of size #{res.body.size} does not match expected output"
+  end
+end

data/test/test_shotgun_static.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'rack/mock'
+require 'shotgun'
+
+class ShotgunStaticTest < Test::Unit::TestCase
+  def setup
+    @app = lambda { |env| [200,{'Content-Type'=>'text/plain'}, ['holla']] }
+    @public = File.dirname(__FILE__)
+  end
+
+  def test_serving_files
+    static = Shotgun::Static.new(@app, @public)
+    request = Rack::MockRequest.new(static)
+    res = request.get("/big.ru")
+    assert_equal 200, res.status
+    assert_equal File.size("#{@public}/big.ru"), res.body.size
+  end
+
+  def test_cascading_when_file_not_found
+    static = Shotgun::Static.new(@app, @public)
+    request = Rack::MockRequest.new(static)
+    res = request.get("/does-not-exist")
+    assert_equal 200, res.status
+    assert_equal 'holla', res.body
+  end
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: shotgun
 version: !ruby/object:Gem::Version 
-  version: "0.6"
+  hash: 5
+  prerelease: false
+  segments: 
+  - 0
+  - 7
+  version: "0.7"
 platform: ruby
 authors: 
 - Ryan Tomayko
@@ -9,21 +14,26 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-28 00:00:00 -08:00
+date: 2010-06-22 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rack
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.1
-    version: 
-description: Because reloading sucks.
-email: r@tomayko.com
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+description: reloading rack development server
+email: rtomayko@gmail.com
 executables: 
 - shotgun
 extensions: []
@@ -31,16 +41,26 @@ extensions: []
 extra_rdoc_files: 
 - README
 files: 
-- README
 - COPYING
+- README
 - Rakefile
-- shotgun.gemspec
-- lib/shotgun.rb
 - bin/shotgun
-- test/shotgun_test.rb
+- lib/shotgun.rb
+- lib/shotgun/favicon.rb
+- lib/shotgun/loader.rb
+- lib/shotgun/static.rb
+- man/index.txt
+- man/shotgun.1.ronn
+- shotgun.gemspec
+- test/big.ru
+- test/boom.ru
+- test/slow.ru
+- test/test-sinatra.ru
 - test/test.ru
+- test/test_shotgun_loader.rb
+- test/test_shotgun_static.rb
 has_rdoc: true
-homepage: http://github.com/rtomayko/shotgun/
+homepage: http://rtomayko.github.com/shotgun/
 licenses: []
 
 post_install_message: 
@@ -49,23 +69,30 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
-specification_version: 2
-summary: Because reloading sucks.
+specification_version: 3
+summary: reloading rack development server
 test_files: 
-- test/shotgun_test.rb
+- test/test_shotgun_loader.rb
+- test/test_shotgun_static.rb

data/test/shotgun_test.rb

@@ -1,22 +0,0 @@
-require 'test/unit'
-require 'rack/mock'
-require 'shotgun'
-
-class ShotgunTest < Test::Unit::TestCase
-  def setup
-    @rackup_file = "#{File.dirname(__FILE__)}/test.ru"
-    @shotgun = Shotgun.new(@rackup_file)
-  end
-
-  def test_knows_the_rackup_file
-    assert_equal @rackup_file, @shotgun.rackup_file
-  end
-
-  def test_processes_requests
-    request = Rack::MockRequest.new(@shotgun)
-    res = request.get("/")
-    assert_equal 200, res.status
-    assert_equal "BANG!", res.body
-    assert_equal "text/plain", res.headers['Content-Type']
-  end
-end