dyoder-waves 0.7.3 → 0.7.6

data/lib/mapping/pretty_urls.rb

@@ -66,14 +66,16 @@ module Waves
             # create a new resource for the given model
             path %r{^/#{model}/?$}, :method => :post do | model |
               resource( model.singular ) do
-                instance = controller { create }
-                redirect( "/#{model.singular}/#{instance.name}/editor" )
+                controller do 
+                  instance = create
+                  redirect( "/#{model_name}/#{instance.name}/editor" )
+                end
               end
             end
 
             # update the given resource for the given model
             path %r{^/#{model}/#{name}/?$}, :method => :put do | model, name |
-              resource( model ) { controller { update( name ) }; redirect( url ) }
+              resource( model ) { controller { update( name ); redirect( url ) }  }
             end
 
             # delete the given resource for the given model

data/lib/renderers/erubis.rb

@@ -1,12 +1,14 @@
 require 'erubis'
 
-module Erubis
+module Erubis # :nodoc:
 
   # This is added to the Erubis Content class to allow the same helper methods
   # to be used with both Markaby and Erubis.
   class Context
     include Waves::Helpers::UrlHelper
     include Waves::Helpers::TagHelper
+    include Waves::Helpers::AssetHelper
+    include Waves::Helpers::NumberHelper
     
     def <<(s) 
       eval("_buf", @binding).concat s # add to rendered output

data/lib/renderers/mixin.rb

@@ -1,9 +1,6 @@
 module Waves
 
-  module Renderers
-
-    extend Autocode
-    # autoload :renderers, Class
+  module Renderers # :nodoc:
 
     # The renderers mixin provides a number of methods to simplify writing new renderers.
     # Just include this in your Renderer class and write your render method.

data/lib/runtime/application.rb

@@ -7,10 +7,8 @@ module Waves
     attr_reader :application
 
     # Register a module as a Waves application.
-    # Also, initialize the database connection if necessary.
     def << ( app )
       @application = app if Module === app
-      app.database if app.respond_to? 'database'
     end
 
     def instance ; Waves::Application.instance ; end
@@ -28,9 +26,9 @@ module Waves
   # main Waves application, you can use +Waves+.+application+.
   class Application
 
-  class << self; attr_accessor :instance; end
+    class << self; attr_accessor :instance; end
 
-    # Accessor for options passed to the application. Valid options include
+    # Accessor for options passed to the application.
     attr_reader :options
 
     # Create a new Waves application instance.
@@ -41,16 +39,22 @@ module Waves
       Kernel.load( :lib / 'application.rb' ) if Waves.application.nil?
     end
 
-    def synchronize( &block ) ; ( @mutex ||= Mutex.new ).synchronize( &block ) ; end
+    def synchronize( &block )
+      ( @mutex ||= Mutex.new ).synchronize( &block )
+    end
 
     # The 'mode' of the application determines which configuration it will run under.
-    def mode ; @mode ||= @options[:mode]||:development ; end
-
+    def mode
+      @mode ||= @options[:mode]||:development
+    end
+    
     # Debug is true if debug is set to true in the current configuration.
     def debug? ; config.debug ; end
 
     # Access the current configuration. *Example:* +Waves::Server.config+
-    def config ; Waves.application.configurations[ mode ] ; end
+    def config
+      Waves.application.configurations[ mode ]
+    end
 
     # Access the mappings for the application.
     def mapping ; Waves.application.configurations[ :mapping ] ; end

data/lib/runtime/blackboard.rb

@@ -0,0 +1,57 @@
+module Waves
+
+  # Encapsulates the blackboard associated with a given request. The scope of the blackboard is
+  # the same as the request object it gets attached to.
+  #
+  # The Waves blackboard is a very simple shared storaged usable during the request processing.
+  # It is available within:
+  #    - mappings
+  #    - controllers
+  #    - helpers
+  #
+  # Adding a value:
+  #   blackboard.value1 = 1
+  #   blackboard[:value2] = 2
+  #
+  # Retrieving values
+  #   blackboard.value1
+  #   blackboard[:value2]
+  #
+  # see also blackboard_verify.rb  
+  
+  class Blackboard
+
+    # Create a new blackboard object using the given request.
+    def initialize( request )
+      @request = request
+      @data = {}
+    end
+
+    # Access a given data element of the blackboard using the given key.
+    def [](key)
+      @data[key]
+    end
+
+    # Set the given data element of the blackboard using the given key and value.
+    def []=(key,val)
+      @data[key] = val
+    end
+    
+    def each(&block)
+      @data.each(&block)
+    end
+
+    # also allow things like
+    # blackboard.test1 instead of blackboard[:test1]
+    # blackboard.test1 = 2 instead of blackboard[:test1] = 2
+    def method_missing(name,*args)
+      if (name.to_s =~ /=$/)
+        self[name.to_s.gsub('=', '')] = args[0]
+      else
+        self[name.to_s]
+      end
+    end
+
+  end
+  
+end

data/lib/runtime/configuration.rb

@@ -1,12 +1,11 @@
 module Waves
 
-  # Waves configurations are simply Ruby code, meaning you can use an Ruby expression as
-  # a value for a configuration parameter, extend and inherit your configurations, and
-  # add your own configuration attributes. You can even use it as a configuration repository
-  # for your applications.
+  # 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.
   #
-  # The form for configuration parameters to use the parameter name as a method name. Passing
-  # in a parameter sets the value.
+  # You can access configuration attributes using the attribute name as a method, with the value as the argument.
   #
   # == Example
   #
@@ -25,28 +24,27 @@ module Waves
   #      end
   #    end
   #
-  # There are three forms for accessing parameters:
+  # There are three forms for accessing attributes:
   #
-  #   Waves.config.port                        # generic form - gets current config
-  #   Blog.configurations[:development]        # gets a value for a specific config
-  #   Blog::Configurations::Development.port   # Access config constant directly
+  #   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
   #
-  # You can inherit configurations, as is shown in the example above. Typically, you
-  # can use the application's "default" configuration to set shared configurations,
-  # and then inherit from it for specific variations.
+  # 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.
   #
-  # To define your own attributes, and still make them inheritable, you should use
-  # the +attribute+ class method, like this:
+  # You may define your own heritable attributes using the +attribute+ class method:
   #
   #   class Default < Waves::Configurations::Default
-  #     attribute 'theme' # define a theme attribute
-  #     theme 'ultra'     # give it a default
+  #     attribute 'theme' # define an attribute named "theme"
+  #     theme 'ultra'     # set an inheritable default
   #   end
   #
-  # There are a number of reserved or built-in attributes. These are:
+  # Certain attributes are reserved for internal use by Waves:
   #
   # - application: configure the application for use with Rack
-  # - database: takes a hash of parameters used to initalize the database; see below
+  # - 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)
@@ -58,7 +56,7 @@ module Waves
   #
   # 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 parameter.
+  # directly to the application developer via the +application+ configuration method.
   #
   # *Example*
   #
@@ -70,51 +68,50 @@ module Waves
   #
   # == Configuring Database Access
   #
-  # The database parameter takes a hash with the following elements:
-  #
-  # - host: which host the database is running on
-  # - adapter: which adapter is being used to access the database (mysql, postgres, etc.)
-  # - database: the name of the database the application is connecting to
-  # - user: the user for authentication
-  # - password: password for authentication
-  #
-  # *Example*
+  # 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
   #
-  # You can specify a list of modules to reload on each request using the +reloadable+
-  # configuration parameter. The Waves server will call +reload+ on each module to trigger
-  # the reloading. Typically, your modules will use the Autocode gem to set parameters for
-  # reloading. This is done for you when you generate an application using the +waves+
-  # command, but you can change the default settings. See the documentation for Autocode
-  # for more information. Typically, you will set this parameter to just include your
-  # main application:
+  # 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 ]
   #
-  # although you could do this with several modules just as easily (say, your primary
-  # application and several helper applications).
+  # As an alternative, you could reload only some of the modules within your application:
+  #
+  #   reloadable [ Blog::Models, Blog::Controllers ]
   #
   # == Configuring Logging
   #
-  # The +log+ configuration parameter takes the following options (as a hash):
-  # - level: The level to filter logging at. Uses Ruby's built in Logger class.
-  # - output: A filename or IO object. Should be a filename if running as a daemon.
+  # 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'
+  #  log :level => :info, :output => $stderr
+  #  log :level => :error, :output => 'log/blog.log'
   #
 
   module Configurations
 
     class Base
-
       # Set the given attribute with the given value. Typically, you wouldn't
       # use this directly.
       def self.[]=( name, val )
@@ -125,7 +122,8 @@ module Waves
       # use this directly.
       def self.[]( name ) ; send "_#{name}" ; end
 
-      # Define a new attribute. After calling this, you can get and set the value.
+      # Define a new attribute. After calling this, you can get and set the value
+      # using the attribute name as the method
       def self.attribute( name )
         meta_def(name) do |*args|
           raise ArgumentError.new('Too many arguments.') if args.length > 1
@@ -136,16 +134,22 @@ module Waves
 
     end
 
-    # The Default configuration provides a good starting point for your applications,
-    # defining a number of attributes that are required by Waves.
+    # 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 ).
+      %w( host port ports log reloadable database session debug root synchronize? ).
       each { |name| attribute(name) }
 
-      # Set the handler for use with Rack, along with any handler-specific options
-      # that will be passed to the handler's #run method. When accessing the value
-      # (calling with no arguments) returns an array of the handler and options.
+      # 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
@@ -154,13 +158,14 @@ module Waves
         end
       end
 
-      # Provide access to the Waves::MimeTypes class via the configuration. You
-      # could potentially point this to your own MIME types repository class.
+      # 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
         Waves::MimeTypes
       end
 
-      # Defines the application for use with Rack.
+      # Defines the application for use with Rack.  Treat this method like an
+      # instance of Rack::Builder
       def self.application( &block )
         if block_given?
           self['application'] = Rack::Builder.new( &block )
@@ -169,7 +174,7 @@ module Waves
         end
       end
 
-      debug true
+      debug true ; synchronize? true
       session :duration => 30.minutes, :path => '/tmp/sessions'
       log :level => :info, :output => $stderr
       reloadable []

data/lib/runtime/logger.rb

@@ -27,18 +27,25 @@ module Waves
       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
+      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

data/lib/runtime/request.rb

@@ -1,12 +1,10 @@
 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.
+  # 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
+    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.
@@ -14,7 +12,10 @@ module Waves
       @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.

data/lib/runtime/response.rb

@@ -1,9 +1,7 @@
 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.
+  # 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
@@ -13,6 +11,8 @@ 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 |

data/lib/runtime/response_mixin.rb

@@ -30,6 +30,9 @@ module Waves
     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