waves 0.7.7 → 0.8.0

data/lib/resources/mixin.rb

@@ -0,0 +1,132 @@
+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 Exception => e
+              response.status = ( StatusCodes[ e.class ] || 500 )
+              ( body = handler( e ) ) rescue raise e
+              Waves::Logger.warn e.to_s
+              Waves::Logger.debug "#{e.class.name} : #{e.message}"
+              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 {}
+      
+          %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,51 @@ 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 )
+      
+      # options for the session: options for duration and path
+      attribute( :session )
+      
+      # 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 +82,24 @@ module Waves
           self['application']
         end
       end
-
-      debug true ; synchronize? true
+      
+      # default options
+      debug true
       session :duration => 30.minutes, :path => '/tmp/sessions'
       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
-
-

data/lib/runtime/console.rb

@@ -1,6 +1,7 @@
+require 'runtime/mocks'
 module Waves
 
-  class Console < Application
+  class Console < Runtime
 
     class << self
 
@@ -8,6 +9,8 @@ module Waves
 
       def load( options={} )
         @console ||= Waves::Console.new( options )
+        Kernel.load( options[:startup] || 'startup.rb' )
+        Object.instance_eval { include Waves::Mocks }
       end
 
       # allow Waves::Console to act as The Console Instance

data/lib/runtime/logger.rb

@@ -1,56 +1,32 @@
 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
-
+    # Returns the object being used for output by the logger.
+    def self.output
+      @output ||= ( config[:output] or $stderr )
+    end
+    
+    # Returns the active configuration for the logger.
+    def self.config ; @config ||= Waves.config.log ; end
+    
+    # Returns the logging level used to filter logging events.
+    def self.level ; @level ||= ::Logger.const_get( config[:level].to_s.upcase || 'INFO' ) ; end
+    
+    # Starts the logger, using the active configuration to initialize it.
+    def self.start
+      @log = config[:rotation] ?
+        ::Logger.new( output, config[:rotation].to_sym ) :
+        ::Logger.new( output )
+      @log.level = level
+      @log.datetime_format = "%Y-%m-%d %H:%M:%S "
+      self
+    end
+    
+    # Forwards logging methods to the logger.
+    def self.method_missing(name,*args,&block)
+      @log.send name,*args, &block if @log
     end
 
   end