nitro 0.10.0 → 0.11.0

data/lib/nitro/output.rb

@@ -0,0 +1,28 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: output.rb 267 2005-02-28 14:52:41Z gmosx $
+
+require 'nitro/builders/xml'
+require 'nitro/builders/xhtml'
+require 'nitro/builders/rss'
+require 'nitro/builders/form'
+require 'nitro/builders/table'
+
+module N
+	
+# The output buffer string. This buffer integrates
+# the programmatic rendering support (XhtmlBuilder)
+# and the various builders required by the application.
+#--
+# TODO: Implement a FAST string (maybe in C)
+#++
+
+class OutputBuffer < String
+	include XmlBuilderMixin
+	include XhtmlBuilderMixin
+	include RssBuilderMixin
+	include FormBuilderMixin
+	include TableBuilderMixin
+end
+
+end

data/lib/nitro/render.rb

@@ -2,6 +2,10 @@
 # (c) 2004-2005 Navel, all rights reserved.
 # $Id$
 
+require 'sync'
+
+require 'nitro'
+
 require 'glue/attribute'
 require 'glue/misc'
 require 'glue/object'
@@ -19,6 +23,8 @@ class RenderExit < Exception; end
 
 module Rendering
 
+	@@sync = Sync.new
+
 	# The default template name (no extension).
 
 	mattr_accessor :default_template, 'index'
@@ -84,80 +90,85 @@ module Rendering
 	# Compile a controller action.
 	
 	def self.compile_action(klass, action, base)
-		dummy, api, action = action.to_s.split('__')
+		@@sync.synchronize do
+			dummy, api, action = action.to_s.split('__')
 
-		# This is not a controller action.
+			# This is not a controller action.
 
-		return false unless action
+			return false unless action
 
-		Logger.debug "Compiling action '#{base}/#{action}'" if $DBG
+			Logger.debug "Compiling action '#{base}/#{action}'" if $DBG
 
-		valid = false
-		
-		code = %{
-			def __#{api}__#{action}
-		}
-		
-		# call 'before' filter chain.
-		
-		if klass.respond_to?(:before_filters)
-			code << %{
-				#{klass.gen_filters_call_code(klass.before_filters)}
+			valid = false
+			
+			code = %{
+				def __#{api}__#{action}
 			}
-		end
+			
+			# call 'before' filter chain.
+			
+			if klass.respond_to?(:before_filters)
+				code << %{
+					#{klass.gen_filters_call_code(klass.before_filters)}
+				}
+			end
 
-		# call the action
-		
-		if klass.instance_methods.include?(action)
-			valid = true
-			code << %{
-				#{action}();
-			}
-		end
+			# call the action
+			
+			if klass.action_methods.include?(action)
+				valid = true
+
+				args = klass.action_method_arguments(action).map { |a| "@#{a} = @context['#{a}']" }
+				
+				code << %{
+					#{action}(#{args.join(',')});
+				}
+			end
 
-		# call the programmatically generated template if exists.
+			# call the programmatically generated template if exists.
 
-		if klass.instance_methods.include?("#{action}__#{api}")
-			valid = true
-			code << %{
-				return unless #{action}__#{api}();
-			}
-		end
-		
-		# call the template if exists.
-		
-		if template = template_for_action(base, action)
-			valid = true
-			code << %{
-				return unless __#{api}__#{action}__template();
-			}
-		end
+			if klass.action_methods.include?("#{action}__#{api}")
+				valid = true
+				code << %{
+					return unless #{action}__#{api}();
+				}
+			end
+			
+			# call the template if exists.
+			
+			if template = template_for_action(base, action)
+				valid = true
+				code << %{
+					return unless __#{api}__#{action}__template();
+				}
+			end
 
-		# raise "Invalid action '#{action}' for '#{klass}'!" unless valid
-		return false unless valid
+			# raise "Invalid action '#{action}' for '#{klass}'!" unless valid
+			return false unless valid
 
-		# call 'after' filter chain.
+			# call 'after' filter chain.
 
-		if klass.respond_to?(:after_filters)
-			code << %{
-				#{klass.gen_filters_call_code(klass.after_filters)}
-			}
-		end
-		
-		code << %{
-				redirect_referer if @out.empty?
+			if klass.respond_to?(:after_filters)
+				code << %{
+					#{klass.gen_filters_call_code(klass.after_filters)}
+				}
 			end
-		}
-		
-		if template
+			
 			code << %{
-				def __#{api}__#{action}__template
-					#{transform_template(template, Rendering.shader)}
+					redirect_referer if @out.empty?
 				end
 			}
-		end
+			
+			if template
+				code << %{
+					def __#{api}__#{action}__template
+						#{transform_template(template, Rendering.shader)}
+					end
+				}
+			end
 		
-		klass.class_eval(code)
+			klass.class_eval(code)
+		end
 
 		return true
 	end
@@ -198,7 +209,7 @@ module Render
 		@out = context.out
 		@base = base
 	end
-	
+
 	# Renders the action denoted by path. The path
 	# is resolved by the dispatcher to get the correct
 	# controller.
@@ -233,6 +244,8 @@ module Render
 		@out << '(error)'
 	end
 
+private
+
 	# Send a redirect response.
 	
 	def redirect(url, status = 303)
@@ -267,6 +280,12 @@ module Render
 		@context.session
 	end
 	
+	# Convenience method to access the output buffer.
+
+	def o
+		@out
+	end
+
 end
 
 end

data/lib/nitro/request.rb

@@ -55,6 +55,10 @@ module Request
 		uri ? uri.split('?').first : ''
 	end
 
+	def path_info
+		@headers['PATH_INFO']
+	end
+
 	# The request query string.
 
 	def query_string 
@@ -71,7 +75,7 @@ module Request
 	# clickstream there is no referer, set "/" by default.
 		
 	def referer
-		return @headers['REFERER'] || '/'
+		return @headers['HTTP_REFERER'] || '/'
 	end
 
 	# The remote IP address. REMOTE_ADDR is the standard

data/lib/nitro/runner.rb

@@ -110,6 +110,11 @@ class Runner
 				Logger.set(Logger.new('log/app.log'))
 			end
 
+			opts.on('-a', '--apache', 'Use an apache server.') do
+				@server = :apache
+				Logger.set(Logger.new('log/app.log'))
+			end
+
 			opts.on('-C', '--console', 'Start a console attached to an instance of the application.') do
 				if RUBY_PLATFORM =~ /mswin32/
     			irb_name = 'irb.bat'
@@ -122,11 +127,6 @@ class Runner
 				exit
 			end
 
-			opts.on('-l', '--lhttpd', 'Use a lighttpd server.') do
-				@server = :lhttpd
-				Logger.set(Logger.new('log/app.log'))
-			end
-
 			opts.on_tail('-v', '--version', 'Show version.') do 
 				puts "Nitro #{Nitro::Version}"
 				exit
@@ -205,8 +205,9 @@ class Runner
 		case @action
 		when :start
 			
-			case @server
+			puts "\n==> Application listening at #{conf.host}:#{conf.port}.\n\n"
 
+			case @server
 			when :webrick
 				require 'nitro/adapters/webrick'
 				Webrick.start(conf)
@@ -214,10 +215,23 @@ class Runner
 			when :lhttpd
 				require 'nitro/adapters/fastcgi'
 				`lighttpd -f conf/lhttpd.conf`
+
+			when :apache
+				require 'nitro/adapters/fastcgi'
+				`apachectl -d #{Dir.pwd} -f conf/apache.conf -k start`
 			end
 		
 		when :stop
 
+			case @server
+			when :webrick
+				
+			when :lhttpd
+
+			when :apache
+				`apachectl -d #{Dir.pwd} -f conf/apache.conf -k stop`
+			end
+
 		end
 	end
 

data/lib/nitro/session.rb

@@ -5,19 +5,19 @@
 require 'md5'
 require 'webrick'
 
+require 'glue/hash'
 require 'glue/attribute'
-
 require 'nitro/cookie'
 
 module N
 	
 # A web application session. 
 #
-# State is a neccessary evil but session variables should
-# be avoided as much as possible. Session state is typically
-# distributed to many servers so avoid storing complete 
-# objects in session variables, only store oids and small
-# integer/strings.
+# State is a neccessary evil but session variables
+# should be avoided as much as possible. Session state 
+# is typically distributed to many servers so avoid 
+# storing complete objects in session variables, only 
+# store oids and small integer/strings.
 # 
 # The session should be persistable to survive server 
 # shutdowns.
@@ -32,42 +32,99 @@ class Session < Hash
 
 	cattr_accessor :cookie_name, 'nsid'
 
-	# The sessions 
-
-	cattr_accessor :manager; @@manager = {}
+	# The sessions store. By default sessions are 
+	# stored in memory.
 
-	# The unique id of this session.
+	cattr_accessor :store; @@store = N::SafeHash.new 
 
-	attr_reader :session_id
+	# Set the session store. The following options are
+	# available:
+	#
+	# * :memory [default]
+	# * :drb
+	# * :memcached (not available yet)
+	# * :og (not available yet)
+	# * :file (not available yet)
+
+	def self.store_type=(store_type)
+		require "nitro/session/#{store_type}"
+	end
 
+	# Lookup the session in the store by using the session
+	# cookie value as a key. If the session does not exist
+	# creates a new session, inserts it in the store and 
+	# appends a new session cookie in the response.
+	
 	def self.lookup(context)
-		if cookie = context.cookies[Session.cookie_name]
-			session = context.sessions[cookie]
+		if session_id = context.cookies[Session.cookie_name]
+			session = Session.store[session_id]
 		end
 
 		unless session
+			# Create new session.
 			session = Session.new(context)
-			context.add_cookie(Cookie.new(Session.cookie_name, session.session_id))
-			context.sessions[session.session_id] = session
+			context.add_cookie(
+				Cookie.new(Session.cookie_name, session.session_id)
+			)
+			Session.store[session.session_id] = session 
+		else
+			# Access ('touch') the existing session.
+			session.touch!
 		end
 		
 		return session
 	end
 
+	# The unique id of this session.
+
+	attr_reader :session_id
+
+	# The time this session was created.
+
+	attr_reader :ctime
+	alias_method :create_time, :ctime
+
+	# The time this session was last modified.
+
+	attr_accessor :mtime
+	alias_method :modify_time, :mtime
+
+	# The time this session was last accessed.
+
+	attr_accessor :atime
+	alias_method :access_time, :mtime
+
 	# Create the session for the given context.
 
 	def initialize(context = nil)
 		@session_id = create_id
+		@ctime = @mtime = @atime = Time.now
+	end
+
+	# Like the unix touch command, upadtes
+	# the atime to now.
+
+	def touch!
+		@atime = Time.now
 	end
 
+	# Synchronize the session store, by 
+	# restoring this session. Especially useful
+	# in distributed and/or multiprocess setups.
+	
+	def sync
+		Session.store[@session_id] = self
+	end
+	alias_method :restore, :sync
+	
 protected
 	
 	# Calculates a unique id.
 	#
 	# The session id must be unique, a monotonically 
-	# increasing function like time is appropriate. Random 
-	# may produce equal ids? add a prefix (SALT) to stop 
-	# hackers from creating session_ids.
+	# increasing function like time is appropriate. 
+	# Random may produce equal ids? add a prefix 
+	# (SALT) to stop hackers from creating session_ids.
 	
 	def create_id
 		now = Time.now
@@ -81,4 +138,18 @@ protected
 
 end
 
+# Abstract class for a session store manager. 
+
+class SessionStore
+	def []=(sid, session)
+	end
+
+	def [](sid)
+	end
+
+	def delete(sid)
+	end
+	
+end
+
 end