waves 0.6.7 → 0.6.9

data/app/Rakefile

@@ -1,4 +1,4 @@
 require 'waves'
 Waves::Console.load
-%w( schema ).each { |task| require "lib/tasks/#{task}.rb" }
+%w( schema cluster generate ).each { |task| require "lib/tasks/#{task}.rb" }
 

data/app/configurations/default.rb.erb

@@ -1,7 +1,7 @@
 module <%= name %>
   module Configurations
     class Default < Waves::Configurations::Default
-      database :host => host, :adapter => 'mysql', :database => 'blog',
+      database :host => host, :adapter => 'mysql', :database => '<%= name.downcase %>',
         :user => 'root', :password => ''
     end
   end

data/app/configurations/mapping.rb.erb

@@ -4,43 +4,12 @@ module <%= name %>
     
     module Mapping
       
-      extend Waves::Mapping
-
-      name = '([\w\-\_\.\+\@]+)'; model = '([\w\-]+)'
-      
-			path %r{^/$} { redirect('/entries') }
-			
-      # get all resources for the given model
-			path %r{^/#{model}/?$} do | model |
-				use( model ) | controller { all } | view { |data| list( model.plural => data ) }
-			end
-
-      # get all resources identifiers for the given model in json format
-			path %r{^/#{model}/?$}, :accept => /json/ do | model |
-				use( model ) | controller { all } | view { |data| list( model.plural => data ) }
-			end
-
-      # get the given resource for the given model
-			path %r{^/#{model}/#{name}/?$} do | model, name |
-				use(model) | controller { find( name ) } | 
-				  view { |data| show( model => data ) }
-			end
-      
-			# display an editor for the given resource / model
-			path %r{^/#{model}/#{name}/editor/?$} do | model, name |
-				use(model) | controller { find( name ) } | 
-				  view { |data| editor( model => data ) }				
-			end
-      
-      # add / update the given resource for the given model
-			path %r{^/#{model}/#{name}/?$}, :method => :post do | model, name |
-				use(model) | controller { update( name ) }; redirect( url )
-			end
-      
-      # delete the given resource for the given model
-			path %r{^/#{model}/#{name}/?$}, :method => :delete do | model, name |
-				use(model) | controller { delete( name ) }; redirect( "/#{model}/" )
-			end
+      module Mapping
+        extend Waves::Mapping
+        # your custom rules go here
+        include Waves::Mapping::PrettyUrls::RestRules
+        include Waves::Mapping::PrettyUrls::GetRules
+      end
 
     end
   

data/app/controllers/default.rb.erb

@@ -6,31 +6,21 @@ module <%= name %>
 			
 			include Waves::Controllers::Mixin
 			
-			def all
-				model.all
-			end
+			def attributes; params[model_name.singular.intern]; end
+			
+			def all; model.all; end
 
-			def find( name )
-				model[ name ]
-			end
+			def find( name ); model[ :name => name ] or not_found; end
 		
-			def create( attrs = {} )
-				model.new( attrs )
-			end
+			def create; model.create( attributes ); end
 		
-			def update
-				attrs = params[model_name.singular]
-				if instance = find( attrs[:name] )
-					instance.set( attrs )
-					instance.save
-				else
-					model.create( attrs )
-				end
+			def update( name )
+			  instance = find( name )
+			  instance.set( attributes )
+			  instance.save_changes
 			end
 		
-			def delete
-				model[ name ].destroy
-			end
+			def delete( name ); find( name ).destroy; end
 			
 		end
 

data/app/lib/tasks/cluster.rb

@@ -1,21 +1,19 @@
 namespace :cluster do
 
 	desc 'Start a cluster of waves applications.'
-  task :start => :stop do |task|
-    pids = []; path = :log / :pids
-    Waves::Console.config.ports.each do |port|
-      pid = fork { exec "waves_server -p #{port} #{ENV['mode']} -d" }
-      Process.detach( pid ); pids << pid
+  task :start do |task|
+    ( Waves::Console.config.ports || [ Waves::Console.config.port ] ).each do |port|
+      cmd = "waves-server -p #{port} -c #{ENV['mode']||'development'} -d"
+      puts cmd ; `#{cmd}`
     end
-    File.write( path, pids.join(',') )
 	end
 	
 	desc 'Stop a cluster of waves applications.'
 	task :stop do |task|
-	  path = :log / :pids
-	  if File.exist? path
-  	  File.read( path ).split(',').each { |pid| Process.kill( 'INT', pid.to_i ) rescue nil }
-  	  FileUtils.rm( path )
+  	 Dir[ :log / '*.pid' ].each do |path| 
+  	   pid = File.basename(path,'.pid').to_i
+  	   puts "Stopping process #{pid} ..."
+  	   Process.kill( 'INT', pid ) rescue nil
   	end
 	end
 	

data/app/lib/tasks/generate.rb

@@ -0,0 +1,15 @@
+namespace :generate do
+  desc 'Generate a new model'
+  task :model do |task|
+    template = File.read :models / 'default.rb'
+    File.write( :models / ENV['name'] + '.rb', 
+      template.gsub('class Default < Sequel::Model',
+      "class #{ENV['name'].camel_case} < Sequel::Model(:#{ENV['name'].plural})") )
+  end
+  desc 'Generate a new controller'
+  task :controller do |task|
+    template = File.read :controllers / 'default.rb'
+    File.write( :controllers / ENV['name'] + '.rb', 
+      template.gsub('class Default',"class #{ENV['name'].camel_case}") )
+  end
+end

data/app/lib/tasks/schema.rb

@@ -4,15 +4,16 @@ namespace :schema do
 	desc 'Create a new Sequel Migration using name.'
   task :migration do |task|
 	
-		version = ( ENV['version'].to_i || 
-			Sequel::Migrator.get_current_migration_version( Blog.database ) ) + 1
+		version = ( ENV['version'].nil? ? 
+			Sequel::Migrator.get_current_migration_version( Blog.database ) :
+			ENV['version'].to_i  ) + 1
 
 		name = ENV['name'] || 'migration'
 		class_name = name.camel_case
 
 		template = ( ENV['template'] || 'empty' ) + '.rb.erb'
-		source = :schema / :migration / :templates / template
-		destination = :schema / :migration / "#{'%03d' % version}_#{name}.rb"
+		source = :schema / :migrations / :templates / template
+		destination = :schema / :migrations / "#{'%03d' % version}_#{name}.rb"
 		code = Erubis::Eruby.new( File.read( source ) ).result( binding )
 		File.write( destination, code )
 
@@ -21,7 +22,7 @@ namespace :schema do
 	desc 'Performs migration from version, to version.'
 	task :migrate do |task|
 		version = ENV['version']; version = version.to_i unless version.nil? 
-		Sequel::Migrator.apply( Waves.application.database, :schema / :migration , version )
+		Sequel::Migrator.apply( Waves.application.database, :schema / :migrations , version )
 	end
 	
 end

data/app/templates/layouts/default.mab

@@ -1,6 +1,6 @@
 doctype :html4_strict
 
-html
+html do
 
   head do
     title @title

data/bin/waves

@@ -18,7 +18,7 @@ Dir["#{app_name}/**/EMPTY"].each { |path| system "rm #{path}" }
 
 # next, process all template files ...
 Dir["#{app_name}/**/*.erb"].each do |path|
-  unless path =~ %r{^#{app_name}/(schema/migration/templates|templates)}
+  unless path =~ %r{^#{app_name}/(schema/migrations/templates|templates)}
     name = app_name.camel_case
     File.write( path.gsub(/\.erb$/,''), 
       Erubis::Eruby.new( File.read( path ) ).result( binding ) )

data/bin/waves-console

@@ -1,8 +1,25 @@
 require 'waves'
+require 'choice'
 
-if ARGV.length > 1 
-	puts STDERR, "Usage: console [mode]"; exit 1
+Choice.options do
+  header 'Run a waves application server.'
+  header ''
+  option :mode do
+    short '-c'
+    long '--config=CONFIG'
+    desc 'Configuration to use.'
+    desc 'Defaults to development.'
+    cast Symbol
+  end
+  separator ''
+  option :directory do
+    short '-D'
+    long '--dir=DIR'
+    desc 'Directory containing the application.'
+    desc 'Defaults to the current directory.'
+  end
+  separator ''  
 end
-
-Waves::Console.load( ARGV[0] ? ARGV[0].intern : :development )
+    
+Waves::Console.load( Choice.choices )
 require 'irb'; IRB.start

data/lib/controllers/mixin.rb

@@ -1,36 +1,105 @@
 module Waves
+  
+  #
+  # Controllers in Waves are simply classes that provide a request / response context for operating on a model. While models are essentially just a way to manage data in an application, controllers manage data in response to 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 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 several different views. In some cases, controllers can choose to directly modify the response and possibly even short-circuit the view entirely. A good example of this is a redirect.
+  #
+  # Controllers, like Views and Mappings, use the Waves::ResponseMixin to provide a rich context for working with the request and response objects. They can even call other controllers or views using the controllers method. In addition, they provide some basic reflection (access to the model and model_name that corresponds to the class name for the given model) and automatic parameter destructuring. This allows controller methods to access the request parameters as a hash, so that a POST variable named <tt>entry.title</tt> is accessed as <tt>params[:entry][:title]</tt>.
+  #
+  # Controllers often do not have to be explicitly defined. Instead, one or more default controllers can be defined that are used as exemplars for a given model. By default, the +waves+ command generates a single default, placed in the application's <tt>controllers/default.rb</tt> file. This can be modified to change the default behavior for all controllers. Alternatively, the <tt>rake generate:controller</tt> command can be used to explicitly define a controller.
+  #
+  # As an example, the code for the default controller is below for the Blog application.
+  #
+  #   module Blog
+  #   	module Controllers
+  #   		class Default
+  #
+  #         # Pick up the default controller methods, like param, url, etc.
+  #   			include Waves::Controllers::Mixin
+  #
+  #         # This gets me the parameters associated with this model
+  #   			def attributes; params[model_name.singular.intern]; end
+  #
+  #         # A simple generic delegator to the model
+  #   			def all; model.all; end
+  #
+  #         # Find a specific instance based on a name or raise a 404
+  #   			def find( name ); model[ :name => name ] or not_found; end
+  #
+  #         # Create a new instance based on the request params
+  #   			def create; model.create( attributes ); end
+  #
+  #         # Update an existing record. find will raise a 404 if not found.
+  #   			def update( name )
+  #   			  instance = find( name )
+  #   			  instance.set( attributes )
+  #   			  instance.save_changes
+  #   			end
+  #
+  #         # Find and delete - or will raise a 404 if it doesn't exist
+  #   			def delete( name ); find( name ).destroy; end
+  #
+  #   		end
+  #   	end
+  #   end
+  #
+  # Since the mapping file handles "glueing" controllers to views, controllers don't have to be at all concerned with views. They don't have to set instance variables, layouts, or contain logic to select the appropriate view based on the request. All they do is worry about updating the model when necessary based on the request.  
 
 	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.
+	  #
+	  # 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
+	  # parameter destructuring for the request parameters.
+	  #
+
 		module Mixin
-		
+		  
 			attr_reader :request
 			
 			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.
+      
 			def self.included( c )
 				def c.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:
+			#
+			#   params['blog']['title']
+			#
+			# If you want to access the original parameters object, you can still do so using
+			# +request.parameters+ instead of simply +params+.
+			def params; @params ||= destructure(request.params); end
 			
-			# override to convert 'foo.bar' to 'foo' => 'bar' => value
-			def params
-				@params ||= destructure(request.params)
-			end
-
-			def model_name
-				self.class.basename.snake_case
-			end
-		
-			def model
-				Waves.application.models[ model_name.intern ]
-			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.
+			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:
+			#
+			#   model.find( name )
+			#
+			# to find an instance of a given model. Again, the plurality of the controller and 
+			# model must be the same for this to work.
+			def model; Waves.application.models[ model_name.intern ]; end
 			
 			private
 			

data/lib/dispatchers/base.rb

@@ -11,29 +11,40 @@ 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.
+		
 		class Base
 				
+			# Like any Rack application, Waves' dispatchers must provide a call method
+			# taking an +env+ parameter. 
 			def call( env )
 			  Waves::Server.synchronize do
   				request = Waves::Request.new( env )
   				response = request.response
-  				begin
-  					safe( request )
-  				rescue Dispatchers::Redirect => redirect
-  					response.status = '302'
-  					response.location = redirect.path
-  				rescue Dispatchers::NotFoundError => e
-  					html = Waves.application.views[:errors].process( request ) do
-  				    not_found_404( :error => e ) 
-  				  end
-  					response.status = '404'
-  					response.content_type = 'text/html'
-  					response.write( html )
-  				end
+  			  t = Benchmark.realtime do 
+    				begin
+    					safe( request )
+    				rescue Dispatchers::Redirect => redirect
+    					response.status = '302'
+    					response.location = redirect.path
+    				rescue Dispatchers::NotFoundError => e
+    					html = Waves.application.views[:errors].process( request ) do
+    				    not_found_404( :error => e ) 
+    				  end
+    					response.status = '404'
+    					response.content_type = 'text/html'
+    					response.write( html )
+    				end
+    			end
+      		Waves::Logger.info "#{request.method}: #{request.url} handled in #{(t*1000).round} ms."
   				response.finish
   			end
-			end
-			
+  		end
+
 		end
 
 	end	

data/lib/dispatchers/default.rb

@@ -2,13 +2,34 @@ 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.
+	  # 
+	  # 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.
+	  #
+	  # You can write your own dispatcher and use it in your application's configuration 
+	  # file. By default, they use the default dispatcher, like this:
+	  #
+	  #   application do
+		#	    use Rack::ShowExceptions
+		#	    run Waves::Dispatchers::Default.new
+		#   end
+		#				
+    
 		class Default < Base
 		
+		  # All dispatchers using the Dispatchers::Base to provide thread-safety, logging, etc.
+		  # must provide a +safe+ method to handle creating a response from a request.
+		  # Takes a Waves::Request and returns a Waves::Reponse
 			def safe( request  )
 			  
 				response = request.response
-			
-				Waves::Server.reset if Waves::Server.debug?
+		
+				Waves::Server.reload if Waves::Server.debug?
 				response.content_type = Waves::Server.config.mime_types[ request.path ] || 'text/html'
 
 				mapping = Waves::Server.mapping[ request ]
@@ -16,14 +37,14 @@ module Waves
 				mapping[:before].each do | block, args |
 				  ResponseProxy.new(request).instance_exec(*args,&block)
 				end
-				
+			
 				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
-									
+  													
 			end
 			
 		end