waves-stable 0.7.7 → 2009.3.10

data/lib/matchers/resource.rb

@@ -0,0 +1,19 @@
+module Waves
+
+  module Matchers
+
+    class Resource
+      
+      def initialize( options )
+        @matcher = Waves::Matchers::Request.new( options )
+      end
+
+      def call( resource ) ; @matcher.call( resource.request ) ; end
+      def []( *args ) ; call( *args ) ; end
+      
+          
+    end
+    
+  end
+  
+end

data/lib/matchers/traits.rb

@@ -0,0 +1,19 @@
+module Waves
+
+  module Matchers
+
+    class Traits < Base
+      
+      def initialize( pattern ) ; @pattern = ( pattern or {} ) ; end
+    
+      def call( request )
+        @pattern.all? do | key, val |
+          ( val.is_a? Proc and val.call( request.traits[ key ] ) ) or val === request.traits[ key ]
+        end
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/matchers/uri.rb

@@ -0,0 +1,20 @@
+module Waves
+
+  module Matchers
+
+    class URI < Base
+      
+      def initialize( options )
+        @path = Waves::Matchers::Path.new( options[ :path ] )
+        @constraints = { :server => options[ :server ], :scheme => options[ :scheme ] }
+      end
+    
+      def call( request )
+        @path.call( request ) if test( request )
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/renderers/mixin.rb

@@ -6,42 +6,28 @@ module Waves
     # Just include this in your Renderer class and write your render method.
     module Mixin
 
-      # Adds the following methods to the target class:
-      #
-      # - extension: allows you to set or get the extension used by this renderer.
-      #
-      #     Renderers::Markaby.extension 'foo' # tell Waves to use .foo as Markaby extension
+      # Adds the following methods to the mod class:
       #
       # - filename: generate a filename for the template based on a logical path.
       # - template: read the template from the file corresponding to the given logical path.
       # - helper: return a helper module that corresponds to the given logical path.
       #
-      def self.included(target)
-        class << target
-
-          def extension(*args)
-            return @extension if args.length == 0
-            @extension = args.first
-          end
-
-          def filename(path)
-            :templates / "#{path}.#{self.extension}"
-          end
-
-          def render(path,args=nil)
-          end
-
-          def template( path )
-            File.read( filename( path ) )
-          end
-
-          def helper( path )
-            Waves.application.helpers[
-              File.basename( File.dirname( path ) ).camel_case ]
-          end
-        end
+
+      def included( app )
+        Waves::Views.renderers << self
+      end
+
+      def filename(path)
+        "#{path}.#{self::Extension}"
+      end
+
+      def template( path )
+        File.read( filename( path ) )
       end
 
+      def helper( path )
+        Waves.main[ :helpers ][ File.basename( File.dirname( path ) ).camel_case ]
+      end
 
     end
 

data/lib/resources/mixin.rb

@@ -0,0 +1,134 @@
+module Waves
+  
+  module Resources
+    
+    StatusCodes = {
+      Waves::Dispatchers::NotFoundError => 404
+    }
+    
+    
+    module Mixin
+      
+      attr_reader :request
+      
+      module ClassMethods
+          
+        def paths
+          unless @paths
+            resource = self
+            @paths = Class.new( superclass.respond_to?( :paths ) ? superclass.paths : Waves::Resources::Paths ) do
+              @resource = resource
+              def self.resource ; @resource ; end
+            end
+          else
+            @paths
+          end
+        end
+        def with( options ) ; @options = options ; yield ; @options = nil ; end
+        def on( method, path = true, options = nil, &block )
+          if path.is_a? Hash
+            generator = path.keys.first
+            path = path.values.first
+          end
+          if options
+            options[ :path ] = path
+          else
+            options = { :path => path }
+          end
+          options = @options.merge( options ) if @options
+          matcher = Waves::Matchers::Resource.new( options )
+          methods = case method
+            when nil then nil
+            when true then [ :post, :get, :put, :delete ]
+            when Array then method
+            else [ method ]
+          end
+          methods.each do | method |
+            functor_with_self( method, matcher, &block )
+          end
+          paths.module_eval { 
+            define_method( generator ) { | *args | generate( path, args ) }
+          } if generator
+        end
+        def before( path = nil, options = {}, &block )
+          on( :before, path, options, &block )
+        end
+        def after( path = nil, options = {}, &block )
+          on( :after, path, options, &block )
+        end
+        def wrap( path = nil, options = {}, &block )
+          before( path, options, &block )
+          after( path, options, &block )
+        end
+        def handler( exception, &block ) ; functor( :handler, exception, &block ) ; end
+        def always( &block ) ; define_method( :always, &block ) ; end
+        
+      end
+
+      # this is necessary because you can't define functors within a module because the functor attempts
+      # to incorporate the superclass functor table into it's own
+      def self.included( resource )
+        
+        resource.module_eval do 
+      
+          include ResponseMixin, Functor::Method ; extend ClassMethods
+
+          def initialize( request ); @request = request ; end
+      
+          def process
+            begin
+              before ; body = send( request.method ) ; after
+            rescue Waves::Dispatchers::Redirect => e
+              raise e
+            rescue Exception => e
+              response.status = ( StatusCodes[ e.class ] || 500 )
+              ( body = handler( e ) ) rescue raise e
+              Waves::Logger.warn e.to_s
+              e.backtrace.each { |t| Waves::Logger.debug "    #{t}" }
+            ensure
+              always
+            end
+            return body
+          end
+      
+          def to( resource )
+            resource = case resource
+            when Base
+              resource
+            when Symbol, String
+              begin 
+                Waves.main::Resources[ resource ]
+              rescue NameError
+                raise Waves::Dispatchers::NotFoundError
+              end
+              Waves.main::Resources[ resource ]
+            end
+            r = traits.waves.resource = resource.new( request )
+            r.process
+          end
+          
+          def redirect( path ) ; request.redirect( path ) ; end
+      
+          # override for resources that may have long-running requests. this helps servers 
+          # determine how to handle the request
+          def deferred? ; false ; end
+          
+          before {} ; after {} ; always {}
+          # handler( Waves::Dispatchers::Redirect ) { |e| raise e }
+      
+          %w( post get put delete head ).each do | method |
+            on( method ) { not_found }
+          end
+                
+        end
+        
+      end
+
+    end
+      
+    class Base ; include Mixin ; end 
+
+  end
+
+
+end

data/lib/resources/paths.rb

@@ -0,0 +1,34 @@
+module Waves
+  
+  module Resources
+    
+    class Paths
+      
+      attr_accessor :request
+      
+      include Waves::ResponseMixin
+      
+      def initialize( request ) ; @request = request ; end
+      
+      def generate( template, args )
+        return "/#{ args * '/' }" unless template.is_a?( Array ) and not template.empty?
+        path = []
+        ( "/#{ path * '/' }" ) if template.all? do | want |
+          case want
+          when true then path += args
+          when String then path << want
+          when Symbol then path << args.shift
+          when Regexp then path << args.shift
+          when Hash
+            key, value = want.to_a.first
+            case value
+            when true then path += args
+            when String, Symbol, RegExp then path << args.unshift
+            end
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/runtime/configuration.rb

@@ -1,114 +1,5 @@
 module Waves
 
-  # Waves configurations are Ruby code.  This means you can use a Ruby expression as
-  # the value of a configuration attribute, extend and inherit your configurations, and
-  # add your own attributes. You can even use it as a repository
-  # for your application configuration.
-  #
-  # You can access configuration attributes using the attribute name as a method, with the value as the argument.
-  #
-  # == Example
-  #
-  #    module Blog
-  #      module Configurations
-  #        class Development < Default
-  #          host '127.0.0.1'
-  #          port 2000
-  #          reloadable [ Blog ]
-  #          log :level => :debug
-  #          application do
-  #            use Rack::ShowExceptions
-  #            run Waves::Dispatchers::Default.new
-  #          end
-  #        end
-  #      end
-  #    end
-  #
-  # There are three forms for accessing attributes:
-  #
-  #   Waves.config.port                        # generic form - gets the value for current config
-  #   Blog.configurations[:development].port   # gets the value for a specified config
-  #   Blog::Configurations::Development.port   # Access a specific config constant directly
-  #
-  # Configuration data is inheritable, as shown in the example above. Typically, you
-  # would set data common to all configurations in the Default class, from which
-  # your variations inherit.
-  #
-  # You may define your own heritable attributes using the +attribute+ class method:
-  #
-  #   class Default < Waves::Configurations::Default
-  #     attribute 'theme' # define an attribute named "theme"
-  #     theme 'ultra'     # set an inheritable default
-  #   end
-  #
-  # Certain attributes are reserved for internal use by Waves:
-  #
-  # - application: configure the application for use with Rack
-  # - database: initialization parameters needed by the ORM layer
-  # - reloadable: an array of module names to reload; see below for more
-  # - log: takes a hash of parameters; see below for more
-  # - host: the host to bind the server to (string)
-  # - port: the port for the server to listen on (number)
-  # - ports: used by the cluster:start task for clustering servers (array of numbers)
-  # - debug: true if running in "debug" mode, which automatically reloads code
-  #
-  # == Configuring The Rack Application
-  #
-  # One of the really nice features of Rack is the ability to install "middleware"
-  # components to optimize the way you handle requests. Waves exposes this ability
-  # directly to the application developer via the +application+ configuration method.
-  #
-  # *Example*
-  #
-  #   # Typical debugging configuration
-  #   application do
-  #     use Rack::ShowExceptions
-  #     run Waves::Dispatchers::Default.new
-  #   end
-  #
-  # == Configuring Database Access
-  #
-  # The ORM layers provided with Waves use the +database+ attribute for connection initialization.
-  # Most ORMs take a hash for this purpose, with keys that may vary depending on the ORM and backend.
-  #
-  #   # Sequel with a MySQL db
-  #   database :host => 'localhost', :adapter => 'mysql', :database => 'blog',
-  #     :user => 'root', :password => 'guess'
-  #
-  #   # Sequel with an SQLite db
-  #   database :adapter => 'sqlite', :database => 'blog'
-  #
-  # See the documentation for each ORM layer for details.
-  #
-  # == Configuring Code Reloading
-  #
-  # The +reloadable+ attribute takes an array of modules. Before every request, the default Waves 
-  # dispatcher calls +reload+ on each listed module.  The module should remove any reloadable constants
-  # currently defined in its namespace.  
-  #
-  # In a Waves application built on the Default foundation, +reload+ functionality is provided
-  # by AutoCode for the Configurations, Controllers, Helpers, Models, and Views modules.
-  # 
-  # Listing only your application module will work in most cases:  
-  #
-  #   reloadable [ Blog ]
-  #
-  # As an alternative, you could reload only some of the modules within your application:
-  #
-  #   reloadable [ Blog::Models, Blog::Controllers ]
-  #
-  # == Configuring Logging
-  #
-  # The +log+ configuration attribute takes hash with these keys:
-  # - :level - The log filter level. Uses Ruby's built in Logger class.
-  # - :output - A filename or IO object. Should be a filename if running as a daemon.
-  #
-  # *Examples*
-  #
-  #  log :level => :info, :output => $stderr
-  #  log :level => :error, :output => 'log/blog.log'
-  #
-
   module Configurations
 
     class Base
@@ -131,33 +22,48 @@ module Waves
         end
         self[ name ] = nil
       end
+      
+      def self.attributes( *names )
+        names.each { |name| attribute( name ) }
+      end
 
     end
 
     # The Default configuration defines sensible defaults for attributes required by Waves.
-    #   debug true
-    #   synchronize? true
-    #   session :duration => 30.minutes, :path => '/tmp/sessions'
-    #   log :level => :info, :output => $stderr
-    #   reloadable []
     class Default < Base
-
-      %w( host port ports log reloadable database session debug root synchronize? ).
-      each { |name| attribute(name) }
-
-      # Set the Rack handler, along with any specific options
-      # that need to be passed to the handler's #run method. 
-      #
-      # When accessing the value
-      # (calling with no arguments), returns an array of the handler and options.
-      def self.handler(*args)
-        if args.length > 0
-          @rack_handler, @rack_handler_options = args
-        else
-          [ @rack_handler, @rack_handler_options ]
-        end
-      end
-
+      
+      # 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 ) 
+      
+      # 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 )
+      
+      # are there any gems we need to check for on startup?
+      attributes( :dependencies )
+      
       # 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
@@ -173,13 +79,22 @@ module Waves
           self['application']
         end
       end
-
-      debug true ; synchronize? true
-      session :duration => 30.minutes, :path => '/tmp/sessions'
+      
+      # default options
+      debug true
       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
+      }
     end
   end
 end
-
-