nitro 0.20.0 → 0.21.0

data/lib/nitro/mixin/table.rb

@@ -0,0 +1,63 @@
+module Nitro
+
+# The TableBuilder is a helper class that automates the creation
+# of tables from collections of objects. The resulting html
+# can be styled using css.
+#
+# === Example
+#
+# <?r
+# users = User.all.map { |u| [u.name, u.first_name, u.last_name, u.email] }
+# header = ['Username', 'First name', 'Last name', 'Email']
+# ?>
+# 
+# <div class="custom-table-class">
+#   #{table(users, header)}
+# </div>
+#--
+# TODO: sorting, thead/tbody/legend etc, verbose...
+#++
+
+module TableMixin
+
+  # [+options+]
+  #    A hash of options.
+  # 
+  # :id = id of the component.
+  # :headers = an array of the header values
+  # :values = an array of arrays.
+
+  def table(options)
+    c = options
+
+    str = '<table'
+    str << %| id="#{c[:id]}"| if c[:id]
+    str << '><tr>'
+
+    for h in c[:headers]
+      str << %|<th>#{h}</th>|
+    end
+
+    str << "</tr>"
+
+    for row in c[:values]
+      str << "<tr>"
+      
+      for v in row
+        str << %|<td>#{v}</td>|
+      end
+      
+      str << "</tr>"
+    end
+
+    str << "</table>"
+
+    return str
+  end
+  alias_method :build_table, :table
+
+end
+
+end 
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/mixin/xhtml.rb

@@ -0,0 +1,75 @@
+module Nitro
+
+# A helper mixin for programmatically building XHTML 
+# blocks. 
+
+module XhtmlMixin
+
+  # Render select options. The parameter is a hash of options.
+  #
+  # [+labels+]
+  #   The option labels.
+  #
+  # [+values+]
+  #    The corresponding values.
+  #
+  #  [+selected+]
+  #    The value of the selected option.
+  #
+  # === Examples
+  #
+  # labels = ['Male', 'Female']
+  # o.select(:name => 'sex') { 
+  #    o.options(:labels => labels, :selected => 1) 
+  # }
+  #
+  # or
+  #
+  # #{options :labels => labels, :values => [..], :selected => 1}
+  # #{build :options, :labels => labels, :values => [..], :selected => 1}
+  
+  def options(options = {})
+    if labels = options[:labels]
+      str = ''
+      
+      unless values = options[:values]
+        values = (0...labels.size).to_a
+      end
+      
+      selected = (options[:selected] || -1).to_i
+      
+      labels.each_with_index do |label, idx|
+        value = values[idx]
+        if value == selected
+          str << %|<option value="#{value}" selected="1">#{label}</option>|
+        else
+          str << %|<option value="#{value}">#{label}</option>|
+        end
+      end
+      
+      return str
+    else
+      raise ArgumentError.new('No labels provided')
+    end
+  end
+
+  # Render a submit input.
+  
+  def submit(options = nil)
+    str = ''
+    
+    if options
+      opts = options.collect { |k, v| %[#{k}="#{v}"] }.join(' ')
+      str << %[<input type="submit" #{opts} />]
+    else
+      str << %|<input type="submit" />|
+    end
+
+    return str
+  end
+  
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/mixin/xml.rb

@@ -0,0 +1,124 @@
+module Nitro
+
+# A helper mixin for programmatically building XML
+# blocks. 
+
+module XmlMixin
+
+  def method_missing(tag, *args, &block)
+    self.class.module_eval <<-"end_eval", __FILE__, __LINE__
+      def #{tag}(*args)
+        attrs = args.last.is_a?(Hash) ? args.pop : nil
+
+        if block_given?
+          start_tag!('#{tag}', attrs)
+          yield
+          end_tag!('#{tag}')
+        elsif (!args.empty?)
+          start_tag!('#{tag}', attrs)
+          self << args.first 
+          end_tag!('#{tag}')
+        else
+          start_tag!('#{tag}', attrs, false)
+          self << ' />'
+        end
+      end
+    end_eval
+
+    self.send(tag, *args, &block)
+  end
+
+  # Emit the start (opening) tag of an element.
+
+  def start_tag!(tag, attributes = nil, close = true)
+    unless attributes
+      if close
+        self << "<#{tag}>"
+      else
+        self << "<#{tag}"
+      end
+    else
+      self << "<#{tag}"
+      for name, value in attributes
+        if value
+          self << %| #{name}="#{value}"|
+        else
+          self << %| #{name}="1"|
+        end
+      end
+      self << ">" if close
+    end
+
+    return self
+  end
+
+  # Emit the end (closing) tag of an element.
+
+  def end_tag!(tag)
+    self << "</#{tag}>" 
+
+    return self
+  end
+
+  # Emit a text string.
+
+  def text!(str)
+    self << str
+
+    return self
+  end
+  alias_method :print, :text!
+
+  # Emit a comment.
+
+  def comment!(str)
+    self << "<!-- #{str} -->" 
+
+    return self
+  end
+
+  # Emit a processing instruction.
+
+  def processing_instruction!(name, attributes = nil)
+    unless attributes
+      self << "<?#{name} ?>"
+    else
+      self << "<?#{name} "
+      attributes.each do |a, v|
+        self << %[#{a}="#{v}" ]
+      end
+      self << "?>"
+    end
+  end
+  alias_method :pi!, :processing_instruction!
+
+end
+
+# A class that encapsulats the XML generation
+# functionality. Utilizes duck typing to redirect 
+# output to a target buffer.
+
+class XmlBuilder
+  include XmlMixin
+
+  # The target receives the generated xml,
+  # should respond_to :<<
+  
+  attr_accessor :target
+  
+  def initialize(target = '')
+    @target = target
+  end
+
+  def << (str)
+    @target << str
+  end
+
+  def to_s
+    @target.to_s
+  end
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/render.rb

@@ -1,3 +1,4 @@
+require 'singleton'
 require 'sync'
 
 require 'facet/string/blank%3F'
@@ -6,388 +7,211 @@ require 'glue/attribute'
 require 'glue/misc'
 require 'glue/object'
 require 'glue/settings'
+require 'glue/builder'
+require 'glue/builder/xml'
 
-require 'nitro/shaders'
-require 'nitro/buffering'
-require 'nitro/errors'
+require 'nitro/mixin/xhtml'
+require 'nitro/mixin/form'
+require 'nitro/mixin/table'
+require 'nitro/mixin/buffer'
 
 module Nitro
 
-# Raise this exception to stop the current action.
+# Raise or Throw this exception to stop the current action.
 # Typically called to skip the template.
 
 class ActionExit < Exception; end
-	
-# Raise this exception to stop rendering altogether.
+  
+# Raise or Thorw this exception to stop rendering altogether.
 # Typically called by redirects.
 
 class RenderExit < Exception; end
 
-# Rendering utility methods
-
-module Rendering
-
-	@@sync = Sync.new
-
-	# The default template root
-
-	setting :default_template_root, :default => 'public', :doc => 'The default template root'
-		
-	# The default template name (no extension).
-
-	setting :default_template, :default => 'index', :doc => 'The default template name (no extension).'
-
-	# The shader used for transforming templates.
-	# The default shader is very simple, here is a 
-	# typical example of a production shader pipeline:
-	#
-	# <tt>
-	#	Rendering.shader = 
-	#		XSLTShader.new("xsl/style.xsl",
-	#			RubyShader.new(
-	#				CompressShader.new
-	#			)
-	#		)
-	# </tt>
-
-	mattr_accessor :shader; @@shader = RubyShader.new
-#	setting :shader, :default => RubyShader.new, :doc => 'The shader used for transforming templates'
-
-	# If set to :full, reloads all controllers. Useful in 
-	# development.
-
-	setting :reload, :default => false, :doc => 'If set to :full reloads everything, useful in development'
-	
-	# Given the action try find the matching template.
-	# Can search for xhtml or xml templates.
-	# Returns nil if no template file is found.
-	
-	def self.template_for_action(template_root, action, ext = :xhtml)
-		# attempt to find a template of the form
-		# template_root/action.xhtml
-
-		path = "#{template_root}/#{action.gsub(/__/, '/')}.#{ext}".squeeze('/')
-
-		unless File.exist?(path)
-			# attempt to find a template of the form
-			# template_root/action/index.xhtml
-
-			path = "#{template_root}/#{action.gsub(/__/, '/')}/#{Rendering.default_template}.#{ext}".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, shader)
-		Logger.debug "Transforming '#{path}'" if $DBG
-
-		text = File.read(path)
-		hash, text = shader.process(path, text)
-
-		return text
-	end
-	
-	# Compile a controller action.
-	
-	def self.compile_action(klass, action)
-		@@sync.synchronize do
-			Aspects.include_advice_modules(klass)
-			
-			action = action.to_s.gsub(/_action$/, '')
-			
-			# This is not a controller action.
-
-			return false unless action
-
-			Logger.debug "Compiling action '#{klass.template_root}/#{action}'" if $DBG
-
-			valid = false
-			
-			code = %{
-				def #{action}_action
-					@parent_action_name = @action_name
-					@action_name = '#{action}'
-			}
-		
-			# Inject the pre advices.
-
-			code << Aspects.gen_advice_code(action, klass.advices, :pre) 
-
-			# Call the action
-			
-			if klass.action_methods.include?(action)
-				valid = true
-
-				# Annotated parameters.
-
-        if meta = klass.action_metadata[action.intern]
-					params = meta.params.keys
-				  params = params.collect { |p| "@#{p} = @context['#{p}']" }
-					code << "#{params.join(';')}"
-				end
-																																	
-				# Try to resolve action parameters.
-
-				param_count = klass.instance_method(action.intern).arity 
-				
-				# gmosx, FIXME: REIMPLEMENT THIS!!!!
-				
-				if param_count > 0
-					code << %{
-						params = []
-						qs = context.query_string.split(/[&;]/)
-						
-						#{param_count}.times do |i|
-							params << qs.shift.split(/=/).last
-						end
-						
-						unless :stop == #{action}(*params)
-					}
-				else
-					code << %{
-						unless :stop == #{action}
-					}
-				end
-			end
-
-			# Try to call the template method if it exists. It is a nice
-			# practice to put output related code in this method instead
-			# of the main action so that this method can be overloaded
-			# separately.
-			#
-			# If no template method exists, try to convert an external
-			# template file into a template method. It is an even better
-			# practice to place the output related code in an external
-			# template file.
-
-			# Take :view metadata into account.
-
-			view = nil
-			if md = klass.action_metadata[action.intern] 
-				view = md[:view]
-			end
-			view ||= action
-
-			cklass = klass
-			
-			while cklass.respond_to?(:template_root)
-				if template = template_for_action(cklass.template_root, view.to_s)
-					valid = true
-					code << %{
-						#{action}_template;
-					}
-					break
-				end 
-				
-				# don't search in parent template roots if an
-				# action is defined.
-				
-				break if valid
-				
-				cklass = cklass.superclass
-			end
-
-			# raise "Invalid action '#{action}' for '#{klass}'!" unless valid
-			return false unless valid
-
-			# Inject the post advices.
-
-			code << Aspects.gen_advice_code(action, klass.advices, :post) 
-			
-			if klass.action_methods.include?(action)
-				code << %{
-					end
-				}
-			end
-
-			code << %{
-					@action_name = @parent_action_name
-					redirect_referer if @out.empty?
-				end
-			}
-			
-			# First compile the action method. 
-			
-#			begin
-				klass.class_eval(code)
-#			rescue SyntaxError => e
-#				raise ActionCompileError.new(code, action, e)
-#			end
-			
-			# Try to compile the template (if exists).
-			
-			if template
-				code = %{
-					def #{action}_template
-						#{transform_template(template, Rendering.shader)}
-					end
-				}
-				
-				begin
-					klass.class_eval(code, template)
-				rescue SyntaxError => e
-					raise TemplateCompileError.new(code, template, e)
-				end				
-			end
-		end
-
-		return true
-	end
+# The output buffer. 
+#--
+# TODO: Implement a FAST string (maybe in C)
+#++
 
+class OutputBuffer < String
 end
 
-# The rendering mixin. 
+# The rendering mixin. This module is typically included in
+# published objects and/or controllers to provide rendering
+# functionality.
 #--
 # TODO: handle template_root here instead of the
 # controller.
 #++
 
 module Render
-
-	# The output buffer. The output of a script/action is 
-	# accumulated in this buffer.
-	
-	attr_accessor :out	
-
-	# A nice alias
-
-	alias_method :body, :out
-	
-	# The context.
-	
-	attr_accessor :context
-	alias_method :ctx, :context
-	alias_method :ctx=, :context=
-	
-	# Aliases for context.
-
-	attr_accessor :request, :response
-
-	# An array holding the rendering errors for this
-	# request.
-	
-	attr_accessor :rendering_errors
-
-	# The name of the currently executing action.
-
-	attr_accessor :action_name
-	
-	# The name of the current controller.
-	
-	attr_accessor :controller_name
-	
-	# Initialize the render.
-	#
-	# [+context+]
-	#		A parent render/controller acts as the context.
-
-	def initialize(context, base = nil)
-		@request = @response = @context = context
-		@controller_name = base
-		@out = context.out
-	end
-
-	# Renders the action denoted by path. The path
-	# is resolved by the dispatcher to get the correct
-	# controller.
-	
-	def render(path)
-		Logger.debug "Rendering '#{path}'." if $DBG
-		
-		klass, action, base = @context.dispatcher.dispatch(path, @context)
-
-		# FIXME: 
-		@context.content_type = klass.instance_variable_get('@content_type') || 'text/html'
-
-		raise 'No controller for action' unless klass
-		
-		if self.class == klass 
-			self.send(action)
-		else
-			klass.new(self, base).send(action)
-		end
-
-	rescue RenderExit => e
-
-		# Just stop rendering.
-		# For example called by redirects.
-		
-	rescue Exception, StandardError => e
-		log_error(e, path)
-
-		# More fault tolerant, only flags the erroneous box with 
-		# error not the full page.
-		
-		@out << '(error)'
-	end
+  include BufferMixin
+
+  # If true, auto redirect to referer on empty buffer.
+  
+  setting :redirect_on_empty, :default => false, :doc => 'If true,  auto redirect to referer on empty buffer'
+
+  # The output buffer. The output of a script/action is 
+  # accumulated in this buffer.
+  
+  attr_accessor :out  
+
+  alias_method :body, :out
+    
+  # The context.
+  
+  attr_accessor :context
+  alias_method :ctx, :context
+  alias_method :ctx=, :context=
+  
+  # Aliases for context.
+
+  attr_accessor :request, :response
+
+  # An array holding the rendering errors for this
+  # request.
+  
+  attr_accessor :rendering_errors
+
+  # The name of the currently executing action.
+
+  attr_accessor :action_name
+  
+  # The name of the current controller.
+  
+  attr_accessor :controller_name
+  
+  # Initialize the render.
+  #
+  # [+context+]
+  #    A parent render/controller acts as the context.
+
+  def initialize(context, base = nil)
+    @request = @response = @context = context
+    @controller_name = base
+    @out = context.out
+  end
+
+  # Renders the action denoted by path. The path
+  # is resolved by the dispatcher to get the correct
+  # controller.
+  
+  def render(path)
+    Logger.debug "Rendering '#{path}'." if $DBG
+    
+    klass, action, base = @context.dispatcher.dispatch(path, @context)
+
+    # FIXME: 
+    @context.content_type = klass.instance_variable_get('@content_type') || 'text/html'
+
+    raise 'No controller for action' unless klass
+    
+    if self.class == klass 
+      self.send(action)
+    else
+      klass.new(self, base).send(action)
+    end
+
+  rescue RenderExit => e
+
+    # Just stop rendering.
+    # For example called by redirects.
+    
+  rescue Exception, StandardError => e
+    log_error(e, path)
+
+    # More fault tolerant, only flags the erroneous box with 
+    # error not the full page.
+    
+    @out << '(error)'
+  end
 
 private
 
-	# Send a redirect response.
-	
-	def redirect(url, status = 303)
-		url = url.to_s
-  	url = "#{@context.host_url}/#{url.gsub(/^\//, '')}" unless url =~ /http/
-
-		@context.status = status
-		@context.out = "<html><a href=\"#{url}\">#{url}</a>.</html>\n"
-		@context.response_headers['location'] = url
-
-		raise RenderExit
-	end
-	
-	# Redirect to the referer of this method.
-	
-	def redirect_referer(postfix = nil, status = 303)
-		redirect("#{@context.referer}#{postfix}", status)
-	end
-
-	# Log a rendering error.
-
-	def log_error(error, path)
-		@rendering_errors ||= []
-		@rendering_errors << [error, path]
-
-		# gmosx: Hmm perhaps this should not be logged 
-		# to avoid DOS attacks.
-
-		Logger.error "Error while handling '#{path}'."
-		Logger.error pp_exception(error)
-	end
-
-	# Convenience method to lookup the session.
-
-	def session
-		@context.session
-	end
-	
-	# Convenience method to access the output buffer.
-
-	def o
-		@out
-	end
-
-	# Add some text to the output buffer.
-
-	def render_text(text)
-		@out << text
-	end
-	alias_method :print, :render_text
-		
-	#--
-	# FIXME: do something better to stop the redirect.
-	#++
-
-	def render_nothing
-		@out = ' '
-	end
+  # Send a redirect response.
+  
+  def redirect(url, status = 303)
+    url = url.to_s
+    url = "#{@context.host_url}/#{url.gsub(/^\//, '')}" unless url =~ /http/
+
+    @context.status = status
+    @context.out = "<html><a href=\"#{url}\">#{url}</a>.</html>\n"
+    @context.response_headers['location'] = url
+
+    raise RenderExit
+  end
+  
+  # Redirect to the referer of this method.
+  
+  def redirect_referer(postfix = nil, status = 303)
+    redirect("#{@context.referer}#{postfix}", status)
+  end
+
+  # Log a rendering error.
+
+  def log_error(error, path)
+    @rendering_errors ||= []
+    @rendering_errors << [error, path]
+
+    # gmosx: Hmm perhaps this should not be logged 
+    # to avoid DOS attacks.
+
+    Logger.error "Error while handling '#{path}'."
+    Logger.error pp_exception(error)
+  end
+
+  # Convenience method to lookup the session.
+
+  def session
+    @context.session
+  end
+  
+  # Add some text to the output buffer.
+
+  def render_text(text)
+    @out << text
+  end
+  alias_method :print, :render_text
+
+  # Access the programmatic renderer (builder).
+  
+  def build(&block)
+    if block.arity == 1
+      yield XmlBuilder.new(@out)
+    else
+      XmlBuilder.new(@out).instance_eval(&block)
+    end
+  end
+
+  # Return a programmatic renderer that targets the
+  # output buffer.
+  
+  def builder
+    XmlBuilder.new(@out)
+  end
+  
+  # A Helper class to access rendering mixins. Useful to avoid 
+  # poluting the Render with utility methods.
+  #--
+  # TODO: find a less confusing name.
+  #++
+  
+  class Emitter
+    include Singleton
+     include XhtmlMixin
+     include FormMixin
+     include TableMixin
+  end
+
+  # A helper to access the utilities emitter:
+  #
+  # #{emit :form, entity}
+  # #{emit :options, :labels => [..], :values => [..], :selected => 1}
+  #
+  # Useful to avoid poluting the render with mixin methods.
+  
+  def emit(meth, *options)
+    Emitter.instance.send(meth, *options)
+  end
 
 end