shotgun 0.1

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Ryan Tomayko <tomayko.com/about>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,46 @@
+                                    Shotgun
+
+This is an automatic reloading version of the rackup command that's shipped with
+Rack. It can be used as an alternative to the complex reloading logic provided
+by web frameworks or in environments that don't support application reloading.
+
+The shotgun command starts one of Rack's supported servers (e.g., mongrel, thin,
+webrick) and listens for requests but does not load any part of the actual
+application. Each time a request is received, it forks, loads the application in
+the child process, processes the request, and exits the child process. The
+result is clean, application-wide reloading of all source files and templates on
+each request.
+
+Usage
+-----
+
+Installation:
+
+    gem install shotgun
+
+Starting a server with a rackup file:
+
+    shotgun config.ru
+
+Using Thin and starting on port 6000 instead of 9393 (default):
+
+    shotgun --server=thin --port=6000 config.ru
+
+Running Sinatra apps:
+
+    shotgun hello.rb
+
+See 'shotgun --help' for more advanced usage.
+
+Links
+-----
+
+Shotgun:       http://github.com/rtomayko/shotgun
+Rack:          http://rack.rubyforge.org/
+Sinatra:       http://www.sinatrarb.com/
+
+The reloading system in Ian Bicking's webware framework served as inspiration
+for the approach taken in Shotgun. Ian lays down the pros and cons of this
+approach in the following article:
+
+http://ianbicking.org/docs/Webware_reload.html

data/Rakefile

@@ -0,0 +1,56 @@
+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.ruby_opts = ['-rubygems'] if defined? Gem
+end
+
+$spec =
+  begin
+    require 'rubygems/specification'
+    data = File.read('shotgun.gemspec')
+    spec = nil
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+    spec
+  end
+
+def package(ext='')
+  "pkg/#{$spec.name}-#{$spec.version}" + ext
+end
+
+desc 'Build packages'
+task :package => %w[.gem .tar.gz].map { |e| package(e) }
+
+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/ #{$spec.name}.gemspec] + $spec.files do |f|
+  sh "gem build #{$spec.name}.gemspec"
+  mv File.basename(f.name), f.name
+end
+
+file package('.tar.gz') => %w[pkg/] + $spec.files do |f|
+  sh <<-SH
+    git archive \
+      --prefix=#{$spec.name}-#{$spec.version}/ \
+      --format=tar \
+      HEAD | gzip > #{f.name}
+  SH
+end
+
+desc 'Publish gem and tarball to rubyforge'
+task 'publish:gem' => [package('.gem'), package('.tar.gz')] do |t|
+  sh <<-end
+    rubyforge add_release wink #{$spec.name} #{$spec.version} #{package('.gem')} &&
+    rubyforge add_file    wink #{$spec.name} #{$spec.version} #{package('.tar.gz')}
+  end
+end

data/bin/shotgun

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+
+libdir = "#{File.dirname(File.dirname(__FILE__))}/lib"
+$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
+
+require 'optparse'
+
+automatic = false
+server = nil
+env = ENV['RACK_ENV'] || 'development'
+daemonize = false
+pid = nil
+options = {:Port => 9393, :Host => "0.0.0.0", :AccessLog => []}
+
+opts = OptionParser.new("", 24, '  ') { |opts|
+  opts.banner = "Usage: shotgun [ruby options] [rack options] [rackup config]"
+
+  opts.separator ""
+  opts.separator "Ruby options:"
+
+  lineno = 1
+  opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
+    eval line, TOPLEVEL_BINDING, "-e", lineno
+    lineno += 1
+  }
+
+  opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
+    $DEBUG = true
+  }
+  opts.on("-w", "--warn", "turn warnings on for your script") {
+    $-w = true
+  }
+
+  opts.on("-I", "--include PATH",
+          "specify $LOAD_PATH (may be used more than once)") { |path|
+    $LOAD_PATH.unshift(*path.split(":"))
+  }
+
+  opts.on("-r", "--require LIBRARY",
+          "require the library, before executing your script") { |library|
+    require library
+  }
+
+  opts.separator ""
+  opts.separator "Rack options:"
+  opts.on("-s", "--server SERVER", "server (webrick, mongrel, thin, etc.)") { |s|
+    server = s
+  }
+
+  opts.on("-o", "--host HOST", "listen on HOST (default: 0.0.0.0)") { |host|
+    options[:Host] = host
+  }
+
+  opts.on("-p", "--port PORT", "use PORT (default: 9393)") { |port|
+    options[:Port] = port
+  }
+
+  opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development)") { |e|
+    env = e
+  }
+
+  opts.separator ""
+  opts.separator "Common options:"
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("--version", "Show version") do
+    require 'rack'
+    puts "Rack #{Rack.version}"
+    exit
+  end
+
+  opts.parse! ARGV
+}
+
+config = ARGV[0] || "config.ru"
+abort "configuration #{config} not found"  unless File.exist? config
+
+if config =~ /\.ru$/ && File.read(config)[/^#\\(.*)/]
+  opts.parse! $1.split(/\s+/)
+end
+
+require 'rack'
+
+unless server = Rack::Handler.get(server)
+  begin
+    server = Rack::Handler::Mongrel
+  rescue LoadError => e
+    server = Rack::Handler::WEBrick
+  end
+end
+
+app_wrapper =
+  lambda do |inner_app|
+    if env == 'development'
+      Rack::Builder.new {
+        use Rack::ShowExceptions
+        use Rack::Lint
+        run inner_app
+      }.to_app
+    else
+      inner_app
+    end
+  end
+
+ENV['RACK_ENV'] = env
+
+require 'shotgun'
+app = Shotgun.new(config, app_wrapper)
+
+server.run app, options do |inst|
+  puts "== Shotgun starting #{server.to_s} on #{options[:Host]}:#{options[:Port]}"
+end

data/lib/shotgun.rb

@@ -0,0 +1,82 @@
+require 'rack'
+require 'thread'
+
+class Shotgun
+  attr_reader :rackup_file
+
+  def initialize(rackup_file, wrapper=nil)
+    @rackup_file = rackup_file
+    @wrapper = wrapper || lambda { |inner_app| inner_app }
+  end
+
+  def call(env)
+    dup.call!(env)
+  end
+
+  def call!(env)
+    @env = env
+    @reader, @writer = IO.pipe
+
+    # Disable GC before forking in an attempt to get some advantage
+    # out of COW.
+    GC.disable
+
+    if fork
+      proceed_as_parent
+    else
+      proceed_as_child
+    end
+
+  ensure
+    GC.enable
+  end
+
+  # ==== Stuff that happens in the parent process
+
+  def proceed_as_parent
+    @writer.close
+    status, headers, body = Marshal.load(@reader)
+    @reader.close
+    Process.wait
+    [status, headers, body]
+  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
+    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
+      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
+end

data/shotgun.gemspec

@@ -0,0 +1,33 @@
+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.1'
+  s.date = '2009-02-20'
+
+  s.description = "Because reloading sucks."
+  s.summary     = s.description
+
+  s.authors = ["Ryan Tomayko"]
+  s.email = "r@tomayko.com"
+
+  s.files = %w[
+    README
+    COPYING
+    Rakefile
+    shotgun.gemspec
+    lib/shotgun.rb
+    bin/shotgun
+  ]
+  s.executables = ['shotgun']
+  s.test_files = s.files.select {|path| path =~ /^test\/.*_test.rb/}
+
+  s.extra_rdoc_files = %w[README]
+  s.add_dependency 'rack', '>= 0.9.1', '< 1.0'
+
+  s.homepage = "http://github.com/rtomayko/shotgun/"
+  s.require_paths = %w[lib]
+  s.rubyforge_project = 'wink'
+  s.rubygems_version = '1.1.1'
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: shotgun
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Ryan Tomayko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-20 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.1
+    - - <
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+description: Because reloading sucks.
+email: r@tomayko.com
+executables: 
+- shotgun
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- COPYING
+- Rakefile
+- shotgun.gemspec
+- lib/shotgun.rb
+- bin/shotgun
+has_rdoc: false
+homepage: http://github.com/rtomayko/shotgun/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: wink
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Because reloading sucks.
+test_files: []
+