waves 0.6.7

data/lib/runtime/console.rb

@@ -0,0 +1,21 @@
+module Waves
+	
+	class Console < Application
+		
+		class << self
+
+			attr_reader :console
+
+			def load(mode=:development)
+				@console ||= Waves::Console.new(mode)
+				Kernel.load( :lib / 'startup.rb' )
+			end
+			
+			# allow Waves::Console to act as The Console Instance
+			def method_missing(*args); @console.send(*args); end
+			
+		end
+	
+	end
+	
+end

data/lib/runtime/logger.rb

@@ -0,0 +1,28 @@
+require 'logger'
+module Waves
+	
+	module Logger
+
+		# Initializes the logger based on the config, and then adds Waves#log.
+
+		def self.start
+			config = Waves::Server.config
+			output = ( config.log[:output] || $stderr )
+			level = ::Logger.const_get( config.log[:level].to_s.upcase || 'INFO' )
+			@log = if config.log(:rotation)
+  			::Logger.new( output, config.log[:rotation].intern ); 
+  		else
+  			::Logger.new( output ); 
+  		end
+			@log.level = level
+		end
+		
+		# delegate everything to the logger
+		def self.method_missing(name,*args,&block)
+		  @log.send name,*args, &block
+		end
+		
+	end
+
+end
+

data/lib/runtime/mapping.rb

@@ -0,0 +1,82 @@
+module Waves
+
+	module Mapping
+		
+		def before( pattern, options=nil, &block )
+			filters[:before] << [ pattern, options, block ]
+		end
+		
+		def after( pattern, options=nil, &block )
+			filters[:after] << [ pattern, options, block ]
+		end
+		
+		def wrap( pattern, options=nil, &block )
+			filters[:before] << [ pattern, options, block ]
+			filters[:after] << [ pattern, options, block ]
+		end		
+
+		def map( options, &block )
+			pattern = options[:path] || options[:url]
+			mapping << [ pattern, options, block ]
+		end
+		
+		def path( pat, options = {}, &block )
+			options[:path] = pat; map( options, &block )
+		end
+		
+		def url( pat, options = {}, &block )
+			options[:url] = pat; map( options, block )
+		end
+		
+		def []( request )
+
+			rx = { :before => [], :after => [], :action => nil }
+			
+			( filters[:before] + filters[:wrap] ).each do | pattern, options, function |
+				matches = pattern.match(request.path)
+				rx[:before] << [ function, matches[1..-1] ] if matches &&
+					( ! options || satisfy( request, options ))
+			end
+			
+			mapping.find do |pattern, options, function|
+				matches = pattern.match(request.path)
+				rx[:action] = [ function, matches[1..-1] ] if matches && 
+					( ! options || satisfy( request, options ) )
+			end
+			
+			( filters[:after] + filters[:wrap] ).each do | pattern, options, function |
+				matches = pattern.match(request.path)
+				rx[:after] << [ function, matches[1..-1] ] if matches &&
+					( ! options || satisfy( request, options ))
+			end
+			
+			not_found(request) unless rx[:action]
+			
+			return rx
+				
+		end		
+				
+		private
+		
+		def mapping; @mapping ||= []; end
+		
+		def filters; @filters ||= { :before => [], :after => [], :wrap => [] }; end
+
+		def not_found(request)
+			raise Waves::Dispatchers::NotFoundError.new( request.url + ' not found.')
+		end
+		
+		def satisfy( request, options )
+			options.each do |method, param|
+				return false unless self.send( method, param, request )
+			end
+			return true
+		end
+		
+		def method( method, request )
+			request.method == method
+		end
+
+	end
+
+end

data/lib/runtime/mime_types.rb

@@ -0,0 +1,18 @@
+module Waves
+	module MimeTypes
+	  
+		def self.[]( path )
+		  mapping[ File.extname( path ) ]
+		end
+		
+		# TODO: why isn't this working?
+		# def self.<<( mapping )
+		#  mapping.merge!( mapping )
+		# end
+		
+		def self.mapping
+		  @mapping ||= Mongrel::DirHandler::MIME_TYPES
+		end
+		
+	end
+end

data/lib/runtime/request.rb

@@ -0,0 +1,43 @@
+module Waves
+	class Request
+		
+		class ParseError < Exception ; end
+		
+		attr_reader :response, :session
+		
+		def initialize( env ) # Rack::Request
+			@request = Rack::Request.new( env )
+			@response = Waves::Response.new( self )
+			@session = Waves::Session.new( self )
+		end
+				
+		# if we haven't overridden it, give it to Rack
+		def method_missing(name,*args)
+			@request.send(name,*args)
+		end
+		
+		# TODO: should / does this exclude the query_string?
+		# Is there a Rack API that is more appropos
+		def path
+			@request.path_info
+		end
+		
+    def domain
+      @request.host
+    end
+    
+		def method
+			@request.request_method.downcase.intern
+		end	
+		
+		def not_found
+  		raise Waves::Dispatchers::NotFoundError.new( @request.url + ' not found.')
+  	end
+
+		def redirect( path )
+			raise Waves::Dispatchers::Redirect.new( path )
+		end
+		
+	end
+	
+end

data/lib/runtime/response.rb

@@ -0,0 +1,26 @@
+module Waves
+	class Response
+		
+		attr_reader :request
+		
+		def initialize( request )
+			@request = request
+			@response = Rack::Response.new
+		end
+				
+		%w( Content-Type Content-Length Location Expires ).each do |header|
+			define_method( header.downcase.gsub('-','_')+ '=' ) do | val |
+				@response.headers[header] = val
+			end
+		end
+				
+		def session ; request.session ; end
+		
+		def finish ; request.session.save ; @response.finish ; end
+				
+		def method_missing(name,*args)
+			@response.send(name,*args)
+		end
+		
+	end
+end

data/lib/runtime/response_mixin.rb

@@ -0,0 +1,53 @@
+module Waves
+  
+  module ResponseMixin
+    
+    # assumes request method
+    
+    def response
+      request.response
+    end
+    
+    def params
+			request.params
+		end
+		
+		def session
+			request.session
+		end
+		
+		def path
+		  request.path
+		end
+		
+		def url
+		  request.url
+		end
+		
+		def domain
+		  request.domain
+		end
+		
+		def redirect(location)
+		  request.redirect(location)
+		end
+		
+		def models
+		  Waves.application.models
+		end
+		
+		def views
+		  Waves.application.views
+		end
+		
+		def controllers
+		  Waves.application.controllers
+		end
+		
+		def not_found
+		  request.not_found
+		end
+		
+	end
+	
+end

data/lib/runtime/response_proxy.rb

@@ -0,0 +1,29 @@
+module Waves
+	
+	class ResponseProxy 
+
+    attr_reader :request
+
+    include ResponseMixin
+    
+		def initialize(request); @request = request; end
+		
+		def use( model ) ; @model = model ; self ; end
+		
+		def controller( &block )
+			Waves.application.controllers[ @model ].process( @request, &block )
+		end
+		
+		def view( &block )
+			Waves.application.views[ @model ].process( @request, @value, &block )
+		end
+		
+		def |( val ); @value = val; self; end
+		
+		def to_s; @value ; end
+		
+		def redirect(path); @request.redirect(path); end
+		
+	end
+	
+end

data/lib/runtime/server.rb

@@ -0,0 +1,58 @@
+module Waves
+	
+	class Server < Application
+				
+		attr_reader :thread
+		
+		def start
+			load( :lib / 'startup.rb' )
+			Waves::Logger.start
+			log.info "** Waves Server Starting ..."
+			
+			t = Benchmark.realtime do
+				app = config.application.to_app				
+				@server = ::Mongrel::HttpServer.new( config.host, config.port )
+				@server.register('/', Rack::Handler::Mongrel.new( app ) )
+				trap('INT') { puts; stop }
+				@thread = @server.run
+			end
+			log.info "** Waves Server Running on #{config.host}:#{config.port}"
+			log.info "Server started in #{(t*1000).round} milliseconds."
+			@thread.join
+		end
+		
+		def stop
+			log.info "** Waves Server Stopping ..."
+			@server.stop 
+			log.info "** Waves Server Stopped"
+		end
+		
+		def synchronize( &block )
+			( @mutex ||= Mutex.new ).synchronize( &block )
+		end
+		
+		def cache
+			#@cache ||= MemCache::new '127.0.0.1'
+		end
+		
+		# make this a singleton ... we don't use Ruby's std lib
+		# singleton module because it doesn't do quite what we
+		# want - need a run method and implicit instance method
+		class << self
+			
+			private :new, :dup, :clone
+			
+			def run( mode = :development )
+				@server.stop if @server; @server = new( mode ); @server.start
+			end
+			
+			# allow Waves::Server to act as The Server Instance
+			def method_missing(*args); @server.send(*args); end
+			
+			def synchronize(&block) ; @server.synchronize(&block) ; end
+			
+		end
+
+	end
+	
+end

data/lib/runtime/session.rb

@@ -0,0 +1,43 @@
+module Waves
+	class Session
+		
+		def initialize( request )
+			@request = request
+			@data ||= ( File.exist?( session_path  ) ? load_session : {} )
+		end
+		
+		def save
+			if @data && @data.length > 0
+				File.write( session_path, @data.to_yaml )
+				@request.response.set_cookie( 'session_id', 
+					:value => session_id, :path => '/', 
+					:expires => Time.now + Waves::Server.config.session[:duration] )
+			end
+		end
+		
+		def [](key) ; @data[key] ; end
+		def []=(key,val) ; @data[key] = val ; end
+		
+		private
+		
+		def session_id
+			@request.cookies['session_id'] || generate_session_id 
+		end
+		
+		def generate_session_id # from Camping ...
+			chars = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
+			(0..48).inject(''){|s,x| s+=chars[ rand(chars.length) ] }
+		end
+		
+		def session_path
+		  Waves::Server.config.session[:path] / session_id
+		end
+		
+		def load_session
+			YAML.load( File.read( session_path ) )
+		end
+		
+	end
+	
+end
+		

data/lib/utilities/integer.rb

@@ -0,0 +1,8 @@
+class Integer
+	def seconds ; self ; end
+	def minutes ; self * 60 ; end
+	def hours ; self * 60.minutes ; end
+	def days ; self * 24.hours ; end
+	def weeks ; self * 7.days ; end
+	# months and years are not precise
+end

data/lib/utilities/kernel.rb

@@ -0,0 +1,8 @@
+module Kernel
+	
+	# inspired by similar function in rails ...
+	def returning( object, &block )
+		yield object; object
+	end
+
+end

data/lib/utilities/module.rb

@@ -0,0 +1,7 @@
+class Module
+
+	def basename
+		self.name.split('::').last || ''
+	end
+
+end