nitro 0.8.0 → 0.9.3

data/lib/nitro/request.rb

@@ -0,0 +1,128 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: nitro.rb 167 2004-11-23 14:03:10Z gmosx $
+
+module N
+	
+# Encapsulates a request. This is an abstract request
+# typically extended by sub-classes.
+
+module Request
+
+	# The request input stream.
+
+	attr_accessor :in
+
+	# The request headers collection. Also called
+	# the request environment (env).
+
+	attr_accessor :headers
+	alias_method :env, :headers
+	alias_method :env=, :headers=
+	# for compatibility with cgi.rb
+	alias_method :env_table, :headers
+
+	# The parsed query parameters collection.
+
+	attr_accessor :params
+	alias_method :query, :params
+
+	# The request cookies.
+
+	attr_accessor :cookies
+
+	# The request protocol.
+
+	def protocol
+		443 == port ? 'https://' : 'http://'
+	end
+
+	# Is this an ssl request?
+
+	def ssl?
+		443 == port
+	end
+		
+	# The request uri.
+
+	def uri
+		@headers['REQUEST_URI']
+	end
+
+	# The path is the uri without the query string.
+
+  def path
+		uri ? uri.split('?').first : ''
+	end
+
+	# The request query string.
+
+	def query_string 
+		@headers['QUERY_STRING']
+	end
+	
+	# The request method.
+
+	def method
+		@headers['REQUEST_METHOD'].downcase.intern
+	end
+
+	# Return the referer. For the initial page in the
+	# clickstream there is no referer, set "/" by default.
+		
+	def referer
+		return @headers['REFERER'] || '/'
+	end
+
+	# The remote IP address. REMOTE_ADDR is the standard
+  # but will fail if the user is behind a proxy.  
+	# HTTP_CLIENT_IP and/or HTTP_X_FORWARDED_FOR are set by 
+	# proxies so check for these before falling back to 
+	# REMOTE_ADDR. HTTP_X_FORWARDED_FOR may be a comma-delimited 
+	# list in the case of multiple chained proxies; the first 
+	# is the originating IP.
+													
+	def remote_ip
+		return @headers['HTTP_CLIENT_IP'] if @headers.include?('HTTP_CLIENT_IP')
+
+    if @headers.include?('HTTP_X_FORWARDED_FOR') then
+			remote_ips = @headers['HTTP_X_FORWARDED_FOR'].split(',').reject do |ip|
+				ip =~ /^unknown$|^(10|172\.16|192\.168)\./i
+			end
+
+			return remote_ips.first.strip unless remote_ips.empty?
+		end
+
+		return @headers['REMOTE_ADDR']
+	end
+
+	# The server port.
+
+	def port
+		@headers['SERVER_PORT'].to_i
+	end
+
+	# The server host name.
+
+	def host
+		@headers['HTTP_HOST'] 
+	end
+
+	def host_url
+		"http://#{host}"
+	end
+
+	# Lookup a query parameter.
+
+	def [](param)
+		@params[param]
+	end
+
+	# Set a query parameter.
+
+	def []=(param, value)
+		@params[param] = value
+	end
+end
+
+end

data/lib/nitro/response.rb

@@ -0,0 +1,38 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: nitro.rb 167 2004-11-23 14:03:10Z gmosx $
+
+module N
+	
+# HTTP Response.
+
+module Response
+
+	# The Response status.
+
+	attr_accessor :status
+
+	# The Response headers.
+
+	attr_accessor :response_headers
+
+	# The Response cookies.
+
+	attr_accessor :response_cookies
+
+	def content_type=(ctype)
+		@response_headers['Content-Type'] = ctype
+	end
+
+	# Add a cookie to the response. Better use this
+	# method to avoid precreating the cookies array
+	# for every request.
+	
+	def add_cookie(cookie)
+		(@response_cookies ||= []) << cookie
+	end
+	alias_method :send_cookie, :add_cookie
+
+end
+
+end

data/lib/nitro/scaffold.rb

@@ -1,8 +1,6 @@
-# code: 
 # * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: scaffold.rb 175 2004-11-26 16:11:27Z gmosx $
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: scaffold.rb 248 2005-01-31 13:38:34Z gmosx $
 
 require 'glue/inflector'
 
@@ -10,18 +8,19 @@ module N
 
 module Scaffolding
 
-	# Ruby is sometimes VERY surprising, the following trick is needed
-	# to include singleton methods in other classes.
-	#
+	# Ruby is sometimes VERY surprising, the following trick is 
+	# needed to include singleton methods in other classes.
+	
 	def self.append_features(base)
 		super
 		base.extend(SingletonMethods)
 	end
 
 	module SingletonMethods 
+
 		# Enchant the caller with a number of default methods.
 		# Override the automatically generated methods as needed.
-		#
+		
 		def scaffold(klass, options = {})
 			
 			oid = options[:oid] || 'oid'
@@ -54,19 +53,20 @@ module Scaffolding
 			module_eval <<-"end_eval", __FILE__, __LINE__
 				
 				# TODO: add pager support here!
+
 				def list#{suffix}
 					@#{list_name} = #{klass}.all('ORDER BY oid')
 				end
 				
 				def view#{suffix}
-					@#{name} = #{klass}[@params['#{oid}']]
+					@#{name} = #{klass}[@context['#{oid}']]
 				end
 				
 				def save#{suffix}
 				end
 				
 				def del#{suffix}
-					#{klass}.delete(@params['#{oid}'])
+					#{klass}.delete(@context['#{oid}'])
 				end
 				alias_method :delete#{suffix}, :del#{suffix}
 				
@@ -77,4 +77,4 @@ module Scaffolding
 
 end
 
-end # module
+end

data/lib/nitro/session.rb

@@ -0,0 +1,84 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id$
+
+require 'md5'
+require 'webrick'
+
+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.
+# 
+# The session should be persistable to survive server 
+# shutdowns.
+
+class Session < Hash
+
+	# Session id salt.
+
+	cattr_accessor :session_id_salt, 'SALT'
+
+	# The name of the cookie that stores the session id.
+
+	cattr_accessor :cookie_name, 'nsid'
+
+	# The sessions 
+
+	cattr_accessor :manager; @@manager = {}
+
+	# The unique id of this session.
+
+	attr_reader :session_id
+
+	def self.lookup(context)
+		if cookie = context.cookies[Session.cookie_name]
+			session = context.sessions[cookie]
+		end
+
+		unless session
+			session = Session.new(context)
+			context.add_cookie(Cookie.new(Session.cookie_name, session.session_id))
+			context.sessions[session.session_id] = session
+		end
+		
+		return session
+	end
+
+	# Create the session for the given context.
+
+	def initialize(context = nil)
+		@session_id = create_id
+	end
+
+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.
+	
+	def create_id
+		now = Time.now
+		md5 = Digest::MD5.new
+		md5.update(now.to_s)
+		md5.update(now.usec.to_s)
+		md5.update(rand(0).to_s)
+		md5.update(Session.session_id_salt)
+		md5.hexdigest
+	end
+
+end
+
+end

data/lib/nitro/{server/shaders.rb → shaders.rb}

@@ -1,25 +1,25 @@
-# code:
-# * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: shaders.rb 189 2004-12-13 21:38:05Z gmosx $
+#--
+# George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: shaders.rb 202 2005-01-17 10:44:13Z gmosx $
+#++
 
 module N
 
-# = Shader
-#
-# The equivalent of a 3d engine shader. In essence it defines a
-# transformation-pipeline that tansforms the .xhtml files to actual
-# ruby code ready for evaluation (compilation) by the engine.
+# A shader defines a transformation-pipeline that tansforms 
+# the .xhtml files to actual ruby code ready for evaluation 
+# (compilation) by the engine.
 #
 # Shaders are equivalend to the render-pipeline filters, ie they
 # share their folded-filter design.
 #--
 # TODO: pipeline stage mixin to be reused in filters too.
 #++
-#
+
 class Shader
+	
 	# the next stage in the Shader pipeline.
+	
 	attr :next_stage
 	
 	def initialize(next_stage = nil)
@@ -29,20 +29,20 @@ class Shader
 	# Process the text and optionally update the hash.
 	# The hash is a short, unique representation of the input text,
 	# typically used as a caching key.
-	#
+	
 	def process(hash, text)
 		process_next(hash, text)
 	end
 
 	# Set the next stage of the pipeline.
-	#
+	
 	def << (next_stage = nil)
 		@next_stage = next_stage
 		return self
 	end
 	
 	# Process the next stage of the pipeline.
-	#
+	
 	def process_next(hash, text)
 		if @next_stage
 			return @next_stage.process(hash, text)
@@ -52,12 +52,10 @@ class Shader
 	end	
 end
 
-# = RubyShader
-#
 # Convert the xhtml script to actual Ruby code, ready to be 
 # evaluated.
-#
-class RubyShader < N::Shader
+
+class RubyShader < Shader
 
 	# Convert the xhtml script to actual Ruby code, ready to be 
 	# evaluated.
@@ -66,19 +64,19 @@ class RubyShader < N::Shader
 	# Investigate:
 	# perhaps xl:href should be used to be XLink compatible?
 	#++
-	#
+	
 	def process(hash, text)
 		# strip the xml header! (interracts with the following gsub!)
 		text.gsub!(/<\?xml.*\?>/, "")
 
-		# statically include sub script files.
+		# Statically include sub script files.
 		# The target file is included at compile time.
 		#
 		# gmosx: must be xformed before the <?r pi.
 		#
 		# Example:		
 		# <?include xl:href="root/myfile.sx" ?>
-		#
+		
 		text.gsub!(/<\?include href="(.*?)"(.*)\?>/) { |match|
 			# gmosx: xmm match matches the whole string.
 			# match = overload_path($1)				
@@ -87,23 +85,41 @@ class RubyShader < N::Shader
 
 		# xform include instructions <include href="xxx" />
 		# must be transformed before the processinc instructions.
+		# Useful to include fragments cached on disk
+	  #
+		# gmosx, FIXME: NOT TESTED! test and add caching.
+		# add load_statically_included fixes.
+
 		text.gsub!(/<include href="(.*?)"(.*)(.?)\/>/) { |match|
+			"<?r File.read( '\#\{@dispatcher.root\}/#$1' ?>"
+		}
+		
+		# xform render/inject instructions <render href="xxx" />
+		# must be transformed before the processinc instructions.
+
+		text.gsub!(/<inject href="(.*?)"(.*)(.?)\/>/) { |match|
+			"<?r render '/#$1' ?>"
+		}
+		
+		text.gsub!(/<render href="(.*?)"(.*)(.?)\/>/) { |match|
 			"<?r render '/#$1' ?>"
 		}
 		
 		# remove <root> elements. typically removed by xslt but lets
 		# play it safe.
+		
 		text.gsub!(/<(\/)?root>/, '')
 		
 		# runtime ruby code.
 		
 		# xform the processing instructions, use <?r as
 		# a marker.
+		
 		text.gsub!(/\?>/, "\n@out << %^")
 		text.gsub!(/<\?r(\s?)/, "^\n")
 		
 		# xform alternative code tags (very useful in xsl stylesheets)
-		#
+		
 		text.gsub!(/<\/ruby>/, "\n@out << %^")
 		text.gsub!(/<ruby>/, "^\n")
 		
@@ -120,7 +136,7 @@ class RubyShader < N::Shader
 	end
 
 	# Loads and statically includes a file.
-	#
+	
 	def load_statically_included(filename)
 		Logger.debug "Statically including '#{filename}'" if $DBG
 		
@@ -134,20 +150,26 @@ class RubyShader < N::Shader
 	
 end
 
-# = XSLTShader
-#
 # Apply an XSL transformation to the script code.
 # There is no need to keep post xsl. I can reuse the same xsl 
 # by calling transform again. 
-#
-class XSLTShader < N::Shader
+
+class XSLTShader < Shader
+	
 	# The name
+	
 	attr :name
+	
 	# The xslt filename.
+	
 	attr :xsl_filename
+	
 	# The xslt transformer.
+	
 	attr :xslt
+	
 	# Last modified time of the xslt.
+	
 	attr :mtime
 	
 	def initialize(xsl_filename, next_stage = nil)
@@ -161,8 +183,8 @@ class XSLTShader < N::Shader
 		@next_stage = next_stage
 	end
 	
-	# Transform the given text
-	#
+	# Transform the given text.
+	
 	def process(hash, text)
 		parse_xsl()
 		@xslt.xml = text
@@ -174,7 +196,7 @@ class XSLTShader < N::Shader
 	private 
 	
 	# Parse the xsl.
-	#
+	
 	def parse_xsl
 		Logger.debug "Parsing xsl '#{@xsl_filename}'" if $DBG
 		@mtime = File.mtime(@xsl_filename)
@@ -183,14 +205,12 @@ class XSLTShader < N::Shader
 
 end
 
-# = CompressShader
-# 
 # Compress the inline xhtml. Does not touch the ruby code.
-# 
-class CompressShader < N::Shader
+ 
+class CompressShader < Shader
 	
 	# Compress the inline xhtml. Does not touch the ruby code.
-	# 
+	 
 	def process(hash, text)
 		text.gsub!(/\@out \<\< \%\^(.*?)\^/m) do |match|
 			c = $1.gsub(/^(\s*)/m, '').squeeze(" \t").tr("\n", '').tr("\t", ' ')
@@ -202,5 +222,5 @@ class CompressShader < N::Shader
 	
 end
 
-end # module
+end