nitro 0.8.0 → 0.9.3

data/lib/nitro/server/handlers.rb

@@ -1,127 +0,0 @@
-# code: 
-# * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: handlers.rb 167 2004-11-23 14:03:10Z gmosx $
-
-require "glue/cache"
-require "nitro/server/filters"
-
-module N
-
-# = Handler
-# 
-# App server handlers handle requests to specific resources.
-# Handlers are a special kinf of filters so the can be chained
-# in the rendering pipeline.
-#
-# === Design:
-#
-# Handlers are NOT singleton classes. This way we can assign one 
-# handler class to multiple resources, and keep statistics and 
-# metrics for each resource.
-#
-class Handler < N::ServerFilter
-
-	# Perform the actual work of the handler
-	# Typically calls the next filter in the pipeline afterwards.
-	#
-	def process(request)
-		# nop
-		
-		# walk the filter pipeline		
-		@next_filter.process(request) if @next_filter
-	end
-
-end # class
-
-# = Handler Error
-#
-# Raise this if an error happens when handling a request
-#
-class HandlerError < StandardError; end
-
-# = Script Handler
-#
-# Base handler for scripts. All othere script handlers are extensions
-# from this class.
-#
-class ScriptHandler < Handler
-
-	# cache the compiled page scripts to optimize future references.
-	# use a thread safe cache.
-	@@compiled_script_cache = N::SafeHash.new()
-
-	# dont allow 2 threads to compile the same script. In fact dont allow
-	# two threads to compile in parallel.
-	@@compile_sync = Sync.new
-
-	# Overload the path.
-	# FIXME: better name and much better documentation.
-	#
-	def	overload_path(path)
-		path.gsub!(/\/\//, '/')
-		
-		if ::File.exists?("#$root_dir/#{path}")
-			return path
-		else
-			Logger.debug "OVERLOAD: '#{path}' -> 'p/#{path}'" if $DBG
-			return "p/#{path}"
-		end		
-	end
-	
-	# the compiler returns a singleton class customized for rendering the
-	# input script. The original idea was to define render() as a static 
-	# method and return the class, but we will use a singleton object to 
-	# keep custom data structures (sub-page-graph, metrics, etc)
-	#
-	# script_path is used as key in the Dynamic class creation and for 
-	# caching
-	#
-	# === Design:
-	# we use __ for out too to avoid nasty collisions.
-	#
-	def compile_script(script)
-		compiled_script = nil
-		
-		# dont allow 2 threads to compile the same script. In fact dont 
-		# allow two threads to compile in parallel.
-		# gmosx: SOS this eval assigns the variable compiled_script!
-		@@compile_sync.synchronize {
-			eval(script)
-		}
-			
-		return compiled_script		
-	end
-	
-	def compiled_script_cache
-		return @@compiled_script_cache
-	end
-
-	# Log a rendering error. The accumulated log is available
-	# for rendering in the offending page when in Debug mode.
-	#
-	def log_error(request, ex)
-		request.log_error "--------"
-		request.log_error "#{request.path}:"
-		request.log_error "#{ex.class}: #{ex}"
-		request.log_error ex.backtrace()
-		raise ScriptHandlerError.new(0, "error")
-	end
-
-end
-
-# =ScriptHandlerError
-#
-# Raise this if an error happens when handling a script.
-#
-class ScriptHandlerError < HandlerError
-	attr_reader :error_line
-
-	def initialize(error_line, message = nil)
-		@error_line, @message = error_line, message
-	end
-	
-end
-
-end # module

data/lib/nitro/server/render.rb

@@ -1,426 +0,0 @@
-# George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: render.rb 200 2004-12-27 11:24:41Z gmosx $
-
-require 'cgi'
-
-module N
-
-# = RenderUtils
-#
-# Various render related utilities.
-
-module RenderUtils
-
-	# Split the path to base, render_class and method.
-	#
-	# == Examples
-	#
-	# / -> nil, index, nil
-	# /add_user -> nil, add_user, nil
-	# /add_user?user=gmosx -> nil, add_user, user=gmosx
-	# /blog/new_entry -> blog, new_entry
-	#	/blog -> blog, index, nil
- 
-	def self.split_path(path)
-		# paths that start with rest/xxx are REST requests.
-		# FIXME: better chack here!
-		if path.slice!(/rest\//)
-			api = :rest
-		else
-			api = :http
-		end
-		
-		parts = path.split('/')
-		
-		case parts.size
-			when 0
-				base = ''
-				render_class = $services[:index]
-				meth = 'index'
-			when 2
-				if render_class = $services[parts[1]]
-					base = parts[1]
-					meth = 'index'
-				else
-					base = ''
-					render_class = $services[:index]
-					meth = parts[1]
-				end
-			when 3
-				base = parts[1]
-				render_class = $services[parts[1]]
-				meth = parts[2]
-		end
-		
-		#		p '--', api, base, render_class, meth, '--'
-		
-		return api, base, render_class, meth
-	end
-
-	# Given the method try find the matching template.
-	# Can search for xhtml or xml templates.
-	# Returns nil if no template file is found.
-	#
-	def self.template_for_method(base, meth, ext = $template_ext)
-		# attempt to find a template of the form
-		# base/meth.xhtml
-		path = "#$root_dir/#{base}/#{meth}.#{ext}".squeeze('/')
-		
-		unless File.exist?(path)
-			# attempt to find a template of the form
-			# base/meth/index.xhtml
-			path = "#$root_dir/#{base}/#{meth}/#{$index_template}".squeeze('/')
-			
-			unless File.exist?(path)
-				# No template found!
-				path = nil
-			end
-		end
-		
-		return path
-	end
-	
-	# Transform a template to ruby rendering code.
-	#
-	def self.transform_template(path)
-		Logger.debug "Transforming '#{path}'" if $DBG
-
-		text = File.read(path)
-		hash, text = $shader.process(path, text)
-		
-		return text
-	end
-
-	
-	# Compile a HTTP method.
-	#	
-	def self.compile_http_method(klass, base, meth)
-		Logger.debug "Compiling HTTP method '#{klass}:#{meth}'" if $DBG
-
-		valid = false
-		
-		code = %{
-			def __#{meth}
-				@response.header['Content-Type'] = 'text/html'
-				@out ||= ''
-		}
-		
-		# 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?(meth)
-			valid = true
-			code << %{
-				#{meth}();
-			}
-		end
-
-		# call the programmatically generated template if exists.
-		if klass.instance_methods.include?("#{meth}__xhtml")
-			valid = true
-			code << %{
-				return unless #{meth}__xhtml();
-			}
-		end
-		
-		# call the template
-		if template = template_for_method(base, meth)
-			valid = true
-			code << %{
-				return unless __#{meth}_xhtml();
-			}
-		end
-		
-		raise "Invalid method '#{meth}' for service '#{klass}'!" unless valid
-
-		# 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?
-			end
-		}
-		
-		if template
-			code << %{
-				def __#{meth}_xhtml
-					#{transform_template(template)}
-				end
-			}
-		end
-=begin	
-		puts '--'
-		puts dump(code)
-		puts '--'
-=end
-		klass.class_eval(code)
-		
-		return "__#{meth}"
-	end
-
-	# Compile a REST method.
-	#	
-	def self.compile_rest_method(klass, base, meth)
-		Logger.debug "Compiling REST method '#{klass}:#{meth}'" if $DBG
-
-		valid = false
-		
-		code = %{
-			def __rest_#{meth}
-				@response.header['Content-Type'] = 'text/xml'
-				@out ||= ''
-		}
-
-		# 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?(meth)
-			valid = true
-			code << %{
-				#{meth}();
-			}
-		end
-
-		# call the programmatically generated template if exists.
-		if klass.instance_methods.include?("#{meth}__xml")
-			valid = true
-			code << %{
-				return unless #{meth}__xml();
-			}
-		end
-		
-		# call the template
-		if template = template_for_method(base, meth, 'xml')
-			valid = true
-			code << %{
-				return unless __#{meth}_xml();
-			}
-		end
-		
-		raise "Invalid method '#{meth}' for service #{klass}!" unless valid
-
-		# call 'after' filter chain.
-		if klass.respond_to?(:after_filters)
-			code << %{
-				#{klass.gen_filters_call_code(klass.after_filters)}
-			}
-		end
-				
-		code << %{
-			end
-		}
-		
-		if template
-			code << %{
-				def __#{meth}_xml
-					#{transform_template(template)}
-				end
-			}
-		end
-
-		klass.class_eval(code)
-		
-		return "__rest_#{meth}"
-	end
-
-	def self.dump(str)
-		str.split("\n").each_with_index do |line, idx|
-			puts "#{idx+1}: #{line}"
-		end
-	end
-end
-
-# = RenderExit
-#
-# Raise this exception to stop rendering.
-
-class RenderExit < Exception
-end
-	
-# = Render
-
-module Render
-	# The outbut buffer. The output of a script/action is accumulated
-	# in this buffer.
-	attr :out	
-	
-	# The parameters of this request as Hash.
-	attr_accessor :params
-	
-	# The request.
-	attr_accessor :request
-	
-	# The response.
-	attr_accessor :response
-
-	# The session contains variables that stay alive for the full
-	# user session.
-	attr_accessor :session
-	
-	# An array holding the rendering errors for this
-	# request.
-	#
-	attr_accessor :rendering_errors
-	
-	def initialize(base_path = '', request = nil, response = nil, session = nil)
-		@base_path = base_path
-		@request = request
-		@response = response
-		@session = session
-		@params = request.query
-		
-		@out_buffers = nil
-	end
-		
-	# Returns the output of the rendering as string.
-	#
-	def render(path, request = nil, response = nil, session = nil)
-		path, query_string = path.split('?')
-	
-		@request ||= request
-		@response ||= response
-		@session ||= session
-
-		@params = @request.set_query(query_string) if query_string
-		
-		base, render_class, meth = $methods[path]
-		
-		unless meth
-			api, base, render_class, meth = RenderUtils.split_path(path)
-			
-			raise "Invalid service!" unless render_class
-			
-			case api
-				when :http
-				meth = RenderUtils.compile_http_method(render_class, base, meth)
-				when :rest
-				meth = RenderUtils.compile_rest_method(render_class, base, meth)
-			end
-				
-			$methods[path] = [base, render_class, meth] unless $reload_scripts
-		end
-
-		begin
-			if self.class == render_class
-				self.send(meth)
-			else
-=begin
-				gmosx: reolading fucks up validation and meta data propagation.
-			 	if $reload_scripts and defined?(render_class::SOURCE_FILE)
-					load(render_class::SOURCE_FILE)
-				end
-=end
-				r = render_class.new(base, @request, @response, @session)
-				r.send(meth)
-				@out = r.out
-			end
-		rescue N::RenderExit => e
-			# Just stop rendering.
-			# For example called by redirects.
-		rescue Exception, StandardError => e
-			log_error "error while handling '#{path}'."
-			log_error pp_exception(e)
-			# more fault tolerant, only flags the erroneous box with 
-			# error not the full page.
-			@out << '(error)'
-		end
-
-		# stop the filter pipeline
-		return false
-	end
-
-	# Render the referer of this method.
-	#
-	def render_referer
-		render(@request.referer.gsub(/#$srv_url/, ''))
-	end
-	
-	# Send a redirect response.
-	#
-	def redirect(url, status = 303)
-		@response.status = status
-		@response.body = "<html><a href=\"#{url.to_s}\">#{url.to_s}</a>.</html>\n"
-		@response.header['location'] = url.to_s
-
-		# stop the rendering
-		raise N::RenderExit
-	end
-	
-	# Redirect to the referer of this method.
-	#
-	def redirect_referer(postfix = nil, status = 303)
-		redirect("#{@request.referer}#{postfix}", status)
-	end
-
-	# Log a rendering error.
-	#--
-	# FIXME: find a better name
-	#++
-	def log_error(str)
-		@rendering_errors ||= []
-		@rendering_errors << str
-		Logger.error str
-	end
-	
-	# --------------------------------------------------------------------
-	# Output buffering methods.
-	
-	# Start (push) a new output buffer.
-	#
-	def ob_start
-		@out_buffers = [] unless @out_buffers
-		@out_buffers.push(@out)
-		@out = ''
-	end
-	
-	# End (pop) the current output buffer.
-	#
-	def ob_end
-		@out = @out_buffers.pop
-	end
-	
-	# End (pop) the current output buffer and write to the parent.
-	#
-	def ob_write_end
-		nested_buffer = @out
-		@out = @out_buffers.pop
-		@out << nested_buffer
-	end
-
-	# --------------------------------------------------------------------
-	# Caching methods.
-	
-	#--
-	# FIXME: pseudocode, not working.
-	#++
-	def cache_start
-		valid?		
-		ob_start
-	end
-
-	#--
-	# FIXME: pseudocode, not working.
-	#++
-	def cache_end
-		save_fragment(@out)
-		ob_write_end
-	end	
-end
-
-end # module
-