serverside 0.2.8 → 0.2.9

data/CHANGELOG

@@ -1,3 +1,27 @@
+==0.2.9
+
+* Improved rake clean task.
+
+* Added HTTP::Request.send_file method.
+
+* Added basic rendering capabilities to ServerSide::Controller.
+
+* Added support for lambda rules in ServerSide::Controller.mount.
+
+* Start work on controller class.
+
+* Renamed Router.route_default to default_route.
+
+* Fixed small errors in documentation.
+
+* Changed ServerSide::Static.serve_static to look for index.html inside directory before serving the directory.
+
+* Added HTTP::Caching.cache_etags and cache_stamp methods.
+
+* Fixed bug in doc_rforge rake task.
+
+* Rewrote request unit test into request spec.
+
 ==0.2.8
 
 * Refactored ServerSide::Static to use HTTP::Caching code.

data/Rakefile

@@ -7,8 +7,8 @@ require 'fileutils'
 include FileUtils
 
 NAME = "serverside"
-VERS = "0.2.8"
-CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+VERS = "0.2.9"
+CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "ServerSide Documentation",
   "--opname", "index.html",
   "--line-numbers", 
@@ -67,6 +67,7 @@ task :uninstall => [:clean] do
   sh %{sudo gem uninstall #{NAME}}
 end
 
+desc 'Update docs and upload to rubyforge.org'
 task :doc_rforge do
   sh %{rake doc}
   sh %{scp -r doc/rdoc/* ciconia@rubyforge.org:/var/www/gforge-projects/serverside}
@@ -124,12 +125,6 @@ RCov::VerifyTask.new(:rcov_verify => :rcov) do |t|
   t.index_html = 'doc/output/coverage/index.html'
 end
 
-desc 'Update docs and upload to rubyforge.org'
-task :doc_rforge do
-  sh %{rake doc}
-  sh "scp -C -r * ciconia@rubyforge.org:/var/www/gforge-projects/serverside/"
-end
-
 ##############################################################################
 # Statistics
 ##############################################################################

data/bin/serverside

@@ -65,7 +65,7 @@ else
   require fn if File.file?(fn)
 end
 unless ServerSide::Router.has_routes?
-  ServerSide::Router.route_default {serve_static('.'/@path)}
+  ServerSide::Router.default_route {serve_static('.'/@path)}
 end
 
 if $cmd == 'serve'

data/lib/serverside/caching.rb

@@ -14,7 +14,30 @@ module ServerSide
       NOT_MODIFIED_CLOSE = "HTTP/1.1 304 Not Modified\r\nDate: %s\r\nConnection: close\r\nLast-Modified: %s\r\nETag: \"%s\"\r\nCache-Control: max-age=%d\r\n\r\n".freeze
       NOT_MODIFIED_PERSIST = "HTTP/1.1 304 Not Modified\r\nDate: %s\r\nLast-Modified: %s\r\nETag: \"%s\"\r\nCache-Control: max-age=%d\r\n\r\n".freeze
       MAX_AGE = 'max-age=%d'.freeze
+      IF_NONE_MATCH_REGEXP = /^"?([^"]+)"?$/.freeze
 
+      # Returns an array containing all etags specified by the client in the
+      # If-None-Match header.
+      def cache_etags
+        h = @headers[IF_NONE_MATCH]
+        return [] unless h
+        h.split(',').inject([]) do |m, i|
+          i.strip =~ IF_NONE_MATCH_REGEXP ? (m << $1) : m
+        end
+      end
+      
+      # Returns the cache stamp specified by the client in the 
+      # If-Modified-Since header. If no stamp is specified, returns nil.
+      def cache_stamp
+        (h = @headers[IF_MODIFIED_SINCE]) ? Time.httpdate(h) : nil
+      rescue
+        nil
+      end
+
+      # Checks the request headers for validators and returns true if the
+      # client cache is valid. The validators can be either etags (specified
+      # in the If-None-Match header), or a modification stamp (specified in the
+      # If-Modified-Since header.)
       def valid_client_cache?(etag, http_stamp)
         none_match = @headers[IF_NONE_MATCH]
         modified_since = @headers[IF_MODIFIED_SINCE]
@@ -22,6 +45,15 @@ module ServerSide
           (modified_since && (modified_since == http_stamp))
       end
       
+      # Validates the client cache by checking any supplied validators in the
+      # request. If the client cache is not valid, the specified block is
+      # executed. This method also makes sure the correct validators are 
+      # included in the response - along with a Cache-Control header, to allow
+      # the client to cache the response. A possible usage:
+      # 
+      #   validate_cache("1234-5678", Time.now, 360) do
+      #     send_response(200, "text/html", body)
+      #   end
       def validate_cache(etag, stamp, max_age = DEFAULT_MAX_AGE, &block)
         http_stamp = stamp.httpdate
         if valid_client_cache?(etag, http_stamp)
@@ -34,23 +66,14 @@ module ServerSide
         end
       end
 
+      # Sends a 304 HTTP response, along with etag and stamp validators, and a
+      # Cache-Control header.
       def send_not_modified(etag, http_time, max_age = DEFAULT_MAX_AGE)
         @socket << ((@persistent ? NOT_MODIFIED_PERSIST : NOT_MODIFIED_CLOSE) % 
           [Time.now.httpdate, http_time, etag, max_age])
       end
-    end          
+    end
   end
 end
 
 __END__
-
-Reality::Controller.new(:node_history) do
-  default_flavor :html
-  valid_method :get
-  
-  def html
-    validate_cache(etag, http_time) {|cache_headers|
-      render_template(cache_headers)
-    }
-  end
-end

data/lib/serverside/controller.rb

@@ -0,0 +1,67 @@
+require File.join(File.dirname(__FILE__), 'routing')
+
+module ServerSide
+  class Controller
+    def self.mount(rule = nil, &block)
+      rule ||= block
+      raise ArgumentError, "No routing rule specified." if rule.nil?
+      c = Class.new(self) {}
+      ServerSide::Router.route(rule) {c.new(self)}
+      c
+    end
+    
+    def initialize(request)
+      @request = request
+      @path = request.path
+      @parameters = request.parameters
+      process
+      render_default if not @rendered
+    end
+    
+    def process
+    end
+    
+    def render_default
+      @request.send_response(200, 'text/plain', 'no response.')
+    end
+    
+    def render(body, content_type)
+      @request.send_response(200, content_type, body)
+      @rendered = true
+    end
+  end
+end
+
+__END__
+
+require 'rubygems'
+require 'active_support/inflector'
+require 'metaid'
+
+class ActionController
+  def self.default_routing_rule
+    if name.split('::').last =~ /(.+)Controller$/
+      controller = Inflector.underscore($1) 
+      {:path => ["/#{controller}/:action", "/#{controller}/:action/:id"]}
+    end
+  end
+
+  def self.inherited(c)
+    routing_rule = c.respond_to?(:routing_rule) ?
+      c.routing_rule : c.default_routing_rule
+    if routing_rule
+      ServerSide::Router.route(routing_rule) {c.new(self)}
+    end
+  end
+  
+  def self.route(arg = nil, &block)
+    rule = arg || block
+    meta_def(:get_route) {rule}
+  end
+end
+
+class MyController < ActionController
+  route "hello"
+end
+
+p MyController.get_route

data/lib/serverside/request.rb

@@ -165,6 +165,16 @@ module ServerSide
         @persistent = false
       end
       
+      CONTENT_DISPOSITION = 'Content-Disposition'.freeze
+      CONTENT_DESCRIPTION = 'Content-Description'.freeze
+
+      def send_file(content, content_type, disposition = :inline, filename = nil, description = nil)
+        disposition = filename ? "#{disposition}; filename=#{filename}" : "#{disposition}"
+        @response_headers[CONTENT_DISPOSITION] = disposition
+        @response_headers[CONTENT_DESCRIPTION] = description if description
+        send_response(200, content_type, content)
+      end
+      
       # Send a redirect response.
       def redirect(location, permanent = false)
         @socket << (STATUS_REDIRECT % 

data/lib/serverside/routing.rb

@@ -1,8 +1,8 @@
 require File.join(File.dirname(__FILE__), 'request')
 
 module ServerSide
-  # The Router class defines a kind of connection that can route requests
-  # to different handlers based on rules that can be specified either by
+  # The Router class is a subclass of HTTP::Request that can invoke
+  # different handlers based on rules that can be specified either by
   # lambdas or by hashes that contain variable names corresponding to patterns.
   #
   # The simplest form of a routing rule specifies a path pattern:
@@ -19,7 +19,7 @@ module ServerSide
   #
   #   ServerSide.route(lambda {@headers['Agent'] =~ /Moz/}) {serve_static('moz'/@path)}
   #
-  # Routing rules are evaluated in backwards, so the rules should be ordered
+  # Routing rules are evaluated backwards, so the rules should be ordered
   # from the general to the specific.
   class Router < HTTP::Request
     # Returns true if routes were defined.
@@ -116,7 +116,7 @@ module ServerSide
     end
 
     # Sets the default handler for incoming requests.
-    def self.route_default(&block)
+    def self.default_route(&block)
       define_method(:default_handler, &block)
       compile_rules
     end

data/lib/serverside/static.rb

@@ -76,7 +76,13 @@ module ServerSide
       elsif serve_template(path)
         return
       elsif File.directory?(path)
-        serve_dir(path)
+        if File.file?(path/'index.html')
+          serve_file(path/'index.html')
+        elsif File.file?(path/'index.rhtml')
+          serve_template(path/'index.rhtml')
+        else
+          serve_dir(path)
+        end
       else
         send_response(404, 'text', FILE_NOT_FOUND)
       end

data/test/functional/static_server.rb

@@ -3,5 +3,5 @@ require 'lib/serverside'
 trap('INT') {exit}
 include ServerSide
 puts "Serving on port 8000..."
-Router.route_default {serve_static('.'/@path)}
+Router.default_route {serve_static('.'/@path)}
 HTTP::Server.new('0.0.0.0', 8000, Router)

data/test/spec/caching_spec.rb

@@ -98,4 +98,42 @@ context "Caching::valid_client_cache?" do
     r.headers['If-Modified-Since'] = t.httpdate
     r.valid_client_cache?('eeee', t.httpdate).should_not_be false
   end
-end
+end
+
+context "Caching::cache_etags" do
+  specify "should return an empty array if no If-None-Match header is included" do
+    r = DummyRequest.new
+    r.cache_etags.should_be_a_kind_of Array
+    r.cache_etags.should_equal []
+  end
+  
+  specify "should return all etags included in the If-None-Match header" do
+    r = DummyRequest.new
+    r.headers['If-None-Match'] = '*'
+    r.cache_etags.should_equal ['*']
+    r.headers['If-None-Match'] = '*, "XXX-YYY","AAA-BBB"'
+    r.cache_etags.should_equal ['*', 'XXX-YYY', 'AAA-BBB']
+    r.headers['If-None-Match'] = '"abcd-EFGH"'
+    r.cache_etags.should_equal ['abcd-EFGH']
+  end
+end
+
+context "Caching::cache_stamps" do
+  specify "should return nil if no If-Modified-Since header is included" do
+    r = DummyRequest.new
+    r.cache_stamp.should_be_nil
+  end
+  
+  specify "should return nil if no an invalid stamp is specified" do
+    r = DummyRequest.new
+    r.headers['If-Modified-Since'] = 'invalid stamp'
+    r.cache_stamp.should_be_nil
+  end
+  
+  specify "should return the stamp specified in the If-Modified-Since header" do
+    r = DummyRequest.new
+    t = Time.now
+    r.headers['If-Modified-Since'] = t.httpdate
+    r.cache_stamp.to_i.should_equal t.to_i
+  end
+end

data/test/spec/controller_spec.rb

@@ -0,0 +1,139 @@
+require File.join(File.dirname(__FILE__), '../../lib/serverside')
+require 'stringio'
+
+class ServerSide::Router
+  def self.rules
+    @@rules
+  end
+  
+  def self.reset_rules
+    @@rules = []
+  end
+  
+  attr_accessor :path
+end
+
+context "ServerSide::Controller.mount" do
+  specify "should accept a routing rule as argument" do
+    proc {ServerSide::Controller.mount}.should_raise ArgumentError
+  end
+  
+  specify "should return a subclass of ServerSide::Controller" do
+    c = ServerSide::Controller.mount(:path => '/test')
+    c.should_be_a_kind_of Class
+    c.superclass.should_be ServerSide::Controller
+  end
+  
+  specify "should add a routing rule using ServerSide::Router.route" do
+    ServerSide::Router.reset_rules
+    rule = {:path => '/test'}
+    c = ServerSide::Controller.mount(rule)
+    r = ServerSide::Router.rules.first
+    r.first.should_equal rule
+    r.last.should_be_a_kind_of Proc
+    c.module_eval do
+      define_method(:initialize) {|req| $req = req}
+    end
+    res = r.last.call
+    res.should_be_a_kind_of c
+    
+    r = ServerSide::Router.new(StringIO.new)
+    r.path = '/test'
+    r.respond
+    $req.should_be_a_kind_of ServerSide::Router
+  end
+
+  specify "should accept either an argument or block as the rule" do
+    ServerSide::Router.reset_rules
+    rule = {:path => '/test'}
+    c = ServerSide::Controller.mount(rule)
+    r = ServerSide::Router.rules.first
+    r.first.should_be rule
+
+    ServerSide::Router.reset_rules
+    rule = proc {true}
+    c = ServerSide::Controller.mount(&rule)
+    r = ServerSide::Router.rules.first
+    r.first.should_be rule
+  end
+end
+
+class ServerSide::Controller
+  attr_accessor :request, :path, :parameters, :rendered
+end
+
+class ServerSide::HTTP::Request
+  attr_accessor :path, :parameters
+end
+
+require 'metaid'
+
+class DummyController < ServerSide::Controller
+  attr_reader :process_called
+  
+  def process
+    @process_called = true
+  end
+  
+  def render_default
+    @rendered = :default
+  end
+end
+
+context "ServerSide::Controller new instance" do
+  specify "should set @request, @path, and @parameters instance variables" do
+    req = ServerSide::HTTP::Request.new(StringIO.new)
+    req.path = '/aa/bb/cc'
+    req.parameters = {:q => 'node_state', :f => 'xml'}
+    c = ServerSide::Controller.new(req)
+    c.request.should_be req
+    c.path.should_be req.path
+    c.parameters.should_be req.parameters
+  end
+  
+  specify "should invoke the process method" do
+    req = ServerSide::HTTP::Request.new(StringIO.new)
+    c = DummyController.new(req)
+    c.process_called.should_be true
+  end
+  
+  specify "should invoke render_default unless @rendered" do
+    req = ServerSide::HTTP::Request.new(StringIO.new)
+    c = DummyController.new(req)
+    c.rendered.should_be :default
+    
+    c_class = Class.new(DummyController) do
+      define_method(:process) {@rendered = true}
+    end
+    c = c_class.new(req)
+    c.rendered.should_be true
+  end
+end
+
+context "ServerSide::Controller.render_default" do
+  specify "should render a default 200 response" do
+    req = ServerSide::HTTP::Request.new(StringIO.new)
+    c = ServerSide::Controller.new(req)
+    req.socket.rewind
+    resp = req.socket.read
+    resp.should_match /HTTP\/1\.1\s200/
+  end
+end
+
+context "ServerSide::Controller.render" do
+  specify "should render a 200 response with body and content type arguments" do
+    req = ServerSide::HTTP::Request.new(StringIO.new)
+    c = ServerSide::Controller.new(req)
+    c.render('hello world', 'text/plain')
+    req.socket.rewind
+    resp = req.socket.read
+    resp.should_match /Content-Type:\stext\/plain\r\n/
+  end
+  
+  specify "should set @rendered to true" do
+    req = ServerSide::HTTP::Request.new(StringIO.new)
+    c = ServerSide::Controller.new(req)
+    c.render('hello world', 'text/plain')
+    c.rendered.should_equal true
+  end
+end

data/test/spec/request_spec.rb

@@ -0,0 +1,288 @@
+require File.join(File.dirname(__FILE__), '../../lib/serverside')
+require 'stringio'
+
+class DummyRequest2 < ServerSide::HTTP::Request
+  attr_accessor :calls, :parse_result, :persistent
+  
+  def parse
+    @calls ||= []
+    @calls << :parse
+    @parse_result
+  end
+  
+  def respond
+    @calls ||= []
+    @calls << :respond
+  end
+end
+
+context "HTTP::Request.process" do
+  specify "should call parse and and short-circuit if the result is nil" do
+    r = DummyRequest2.new(nil)
+    r.process.should_be_nil
+    r.calls.should_equal [:parse]
+
+    r.calls = []
+    r.parse_result = false
+    r.process.should_be false
+    r.calls.should_equal [:parse]
+  end
+  
+  specify "should follow parse with respond and return @persistent" do
+    r = DummyRequest2.new(nil)
+    r.parse_result = true
+    r.process.should_be_nil
+    r.calls.should_equal [:parse, :respond]
+    
+    r.calls = []
+    r.persistent = 'mau'
+    r.process.should_equal 'mau'
+    r.calls.should_equal [:parse, :respond]
+  end
+end
+
+class ServerSide::HTTP::Request
+  attr_writer :socket, :persistent, :response_headers
+end
+
+context "HTTP::Request.parse" do
+  specify "should return nil for invalid requests" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new('POST /test')
+    r.parse.should_be_nil
+    r.socket = StringIO.new('invalid string')
+    r.parse.should_be_nil
+    r.socket = StringIO.new('GET HTTP/1.1')
+    r.parse.should_be_nil
+    r.socket = StringIO.new('GET /test http')
+    r.parse.should_be_nil
+    r.socket = StringIO.new('GET /test HTTP')
+    r.parse.should_be_nil
+    r.socket = StringIO.new('GET /test HTTP/')
+    r.parse.should_be_nil
+    r.socket = StringIO.new('POST /test HTTP/1.1')
+    r.parse.should_be_nil
+  end
+  
+  specify "should parse valid requests and return request headers" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new(
+      "POST /test HTTP/1.1\r\nContent-Type: text/html\r\n\r\n")
+    r.parse.should_be r.headers
+    r.method.should_equal :post
+    r.path.should_equal '/test'
+    r.query.should_be_nil
+    r.version.should_equal '1.1'
+    r.parameters.should_equal({})
+    r.headers.should_equal({'Content-Type' => 'text/html'})
+    r.cookies.should_equal({})
+    r.response_cookies.should_be_nil
+    r.persistent.should_equal true
+  end
+  
+  specify "should correctly handle trailing slash in path" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new("POST /test/asdf/qw/ HTTP/1.1\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.path.should_equal '/test/asdf/qw'
+
+    r.socket = StringIO.new(
+      "POST /test/asdf/qw/?time=24%20hours HTTP/1.1\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.path.should_equal '/test/asdf/qw'
+  end
+  
+  specify "should parse URL-encoded parameters" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new(
+      "POST /test?q=node_history&time=24%20hours HTTP/1.1\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.parameters.size.should_equal 2
+    r.parameters[:time].should_equal '24 hours'
+    r.parameters[:q].should_equal 'node_history'
+  end
+  
+  specify "should correctly parse the HTTP version" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new(
+      "POST / HTTP/1.0\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.version.should_equal '1.0'
+    r.socket = StringIO.new(
+      "POST / HTTP/3.2\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.version.should_equal '3.2'
+  end
+  
+  specify "should set @persistent correctly" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new("POST / HTTP/1.0\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.persistent.should_equal false
+    r.socket = StringIO.new("POST / HTTP/1.1\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.persistent.should_equal true
+    r.socket = StringIO.new("POST / HTTP/0.6\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.persistent.should_equal false
+    r.socket = StringIO.new("POST / HTTP/1.1\r\nConnection: close\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.persistent.should_equal false
+    r.socket = StringIO.new("POST / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.persistent.should_equal true
+  end
+  
+  specify "should parse cookies" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new(
+      "POST / HTTP/1.0\r\nCookie: abc=1342; def=7%2f4\r\n\r\n")
+    r.parse.should_not_be_nil
+    r.headers['Cookie'].should_equal 'abc=1342; def=7%2f4'
+    r.cookies.size.should_equal 2
+    r.cookies[:abc].should_equal '1342'
+    r.cookies[:def].should_equal '7/4'
+  end
+  
+  specify "should parse the post body" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new(
+      "POST /?q=node_history HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 15\r\n\r\ntime=24%20hours")
+    r.parse.should_not_be_nil
+    r.parameters.size.should_equal 2
+    r.parameters[:q].should_equal 'node_history'
+    r.parameters[:time].should_equal '24 hours'
+  end
+end
+
+context "HTTP::Request.send_response" do
+  specify "should format a response with status and body" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new
+    r.send_response(200, 'text', 'Hello there!')
+    r.socket.rewind
+    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!"
+  end
+  
+  specify "should format a response without connect-close when persistent" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new
+    r.persistent = true
+    r.send_response(200, 'text', 'Hello there!')
+    r.socket.rewind
+    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nContent-Type: text\r\nContent-Length: 12\r\n\r\nHello there!"
+  end
+  
+  specify "should format a response without content-length for streaming response" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new
+    r.persistent = true
+    r.send_response(200, 'text')
+    r.socket.rewind
+    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\n\r\n"
+    r.stream('hey there')
+    r.socket.rewind
+    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\n\r\nhey there"
+  end
+  
+  specify "should include response_headers and headers in the response" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new
+    r.persistent = true
+    r.response_headers['XXX'] = 'Test'
+    r.send_response(200, 'text')
+    r.socket.rewind
+    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nXXX: Test\r\n\r\n"
+
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new
+    r.persistent = true
+    r.send_response(200, 'text', nil, nil, {'YYY' => 'TTT'})
+    r.socket.rewind
+    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nYYY: TTT\r\n\r\n"
+  end
+  
+  specify "should set persistent to false if exception is raised" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.persistent = true
+    proc {r.send_response(200, 'text', 'Hello there!')}.should_not_raise
+    r.persistent.should_equal false
+  end
+
+  specify "should include cookies in the response" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new
+    t = Time.now + 360
+    r.set_cookie(:session, "ABCDEFG", t)
+    r.response_cookies.should_equal "Set-Cookie: session=ABCDEFG; path=/; expires=#{t.rfc2822}\r\n" 
+    r.send_response(200, 'text', 'Hi!')
+    r.socket.rewind
+    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nSet-Cookie: session=ABCDEFG; path=/; expires=#{t.rfc2822}\r\nContent-Length: 3\r\n\r\nHi!" 
+
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new
+    r.delete_cookie(:session)
+    r.response_cookies.should_equal "Set-Cookie: session=; path=/; expires=#{Time.at(0).rfc2822}\r\n"
+    r.send_response(200, 'text', 'Hi!')
+    r.socket.rewind
+    r.socket.read.should_equal "HTTP/1.1 200\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nContent-Type: text\r\nSet-Cookie: session=; path=/; expires=#{Time.at(0).rfc2822}\r\nContent-Length: 3\r\n\r\nHi!"
+  end
+end
+
+context "HTTP::Request.send_file" do
+  specify "should include a disposition header in the response" do
+    socket = StringIO.new
+    r = ServerSide::HTTP::Request.new(socket)
+    r.send_file('text', 'text/plain', :attachment)
+    socket.rewind
+    socket.read.should_match /Content-Disposition: attachment\r\n/
+  end
+  
+  specify "should use :inline as default disposition" do
+    socket = StringIO.new
+    r = ServerSide::HTTP::Request.new(socket)
+    r.send_file('text', 'text/plain')
+    socket.rewind
+    socket.read.should_match /Content-Disposition: inline\r\n/
+  end
+  
+  specify "should include filename parameter if specified" do
+    socket = StringIO.new
+    r = ServerSide::HTTP::Request.new(socket)
+    r.send_file('text', 'text/plain', :attachment, 'text.txt')
+    socket.rewind
+    socket.read.should_match /Content-Disposition: attachment; filename=text.txt\r\n/
+  end
+  
+  specify "should include a description header if specified" do
+    socket = StringIO.new
+    r = ServerSide::HTTP::Request.new(socket)
+    r.send_file('text', 'text/plain', :attachment, 'text.txt')
+    socket.rewind
+    socket.read.should_not_match /Content-Description:\s/
+
+    socket = StringIO.new
+    r = ServerSide::HTTP::Request.new(socket)
+    r.send_file('text', 'text/plain', :attachment, 'text.txt', 'this is text.')
+    socket.rewind
+    socket.read.should_match /Content-Description:\sthis is text\./
+  end
+end
+
+context "HTTP::Request.redirect" do
+  specify "should send a 302 response for temporary redirect" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new
+    r.redirect('http://mau.com/132')
+    r.socket.rewind
+    r.socket.read.should_equal "HTTP/1.1 302\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nLocation: http://mau.com/132\r\n\r\n"
+  end
+  
+  specify "should send a 301 response for permanent redirect" do
+    r = ServerSide::HTTP::Request.new(nil)
+    r.socket = StringIO.new
+    r.redirect('http://mau.com/132', true)
+    r.socket.rewind
+    r.socket.read.should_equal "HTTP/1.1 301\r\nDate: #{Time.now.httpdate}\r\nConnection: close\r\nLocation: http://mau.com/132\r\n\r\n"
+  end
+end

data/test/unit/routing_test.rb

@@ -69,7 +69,7 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal nil, R.new(StringIO.new).respond
     R.rules << [{:t => 'abc'}, lambda{1}]
     R.rules << [{:t => 'def'}, lambda{2}]
-    R.route_default {3}
+    R.default_route {3}
     R.compile_rules
     r = R.new(StringIO.new)
     r.t = 'abc'
@@ -148,11 +148,11 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal c, eval("R::#{tag}")
   end
   
-  def test_route_default
-    R.route_default {'mau m'}
+  def test_default_route
+    R.default_route {'mau m'}
     assert_equal 'mau m', R.new(StringIO.new).default_handler
 
-    R.route_default {654321}
+    R.default_route {654321}
     assert_equal 654321, R.new(StringIO.new).default_handler
   end
   
@@ -164,8 +164,8 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal 2, R.rules[0][1].call
   end
   
-  def test_serverside_route_default
-    ServerSide::Router.route_default {1234}
+  def test_serverside_default_route
+    ServerSide::Router.default_route {1234}
     assert_equal 1234, R.new(StringIO.new).default_handler
   end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: serverside
 version: !ruby/object:Gem::Version 
-  version: 0.2.8
-date: 2006-10-14 00:00:00 +02:00
+  version: 0.2.9
+date: 2006-10-25 00:00:00 +02:00
 summary: Performance-oriented web framework.
 require_paths: 
 - lib
@@ -33,43 +33,46 @@ files:
 - README
 - Rakefile
 - bin/serverside
+- test/unit
 - test/functional
 - test/spec
 - test/test_helper.rb
-- test/unit
+- test/unit/connection_test.rb
+- test/unit/cluster_test.rb
+- test/unit/daemon_test.rb
+- test/unit/server_test.rb
+- test/unit/static_test.rb
+- test/unit/routing_test.rb
+- test/unit/core_ext_test.rb
+- test/unit/request_test.rb
+- test/unit/template_test.rb
+- test/functional/routing_server.rb
+- test/functional/static_server.rb
 - test/functional/primitive_static_server_test.rb
 - test/functional/request_body_test.rb
-- test/functional/routing_server.rb
-- test/functional/routing_server_test.rb
 - test/functional/static_profile.rb
 - test/functional/static_rfuzz.rb
-- test/functional/static_server.rb
 - test/functional/static_server_test.rb
+- test/functional/routing_server_test.rb
+- test/spec/controller_spec.rb
+- test/spec/core_ext_spec.rb
+- test/spec/request_spec.rb
 - test/spec/caching_spec.rb
 - test/spec/connection_spec.rb
-- test/spec/core_ext_spec.rb
-- test/unit/cluster_test.rb
-- test/unit/connection_test.rb
-- test/unit/core_ext_test.rb
-- test/unit/daemon_test.rb
-- test/unit/request_test.rb
-- test/unit/routing_test.rb
-- test/unit/server_test.rb
-- test/unit/static_test.rb
-- test/unit/template_test.rb
 - lib/serverside
 - lib/serverside.rb
-- lib/serverside/application.rb
-- lib/serverside/caching.rb
-- lib/serverside/cluster.rb
 - lib/serverside/connection.rb
-- lib/serverside/core_ext.rb
+- lib/serverside/cluster.rb
 - lib/serverside/daemon.rb
-- lib/serverside/request.rb
-- lib/serverside/routing.rb
+- lib/serverside/application.rb
+- lib/serverside/controller.rb
 - lib/serverside/server.rb
 - lib/serverside/static.rb
+- lib/serverside/routing.rb
+- lib/serverside/core_ext.rb
+- lib/serverside/request.rb
 - lib/serverside/template.rb
+- lib/serverside/caching.rb
 - CHANGELOG
 test_files: []