nitro 0.13.0 → 0.14.0

data/lib/nitro/caching/stores.rb

@@ -0,0 +1,84 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: stores.rb 326 2005-03-28 11:07:17Z gmosx $
+
+require 'fileutils'
+
+require 'glue/hash'
+
+module N
+
+# Adds support for caching.
+
+module Caching
+
+	# Cached fragments are stored in memory.
+
+	class MemoryStore < SafeHash
+
+		def read(name, options = {})
+			self[name]
+		end
+		
+    def write(name, content = '', options = {})
+			self[name] = content
+		end
+
+		def delete(name, options = {}) 
+			self.delete(name)
+		end
+
+	end
+
+	# Cached fragments are stored as html files
+	# on the filesystem.
+
+	class FileStore
+		cattr_accessor :cache_root, 'cache'
+		
+		def initialize(cache_root = @@cache_root)
+			@cache_root = FileStore.cache_root
+		end
+		
+		def read(name, options = {})
+			begin
+				IO.read(path_for_name(name))
+			rescue
+				nil
+			end
+		end
+
+		def write(name, content = '', options = {})
+			begin
+				path = path_for_name(name)
+				dir = File.dirname(path)
+				FileUtils.makedirs(dir) unless File.exists?(dir)
+				
+				File.open(path, 'w+') { |f| f.write(content) }
+			rescue
+				Logger.error "Could not save cached file '#{path}'"
+			end
+		end
+
+		def delete(name, options = {})
+			path = path_for_name(name)
+			File.delete(path) if File.exist?(path)
+		end
+		
+		private
+
+		def path_for_name(name)
+			"#@cache_root/#{name}"
+		end
+
+	end
+
+	class DrbStrore
+	end
+	
+	class MemcacheStore
+	end
+
+end
+
+end

data/lib/nitro/controller.rb

@@ -5,6 +5,7 @@
 require 'nitro/render'
 require 'nitro/scaffold'
 require 'nitro/filters'
+require 'nitro/caching'
 
 module N
 
@@ -78,6 +79,7 @@ class Controller
 	include Render
 	include Scaffolding
 	include Filtering		
+	include Caching
 
 	# A hash containing metadata for the action
 	# methods.
@@ -101,7 +103,7 @@ class Controller
 
 		def inherited(subclass)
 			subclass.class_eval %{
-				DEF_FILE = caller[2].split(':').first
+				DEF_FILE = caller[2].split(':')[-2]
 			}	
 			__old_inherited(subclass)
 		end

data/lib/nitro/dispatcher.rb

@@ -162,7 +162,6 @@ class Dispatcher
 	
 		content_type = @apis[:api] || 'text/html'
 
-		# return klass, "__#{api}__#{action}", base, content_type 
 		return klass, "__#{api}__#{action}", content_type 
 	end
 	alias_method :split_path, :dispatch

data/lib/nitro/filters.rb

@@ -1,11 +1,11 @@
 # * George Moschovitis  <gm@navel.gr>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: filters.rb 249 2005-02-04 14:03:00Z gmosx $
+# $Id: filters.rb 326 2005-03-28 11:07:17Z gmosx $
 
 module N
 
-# Filtering functionality for renders/services. The design 
-# and implementation is HEAVILY influenced by Rails.
+# Filtering functionality for renders. 
+# The design and implementation is HEAVILY influenced by Rails.
 #
 # == Examples
 #
@@ -19,68 +19,108 @@ module N
 #		filter
 #		after
 #--
-# TODO: 
-# implement inheritable filters.
+# TODO: implement inheritable filters.
 #++
 
 module Filtering
 
-	# Ruby is sometimes VERY surprising, the following trick is needed
-	# to include singleton methods in other classes.
-	
+	# Store the code and the metadata (options) for
+	# the a Filter.
+
+	Filter = Struct.new(:code, :options)
+		
 	def self.append_features(base)
-		super; base.extend(ClassMethods)
+		super
+		base.extend(ClassMethods)
+		base.class_eval %{
+			@before_filters = []
+
+			def self.before_filters 
+				@before_filters
+			end
+
+			def self.before_filters=(bf)
+				@before_filters = bf
+			end
+			
+			@after_filters = []
+
+			def self.after_filters 
+				@after_filters
+			end
+
+			def self.after_filters=(af)
+				@after_filters = af
+			end
+
+			def self.inherited(sub)
+				super
+				sub.before_filters = self.before_filters.dup
+				sub.after_filters = self.after_filters.dup
+			end
+		}
 	end
 
 	module ClassMethods
-		# the filters to be evaluated before the method
-		@@before_filters = []
-		
-		# the filters to be evaluated after the method
-		@@after_filters = []
-		
-		#
-		#
-		def before_filters 
-			@@before_filters
-		end
-		
-		#
-		#
-		def after_filters
-			@@after_filters
-		end
 		
-		#
+		# Prepend a filter to the before_filters collection.
 		
-		def prepend_before_filter(*filters, &block)
-			filters << block if block_given?
-			@@before_filters = filters + @@before_filters
+		def prepend_before_filter(*args, &block)
+			options = args.pop if args.last.is_a?(Hash)
+
+			if block_given?
+				filters = [ Filter.new(block, options) ]
+			else
+				filters = args.collect { |c| Filter.new(c, options) }
+			end
+
+			self.before_filters = filters + self.before_filters
 		end
 		
-		#
+		# Append a filter to the before_filters collection.
 		
-		def append_before_filter(*filters, &block)
-			filters << block if block_given?
-			@@before_filters = @@before_filters + filters
+		def append_before_filter(*args, &block)
+			options = args.pop if args.last.is_a?(Hash)
+
+			if block_given?
+				filters = [ Filter.new(block, options) ]
+			else
+				filters = args.collect { |c| Filter.new(c, options) }
+			end
+	
+			self.before_filters = self.before_filters + filters
 		end
 		
 		# Alias for the most common case.
 
 		alias :before_filter :prepend_before_filter
 
-		#
+		# Prepend a filter to the after_filters collection.
 		
-		def prepend_after_filter(*filters, &block)
-			filters << block if block_given?
-			@@after_filters = filters + @@after_filters
+		def prepend_after_filter(*args, &block)
+			options = args.pop if args.last.is_a?(Hash)
+
+			if block_given?
+				filters = [ Filter.new(block, options) ]
+			else
+				filters = args.collect { |c| Filter.new(c, options) }
+			end
+			
+			self.after_filters = filters + self.after_filters
 		end
 		
-		#
+		# Append a filter to the after_filters collection.
 		
-		def append_after_filter(*filters, &block)
-			filters << block if block_given?
-			@@after_filters = @@after_filters + filters
+		def append_after_filter(*args, &block)
+			options = args.pop if args.last.is_a?(Hash)
+
+			if block_given?
+				filters = [ Filter.new(block, options) ]
+			else
+				filters = args.collect { |c| Filter.new(c, options) }
+			end
+			
+			self.after_filters = self.after_filters + filters
 		end
 		
 		# Alias for the most common case.
@@ -91,17 +131,19 @@ module Filtering
 		# to the before and after methods. Both methods are prepended to
 		# the respective lists.
 		
-		def prepend_arround_filter(*filters)
-			filters = [filters].flatten
+		def prepend_arround_filter(*args)
+			options = args.pop if args.last.is_a?(Hash)
+
+			filters = [options].flatten
 			
 			for filter in filters
 				if filter.respond_to?(:before)
-					prepend_before_filter { |c| filter.before(c) }
+					prepend_before_filter(options) { |c| filter.before(c) }
 				elsif filter.respond_to?(:filter)
 					# consider 'filter' as synonym of before.
-					prepend_before_filter { |c| filter.filter(c) }
+					prepend_before_filter(options) { |c| filter.filter(c) }
 				end
-				prepend_after_filter { |c| filter.after(c) } if filter.respond_to?(:after)
+				prepend_after_filter(options) { |c| filter.after(c) } if filter.respond_to?(:after)
 			end
 		end
 		
@@ -109,31 +151,46 @@ module Filtering
 		# to the before and after methods. Both methods are appended to
 		# the respective lists.
 		
-		def append_arround_filter(*filters)
+		def append_arround_filter(*args)
+			options = args.pop if args.last.is_a?(Hash)
+
 			filters = [filters].flatten
 			
 			for filter in filters
 				if filter.respond_to?(:before)
-					append_before_filter { |c| filter.before(c) }
+					append_before_filter(options) { |c| filter.before(c) }
 				elsif filter.respond_to?(:filter)
 					# consider 'filter' as synonym of before.
-					append_before_filter { |c| filter.filter(c) }
+					append_before_filter(options) { |c| filter.filter(c) }
 				end
-				append_after_filter { |c| filter.after(c) } if filter.respond_to?(:after)
+				append_after_filter(options) { |c| filter.after(c) } if filter.respond_to?(:after)
 			end
 		end
 		
 		# Alias for the most common case.
 		alias :filter :append_arround_filter
 		
-		#
+		# Generates the code to call the filters
 		
-		def gen_filters_call_code(filters)
+		def gen_filters_call_code(action, filters) # :nodoc: 
 			code = ""
 		
-			filters.each do |filter| 
+			for filter in filters
+				
+				if options = filter.options
+					if only = options[:only]
+						next unless [only].flatten.include?(action.to_sym)
+					elsif except = options[:except]
+						next if [except].flatten.include?(action.to_sym)
+					end
+				end
+				
+				filter = filter.code
+
 				if Symbol === filter
 					code << "if #{filter} == false then return false end;"
+				elsif String === filter
+					code << "#{filter};"
 				elsif filter.respond_to?('call') && (filter.arity == 1 || filter.arity == -1)
 					code << 'if filter.call(self) == false then return false end;'
 				elsif filter.is_a?(Module) and filter.instance_methods.size > 0
@@ -143,7 +200,7 @@ module Filtering
 				elsif filter.respond_to?('filter')
 					code << "if #{filter}.filter(self) == false then return false end"
 				else
-					raise 'Valid filters are either a symbol or a proc/method.'
+					raise 'Valid filters are either a symbol, a string or a proc/method.'
 				end
 			end
 			

data/lib/nitro/mail.rb

@@ -4,7 +4,7 @@
 # 
 # * George Moschovitis  <gm@navel.gr>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: mail.rb 300 2005-03-16 13:23:10Z gmosx $
+# $Id: mail.rb 323 2005-03-24 09:43:52Z gmosx $
 
 require 'net/smtp'
 
@@ -221,8 +221,11 @@ class Mailer < Mail
 				mailer.body = render_body(method_name, mailer)
 			end
 
-			mail = create(mailer.from, mailer.to, mailer.subject, mailer.body, mailer.sent_on, 
-					mailer.headers, mailer.charset)
+			mail = create(
+				mailer.from, mailer.to, mailer.subject, 
+				mailer.body, mailer.sent_on, 
+				mailer.headers, mailer.charset
+			)
 
 			mail.cc = mailer.cc if mailer.cc
 			mail.bcc = mailer.bcc if mailer.bcc

data/lib/nitro/render.rb

@@ -101,13 +101,15 @@ module Rendering
 			
 			code = %{
 				def __#{api}__#{action}
+					old_action_name = @action_name
+					@action_name = '#{action}'
 			}
 			
 			# call 'before' filter chain.
 			
 			if klass.respond_to?(:before_filters)
 				code << %{
-					#{klass.gen_filters_call_code(klass.before_filters)}
+					#{klass.gen_filters_call_code(action, klass.before_filters)}
 				}
 			end
 
@@ -152,11 +154,13 @@ module Rendering
 
 			if klass.respond_to?(:after_filters)
 				code << %{
-					#{klass.gen_filters_call_code(klass.after_filters)}
+					#{klass.gen_filters_call_code(action, klass.after_filters)}
 				}
 			end
 			
 			code << %{
+					@action_name = old_action_name
+				
 					redirect_referer if @out.empty?
 				end
 			}
@@ -168,7 +172,9 @@ module Rendering
 					end
 				}
 			end
-	
+
+			# puts '---', code, '---' if action.to_s == 'index'
+
 			klass.class_eval(code)
 		end
 
@@ -201,6 +207,10 @@ module Render
 	
 	attr_accessor :rendering_errors
 
+	# The name of the currently executing action.
+
+	attr_accessor :action_name
+	
 	# The template root for this render.
 
 	cattr_accessor :template_root
@@ -223,7 +233,6 @@ module Render
 	def render(path)
 		Logger.debug "Rendering '#{path}'." if $DBG
 		
-		# klass, action, template_root, ctype = @context.dispatcher.dispatch(path, @context)
 		klass, action, content_type = @context.dispatcher.dispatch(path, @context)
 
 		@context.content_type = content_type
@@ -250,6 +259,20 @@ module Render
 		@out << '(error)'
 	end
 
+	# Add some text to the output buffer.
+
+	def render_text(text)
+		@out << text
+	end
+		
+	#--
+	# FIXME: do something better to stop the redirect.
+	#++
+
+	def render_nothing
+		@out = ' '
+	end
+
 private
 
 	# Send a redirect response.