waves 0.7.3 → 0.7.5

data/lib/runtime/mime_types.rb

@@ -1,22 +1,22 @@
 module Waves
-  
+
   # Waves::MimeTypes defines an interface for adding MIME types used in mapping requests
   # to content types. Mongrel's MIME_TYPES hash is used as the baseline MIME map.
-  
-	module MimeTypes
-	  
-		def self.[]( path )
-		  mapping[ File.extname( path ) ]
-		end
-		
-		# TODO: This does not seem to be working.
-		def self.<<( mapping )
-		  mapping.merge!( mapping )
-		end
-		
-		def self.mapping
-		  @mapping ||= Mongrel::DirHandler::MIME_TYPES
-		end
-		
-	end
-end
+
+  module MimeTypes
+
+    def self.[]( path )
+      mapping[ File.extname( path ) ]
+    end
+
+    # TODO: This does not seem to be working.
+    def self.<<( mapping )
+      mapping.merge!( mapping )
+    end
+
+    def self.mapping
+      @mapping ||= Mongrel::DirHandler::MIME_TYPES
+    end
+
+  end
+end

data/lib/runtime/request.rb

@@ -1,52 +1,78 @@
 module Waves
-  # Waves::Request represents an HTTP request and has methods for accessing anything
-  # relating to the request. See Rack::Request for more information, since many methods
-  # are actually delegated to Rack::Request.
-	class Request
-		
-		class ParseError < Exception ; end
-		
-		attr_reader :response, :session
-		
-		# Create a new request. Takes a env parameter representing the request passed in from Rack.
-		# You shouldn't need to call this directly.
-		def initialize( env )
-			@request = Rack::Request.new( env )
-			@response = Waves::Response.new( self )
-			@session = Waves::Session.new( self )
-		end
-				
-		# Accessor not explicitly defined by Waves::Request are delegated to Rack::Request. 
-		# Check the Rack documentation for more information.
-		def method_missing(name,*args)
-			@request.send(name,*args)
-		end
-		
-		# The request path (PATH_INFO). Ex: +/entry/2008-01-17+
-		def path
-			@request.path_info
-		end
-
-		# The request domain. Ex: +www.fubar.com+
+  # Waves::Request represents an HTTP request and provides convenient methods for accessing request attributes. See Rack::Request for documentation of any method not defined here.
+  class Request
+
+    class ParseError < Exception ; end
+
+    attr_reader :response, :session, :blackboard
+
+    # Create a new request. Takes a env parameter representing the request passed in from Rack.
+    # You shouldn't need to call this directly.
+    def initialize( env )
+      @request = Rack::Request.new( env )
+      @response = Waves::Response.new( self )
+      @session = Waves::Session.new( self )
+      @blackboard = Waves::Blackboard.new( self )
+    end
+    
+    def rack_request; @request; end
+
+    # Accessor not explicitly defined by Waves::Request are delegated to Rack::Request.
+    # Check the Rack documentation for more information.
+    def method_missing(name,*args)
+      @request.send(name,*args)
+    end
+
+    # The request path (PATH_INFO). Ex: +/entry/2008-01-17+
+    def path
+      @request.path_info
+    end
+
+    # The request domain. Ex: +www.fubar.com+
     def domain
       @request.host
     end
-    
-    # The request method: GET, PUT, POST, or DELETE.
-		def method
-			@request.request_method.downcase.intern
-		end	
-		
-		# Raise a not found exception.
-		def not_found
-  		raise Waves::Dispatchers::NotFoundError.new( @request.url + ' not found.')
-  	end
+
+    # The request content type.
+    def content_type
+      @request.env['CONTENT_TYPE']
+    end
+
+    # Supported request methods
+    METHODS = %w{get post put delete head options trace}
+
+    # Override the Rack methods for querying the request method.
+    METHODS.each do |method|
+      class_eval "def #{method}?; method == :#{method} end"
+    end
+
+    # The request method. Because browsers can't send PUT or DELETE
+    # requests this can be simulated by sending a POST with a hidden
+    # field named '_method' and a value with 'PUT' or 'DELETE'. Also
+    # accepted is when a query parameter named '_method' is provided.
+    def method
+      @method ||= begin
+        request_method = @request.request_method.downcase
+        if request_method == 'post'
+          _method = @request['_method']
+          _method.downcase! if _method
+          METHODS.include?(_method) ? _method.intern : :post
+        else
+          request_method.intern
+        end
+      end
+    end
+
+    # Raise a not found exception.
+    def not_found
+      raise Waves::Dispatchers::NotFoundError.new( @request.url + ' not found.' )
+    end
 
     # Issue a redirect for the given path.
-		def redirect( path )
-			raise Waves::Dispatchers::Redirect.new( path )
-		end
-		
-	end
-	
-end
+    def redirect( path, status = '302' )
+      raise Waves::Dispatchers::Redirect.new( path, status )
+    end
+
+  end
+
+end

data/lib/runtime/response.rb

@@ -1,40 +1,40 @@
 module Waves
   # Waves::Response represents an HTTP response and has methods for constructing a response.
-  # These include setters for +content_type+, +content_length+, +location+, and +expires+ 
-  # headers. You may also set the headers directly using the [] operator. If you don't find
-  # what you are looking for here, check the documentation for Rack::Response since many
-  # methods for this class are delegated to Rack::Response.
-	class Response
-		
-		attr_reader :request
-		
-		# Create a new response. Takes the request object. You shouldn't need to call this directly.
-		def initialize( request )
-			@request = request
-			@response = Rack::Response.new
-		end
-				
-		%w( Content-Type Content-Length Location Expires ).each do |header|
-			define_method( header.downcase.gsub('-','_')+ '=' ) do | val |
-				@response[header] = val
-			end
-		end
-				
-		# Returns the sessions associated with the request, allowing you to set values within it.
-		# The session will be created if necessary and saved when the response is complete.
-		def session ; request.session ; end
-		
-		# Finish the response. This will send the response back to the client, so you shouldn't
-		# attempt to further modify the response once this method is called. You don't usually
-		# need to call it yourself, since it is called by the dispatcher once request processing
-		# is finished.
-		def finish ; request.session.save ; @response.finish ; end
-				
-		# Methods not explicitly defined by Waves::Response are delegated to Rack::Response. 
-		# Check the Rack documentation for more informations
-		def method_missing(name,*args)
-			@response.send(name,*args)
-		end
-		
-	end
+  # These include setters for +content_type+, +content_length+, +location+, and +expires+
+  # headers. You may also set the headers directly using the [] operator. See Rack::Response for documentation of any method not defined here.
+  class Response
+
+    attr_reader :request
+
+    # Create a new response. Takes the request object. You shouldn't need to call this directly.
+    def initialize( request )
+      @request = request
+      @response = Rack::Response.new
+    end
+    
+    def rack_response; @response; end
+
+    %w( Content-Type Content-Length Location Expires ).each do |header|
+      define_method( header.downcase.gsub('-','_')+ '=' ) do | val |
+        @response[header] = val
+      end
+    end
+
+    # Returns the sessions associated with the request, allowing you to set values within it.
+    # The session will be created if necessary and saved when the response is complete.
+    def session ; request.session ; end
+
+    # Finish the response. This will send the response back to the client, so you shouldn't
+    # attempt to further modify the response once this method is called. You don't usually
+    # need to call it yourself, since it is called by the dispatcher once request processing
+    # is finished.
+    def finish ; request.session.save ; @response.finish ; end
+
+    # Methods not explicitly defined by Waves::Response are delegated to Rack::Response.
+    # Check the Rack documentation for more informations
+    def method_missing(name,*args)
+      @response.send(name,*args)
+    end
+
+  end
 end

data/lib/runtime/response_mixin.rb

@@ -1,5 +1,5 @@
 module Waves
-  
+
   # Defines a set of methods that simplify accessing common request and response methods.
   # These include methods not necessarily associated with the Waves::Request and Waves::Response
   # objects, but which may still be useful for constructing a response.
@@ -11,25 +11,28 @@ module Waves
     # Access the request parameters.
     def params; request.params; end
     # Access the request session.
-		def session; request.session; end
-		# Access the request path.
-		def path; request.path; end
-		# Access the request url.
-		def url; request.url; end
-		# Access the request domain.
-		def domain; request.domain; end
-		# Issue a redirect for the given location.
-		def redirect(location); request.redirect(location); end
-		# Access the primary application's models
-		def models; Waves.application.models; end
-		# Access the primary application's views
-		def views; Waves.application.views; end
-		# Access the primary application's controllers
-		def controllers; Waves.application.controllers; end
-		# Raise a "not found" exception.
-		def not_found; request.not_found; end
-		# Access the Waves::Logger.
-		def log; Waves::Logger; end
-	end
-	
-end
+    def session; request.session; end
+    # Access the request path.
+    def path; request.path; end
+    # Access the request url.
+    def url; request.url; end
+    # Access the request domain.
+    def domain; request.domain; end
+    # Issue a redirect for the given location.
+    def redirect(location, status = '302'); request.redirect(location, status); end
+    # Access the primary application's models
+    def models; Waves.application.models; end
+    # Access the primary application's views
+    def views; Waves.application.views; end
+    # Access the primary application's controllers
+    def controllers; Waves.application.controllers; end
+    # Raise a "not found" exception.
+    def not_found; request.not_found; end
+    # Access the Waves::Logger.
+    def log; Waves::Logger; end
+    # Access the Blackboard
+    def blackboard; request.blackboard; end
+
+  end
+
+end

data/lib/runtime/response_proxy.rb

@@ -1,29 +1,30 @@
 module Waves
-	
-	class ResponseProxy 
+
+  # Mapping actions are evaluated in the context of a ResponseProxy.
+  class ResponseProxy
 
     attr_reader :request
 
     include ResponseMixin
-    
-		def initialize(request); @request = request; end
-		
-		def use( model ) ; @model = model ; self ; end
-		
-		def controller( &block )
-			Waves.application.controllers[ @model ].process( @request, &block )
-		end
-		
-		def view( &block )
-			Waves.application.views[ @model ].process( @request, @value, &block )
-		end
-		
-		def |( val ); @value = val; self; end
-		
-		def to_s; @value ; end
-		
-		def redirect(path); @request.redirect(path); end
-		
-	end
-	
-end
+
+    def initialize(request)
+      @request = request
+    end
+
+    def resource( resource, &block )
+      @resource = resource; yield.call
+    end
+
+    def controller( &block )
+      lambda { Waves.application.controllers[ @resource ].process( @request, &block ) }
+    end
+
+    def view( &block )
+      lambda { |val| Waves.application.views[ @resource ].process( @request, val, &block ) }
+    end
+
+    def redirect(path, status = '302'); @request.redirect(path, status); end
+
+  end
+
+end

data/lib/runtime/server.rb

@@ -1,83 +1,102 @@
 module Waves
-	# You can run the Waves::Server via the +waves-server+ command or via <tt>rake cluster:start</tt>. Run <tt>waves-server --help</tt> for options on the <tt>waves-server</tt> command. The <tt>cluster.start</tt> task use the +mode+ environment parameter to determine which configuration to use. You can define +port+ to run on a single port, or +ports+ (taking an array) to run on multiple ports.
-	#
-	# *Example*
-	#
-	# Assume that +ports+ is set in the development configuration like this:
-	#
-	#   ports [ 2020, 2021, 2022 ]
-	#
-	# Then you could start up instances on all three ports using:
-	#
-	#   rake cluster:start mode=development
-	#
-	# This is the equivalent of running:
-	#
-	#   waves-server -c development -p 2020 -d
-	#   waves-server -c development -p 2021 -d
-	#   waves-server -c development -p 2022 -d
-	#  
-	class Server < Application
-		
-		# Access the server thread.		
-		attr_reader :thread
-		
-		# Access the host we're binding to (set via the configuration).
-		def host ; options[:host] || config.host ; end
-		# Access the port we're listening on (set via the configuration).
-		def port ; options[:port] || config.port ; end
-		# Run the server as a daemon. Corresponds to the -d switch on +waves-server+.
-		def daemonize
-		  pwd = Dir.pwd
-		  Daemonize.daemonize( Waves::Logger.output )
-		  Dir.chdir(pwd)
-		  File.write( :log / $$+'.pid', '' )
-		end
-		# Start and / or access the Waves::Logger instance.
-		def log ; @log ||= Waves::Logger.start ; end
-		# Start the server.
-		def start
-			load( :lib / 'startup.rb' )
-		  daemonize if options[:daemon]
-			log.info "** Waves Server Starting ..."
-			t = real_start
-			log.info "** Waves Server Running on #{host}:#{port}"
-			log.info "Server started in #{(t*1000).round} ms."
-			@thread.join
-		end
-		# Stop the server.
-		def stop
-			log.info "** Waves Server Stopping ..."
-			pid_file = :log / $$ + '.pid'
-			FileUtils.rm( pid_file ) if options[:daemon] and File.exist?( pid_file )
-			@server.stop 
-			log.info "** Waves Server Stopped"
-		end
-		# Provides access to the server mutex for thread-safe operation.
-		def synchronize( &block ) ; ( @mutex ||= Mutex.new ).synchronize( &block ) ; end
+  # You can run the Waves::Server via the +waves-server+ command or via <tt>rake cluster:start</tt>. Run <tt>waves-server --help</tt> for options on the <tt>waves-server</tt> command. The <tt>cluster:start</tt> task uses the +mode+ environment variable to determine the active configuration. You can define +port+ to run on a single port, or +ports+ (taking an array) to run on multiple ports.
+  #
+  # *Example*
+  #
+  # Assume that +ports+ is set in the development configuration like this:
+  #
+  #   ports [ 2020, 2021, 2022 ]
+  #
+  # Then you could start up instances on all three ports using:
+  #
+  #   rake cluster:start mode=development
+  #
+  # This is the equivalent of running:
+  #
+  #   waves-server -c development -p 2020 -d
+  #   waves-server -c development -p 2021 -d
+  #   waves-server -c development -p 2022 -d
+  #
+  # The +cluster:stop+ task stops all of the instances.
+  #
+  class Server < Application
 
-		class << self
-			private :new, :dup, :clone
-			# Start or restart the server.
-			def run( options={} )
-				@server.stop if @server; @server = new( options ); @server.start
-			end
-			# Allows us to access the Waves::Server instance.
-			def method_missing(*args); @server.send(*args); end
-			# Probably wouldn't need this if I added a block parameter to method_missing.
-			def synchronize(&block) ; @server.synchronize(&block) ; end
-		end
-		
-		private
-		
-		def real_start
-		  Benchmark.realtime do
-				@server = ::Mongrel::HttpServer.new( host, port )
-				@server.register('/', Rack::Handler::Mongrel.new( config.application.to_app	 ) )
-				trap('INT') { puts; stop }; @thread = @server.run
-			end
-		end
+    # Access the server thread.
+    attr_reader :thread
 
-	end
-	
-end
+    # Access the host we're binding to (set via the configuration).
+    def host ; options[:host] || config.host ; end
+
+    # Access the port we're listening on (set via the configuration).
+    def port ; options[:port] || config.port ; end
+
+    # Run the server as a daemon. Corresponds to the -d switch on +waves-server+.
+    def daemonize
+      pwd = Dir.pwd
+      Daemonize.daemonize( Waves::Logger.output )
+      Dir.chdir(pwd)
+      File.write( :log / "#{port}.pid", $$ )
+    end
+
+    # Start and / or access the Waves::Logger instance.
+    def log
+      @log ||= Waves::Logger.start
+    end
+
+    # Start the server.
+    def start
+      daemonize if options[:daemon]
+      start_debugger if options[:debugger]
+      log.info "** Waves Server starting  on #{host}:#{port}"
+      handler, options = config.handler
+      handler.run( config.application.to_app, options ) do |server|
+        @server = server
+        trap('INT') { puts; stop } if @server.respond_to? :stop
+      end
+    end
+
+    # Stop the server.
+    def stop
+      log.info "** Waves Server Stopping ..."
+      if options[:daemon]
+        pid_file = :log / $$ + '.pid'; FileUtils.rm( pid_file ) if File.exist?( pid_file )
+      end
+      @server.stop
+      log.info "** Waves Server Stopped"
+    end
+
+    # Provides access to the server mutex for thread-safe operation.
+    def synchronize( &block ) ; ( @mutex ||= Mutex.new ).synchronize( &block ) ; end
+
+    class << self
+      private :new, :dup, :clone
+      # Start or restart the server.
+      def run( options={} )
+        @server.stop if @server; @server = new( options ); @server.start
+      end
+      
+      # Allows us to access the Waves::Server instance.
+      def method_missing(*args)
+        @server.send(*args)
+      end
+      
+      #-- Probably wouldn't need this if I added a block parameter to method_missing.
+      def synchronize(&block) ; @server.synchronize(&block) ; end
+    end
+
+    private
+
+    def start_debugger
+      begin
+        require 'ruby-debug'
+        Debugger.start
+        Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+        log.info "Debugger enabled"
+      rescue Exception
+        log.info "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
+        exit
+      end
+    end
+  end
+
+end