reel 0.4.0.pre2 → 0.4.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c139c2fa0dcd5e9456cb8867fbe296eddc1c9f6
-  data.tar.gz: 0ba97001f92ac212ba4184ba5059580e0e124245
+  metadata.gz: a7fd599c0341fa3bf5d015b4425c5edebabdfa82
+  data.tar.gz: 180dc3111577c86b2f255afb2ad95f0596db318b
 SHA512:
-  metadata.gz: 02cfe9e2b456d5f6abb5c7810df4d6133ef5a1acfb49917de65f245d6bfadfe48c525b527ed060348ff8b306c071ac6714fa274c47aef693e08d79330aa639d9
-  data.tar.gz: a9ebba27cce7485bae2ae2236311d5fe43e59fc8e2d03c2d3b5a2f2ca4b728b6cccf430b6962d6abad639b614da846b1367c0880095cae2e420cbdf91bbefedf
+  metadata.gz: 8d53b5db5d246d04c2a22880d52816838485a7c71c9597a55724e69a265c1175308136800ad52e458d6969bf4794d8f9390e0754d5f1ecca11658bca6e34f724
+  data.tar.gz: 967895df5e03fdf13b70d9521f92dec8f3591c8681eeb692253592023c5216363a7d1baa6893dcbd0f23b8b3f44775c51006d220001f2fef067b83170c207989

data/CHANGES.md

@@ -1,5 +1,6 @@
-0.4.0.pre2
+0.4.0.pre3
 ----------
+* Rack adapter moved to the reel-rack project
 * Pipelining support
 * Reel::Connection#each_request for iterating through keep-alive requests
 * Reel::Request#body now returns a Reel::RequestBody object instead of a String
@@ -9,6 +10,8 @@
 * Allow Reel to stop cleanly
 * Remove `on_error` callback system
 * Increase buffer size
+* Remove Reel::App (unmaintained, sorry)
+* Reel::CODENAME added (presently "Garbo")
 
 0.3.0
 -----

data/README.md

@@ -6,7 +6,7 @@
 [![Code Climate](https://codeclimate.com/github/celluloid/reel.png)](https://codeclimate.com/github/celluloid/reel)
 [![Coverage Status](https://coveralls.io/repos/celluloid/reel/badge.png?branch=master)](https://coveralls.io/r/celluloid/reel)
 
-> "A dizzying lifetime... reeling by on Celluloid" _-- Rush / Between The Wheels_
+> "A dizzying lifetime... reeling by on celluloid" _-- Rush / Between The Wheels_
 
 Reel is a fast, non-blocking "evented" web server built on [http_parser.rb][parser],
 [websocket_parser][websockets], [Celluloid::IO][celluloidio], and [nio4r][nio4r]. Thanks
@@ -65,8 +65,9 @@ API
 
 *NOTE: these examples are for the Reel 0.4.0.pre2 API*
 
-Reel also provides a "bare metal" API which was used in the benchmarks above.
-Here are some examples:
+Reel aims to provide a "bare metal" API that other frameworks (such as Rack
+and Webmachine) can leverage. This API can also be nice in performance critical
+applications.
 
 ### Block Form
 
@@ -139,22 +140,9 @@ Framework Adapters
 
 ### Rack
 
-Reel can be used as a standard Rack server via the "reel" command line
-application. Please be aware that Rack support is experimental and that there
-are potential complications between using large numbers of rack middlewares
-and the limited 4kB stack depth of Ruby Fibers, which are used extensively
-by Celluloid. In addition, the Rack specification mandates that request bodies
-are rewindable, which prevents streaming request bodies as the spec dictates
-they must be written to disk.
+A Rack adapter for Reel is available at:
 
-To run `.ru` file using Reel w/ 16 workers
-
-```
-rackup -p 1234 -s reel config.ru -Enone -O "workers=16" 
-```
-
-To really leverage Reel's capabilities, you must use Reel via its own API,
-or another Ruby library with direct Reel support.
+https://github.com/celluloid/reel-rack
 
 ### Webmachine
 

data/examples/hello_world.rb

@@ -9,13 +9,14 @@ addr, port = '127.0.0.1', 1234
 
 puts "*** Starting server on #{addr}:#{port}"
 Reel::Server.run(addr, port) do |connection|
-  # To use keep-alive with Reel, use a while loop that repeatedly calls
-  # connection.request and consumes connection objects
-  while request = connection.request
+  # For keep-alive support
+  connection.each_request do |request|
     # Ordinarily we'd route the request here, e.g.
     # route request.url
-    connection.respond :ok, "hello, world!"
+    request.respond :ok, "hello, world!"
   end
 
-  # Reel takes care of closing the connection
+  # Reel takes care of closing the connection for you
+  # If you would like to hand the connection off to another thread or actor,
+  # use, connection.detach and then manually call connection.close when done
 end

data/examples/ssl_hello_world.rb

@@ -13,15 +13,16 @@ options = {
 
 puts "*** Starting server on #{addr}:#{port}"
 Reel::SSLServer.supervise(addr, port, options) do |connection|
-  # To use keep-alive with Reel, use a while loop that repeatedly calls
-  # connection.request and consumes connection objects
-  while request = connection.request
+  # For keep-alive support
+  connection.each_request do |request|
     # Ordinarily we'd route the request here, e.g.
     # route request.url
-    connection.respond :ok, "hello, world!"
+    request.respond :ok, "hello, world!"
   end
 
-  # Reel takes care of closing the connection
+  # Reel takes care of closing the connection for you
+  # If you would like to hand the connection off to another thread or actor,
+  # use, connection.detach and then manually call connection.close when done
 end
 
-sleep
+sleep

data/lib/reel.rb

@@ -22,11 +22,6 @@ require 'reel/ssl_server'
 require 'reel/websocket'
 require 'reel/stream'
 
-require 'rack'
-require 'rack/handler'
-require 'rack/handler/reel'
-require 'reel/rack_worker'
-
 # A Reel good HTTP server
 module Reel
 

data/lib/reel/request.rb

@@ -5,7 +5,7 @@ module Reel
     extend Forwardable
     include RequestMixin
 
-    def_delegators :@connection, :<<, :write, :respond, :finish_response
+    def_delegators :@connection, :<<, :write, :remote_addr, :respond, :finish_response
     attr_reader :body
 
     # request_info is a RequestInfo object including the headers and

data/lib/reel/request_info.rb

@@ -12,14 +12,6 @@ module Reel
     UPGRADE   = 'Upgrade'.freeze
     WEBSOCKET = 'websocket'.freeze
 
-    # Array#include? seems slow compared to Hash lookup
-    request_methods = Http::METHODS.map { |m| m.to_s.upcase }
-    REQUEST_METHODS = Hash[request_methods.zip(request_methods)].freeze
-
-    def method
-      REQUEST_METHODS[http_method]
-    end
-
     def websocket_request?
       headers[UPGRADE] && headers[UPGRADE].downcase == WEBSOCKET
     end

data/lib/reel/version.rb

@@ -1,3 +1,4 @@
 module Reel
-  VERSION = "0.4.0.pre2"
+  VERSION  = "0.4.0.pre3"
+  CODENAME = "Garbo"
 end

data/reel.gemspec

@@ -17,12 +17,10 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency 'celluloid',        '>= 0.14.1'
   gem.add_runtime_dependency 'celluloid-io',     '>= 0.14.1'
-  gem.add_runtime_dependency 'http',             '>= 0.2.0'
+  gem.add_runtime_dependency 'http',             '>= 0.5.0.pre'
   gem.add_runtime_dependency 'http_parser.rb',   '>= 0.6.0.beta.2'
   gem.add_runtime_dependency 'websocket_parser', '>= 0.1.4'
-  gem.add_runtime_dependency 'rack',             '>= 1.4.0'
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'octarine'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reel
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre2
+  version: 0.4.0.pre3
 platform: ruby
 authors:
 - Tony Arcieri
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.5.0.pre
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.5.0.pre
 - !ruby/object:Gem::Dependency
   name: http_parser.rb
   requirement: !ruby/object:Gem::Requirement
@@ -80,20 +80,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 0.1.4
-- !ruby/object:Gem::Dependency
-  name: rack
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -122,25 +108,10 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: octarine
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 description: A Celluloid::IO-powered HTTP server
 email:
 - tony.arcieri@gmail.com
-executables:
-- reel
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -156,26 +127,16 @@ files:
 - Rakefile
 - benchmarks/hello_goliath.rb
 - benchmarks/hello_node.js
-- benchmarks/hello_rack.ru
 - benchmarks/hello_reel.rb
-- bin/reel
 - examples/chunked.rb
 - examples/hello_world.rb
 - examples/roundtrip.rb
-- examples/server-sent-events.rb
 - examples/ssl_hello_world.rb
-- examples/stream.rb
-- examples/websocket-wall.rb
-- examples/websocket.ru
-- examples/websocket_rack.sh
 - examples/websockets.rb
-- lib/rack/handler/reel.rb
 - lib/reel.rb
-- lib/reel/app.rb
 - lib/reel/connection.rb
 - lib/reel/logger.rb
 - lib/reel/mixins.rb
-- lib/reel/rack_worker.rb
 - lib/reel/request.rb
 - lib/reel/request_body.rb
 - lib/reel/request_info.rb
@@ -195,9 +156,7 @@ files:
 - spec/fixtures/example.txt
 - spec/fixtures/server.crt
 - spec/fixtures/server.key
-- spec/reel/app_spec.rb
 - spec/reel/connection_spec.rb
-- spec/reel/rack_worker_spec.rb
 - spec/reel/response_spec.rb
 - spec/reel/server_spec.rb
 - spec/reel/ssl_server_spec.rb
@@ -233,9 +192,7 @@ test_files:
 - spec/fixtures/example.txt
 - spec/fixtures/server.crt
 - spec/fixtures/server.key
-- spec/reel/app_spec.rb
 - spec/reel/connection_spec.rb
-- spec/reel/rack_worker_spec.rb
 - spec/reel/response_spec.rb
 - spec/reel/server_spec.rb
 - spec/reel/ssl_server_spec.rb

data/benchmarks/hello_rack.ru

@@ -1,5 +0,0 @@
-# Run with: thin -e production -R hello_rack.ru start
-require 'rack'
-
-body = "Hello World"
-run proc { |env| [200, {}, body] }

data/bin/reel

@@ -1,65 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'reel'
-require 'optparse'
-
-options = {
-  rackup: "config.ru"
-}
-
-parser = OptionParser.new do |opts|
-  opts.on "-p", "--port PORT", Integer,
-  "Define what port TCP port to bind to (default: 3000)" do |arg|
-    options[:port] = arg
-  end
-
-  opts.on "-a", "--address HOST",
-  "bind to HOST address (default: 0.0.0.0)" do |arg|
-    options[:host] = arg
-  end
-
-  opts.on "-q", "--quiet", "Quiet down the output" do
-    options[:quiet] = true
-  end
-
-  opts.on "-e", "--environment ENVIRONMENT",
-  "The environment to run the Rack app on (default: development)" do |arg|
-    options[:environment] = arg
-  end
-
-  opts.on "-t", "--threads NUM", Integer,
-  "The number of worker threads (default: 10)" do |arg|
-    options[:workers] = arg
-  end
-
-  opts.on "-r", "--rackup FILE",
-  "Load Rack config from this file (default: config.ru)" do |arg|
-    options[:rackup] = arg
-  end
-end
-
-parser.banner = "reel <options> <rackup file>"
-
-parser.on_tail "-h", "--help", "Show help" do
-  puts parser
-  exit 1
-end
-
-parser.parse!(ARGV)
-
-if ARGV.last =~ /\.ru$/
-  options[:rackup] = ARGV.shift
-end
-
-unless File.exists?(options[:rackup])
-  abort "No rackup found at #{options[:rackup]}"
-end
-
-handler = Rack::Handler::Reel.new(options)
-
-Reel::Logger.info "A Reel good HTTP server!"
-Reel::Logger.info "Listening on #{handler[:host]}:#{handler[:port]}"
-
-handler.start
-
-sleep

data/examples/server-sent-events.rb

@@ -1,65 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'reel'
-require 'reel/app'
-
-class ServerSideEvents
-  include Reel::App
-
-  def initialize(host, port)
-    super
-    @connections = []
-    @body = DATA.read
-  end
-
-  get '/' do
-    [200, {'Content-Type' => 'text/html'}, @body]
-  end
-
-  get '/subscribe' do
-    Celluloid.logger.info "subscribing a client"
-    body = Reel::EventStream.new do |socket|
-      @connections << socket
-    end
-    Celluloid.logger.info "subscribing a client"
-    [200, {'Content-Type' => 'text/event-stream'}, body]
-  end
-
-  get '/wall/:rest' do |request|
-    deliver request.path.rest
-  end
-
-  get '/wall' do
-    deliver Time.now.to_s
-  end
-
-  def deliver(msg)
-    Celluloid.logger.info "sending a message to clients: #{msg.inspect}"
-    @connections.each do |s|
-      begin
-        s.data(msg)
-      rescue SocketError
-        @connections.delete(s)
-      end
-    end
-
-    [200, {'Content-Type' => 'text/html'}, "Sent \"#{msg}\" to #{@connections.size} clients"]
-  end
-end
-
-ServerSideEvents.new("0.0.0.0", 9292)
-sleep
-
-__END__
-<!doctype html>
-<html lang="en">
-<body>
-  <div id="content">Waiting for messages...</div>
-</body>
-<script type="text/javascript">
-var evs = new EventSource('/subscribe');
-evs.onmessage = function(e){
-  document.getElementById('content').innerHTML = e.data;
-}
-</script>
-</html>

data/examples/stream.rb

@@ -1,28 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'reel'
-require 'reel/app'
-
-class Streamer
-  include Reel::App
-
-  get '/' do
-    body = Reel::Stream.new do |body|
-      # sending a payload to make sure browsers will render chunks as received
-      body << "<html>#{' '*1024}\n"
-      ('A'..'Z').each do |l|
-        body << "<div>#{l}</div>\n"
-        sleep 0.5
-      end
-      body << "</html>\n"
-      body.finish
-    end
-    [200, {
-      'Transfer-Encoding' => 'identity',
-      'Content-Type' => 'text/html'
-    }, body]
-  end
-end
-
-Streamer.new("0.0.0.0", 9292)
-sleep

data/examples/websocket-wall.rb

@@ -1,66 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'reel'
-
-Connections = []
-Body = DATA.read
-app = Rack::Builder.new do
-  map '/' do
-    run lambda { |env|
-      [200, {'Content-Type' => 'text/html'}, [Body]]
-    }
-  end
-
-  map '/subscribe' do
-    run lambda { |env|
-      if socket = env['rack.websocket']
-      
-        socket.on_message do |m|
-          begin
-            socket << 'Server got "%s" message' % m
-          rescue => SocketError
-            Connections.delete(socket)
-          end
-        end
-        
-        Connections << socket
-        socket.read_every 1
-      end
-      [200, {}, []]
-    }
-  end
-
-  map '/wall' do
-    run lambda { |env|
-      msg = env['PATH_INFO'].gsub(/\/+/, '').strip
-      msg = Time.now if msg.empty?
-      
-      Connections.each do |s|
-        begin
-          s << msg
-        rescue => SocketError
-          Connections.delete(s)
-        end
-      end
-      
-      [200, {'Content-Type' => 'text/html'}, ["Sent \"#{msg}\" to #{Connections.size} clients"]]
-    }
-  end
-end.to_app
-
-Rack::Handler::Reel.run app, Port: 9292
-
-__END__
-<!doctype html>
-<html lang="en">
-<body>
-  <input type="button" onClick="ws.send(Math.random());" value="Send a message to server">
-  <div id="content"></div>
-</body>
-<script type="text/javascript">
-ws = new WebSocket('ws://' + window.location.host + '/subscribe');
-ws.onmessage = function(e) {
-  document.getElementById('content').innerHTML += e.data + '<br>';
-}
-</script>
-</html>

data/examples/websocket.ru

@@ -1,93 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'reel'
-require 'celluloid/autostart'
-
-class TimeServer
-  include Celluloid
-  include Celluloid::Notifications
-
-  def initialize
-    run!
-  end
-
-  def run
-    now = Time.now.to_f
-    sleep now.ceil - now + 0.001
-
-    every(1) { publish 'time_change', Time.now }
-  end
-end
-
-class TimeClient
-  include Celluloid
-  include Celluloid::Notifications
-  include Celluloid::Logger
-
-  def initialize(websocket)
-    info "Streaming time changes to client"
-    @socket = websocket
-    subscribe('time_change', :notify_time_change)
-  end
-
-  def notify_time_change(topic, new_time)
-    @socket << new_time.inspect
-  rescue Reel::SocketError
-    info "Time client disconnected"
-    terminate
-  end
-end
-
-class Web
-  include Celluloid::Logger
-
-  def render_index
-    info "200 OK: /"
-    <<-HTML
-      <!doctype html>
-      <html lang="en">
-      <head>
-        <meta charset="utf-8">
-        <title>Reel WebSockets time server example</title>
-        <style>
-          body {
-            font-family: "HelveticaNeue-Light", "Helvetica Neue Light", "Helvetica Neue", Helvetica, Arial, "Lucida Grande", sans-serif;
-            font-weight: 300;
-            text-align: center;
-          }
-
-          #content {
-            width: 800px;
-            margin: 0 auto;
-            background: #EEEEEE;
-            padding: 1em;
-          }
-        </style>
-      </head>
-      <script>
-        var SocketKlass = "MozWebSocket" in window ? MozWebSocket : WebSocket;
-        var ws = new SocketKlass('ws://' + window.location.host + '/timeinfo');
-        ws.onmessage = function(msg){
-          document.getElementById('current-time').innerHTML = msg.data;
-        }
-      </script>
-      <body>
-        <div id="content">
-          <h1>Time Server Example</h1>
-          <div>The time is now: <span id="current-time">...</span></div>
-        </div>
-      </body>
-      </html>
-    HTML
-  end
-end
-
-TimeServer.supervise_as :time_server
-
-run Rack::URLMap.new(
-  "/" => Proc.new{ [200, {"Content-Type" => "text/html"}, [Web.new.render_index]]},
-  "/timeinfo" => Proc.new{ |env|
-    TimeClient.new(env["websocket.rack"])
-    [200, {}, []] # Fake response for middleware.
-  }
-)

data/examples/websocket_rack.sh

@@ -1 +0,0 @@
-rackup -s reel websocket.ru -Enone -O "workers=16"

data/lib/rack/handler/reel.rb

@@ -1,93 +0,0 @@
-require 'reel'
-
-module Rack
-  module Handler
-    class Reel
-      attr_reader :options
-
-      # Don't mess with Rack::File
-      File = ::File
-
-      DEFAULT_OPTIONS = {
-        :host    => "0.0.0.0",
-        :port    => 3000,
-        :quiet   => false,
-        :workers => 10,
-        :rackup  => "config.ru"
-      }
-
-      def self.run(app, options = {})
-
-        @handler = Reel.new(options.merge :app => app)
-
-        ::Reel::Logger.info "A Reel good HTTP server!"
-        ::Reel::Logger.info "Listening on #{@handler[:host]}:#{@handler[:port]}"
-
-        yield @handler if block_given?
-        @handler.start
-      end
-
-      def initialize(opts = {})
-        opts  = normalize_options(opts)
-
-        @options = DEFAULT_OPTIONS.merge(opts)
-
-        if @options[:environment]
-          ENV['RACK_ENV'] = @options[:environment].to_s
-        end
-      end
-
-      def start
-        Celluloid::Actor[:reel_rack_pool] = ::Reel::RackWorker.pool(size: options[:workers], args: [self])
-
-        ::Reel::Server.supervise_as(:reel_server, options[:host], options[:port]) do |connection|
-          Celluloid::Actor[:reel_rack_pool].handle(connection.detach)
-        end
-
-        sleep
-      end
-
-      def stop
-        Celluloid::Actor[:reel_server].terminate!
-        Celluloid::Actor[:reel_rack_pool].terminate!
-        exit
-      end
-
-      def [](option)
-        @options[option]
-      end
-
-      def rack_app
-        return @options[:app] if @options[:app]
-
-        path = @options[:rackup]
-
-        unless File.exists?(path)
-          raise "Missing rackup file '#{path}'"
-        end
-
-        @options[:app], options = Rack::Builder.parse_file path
-        @options.merge! options
-
-        unless @options[:quiet]
-          @options[:app] = Rack::CommonLogger.new(@options[:app], STDOUT)
-        end
-
-        @options[:app]
-      end
-
-      private
-
-      # Transform the options that rails s reel passes
-      def normalize_options(options)
-        options = options.inject({}) { |h, (k,v)| h[k.downcase] = v ; h }
-        options[:rackup] = options[:config] if options[:config]
-        options[:port] = options[:port].to_i if options[:port]
-        options[:workers] = options[:workers].to_i if options[:workers]
-        options
-      end
-    end
-
-    register :reel, Reel
-  end
-end

data/lib/reel/app.rb

@@ -1,34 +0,0 @@
-require 'reel'
-require 'octarine'
-
-module Reel
-  # Define Reel endpoints using a sinatra-like dsl (provided by octarine)
-  module App
-    def self.included(base)
-      base.class_eval do
-        include Octarine::App
-
-        attr_accessor :server
-      end
-    end
-
-    def initialize(host, port)
-      super()
-      @server = Reel::Server.supervise(host, port) do |connection|
-        while request = connection.request
-          status, headers, body = call Rack::MockRequest.env_for(request.url, :method => request.method, :input => request.body.to_s)
-          response_klass = body.is_a?(Stream) ? StreamResponse : Response
-          connection.respond(response_klass.new(status_symbol(status), headers, body))
-        end
-      end
-    end
-
-    def status_symbol(status)
-      status.is_a?(Fixnum) ? Http::Response::STATUS_CODES[status].downcase.gsub(/\s|-/, '_').to_sym : status.to_sym
-    end
-
-    def terminate
-      @server.terminate if @server
-    end
-  end
-end

data/lib/reel/rack_worker.rb

@@ -1,132 +0,0 @@
-module Reel
-  class RackWorker
-    include Celluloid
-    include Celluloid::Logger
-
-    INITIAL_BODY = ''
-
-    # Freeze some HTTP header names & values
-    CONTENT_TYPE_ORIG   = 'Content-Type'.freeze
-    CONTENT_LENGTH_ORIG = 'Content-Length'.freeze
-    CONTENT_TYPE        = 'CONTENT_TYPE'.freeze
-    CONTENT_LENGTH      = 'CONTENT_LENGTH'.freeze
-
-    SERVER_SOFTWARE     = 'SERVER_SOFTWARE'.freeze
-    SERVER_NAME         = 'SERVER_NAME'.freeze
-    SERVER_PORT         = 'SERVER_PORT'.freeze
-    SERVER_PROTOCOL     = 'SERVER_PROTOCOL'.freeze
-    GATEWAY_INTERFACE   = "GATEWAY_INTERFACE".freeze
-    LOCALHOST           = 'localhost'.freeze
-    HTTP_VERSION        = 'HTTP_VERSION'.freeze
-    CGI_1_1             = 'CGI/1.1'.freeze
-    REMOTE_ADDR         = 'REMOTE_ADDR'.freeze
-    CONNECTION          = 'HTTP_CONNECTION'.freeze
-    SCRIPT_NAME         = 'SCRIPT_NAME'.freeze
-    PATH_INFO           = 'PATH_INFO'.freeze
-    REQUEST_METHOD      = 'REQUEST_METHOD'.freeze
-    QUERY_STRING        = 'QUERY_STRING'.freeze
-    HTTP_1_0            = 'HTTP/1.0'.freeze
-    HTTP_1_1            = 'HTTP/1.1'.freeze
-    HTTP_               = 'HTTP_'.freeze
-    HOST                = 'Host'.freeze
-    
-    # Freeze some Rack header names
-    RACK_INPUT          = 'rack.input'.freeze
-    RACK_LOGGER         = 'rack.logger'.freeze
-    RACK_VERSION        = 'rack.version'.freeze
-    RACK_ERRORS         = 'rack.errors'.freeze
-    RACK_MULTITHREAD    = 'rack.multithread'.freeze
-    RACK_MULTIPROCESS   = 'rack.multiprocess'.freeze
-    RACK_RUN_ONCE       = 'rack.run_once'.freeze
-    RACK_URL_SCHEME     = 'rack.url_scheme'.freeze
-    RACK_WEBSOCKET      = 'rack.websocket'.freeze
-
-    PROTO_RACK_ENV = {
-      RACK_VERSION      => ::Rack::VERSION,
-      RACK_ERRORS       => STDERR,
-      RACK_MULTITHREAD  => true,
-      RACK_MULTIPROCESS => false,
-      RACK_RUN_ONCE     => false,
-      RACK_URL_SCHEME   => "http".freeze,
-      SCRIPT_NAME       => ENV[SCRIPT_NAME] || "",
-      SERVER_PROTOCOL   => HTTP_1_1,
-      SERVER_SOFTWARE   => "Reel/#{Reel::VERSION}".freeze,
-      GATEWAY_INTERFACE => CGI_1_1
-    }.freeze
-
-    def initialize(handler)
-      @handler, @app = handler, handler.rack_app
-    end
-
-    def handle(connection)
-      while request = connection.request
-        case request
-        when Request
-          handle_request(request, connection)
-        when WebSocket
-          handle_websocket(request, connection)
-        end
-      end
-    end
-
-    def handle_request(request, connection)
-      status, headers, body_parts = @app.call(request_env(request, connection))
-      body, is_stream = response_body(body_parts)
-      connection.respond (is_stream ? StreamResponse : Response).new(status, headers, body)
-    end
-
-    def handle_websocket(request, connection)
-      status, *rest = @app.call(websocket_env(request))
-      request.close unless status < 300
-    end
-
-    def request_env request, connection
-      env = env(request)
-      env[REMOTE_ADDR] = connection.remote_ip
-      env
-    end
-
-    def websocket_env request
-      env = env(request)
-      env[RACK_WEBSOCKET] = request.websocket
-      env[REMOTE_ADDR]    = request.websocket.remote_ip
-      env
-    end
-
-    def response_body(body_parts)
-      if body_parts.respond_to?(:to_path)
-        ::File.new(body_parts.to_path)
-      else
-        body = ''
-        body_parts.each do |c|
-          return [c, true] if c.is_a?(Reel::Stream)
-          body << c
-        end
-        body_parts.close if body_parts.respond_to?(:close)
-        body
-      end
-    end
-
-    private
-    def env request
-      env = Hash[PROTO_RACK_ENV]
-
-      env[RACK_INPUT] = StringIO.new(request.body.to_s || INITIAL_BODY)
-      env[RACK_INPUT].set_encoding(Encoding::BINARY) if env[RACK_INPUT].respond_to?(:set_encoding)
-      env[SERVER_NAME], env[SERVER_PORT] = (request[HOST]||'').split(':', 2)
-      env[SERVER_PORT] ||= @handler[:port].to_s
-      env[HTTP_VERSION]   = request.version || env[SERVER_PROTOCOL]
-      env[REQUEST_METHOD] = request.method
-      env[PATH_INFO]      = request.path
-      env[QUERY_STRING]   = request.query_string || ''
-
-      (_ = request.headers.delete CONTENT_TYPE_ORIG) && (env[CONTENT_TYPE] = _)
-      (_ = request.headers.delete CONTENT_LENGTH_ORIG) && (env[CONTENT_LENGTH] = _)
-
-      request.headers.each_pair do |key, val|
-        env[HTTP_ + key.gsub('-', '_').upcase] = val
-      end
-      env
-    end
-  end
-end

data/spec/reel/app_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-require 'reel/app'
-
-describe Reel::App do
-  let(:app) {
-    Class.new do
-      include Reel::App
-
-      get example_path do
-        [200, {}, "hello foo"]
-      end
-
-    end
-  }
-
-  before(:each) do
-    @app = app.new(example_addr, example_port)
-  end
-
-  after(:each) do
-    @app.server.terminate if @app && @app.server.alive?
-  end
-
-  it 'responds to get requests' do
-    res = Http.with_response(:object).get example_url
-    res.status.should == 200
-    res.headers.should == {"Content-Length" => res.body.length.to_s}
-    res.body.should == "hello foo"
-  end
-
-  it 'terminates the server' do
-    @app.terminate
-    @app.server.should_not be_alive
-  end
-end

data/spec/reel/rack_worker_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-describe Reel::RackWorker do
-  let(:endpoint) { URI(example_url) }
-
-  RackApp = Proc.new do |env|
-    [200, {'Content-Type' => 'text/plain'}, ['Hello rack world!']]
-  end
-
-  let(:worker) do
-    handler = Rack::Handler::Reel.new
-    handler.options[:app] = RackApp
-
-    Reel::RackWorker.new(handler)
-  end
-
-  it "creates a rack env from a request" do
-    with_socket_pair do |client, connection|
-      client << ExampleRequest.new(:get, '/test?hello=true').to_s
-      request = connection.request
-      env = worker.request_env(request, connection)
-
-      Reel::RackWorker::PROTO_RACK_ENV.each do |k, v|
-        env[k].should == v
-      end
-
-      env["SERVER_NAME"].should == 'www.example.com'
-      env["SERVER_PORT"].should == "3000"
-      env["REMOTE_ADDR"].should == "127.0.0.1"
-      env["PATH_INFO"].should == "/test"
-      env["REQUEST_METHOD"].should == "GET"
-      env["QUERY_STRING"].should == "hello=true"
-      env["HTTP_HOST"].should == 'www.example.com'
-      env["HTTP_ACCEPT_LANGUAGE"].should == "en-US,en;q=0.8"
-
-      env["rack.input"].should be_kind_of(StringIO)
-      env["rack.input"].string.should == ''
-
-      validator = ::Rack::Lint.new(RackApp)
-      status, *rest = validator.call(env)
-      status.should == 200
-    end
-  end
-
-  context "WebSocket" do
-    include WebSocketHelpers
-
-    it "places websocket into rack env" do
-      with_socket_pair do |client, connection|
-        client << handshake.to_data
-        request = connection.request
-        env = worker.websocket_env(request)
-        
-        env["REMOTE_ADDR"].should == "127.0.0.1"
-        env["rack.websocket"].should be_a Reel::WebSocket
-      end
-    end    
-  end
-
-  it "delegates web requests to the rack app" do
-    ex = nil
-
-    handler = proc do |connection|
-      begin
-        worker.async.handle(connection.detach)
-      rescue => ex
-      end
-    end
-
-    with_reel(handler) do
-      http = Net::HTTP.new(endpoint.host, endpoint.port)
-      request = Net::HTTP::Get.new(endpoint.request_uri)
-      response = http.request(request)
-      response.should be_a Net::HTTPOK
-      response.body.should == 'Hello rack world!'
-    end
-
-    raise ex if ex
-  end
-end