waves-stable 0.7.7

data/lib/runtime/console.rb

@@ -0,0 +1,20 @@
+module Waves
+
+  class Console < Application
+
+    class << self
+
+      attr_reader :console
+
+      def load( options={} )
+        @console ||= Waves::Console.new( options )
+      end
+
+      # allow Waves::Console to act as The Console Instance
+      def method_missing(*args); @console.send(*args); end
+
+    end
+
+  end
+
+end

data/lib/runtime/debugger.rb

@@ -0,0 +1,9 @@
+module Kernel
+  unless respond_to?(:debugger)
+    # Starts a debugging session if ruby-debug has been loaded (call waves-server --debugger to do load it).
+    def debugger
+      puts "debugger called"
+      Waves::Logger.info "\n***** Debugger requested, but was not available: Start server with --debugger to enable *****\n"
+    end
+  end
+end

data/lib/runtime/logger.rb

@@ -0,0 +1,59 @@
+require 'logger'
+module Waves
+
+  # Waves::Logger is based on Ruby's built-in Logger. It uses the same filtering approach
+  # (debug, info, warn, error, fatal), although the interface is slightly different.
+  # You won't typically instantiate this class directly; instead, you will specify the
+  # logging configuration you want in your configuration files. See Waves::Configurations
+  # for more information on this.
+  #
+  # To use the logger for output, you can usually just call +log+, since the Waves::ResponseHelper
+  # mixin defines it (meaning it is available in the mapping file, controllers, views, and
+  # templates). Or, you can access Waves::Logger directly. Either way, the logger provides five
+  # methods for output corresponding to the log levels.
+  #
+  # *Examples*
+  #   # log the value of foo
+  #   log.info "Value of foo: #{foo}"
+  #
+  #   # fatal error!
+  #   Waves::Logger.fatal "She can't hold up any longer, cap'n!"
+  #
+  module Logger
+
+    class << self
+
+      # Returns the object being used for output by the logger.
+      def output
+        @output ||= ( config[:output] ? File.expand_path( config[:output] ) : $stderr )
+      end
+      
+      # Returns the active configuration for the logger.
+      def config
+        @config ||= Waves::Server.config.log
+      end
+      
+      # Returns the logging level used to filter logging events.
+      def level ; @level ||= ::Logger.const_get( config[:level].to_s.upcase || 'INFO' ) ; end
+      
+      # Starts the logger, using the active configuration to initialize it.
+      def start
+        @log = config[:rotation] ?
+          ::Logger.new( output, config[:rotation].intern ) :
+          ::Logger.new( output )
+        @log.level = level
+        @log.datetime_format = "%Y-%m-%d %H:%M:%S "
+        self
+      end
+      
+      # Forwards logging methods to the logger.
+      def method_missing(name,*args,&block)
+        @log.send name,*args, &block if @log
+      end
+
+    end
+
+  end
+
+end
+

data/lib/runtime/mime_types.rb

@@ -0,0 +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

data/lib/runtime/request.rb

@@ -0,0 +1,78 @@
+module Waves
+  # 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 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, status = '302' )
+      raise Waves::Dispatchers::Redirect.new( path, status )
+    end
+
+  end
+
+end

data/lib/runtime/response.rb

@@ -0,0 +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. 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

@@ -0,0 +1,38 @@
+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.
+  #
+  # This mixin assumes that a @request@ accessor already exists.
+  module ResponseMixin
+    # Access the response.
+    def response; request.response; end
+    # 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, 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

@@ -0,0 +1,30 @@
+module Waves
+
+  # Mapping actions are evaluated in the context of a ResponseProxy.
+  class ResponseProxy
+
+    attr_reader :request
+
+    include ResponseMixin
+
+    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

@@ -0,0 +1,107 @@
+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 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
+
+    # 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 / "#{port}.pid", $$ )
+    end
+
+    def trap(signal)
+      Kernel::trap(signal) { yield }
+      Thread.new { loop {sleep 1} } if RUBY_PLATFORM =~ /mswin32/
+    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
+        self.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

data/lib/runtime/session.rb

@@ -0,0 +1,66 @@
+module Waves
+
+  # Encapsulates the session associated with a given request. A session has an expiration
+  # and path, which must be provided in a Waves::Configuration. Sensible defaults are defined
+  # in Waves::Configurations::Default
+  class Session
+    
+    # Concoct a (probably) unique session id
+    def self.generate_session_id 
+      # from Camping ...
+      chars = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
+      (0..48).inject(''){|s,x| s+=chars[ rand(chars.length) ] }
+    end
+
+    # Create a new session object using the given request. This is not necessarily the
+    # same as constructing a new session. The session_id cookie for the request domain
+    # is used to store a session id. The actual session data will be stored in a directory
+    # specified by the application's configuration file.
+    def initialize( request )
+      @request = request
+      @data ||= ( File.exist?( session_path  ) ? load_session : {} )
+    end
+    
+    # Return the session data as a hash
+    def to_hash
+      @data.to_hash
+    end
+    
+    def self.base_path
+      Waves::Application.instance.config.session[:path]
+    end
+
+    # Save the session data. You shouldn't typically have to call this directly, since it
+    # is called by Waves::Response#finish.
+    def save
+      if @data && @data.length > 0
+        File.write( session_path, @data.to_yaml )
+        @request.response.set_cookie( 'session_id',
+          :value => session_id, :path => '/',
+          :expires => Time.now + Waves::Server.config.session[:duration] )
+      end
+    end
+
+    # Access a given data element of the session using the given key.
+    def [](key) ; @data[key] ; end
+    # Set the given data element of the session using the given key and value.
+    def []=(key,val) ; @data[key] = val ; end
+
+    private
+
+    def session_id
+      @session_id ||= ( @request.cookies['session_id'] || Waves::Session.generate_session_id )
+    end
+
+    def session_path
+      Waves::Session.base_path / session_id
+    end
+
+    def load_session
+      YAML.load( File.read( session_path ) )
+    end
+
+  end
+
+end
+