waves 0.8.2 → 0.9.0

data/lib/waves/response/client_errors.rb

@@ -0,0 +1,10 @@
+module Waves
+  class Response
+    module ClientError ; end
+    module ClientErrors
+      class NotFound < Packaged[404]
+        include ClientError
+      end
+    end
+  end
+end

data/lib/waves/response/packaged.rb

@@ -0,0 +1,19 @@
+module Waves
+  class Response
+    
+    class Packaged < Exception
+      def self.[]( status )
+        Class.new( self ) do 
+          define_method( :status ) { status }
+        end
+      end
+      def call( response )
+        response.status = status.to_s
+      end
+      def message
+        "HTTP Reponse #{status}"
+      end
+    end
+        
+  end
+end

data/lib/waves/response/redirects.rb

@@ -0,0 +1,35 @@
+module Waves
+  class Response
+
+    module Redirect ; end
+
+    # Redirects are raised by applications and rescued by the Waves 
+    # dispatcher and used to set the response status and location.
+
+    module Redirects
+      
+      class Found < Packaged[302]
+        include Redirect
+        attr_reader :location
+        def initialize( location )
+          @location = location ; super()
+        end
+        def call( response )
+          response.location = location
+          super( response )
+        end
+      end
+    
+      class NotModified < Packaged[304]
+        include Redirect
+        def call ( response )
+          %w( Allow Content-Encoding Content-Language Content-Length Content-MD5
+                Content-Type Last-Modified ).each { |h| response.headers.delete( h ) }
+          response.cache_control = 'public'
+          response.body = []
+          super( response )
+        end
+      end
+    end
+  end
+end

data/lib/{runtime → waves/response}/response.rb

@@ -1,10 +1,10 @@
 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
@@ -14,13 +14,21 @@ module Waves
       @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
+    %w( Status Content-Type Content-Length Cache-Control Location Expires ).each do |header|
+      name = header.downcase.tr( '-','_' )
+      define_method("#{name}=") {|val| @response[header] = val }
+      define_method("#{name}") { @response[header] }
+    end
+    
+    def last_modified
+      @last_modified
+    end
+    
+    def last_modified=( timestamp )
+      @last_modified = timestamp
     end
 
     # Returns the sessions associated with the request, allowing you to set values within it.
@@ -31,12 +39,22 @@ module Waves
     # 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 ;  @response.finish ; end
+    def finish
+      @response['Last-Modified'] = @last_modified.to_http_timestamp if @last_modified
+      @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)
+    # Check the Rack documentation for more information
+    extend Forwardable
+    def method_missing( name, *args, &block )
+      if @response.respond_to?( name )
+        # avoid having to use method missing in the future
+        self.class.class_eval { def_delegator :@response, name }
+        @response.send( name, *args, &block )
+      else
+        super
+      end
     end
 
   end

data/lib/{runtime → waves/response}/response_mixin.rb

@@ -10,7 +10,7 @@ module Waves
     # Access the response.
     def response; request.response; end
     
-    def resource ; traits.waves.resource ; end
+    def resource; traits.waves.resource || ( self if self.kind_of? Waves::Resources::Mixin ) ; end
 
     def traits ; request.traits ; end
     
@@ -23,35 +23,48 @@ module Waves
     
     # Both the query and capture merged together
     def params 
-      query = captured ? request.query.merge( captured.to_h ) : request.query
-      @params ||= Waves::Request::Query.new( query ) 
+      @params ||= Waves::Request::Query.new( captured ? 
+        request.query.merge( captured.to_h ) : request.query ) 
     end
     
-    %w( session path url domain not_found ).each do | m |
+    %w( session path url domain ).each do | m |
       define_method( m ) { request.send( m ) }
     end
     
-    # Issue a redirect for the given location.
-    def redirect(location, status = '302'); request.redirect(location, status); end
-    # Access the Waves::Logger.
     def log; Waves::Logger; end
-    # access stuff from an app
-    def app_name ; self.class.rootname.snake_case.to_sym ; end
-    def app ; eval(  "::#{app_name.to_s.camel_case}" ) ; end    
+
+    def app ; self.class.root ; end
+
+    def main ; Waves.main ; end
+
     def paths( rname = nil )
-      ( rname.nil? ? resource.class.paths : app::Resources[ rname ].paths ).new( request )
+      ( rname ? app::Resources[ rname ].paths : resource.class.paths ).new
     end
 
-    # these take strings or operate on the path by default
-    def basename( str = nil ) ; ( str or path ).sub(/\.([^\.]+)$/,'') ; end
+    def http_cache( last_modified )
+      response.last_modified = last_modified
+      modified?( last_modified ) ? yield : not_modified
+    end
 
-    def extension( str = nil )
-      ( m = ( str or path ).match(/\.([^\.]+)$/) ) ? m[1] : nil
+    def modified?( last_modified )
+      request.if_modified_since.nil? || 
+        last_modified > request.if_modified_since
     end
     
-    def render( path, assigns = {} )
-      Waves::Views::Base.new( request ).render( path, assigns )
+    # Raise a not found exception.
+    def not_found
+      raise Waves::Response::ClientErrors::NotFound.new
     end
+
+    # Issue a redirect for the given path.
+    def redirect( path )
+      raise Waves::Response::Redirects::Found.new( path )
+    end
+
+    def not_modified
+      raise Waves::Response::Redirects::NotModified.new
+    end
+    
   end
 
 end

data/lib/waves/runtime/applications.rb

@@ -0,0 +1,18 @@
+module Waves
+  
+  class Applications < Array
+    def []( name ) ; self.find { |app| app.name.snake_case.to_sym == name } ; end
+  end
+
+  def self.config; instance.config ; end
+
+  # The list of all loaded applications
+  def self.applications ; @applications ||= Applications.new ; end
+
+  # Access the principal Waves application.
+  def self.main ; applications.first ; end
+
+  # Register a module as a Waves application.
+  def self.<< ( app ) ; applications << app ; end
+
+end

data/lib/{runtime → waves/runtime}/configuration.rb

@@ -11,7 +11,7 @@ module Waves
 
       # Get the value of the given attribute. Typically, you wouldn't
       # use this directly.
-      def self.[]( name ) ; send "_#{name}" ; end
+      def self.[]( name ) ; send "_#{name}" rescue nil ; end
 
       # Define a new attribute. After calling this, you can get and set the value
       # using the attribute name as the method
@@ -22,7 +22,7 @@ module Waves
         end
         self[ name ] = nil
       end
-      
+
       def self.attributes( *names )
         names.each { |name| attribute( name ) }
       end
@@ -31,39 +31,47 @@ module Waves
 
     # The Default configuration defines sensible defaults for attributes required by Waves.
     class Default < Base
-      
+
       # define where a server should listen
       # can be overridden by -p and -h options
       attributes( :host, :port, :ports )
-      
+
       # which server to use, ex: Waves::Servers::Mongrel
       attribute( :server )
-      
+
       # where will the logger write to? can be a IO object or a pathname
       # also can set the level here to :fatal, :debug, :warn, :info
       attribute( :log )
-      
+
       # which modules are going to be reloaded on each request?
       attribute( :reloadable )
-      
+
       # which resource to use as the "main" resource for this server
-      attribute( :resource ) 
-      
+      attribute( :resource )
+
       # parameters for the database connection, varies by ORM
       attribute( :database )
-      
+
       # set the debug mode flag; typically done in dev / test configurations
       attribute( :debug )
-      
+
       # what object to use as the main Waves cache
       attribute( :cache )
-      
+
       # do you want to run a console thread (ex: LiveConsole)
       attribute( :console )
       
+      # what dispatcher do you want to use
+      attribute( :dispatcher )
+
       # are there any gems we need to check for on startup?
-      attributes( :dependencies )
-      
+      def self.dependencies( list )
+        list.each do |d| 
+          gem d[:name], d[:version]
+          require d[:load] if d[:load]
+        end
+      end
+
       # Provides access to the Waves::MimeTypes class via the configuration. You
       # can override #mime_types to return your own MIME types repository class.
       def self.mime_types
@@ -76,25 +84,23 @@ module Waves
         if block_given?
           self['application'] = Rack::Builder.new( &block )
         else
-          self['application']
+          self['application'] ||= Rack::Builder.new
         end
       end
       
+      def self.use( middleware, options )
+        application.use( middleware, options )
+      end
+      
       # default options
-      debug true
+      debug false
       log :level => :info, :output => $stderr
       reloadable []
       dependencies []
       server Waves::Servers::WEBrick
-      application {
-        use ::Rack::ShowExceptions
-        use Rack::Session::Cookie, :key => 'rack.session',
-        # :domain => 'foo.com',
-        :path => '/',
-        :expire_after => 2592000,
-        :secret => 'Change it'
-        run ::Waves::Dispatchers::Default.new
-      }
+      application.use ::Rack::ShowExceptions
+      dispatcher Waves::Dispatchers::Default
+
     end
   end
 end

data/lib/waves/runtime/console.rb

@@ -0,0 +1,24 @@
+require 'waves/runtime/mocks'
+
+module Waves
+
+  class Console
+
+    attr_accessor :options
+    
+    include Waves::Runtime
+    
+    def self.load( options={} )
+      Object.instance_eval { include Waves::Mocks }
+      new( options )
+    end
+    
+    
+    def initialize( options = {} )
+      @options = options
+      load # load the runtime
+    end
+
+  end
+
+end

data/lib/{runtime → waves/runtime}/logger.rb

@@ -24,9 +24,9 @@ module Waves
       self
     end
     
-    # Forwards logging methods to the logger.
-    def self.method_missing(name,*args,&block)
-      @log.send name,*args, &block if @log
+    class << self
+      extend Forwardable
+      def_delegators :@log, *%w( debug info warn error )
     end
 
   end

data/lib/{runtime → waves/runtime}/mocks.rb

@@ -1,6 +1,6 @@
 module Waves
   module Mocks
-    
+
     def dispatcher ; Waves::Dispatchers::Default ; end
     def request ; Rack::MockRequest.new( dispatcher.new ) ; end
     def env( uri, opts ) ; Rack::MockRequest.env_for( uri, opts ) ; end
@@ -9,6 +9,6 @@ module Waves
     def post( uri, opts = {} ) ; request.post( uri, opts ) ; end
     def delete( uri, opts = {} ) ; request.delete( uri, opts ) ; end
     def head( uri, opts = {} ) ; request.request( 'HEAD', uri, opts ) ; end
-    
+
   end
 end

data/lib/waves/runtime/rackup.rb

@@ -0,0 +1,37 @@
+module Waves
+
+  # Runtime to use with Rackup specifically.
+  #
+  # The actual Rack application is built using `config.application`
+  # (see runtime/configuration.rb), not in the .ru file. Rackup
+  # expects to be used in the context of an already-running server.
+  # See the documentation for your webserver and Rack for details.
+  #
+  # Your config.ru file should minimally look something like this:
+  #
+  #   require "waves"
+  #   require "waves/runtime/rackup"
+  #
+  #   run Waves::Rackup.load
+  #
+  class Rackup
+    
+    attr_accessor :options
+    
+    include Waves::Runtime
+
+    # Load the runtime and return an application.
+    def self.load(options = {})
+      new( options )
+      config.application.to_app
+    end
+    
+    def initialize( options = {} )
+      @options = options
+      load # load runtime
+    end
+
+  end
+
+end
+

data/lib/waves/runtime/runtime.rb

@@ -0,0 +1,48 @@
+require 'forwardable'
+
+module Waves
+
+  module Runtime
+
+    class << self; attr_accessor :instance; end
+
+    # Create a new Waves application instance.
+    def load
+      Dir.chdir( options[:directory] ) if options[:directory]
+      Kernel.load( options[:startup] || 'startup.rb' )
+      Runtime.instance = self
+      options[:logger] ||= logger
+    end
+
+    # The 'mode' of the runtime determines which configuration it will run under.
+    def mode ; options[:mode]||:development ; end
+
+    # Returns true if debug was set to true in the current configuration.
+    def debug? ; options[:debugger] or config.debug ; end
+
+    # Returns the current configuration.
+    def config ; Waves.main[:configurations][ mode ] ; end
+
+    # Reload the modules specified in the current configuration.
+    def reload ; config.reloadable.each { |mod| mod.reload } ; end
+
+    # Start and / or access the Waves::Logger instance.
+    def logger ; @log ||= Waves::Logger.start ; end
+
+    # Provides access to the server mutex for thread-safe operation.
+    def synchronize( &block ) ; ( @mutex ||= Mutex.new ).synchronize( &block ) ; end
+    def synchronize? ; !options[ :turbo ] ; end
+
+  end
+  
+  class << self 
+    
+    # Returns the most recently created instance of Waves::Runtime.
+    def instance ; Waves::Runtime.instance ; end
+  
+    extend Forwardable
+    def_delegators :instance, *%w( mode debug? config reload logger synchronize synchronize? )
+    
+  end
+
+end