dyoder-waves 0.7.3 → 0.7.6

data/app/bin/waves-console

@@ -1,3 +1,4 @@
 #!/usr/bin/env ruby
+require 'rubygems'
 require 'startup'
 require 'commands/waves-console'

data/app/bin/waves-server

@@ -1,3 +1,4 @@
 #!/usr/bin/env ruby
+require 'rubygems'
 require 'startup'
 require 'commands/waves-server'

data/app/configurations/development.rb.erb

@@ -1,13 +1,12 @@
-module <%= name %>
+module <%= @name %>
 
   module Configurations
 
-    class Development
+    class Development < Default
 
-      database :host => 'localhost', :adapter => 'sqlite', :database => '<%= name.downcase %>',
-        :user => 'root', :password => ''
+      database :adapter => 'sqlite', :database => '<%= @name.downcase %>'
 
-      reloadable [ <%= name %> ]
+      reloadable [ <%= @name %> ]
 
       log :level => :debug
 
@@ -15,7 +14,7 @@ module <%= name %>
 
       port 3000
 
-    handler ::Rack::Handler::Mongrel, :Host => host, :Port => port
+      handler ::Rack::Handler::Mongrel, :Host => host, :Port => port
       # handler ::Rack::Handler::WEBrick, :BindAddress => host, :Port => port
       # handler ::Rack::Handler::Thin, :Host => host, :Port => port
 

data/app/configurations/mapping.rb.erb

@@ -1,9 +1,8 @@
-module <%= name %>
+module <%= @name %>
 
   module Configurations
 
     module Mapping
-      extend Waves::Mapping
       # your custom rules go here
       include Waves::Mapping::PrettyUrls::RestRules
       include Waves::Mapping::PrettyUrls::GetRules

data/app/configurations/production.rb.erb

@@ -1,10 +1,10 @@
-module <%= name %>
+module <%= @name %>
 
   module Configurations
 
     class Production < Default
 
-      database :host => 'localhost', :adapter => 'mysql', :database => '<%= name.downcase %>',
+      database :host => 'localhost', :adapter => 'mysql', :database => '<%= @name.downcase %>',
         :user => 'root', :password => ''
 
       reloadable []

data/app/lib/application.rb.erb

@@ -1,3 +1,5 @@
-module <%= name %>
+require 'layers/orm/sequel'
+module <%= @name %>
   include Waves::Foundations::Default
-end
+  include Waves::Layers::ORM::Sequel
+end

data/bin/waves

@@ -1,10 +1,26 @@
 #!/usr/bin/env ruby
+require 'rubygems'
+require 'choice'
+require 'rakegen'
+
+# if we're in the waves source, prepend it to the load path
+waves_lib = File.expand_path( "#{File.dirname(__FILE__)}/../../waves/lib" )
+$:.unshift waves_lib if File.exist?(waves_lib)
+require 'waves'
+
+begin
+  require 'utilities/string'
+rescue LoadError
+  require File.join(File.dirname(__FILE__), '..', 'lib', 'utilities', 'string')
+end
 
-# rudimentary argument checks
-if ARGV.length != 1 || ARGV[0] == '--help'
-  $stderr.puts "Usage: waves {app_name}"
-  $stderr.puts "app_name may contain only letters, numbers, and underscores."
-  exit 1
+Choice.options do
+  banner 'Usage:  waves path/to/app [-h]'
+  option :help  do
+    long '--help'
+    desc 'Show this message'
+  end
+  
 end
 
 app_path = ARGV[0]
@@ -16,51 +32,18 @@ if app_name =~ /[^\w\d_]/
 TEXT
 end
 
+template = "#{WAVES}/app"
 
-require 'rubygems'
-require 'erubis'
-require 'extensions/all'
-begin
-  require 'utilities/string'
-rescue LoadError
-  require File.join(File.dirname(__FILE__), '..', 'lib', 'utilities', 'string')
+generator = Rakegen.new("waves:app") do |gen|
+  gen.source = template
+  gen.target = app_path
+  gen.template_assigns = {:name => app_name.camel_case}
+  gen.executables = %w{ bin/waves-console  bin/waves-server}
 end
 
-require 'fileutils'
-include FileUtils
-
-# are we calling this script from within the waves framework source?
-script_path = File.expand_path(__FILE__)
-WAVES_SRC = File.dirname(File.dirname(script_path))
-IN_WAVES_SRC = Dir.pwd.match(WAVES_SRC) ? true : false
-
-
 puts "** Creating new Waves application ..."
-template = begin
-  File.join File.dirname(File.readlink(__FILE__)), '..', 'app'
-rescue Exception
-  File.join( File.dirname(__FILE__),'..','app')
-end
-mkdir(app_path)
-cp_r Dir["#{template}/*"], app_path
 
-# get rid of placeholder files left over from gem install
-Dir["#{app_path}/**/EMPTY"].each { |path| rm path }
-# Dir["#{app_path}/**/EMPTY"].each { |path| system "rm #{path}" }
-
-# next, process all template files ...
-Dir["#{app_path}/**/*.erb"].each do |path|
-  unless path =~ %r{^#{app_path}/(schema/migrations/templates|templates)}
-    name = app_name.camel_case
-    File.write( path.gsub(/\.erb$/,''),
-      Erubis::Eruby.new( File.read( path ) ).result( binding ) )
-    rm path
-  end
-end
-
-unless RUBY_PLATFORM =~ /mswin32/
-  # make the scripts executable
-  system "chmod ug+x #{app_path}/bin/waves-*"
-end
+Rake::Task["waves:app"].invoke
 
 puts "** Application created!"
+

data/bin/waves-console

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
+require 'rubygems'
 require 'startup'
-
 require 'commands/waves-console'

data/bin/waves-server

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
+require 'rubygems'
 require 'startup'
-
 require 'commands/waves-server'

data/lib/commands/waves-console.rb

@@ -15,9 +15,6 @@ end
 
 console = Waves::Console.load( Choice.choices )
 Object.send(:define_method, :waves) { console }
-Object.instance_eval do
-  include Waves::Verify::Helpers::Request
-end
 require 'irb'
 require 'irb/completion'
 ARGV.clear

data/lib/controllers/base.rb

@@ -0,0 +1,11 @@
+module Waves
+  module Controllers
+    class Base
+
+      include Waves::Controllers::Mixin
+
+      def attributes; params[model_name.singular.intern]; end
+
+    end
+  end
+end

data/lib/controllers/mixin.rb

@@ -7,7 +7,7 @@ module Waves
   # a request. For example, a controller updates a model instance using
   # parameters from the request.
   #
-  # Controller methods simply return data (a resource), if necessary, that
+  # Public controller methods simply return data (a resource), if necessary, that
   # can be then used by views to determine how to render that data.
   # Controllers do not determine which view will be invoked. They are
   # independent of the view; one controller method might be suitable for
@@ -76,13 +76,12 @@ module Waves
   module Controllers
 
     #
-    # This mixin provides some handy methods for Waves controllers. You will probably
-    # want to include it in any controllers you define for your application. The default
-    # controllers generated using the +wave+ command already do this.
+    # Waves::Controllers::Mixin adapts a controller class for use in mappings and provides utility methods.     
+    # It is included in controllers autocreated by the Default foundation, so you do not need to include
+    # it in subclasses of the same. 
     #
-    # Basically, what the mixin does is adapt the class so that it can be used within
-    # mappings (see Waves::Mapping); add some simple reflection to allow controller methods
-    # to be written generically (i.e., without reference to a specific model); and provide
+    # The utility methods include simple reflection to allow controller methods
+    # to be written generically (i.e., without reference to a specific model) and
     # parameter destructuring for the request parameters.
     #
 
@@ -92,18 +91,20 @@ module Waves
 
       include Waves::ResponseMixin
 
-      # When you include this Mixin, a +process+ class method is added to your class,
-      # which accepts a request object and a block. The request object is used to initialize
-      # the controller and the block is evaluated using +instance_eval+. This allows the
-      # controller to be used within a mapping file.
+      # When this mixin is included it adds a class method named +process+,
+      # which accepts a request object and a block. The +process+ method initializes the
+      # controller with the request, then evaluates the block using +instance_eval+. This allows the
+      # controller to be used from within a mapping lambda (i.e. a ResponseProxy).
 
-      def self.included( c )
-        def c.process( request, &block )
+      def self.included( mod )
+        def mod.process( request, &block )
           self.new( request ).instance_eval( &block )
         end
       end
 
-      def initialize( request ); @request = request; end
+      def initialize( request )
+        @request = request
+      end
 
       # The params variable is taken from the request object and "destructured", so that
       # a parameter named 'blog.title' becomes:
@@ -111,16 +112,16 @@ module Waves
       #   params['blog']['title']
       #
       # If you want to access the original parameters object, you can still do so using
-      # +request.parameters+ instead of simply +params+.
+      # +request.params+ instead of simply +params+.
       def params; @params ||= destructure(request.params); end
 
-      # You can access the name of the model related to this controller using this method.
-      # It simply takes the basename of the module and converts it to snake case, so if the
-      # model uses a different plurality, this won't, in fact, be the model name.
+      # Returns the name of the model corresponding to this controller by taking the basename
+      # of the module and converting it to snake case. If the model plurality is different than
+      # the controller, this will not, in fact, be the model name.
       def model_name; self.class.basename.snake_case; end
 
-      # This uses the model_name method to attempt to identify the model corresponding to this
-      # controller. This allows you to write generic controller methods such as:
+      # Returns the model corresponding to this controller by naively assuming that 
+      # +model_name+ must be correct. This allows you to write generic controller methods such as:
       #
       #   model.find( name )
       #
@@ -130,24 +131,30 @@ module Waves
 
       private
 
-      def destructure(hash)
-        rval = {}
-        hash.keys.map{ |key|key.split('.') }.each do |keys|
-          destructure_with_array_keys(hash,'',keys,rval)
+      def destructure( hash )
+        destructured = {}
+        hash.keys.map { |key| key.split('.') }.each do |keys|
+          destructure_with_array_keys(hash, '', keys, destructured)
         end
-        rval
+        destructured
       end
 
-      def destructure_with_array_keys(hash,prefix,keys,rval)
+      def destructure_with_array_keys( hash, prefix, keys, destructured )
         if keys.length == 1
-          val = hash[prefix+keys.first]
-          rval[keys.first.intern] = case val
-          when String then val.strip
-          when Hash then val
+          key = "#{prefix}#{keys.first}"
+          val = hash[key]
+          destructured[keys.first.intern] = case val
+          when String
+            val.strip
+          when Hash
+            val
+          when nil
+            raise key.inspect
           end
         else
-          rval = ( rval[keys.first.intern] ||= {} )
-          destructure_with_array_keys(hash,(keys.shift<<'.'),keys,rval)
+          destructured = ( destructured[keys.first.intern] ||= {} )
+          new_prefix = "#{prefix}#{keys.shift}."
+          destructure_with_array_keys( hash, new_prefix, keys, destructured )
         end
       end
 

data/lib/dispatchers/base.rb

@@ -2,8 +2,14 @@ module Waves
 
   module Dispatchers
 
+    # A NotFoundError means what you think it means.  The dispatchers included with Waves do not
+    # natively intercept this exception.  Instead an exception handler must be registered in the application
+    # mappings.  The Simple foundation registers a minimal handler, while the Default foundation registers
+    # a slightly fleshier one.
     class NotFoundError < Exception ; end
 
+    # Redirect exceptions are rescued by the Waves dispatcher and used to set the 
+    # response status and location.
     class Redirect < Exception
       attr_reader :path, :status
       def initialize( path, status = '302' )
@@ -12,38 +18,47 @@ module Waves
       end
     end
 
-    # The Base dispatcher simply makes it easier to write dispatchers by inheriting
-    # from it. It creates a Waves request, ensures the request processing is done
-    # within a mutex, benchmarks the request processing, logs it, and handles common
-    # exceptions and redirects. Derived classes need only process the request within
-    # their +safe+ method, which takes a Waves::Request and returns a Waves::Response.
+    # Waves::Dispatchers::Base provides the basic request processing structure.
+    # All other Waves dispatchers should inherit from it.  It creates a Waves request, 
+    # determines whether to enclose the request processing in a mutex, benchmarks it, 
+    # logs it, and handles common exceptions and redirects. Derived classes need only 
+    # process the request within the +safe+ method, which must take a Waves::Request and return a Waves::Response.
 
     class Base
 
-      # Like any Rack application, Waves' dispatchers must provide a call method
-      # taking an +env+ parameter.
+      # As with any Rack application, a Waves dispatcher must provide a call method
+      # that takes an +env+ parameter.
       def call( env )
-        Waves::Application.instance.synchronize do
-          request = Waves::Request.new( env )
-          response = request.response
-          t = Benchmark.realtime do
-            begin
-              safe( request )
-            rescue Dispatchers::Redirect => redirect
-              response.status = redirect.status
-              response.location = redirect.path
-            end
-          end
-          Waves::Logger.info "#{request.method}: #{request.url} handled in #{(t*1000).round} ms."
-          response.finish
+        if Waves.config.synchronize?
+          Waves::Application.instance.synchronize { _call( env ) }
+        else
+          _call( env )
         end
       end
 
-      # Called by event driven servers like thin and ebb. Return true if
-      # the server should run the request in a separate thread.
+      # Called by event driven servers like thin and ebb. Returns true if
+      # the server should run the request in a separate thread, as determined by
+      # Configurations::Mapping#threaded?
       def deferred?( env )
         Waves::Application.instance.mapping.threaded?( env )
       end
+      
+      private
+      
+      def _call( env )
+        request = Waves::Request.new( env )
+        response = request.response
+        t = Benchmark.realtime do
+          begin
+            safe( request )
+          rescue Dispatchers::Redirect => redirect
+            response.status = redirect.status
+            response.location = redirect.path
+          end
+        end
+        Waves::Logger.info "#{request.method}: #{request.url} handled in #{(t*1000).round} ms."
+        response.finish
+      end
 
     end
 

data/lib/dispatchers/default.rb

@@ -3,13 +3,14 @@ module Waves
   module Dispatchers
 
     #
-    # The default dispatcher essentially checks the application's mapping to see
-    # what to do with the request URL. It checks before and after filters (wrap
-    # filters are just a combination of both) as well as path and url mappings.
+    # Waves::Dispatchers::Default matches requests against an application's mappings to 
+    # determine what main action to take, as well as what before, after, always, and exception-handling
+    # blocks must run.
     #
     # The default dispatcher also attempts to set the content type based on the
-    # MIME type implied by any file extension used in the request URL using Mongrel's
-    # MIME types YAML file.
+    # file extension used in the request URL. It does this using the class defined in
+    # the current configuration's +mime_types+ attribute, which defaults to Mongrel's
+    # MIME type handler.
     #
     # You can write your own dispatcher and use it in your application's configuration
     # file. By default, they use the default dispatcher, like this:
@@ -27,13 +28,14 @@ module Waves
       # Takes a Waves::Request and returns a Waves::Reponse
       def safe( request  )
 
-        begin
-          response = request.response
+        response = request.response
+
+        Waves::Application.instance.reload if Waves::Application.instance.debug?
+        response.content_type = Waves::Application.instance.config.mime_types[ request.path ] || 'text/html'
 
-          Waves::Application.instance.reload if Waves::Application.instance.debug?
-          response.content_type = Waves::Application.instance.config.mime_types[ request.path ] || 'text/html'
+        mapping = Waves::Application.instance.mapping[ request ]
 
-          mapping = Waves::Application.instance.mapping[ request ]
+        begin
 
           mapping[:before].each do | block, args |
             ResponseProxy.new(request).instance_exec(*args,&block)
@@ -43,11 +45,13 @@ module Waves
 
           block, args = mapping[:action]
           response.write( ResponseProxy.new(request).instance_exec(*args, &block) )
-
+          
           mapping[:after].each do | block, args |
             ResponseProxy.new(request).instance_exec(*args,&block)
           end
+
         rescue Exception => e
+          
           handler = mapping[:handlers].detect do | exception, block, args |
             e.is_a? exception
           end
@@ -56,6 +60,16 @@ module Waves
           else
             raise e
           end
+          
+        ensure
+          mapping[:always].each do | block, args |
+            begin
+              ResponseProxy.new(request).instance_exec(*args,&block) 
+            rescue Exception => e
+              Waves::Logger.info e.to_s
+            end
+          end
+          
         end
 
       end