serverside 0.4.1 → 0.4.3

data/lib/serverside/http/server.rb

@@ -37,15 +37,8 @@ module ServerSide::HTTP
       end
     end
     
-    # include the Parsing, Response and Caching modules.
-    include ServerSide::HTTP::Parsing
-    include ServerSide::HTTP::Response
-    include ServerSide::HTTP::Caching
-    
     # attribute readers
-    attr_reader :request_line, :method, :uri, :query, :http_version, :params
-    attr_reader :content_length, :persistent, :request_headers
-    attr_reader :request_cookies, :request_body
+    attr_reader :request, :response_sent
 
     # post_init creates a new @in buffer and sets the connection state to 
     # initial.
@@ -64,8 +57,7 @@ module ServerSide::HTTP
       @in << data
       send(@state)
     rescue => e
-      # if an error is raised, we send an error response
-      send_error_response(e) unless @state == :done
+      handle_error(e)
     end
     
     # set_state is called whenever a state transition occurs. It invokes the
@@ -74,24 +66,22 @@ module ServerSide::HTTP
       @state = s
       send(s)
     rescue => e
+      handle_error(e)
+    end
+
+    # Handle errors raised while processing a request
+    def handle_error(e)
       # if an error is raised, we send an error response
-      send_error_response(e) unless @state == :done
+      unless @response_sent || @streaming
+        send_response(Response.error(e))
+      end
     end
     
-    # state_initial initializes @request_headers, @request_header_count,
-    # @request_cookies and @response_headers. It immediately transitions to the 
-    # request_line state.
+    # state_initial creates a new request instance and immediately transitions
+    # to the request_line state.
     def state_initial
-      # initialize request and response variables
-      @request_line = nil
+      @request = ServerSide::HTTP::Request.new(self)
       @response_sent = false
-      @request_headers = {}
-      @request_header_count = 0
-      @request_cookies = {}
-      @response_headers = []
-      @content_length = nil
-      
-      # immediately transition to the request_line state
       set_state(:state_request_line)
     end
   
@@ -100,13 +90,11 @@ module ServerSide::HTTP
     # line supplies information including the 
     def state_request_line
       # check request line size
-      if @in.size > MAX_REQUEST_LINE_SIZE
-        raise MalformedRequestError, "Invalid request size"
-      end
       if line = @in.get_line
-        parse_request_line(line)
-        # HTTP 1.1 connections are persistent by default.
-        @persistent = @http_version == VERSION_1_1
+        if line.size > MAX_REQUEST_LINE_SIZE
+          raise BadRequestError, "Invalid request size"
+        end
+        @request.parse_request_line(line)
         set_state(:state_request_headers)
       end
     end
@@ -118,18 +106,13 @@ module ServerSide::HTTP
       while line = @in.get_line
         # Check header size
         if line.size > MAX_HEADER_SIZE
-          raise MalformedRequestError, "Invalid header size"
+          raise BadRequestError, "Invalid header size"
         # If the line empty then we move to the next state
         elsif line.empty?
-          expecting_body = @content_length && (@content_length > 0)
+          expecting_body = @request.content_length.to_i > 0
           set_state(expecting_body ? :state_request_body : :state_response)
         else
-          # check header count
-          if (@request_header_count += 1) > MAX_HEADER_COUNT
-            raise MalformedRequestError, "Too many headers"
-          else
-            parse_header(line)
-          end
+          @request.parse_header(line)
         end
       end
     end
@@ -138,9 +121,8 @@ module ServerSide::HTTP
     # the body. Once the body is parsed, the connection transitions to the 
     # response state.
     def state_request_body
-      if @in.size >= @content_length
-        @request_body = @in.slice!(0...@content_length)
-        parse_request_body(@request_body)
+      if @in.size >= @request.content_length
+        @request.parse_body(@in.slice!(0...@request.content_length))
         set_state(:state_response)
       end
     end
@@ -149,13 +131,23 @@ module ServerSide::HTTP
     # error is raised. After the response is sent, the connection is either
     # closed or goes back to the initial state.
     def state_response
-      handle
-      unless @response_sent || @streaming
-        raise "No handler found for this URI (#{@uri})"
+      unless resp = handle(@request)
+        raise "No handler found for this URI (#{@request.url})"
       end
-    ensure
-      unless @streaming
-        set_state(@persistent ? :state_initial : :state_done)
+      send_response(resp)
+    end
+    
+    def send_response(resp)
+      persistent = @request.persistent && resp.persistent?
+      if !persistent
+        resp.headers << CONNECTION_CLOSE
+      end
+      send_data(resp.to_s)
+      @response_sent = true
+      if resp.streaming?
+        start_stream_loop(resp.stream_period, resp.stream_proc)
+      else
+        set_state(persistent ? :state_initial : :state_done)
       end
     end
     
@@ -164,30 +156,14 @@ module ServerSide::HTTP
       close_connection_after_writing
     end
     
-    # periodically implements a periodical timer. The timer is invoked until
-    # the supplied block returns false or nil.
-    def periodically(period, &block)
-      EventMachine::add_timer(period) do
-        if block.call
-          periodically(period, &block)
-        end
-      end
-    end
-
-    # periodically implements a periodical timer. The timer is invoked until
-    # the supplied block returns false or nil.
-    def streaming_periodically(period, &block)
+    # starts implements a periodical timer. The timer is invoked until
+    # the supplied block returns false or nil. When the 
+    def start_stream_loop(period, block)
       @streaming = true
-      if block.call # invoke block for the first time
-        EventMachine::add_timer(period) do
-          if block.call
-            streaming_periodically(period, &block)
-          else
-            set_state(@persistent ? :state_initial : :state_done)
-          end
-        end
+      if block.call(self)
+        EventMachine::add_timer(period) {start_stream_loop(period, block)}
       else
-        set_state(@persistent ? :state_initial : :state_done)
+        set_state(:state_done)
       end
     end
   end

data/lib/serverside/http/static.rb

@@ -13,32 +13,45 @@ module ServerSide::HTTP
     }
     MIME_TYPES.default = 'text/plain'.freeze
     
-    CACHE_AGES = {}
-    CACHE_AGES.default = 86400 # one day
+    CACHE_TTL = {}
+    CACHE_TTL.default = 86400 # one day
+    
+    @@static_root = Dir.pwd
+    
+    def self.static_root
+      @@static_root
+    end
+    
+    def self.static_root=(dir)
+      @@static_root = dir
+    end
     
     INVALID_PATH_RE = /\.\./.freeze
     
     # Serves a static file or directory.
     def serve_static(fn)
+      full_path = @@static_root/fn
+      
       if fn =~ INVALID_PATH_RE
-        raise MalformedRequestError, "Invalid path specified (#{@uri})"
-      elsif !File.exists?(fn)
-        raise FileNotFoundError, "File not found (#{@uri})"
+        raise BadRequestError, "Invalid path specified (#{fn})"
+      elsif !File.exists?(full_path)
+        raise NotFoundError, "File not found (#{fn})"
       end
       
-      if File.directory?(fn)
-        send_directory_representation(fn)
+      if File.directory?(full_path)
+        set_directory_representation(full_path, fn)
       else
-        send_file_representation(fn)
+        set_file_representation(full_path, fn)
       end
     end
     
     # Sends a file representation, setting caching-related headers.
-    def send_file_representation(fn)
-      ext = File.extension(fn)
-      expires = Time.now + CACHE_AGES[ext]
-      cache :etag => File.etag(fn), :expires => expires, :last_modified => File.mtime(fn) do
-        send_file(STATUS_OK, MIME_TYPES[ext], fn)
+    def set_file_representation(full_path, fn)
+      ext = File.extension(full_path)
+      ttl = CACHE_TTL[ext]
+      validate_cache :etag => File.etag(full_path), :ttl => CACHE_TTL[ext], :last_modified => File.mtime(full_path) do
+        add_header(CONTENT_TYPE, MIME_TYPES[ext])
+        @body = IO.read(full_path)
       end
     end
     
@@ -46,14 +59,15 @@ module ServerSide::HTTP
     DIR_LISTING = '<li><a href="%s">%s</a><br/></li>'.freeze
 
     # Sends a directory representation.
-    def send_directory_representation(dir)
-      entries = Dir.entries(dir)
-      entries.reject! {|fn| fn =~ /^\./}
-      entries.unshift('..') if dir != './'
+    def set_directory_representation(full_path, fn)
+      entries = Dir.entries(full_path)
+      entries.reject! {|f| f =~ /^\./}
+      entries.unshift('..') if fn != '/'
       
-      list = entries.map {|e| DIR_LISTING % [@uri/e, e]}.join
-      html = DIR_TEMPLATE % [dir, dir, list]
-      send_representation(STATUS_OK, MIME_TYPES[:html], html)
+      list = entries.map {|e| DIR_LISTING % [fn/e, e]}.join
+      html = DIR_TEMPLATE % [fn, fn, list]
+      add_header(CONTENT_TYPE, MIME_TYPES[:html])
+      @body = html
     end
   end
 end

data/lib/serverside/http.rb

@@ -8,7 +8,8 @@ http_dir = File.dirname(__FILE__)/'http'
 require http_dir/'const'
 require http_dir/'error'
 require http_dir/'parsing'
-require http_dir/'response'
+require http_dir/'request'
 require http_dir/'caching'
 require http_dir/'static'
+require http_dir/'response'
 require http_dir/'server'

data/lib/serverside/js.rb

@@ -27,6 +27,7 @@ module ServerSide
         value = @stack.pop.__content
       else
         value = args.first
+        value = value.__content if value.respond_to?(:__content)
       end
       @stack.last.__add_hash_value(key, value)
       self
@@ -55,7 +56,7 @@ module ServerSide
     NULL = 'null'.freeze
     
     # Serializes the specified object into JS/JSON format. 
-    def __serialize(obj, quote_keys)
+    def __serialize(obj)
       case obj
       when Time: JSON.generate(obj.to_f)
       else
@@ -66,108 +67,11 @@ module ServerSide
     # Returns the document content as a literal Javascript object. If a callback was specified,
     # the object is wrapped in a Javascript function call.
     def to_s
-      j = __serialize(@content, false)
+      j = __serialize(@content)
       @callback ? "#{@callback}(#{j});" : j
     end
     
-    # Returns the content in JSON format.
-    def to_json
-      __serialize(@content, true)
-    end
-    
-    alias_method :inspect, :to_s
-  end
-end
-
-__END__
-
-module ServerSide
-  # Serializes data into a Javscript literal hash format. For example:
-  # ServerSide::JS.new {|j| j}
-  class JS
-    # blank slate
-    instance_methods.each do |m|
-      undef_method m unless (m =~ /^__|instance_eval|meta|respond_to|nil|is_a/)
-    end
-  
-    # Initializes a new document. A callback function name can be supplied to
-    # wrap the hash.
-    def initialize(callback = nil, &block)
-      @callback = callback
-      @stack = [self]
-      block.call(self) if block
-    end
-    
-    # Catches calls to define keys and creates methods on the fly.
-    def method_missing(key, *args, &block)
-      value = nil
-      if block
-        @stack.push JS.new
-        block.call(self)
-        value = @stack.pop.__content
-      else
-        value = args.first
-      end
-      @stack.last.__add_hash_value(key, value)
-      self
-    end
-    
-    def __add_hash_value(key, value)
-      @content ||= {}
-      @content[key] = value
-    end
-    
-    def __add_array_value(value)
-      @content ||= []
-      @content << value
-    end
-    
-    def <<(value)
-      value = value.__content if value.respond_to?(:__js)
-      @stack.last.__add_array_value(value)
-    end
-    
-    # Returns the current document content.
-    def __content
-      @content
-    end
-    
-    NULL = 'null'.freeze
-    
-    # Serializes the specified object into JS/JSON format. 
-    def __serialize(obj, quote_keys)
-      if obj.nil?
-        NULL
-      elsif obj.is_a? Array
-        "[#{obj.map{|v| __serialize(v, quote_keys)}.join(', ')}]"
-      elsif obj.is_a? Hash
-        if quote_keys
-          fields = obj.to_a.map{|kv| "\"#{kv[0]}\": #{__serialize(kv[1], quote_keys)}"}
-        else
-          fields = obj.to_a.map{|kv| "#{kv[0]}: #{__serialize(kv[1], quote_keys)}"}
-        end
-        "{#{fields.join(', ')}}"
-      elsif obj.is_a? Symbol
-        obj.to_s
-      elsif obj.is_a? Time
-        obj.to_f
-      else
-        obj.inspect
-      end
-    end
-    
-    # Returns the document content as a literal Javascript object. If a callback was specified,
-    # the object is wrapped in a Javascript function call.
-    def to_s
-      j = __serialize(@content, false)
-      @callback ? "#{@callback}(#{j});" : j
-    end
-    
-    # Returns the content in JSON format.
-    def to_json
-      __serialize(@content, true)
-    end
-    
+    alias_method :to_json, :to_s
     alias_method :inspect, :to_s
   end
 end

data/lib/serverside/xml.rb

@@ -24,7 +24,7 @@ module ServerSide
     end
   
     def __value(value)
-      @doc << value.to_s
+      @doc << value.to_s.html_escape
     end
   
     INSTRUCT_LEFT = '<?xml'.freeze
@@ -36,8 +36,6 @@ module ServerSide
       @doc << INSTRUCT_RIGHT
     end
   
-    SPACE = ' '.freeze
-
     def __fmt_atts(atts)
       atts.inject('') {|m, i| m << " #{i[0]}=#{i[1].to_s.inspect}"}
     end
@@ -71,8 +69,10 @@ module ServerSide
       self
     end
 
+    INSTRUCT_DEFAULT = {:version => "1.0", :encoding => "UTF-8"}.freeze
+
     def instruct!(atts = nil)
-      __instruct(atts || {:version => "1.0", :encoding => "UTF-8"})
+      __instruct(atts || INSTRUCT_DEFAULT)
     end
 
     def to_s