nitro 0.20.0 → 0.21.0

data/lib/nitro/element.rb

@@ -17,138 +17,144 @@ module Nitro
 #++
 
 class Element
-	# The parent of this element.
-	
-	attr_accessor :_parent
-	
-	# The childrens of this element.
-	
-	attr_accessor :_children
-	
-	# The text of this element.
-	
-	attr_accessor :_text
-
-	# The view of this element.
-	
-	attr_accessor :_view
-
-	def initialize(*args)
-		@_children = []
-		@_text = ''
-	end
-		
-	def open
-	end
-	
-	def content
-#		"#{@_text}#{render_children}"
-		@_text
-	end
-	
-	def close
-	end	
-
-	def render
-		"#{open}#{content}#{close}"
-	end
-
-	def render_children
-		str = ''
-		for c in @_children
-			str << c.render
-		end
-		
-		return str
-	end	
-	
-	def add_child(child)
-		child._parent = self	
-		@_children << child
-	end
+  # The parent of this element.
+  
+  attr_accessor :_parent
+  
+  # The childrens of this element.
+  
+  attr_accessor :_children
+  
+  # The text of this element.
+  
+  attr_accessor :_text
+
+  # The view of this element.
+  
+  attr_accessor :_view
+
+  def initialize(*args)
+    @_children = []
+    @_text = ''
+  end
+    
+  def open
+  end
+  
+  def content
+#    "#{@_text}#{render_children}"
+    @_text
+  end
+  
+  def close
+  end  
+
+  def render
+    "#{open}#{content}#{close}"
+  end
+
+  def render_children
+    str = ''
+    for c in @_children
+      str << c.render
+    end
+    
+    return str
+  end  
+  
+  def add_child(child)
+    child._parent = self  
+    @_children << child
+  end
 end
 
 # Processes a page containing elements.
 
 class ElementProcessor # :nodoc: all
 
-	class Listener # :nodoc: all
-		include REXML::StreamListener
-		
-		attr_accessor :buffer
-		attr_accessor :stack
-		
-		def initialize
-			super
-			@buffer = ''
-			@stack = []
-		end
-		
-		def tag_start(name, attributes)		
-			if name =~ /^[A-Z]/ # .capitalized?		
-				obj = Object.const_get(name).new
-				
-	    	attributes.each do | k, v | 
-	    		obj.instance_variable_set("@#{k}", v)
-	    	end	    	
-	    	
-	    	@stack.push [obj, @buffer]
-	    	
-	    	@buffer = obj._text
-		    @parent.add_child(obj) if @parent
-		    @parent = obj
-	    else # This is a static element.
-	    	attrs = []
-	    	
-	    	attributes.each do | k, v | 
-	    		attrs << %|#{k}="#{v}"|
-	    	end
-	    	
-	    	attrs = attrs.empty? ? nil : " #{attrs.join(' ')}"
-	    	
-				@buffer << "<#{name}#{attrs}>"
-			end
-		end
-
-		def tag_end(name)		
-			if name =~ /^[A-Z]/ # .capitalized?		
-				obj, @buffer = @stack.pop
-				@buffer << obj.render
-			else
-				@buffer << "</#{name}>"
-			end
-		end
-		
-		def text(str)
-			@buffer << str
-		end
-		
-		def instruction(name, attributes)
-			@buffer << "<?#{name}#{attributes}?>"
-		end
-	end
-	
-	class << self
-		def parse(source)
-			self.new.parse(source)
-		end
-		
-		def render(source)
-			self.new.render(source)
-		end
-
-	end
-
-	# Expand the elemens found in source.
-		
-	def render(source)
-		listener = Listener.new
-		REXML::Document.parse_stream(source, listener)
-		# gmosx, FIXME: optimize this, how?
-		listener.buffer.gsub! /<(.*) ([^>]*)><\/\1>/, '<\1 \2 />'
-		listener.buffer.gsub! /<(.*)><\/\1>/, '<\1 />'
-		return listener.buffer
-	end
+  class Listener # :nodoc: all
+    include REXML::StreamListener
+    
+    attr_accessor :buffer
+    attr_accessor :stack
+    
+    def initialize
+      super
+      @buffer = ''
+      @stack = []
+    end
+    
+    def tag_start(name, attributes)    
+      if name =~ /^[A-Z]/ # .capitalized?    
+        obj = Object.const_get(name).new
+        
+        attributes.each do | k, v | 
+          obj.instance_variable_set("@#{k}", v)
+        end        
+        
+        @stack.push [obj, @buffer]
+        
+        @buffer = obj._text
+        @parent.add_child(obj) if @parent
+        @parent = obj
+      else # This is a static element.
+        attrs = []
+        
+        attributes.each do | k, v | 
+          attrs << %|#{k}="#{v}"|
+        end
+        
+        attrs = attrs.empty? ? nil : " #{attrs.join(' ')}"
+        
+        @buffer << "<#{name}#{attrs}>"
+      end
+    end
+
+    def tag_end(name)    
+      if name =~ /^[A-Z]/ # .capitalized?    
+        obj, @buffer = @stack.pop
+        @buffer << obj.render
+      else
+        @buffer << "</#{name}>"
+      end
+    end
+    
+    def text(str)
+      @buffer << str
+    end
+    
+    def instruction(name, attributes)
+      @buffer << "<?#{name}#{attributes}?>"
+    end
+  end
+  
+  class << self
+    def parse(source)
+      self.new.parse(source)
+    end
+    
+    def transform(source)
+      self.new.transform(source)
+    end
+
+  end
+
+  # Expand the elemens found in source.
+    
+  def transform(source)
+    listener = Listener.new
+    REXML::Document.parse_stream(source, listener)
+    # gmosx, FIXME: optimize this, how?
+    listener.buffer.gsub! /<(.*) ([^>]*)><\/\1>/, '<\1 \2 />'
+    listener.buffer.gsub! /<(.*)><\/\1>/, '<\1 />'
+    return listener.buffer
+  end
+end
+
+# An alias.
+
+unless const_defined? :Elements
+  Elements = ElementProcessor
 end
 
 end

data/lib/nitro/element/java_script.rb

@@ -1,15 +1,15 @@
 require 'nitro/element'
 
 class JavaScript < Nitro::Element
-	def render
-		%~
-	  <script type="text/javascript" language="javascript">
+  def render
+    %~
+    <script type="text/javascript" language="javascript">
     // <![CDATA[
-    	#{content}
+      #{content}
     // ]]>
     </script> 
-    ~    	
-	end
+    ~      
+  end
 end
 
 # * George Moschovitis <gm@navel.gr>

data/lib/nitro/flash.rb

@@ -1,46 +1,46 @@
 module Nitro
 
-	# This module adds flashing support to the Controllers. 
-	
-	module Flashing
-	
-		def self.append_features(base)
-			super			
-	    base.pre 'flash.discard'
-	    base.post 'flash.clean'
+  # This module adds flashing support to the Controllers. 
+  
+  module Flashing
+  
+    def self.append_features(base)
+      super      
+      base.pre 'flash.discard'
+      base.post 'flash.clean'
     end
     
-		# A Flash is a special hash object that lives in the session. 
-		# The values stored in the Flash are typically maintained 
-		# for the duration of one request. 
-		# 
-		# You may want to use the Flash to pass error messages or 
-		# other short lived objects.
-		
-		class Flash < Hash
-		
-			def initialize
-				super
-				@dirty = {}
-			end
-		
-			def []=(key, val)
-				super
-				keep(key)
-			end
+    # A Flash is a special hash object that lives in the session. 
+    # The values stored in the Flash are typically maintained 
+    # for the duration of one request. 
+    # 
+    # You may want to use the Flash to pass error messages or 
+    # other short lived objects.
+    
+    class Flash < Hash
+    
+      def initialize
+        super
+        @dirty = {}
+      end
+    
+      def []=(key, val)
+        super
+        keep(key)
+      end
 
-			# Keep the specific key or the whole Flash.
-						
-			def keep(key = nil)
-				set_dirty(key, false)
-			end
-			
-			# Discard the specific key or the whole Flash.
-			
-			def discard(key = nil)
-				set_dirty(key)
-			end			
-			
+      # Keep the specific key or the whole Flash.
+            
+      def keep(key = nil)
+        set_dirty(key, false)
+      end
+      
+      # Discard the specific key or the whole Flash.
+      
+      def discard(key = nil)
+        set_dirty(key)
+      end      
+      
       def clean # :nodoc:
         keys.each do |k|
           unless @dirty[k]
@@ -55,35 +55,35 @@ module Nitro
         
         (@dirty.keys - keys).each { |k| @dirty.delete k } 
       end
-      			
-		private
-			
-			def set_dirty(key = nil, flag = true)
-				if key
-			  	@dirty[key] = flag
-				else
-					keys.each { |k| @dirty[k] = flag }
-				end			
-			end
-			
-		end
+            
+    private
+      
+      def set_dirty(key = nil, flag = true)
+        if key
+          @dirty[key] = flag
+        else
+          keys.each { |k| @dirty[k] = flag }
+        end      
+      end
+      
+    end
 
-		# A Flash for the current request only.
-		#--
-		# gmosx: crap, not really needed!
-		#++
-		
-		class FlashNow
-		end
-	
-	private
+    # A Flash for the current request only.
+    #--
+    # gmosx: crap, not really needed!
+    #++
+    
+    class FlashNow
+    end
+  
+  private
 
-		def flash
-			session[:FLASH] ||= Flash.new
-		end
-				
-		# Some useful aspects.
-			
+    def flash
+      session[:FLASH] ||= Flash.new
+    end
+        
+    # Some useful aspects.
+      
     # Marks flash entries as used and expose the flash to the 
     # view.
     
@@ -98,7 +98,7 @@ module Nitro
       flash.clean
     end
 
-	end	
+  end  
 
 end
 

data/lib/nitro/mail.rb

@@ -12,103 +12,103 @@ module Nitro
 # Encapsulates an email message.
 
 class Mail
-	
-	# Sender, can be an array.
+  
+  # Sender, can be an array.
 
-	attr_accessor :from
+  attr_accessor :from
 
-	# The list of the recipients, can be arrays.
-	
-	attr_accessor :to, :cc, :bcc
+  # The list of the recipients, can be arrays.
+  
+  attr_accessor :to, :cc, :bcc
 
-	# The subject
+  # The subject
 
-	attr_accessor :subject
+  attr_accessor :subject
 
-	# The body of the message.
+  # The body of the message.
 
-	attr_accessor :body
+  attr_accessor :body
 
-	# Reply to.
+  # Reply to.
 
-	attr_accessor :reply_to
+  attr_accessor :reply_to
 
-	# Sent on
+  # Sent on
 
-	attr_accessor :sent_on
+  attr_accessor :sent_on
 
-	# Encode the subject?
+  # Encode the subject?
 
-	attr_accessor :encode_subject
-	
-	# The charset used to encode the message.
+  attr_accessor :encode_subject
+  
+  # The charset used to encode the message.
 
-	attr_accessor :charset
+  attr_accessor :charset
 
-	# Additional headers
+  # Additional headers
 
-	attr_accessor :headers
+  attr_accessor :headers
 
-	def initialize(from = nil, to = nil, subject = nil, body = nil)
-		@from, @to, @subject, @body = from, to, subject, body
-		@headers = {}
-	end
+  def initialize(from = nil, to = nil, subject = nil, body = nil)
+    @from, @to, @subject, @body = from, to, subject, body
+    @headers = {}
+  end
 
-	def [](key)
-		@headers[key]
-	end
+  def [](key)
+    @headers[key]
+  end
 
-	def []=(key, value)
-		@headers[key] = value
-	end
-	
-	# Returns the Mail message in encoded format.
+  def []=(key, value)
+    @headers[key] = value
+  end
+  
+  # Returns the Mail message in encoded format.
 
-	def encoded
-		raise 'No body defined' unless @body
-		raise 'No sender defined' unless @from
-		raise 'No recipients defined' unless @to
+  def encoded
+    raise 'No body defined' unless @body
+    raise 'No sender defined' unless @from
+    raise 'No recipients defined' unless @to
 
-		# gmosx: From is typically NOT an array.
+    # gmosx: From is typically NOT an array.
 
-		from = @from.is_a?(Array) ? @from.join(', ') : @from
-		buf = "From: #{from}\n"
-		
-		to = @to.is_a?(Array) ? @to.join(', ') : @to
-		buf << "To: #{to}\n"
-		
-		if @cc
-			cc = @cc.is_a?(Array) ? @cc.join(', ') : @cc
-			buf << "Cc: #{cc}\n"
-		end
-		
-		if @bcc
-			bcc = @bcc.is_a?(Array) ? @bcc.join(', ') : @bcc
-			buf << "Bcc: #{bcc}\n"
-		end
-		
-		buf << "Subject: #@subject\n" if @subject
-		
-		buf << "\n"	
-		buf << @body
+    from = @from.is_a?(Array) ? @from.join(', ') : @from
+    buf = "From: #{from}\n"
+    
+    to = @to.is_a?(Array) ? @to.join(', ') : @to
+    buf << "To: #{to}\n"
+    
+    if @cc
+      cc = @cc.is_a?(Array) ? @cc.join(', ') : @cc
+      buf << "Cc: #{cc}\n"
+    end
+    
+    if @bcc
+      bcc = @bcc.is_a?(Array) ? @bcc.join(', ') : @bcc
+      buf << "Bcc: #{bcc}\n"
+    end
+    
+    buf << "Subject: #@subject\n" if @subject
+    
+    buf << "\n"  
+    buf << @body
 
-		return buf
-	end
+    return buf
+  end
 end
 
 module MailerMixin
 
-	def self.append_features(base) # :nodoc: 
-		super
-		base.extend(SingletonMethods)
-	end
+  def self.append_features(base) # :nodoc: 
+    super
+    base.extend(SingletonMethods)
+  end
 
-	module SingletonMethods 
+  module SingletonMethods 
 
-		def mailer(klass)
-		end
+    def mailer(klass)
+    end
 
-	end
+  end
 
 end
 
@@ -119,149 +119,149 @@ end
 
 class Mailer < Mail
 
-	# The mail server configuration.
+  # The mail server configuration.
 
-	cattr_accessor :server; @@server = {
-		:address => 'localhost',
-		:port => 25,
-		:domain => 'localhost.localdomain',
-		:username => nil,
-		:password => nil,
-		:authentication => nil
-	}
+  cattr_accessor :server; @@server = {
+    :address => 'localhost',
+    :port => 25,
+    :domain => 'localhost.localdomain',
+    :username => nil,
+    :password => nil,
+    :authentication => nil
+  }
 
-	# The delivery method. The following options are
-	# supported:
-	#
-	# * :smtp
-	# * :sendmail
-	#	* :test
+  # The delivery method. The following options are
+  # supported:
+  #
+  # * :smtp
+  # * :sendmail
+  #  * :test
 
-	cattr_accessor :delivery_method; @@delivery_method = :smtp
+  cattr_accessor :delivery_method; @@delivery_method = :smtp
 
-	# The encode subject.
+  # The encode subject.
 
-	cattr_accessor :encode_subject; @@encode_subject = false # true 
-	
-	# The default charset.
+  cattr_accessor :encode_subject; @@encode_subject = false # true 
+  
+  # The default charset.
 
-	cattr_accessor :default_charset, 'utf-8'
+  cattr_accessor :default_charset, 'utf-8'
 
-	# An array to store the delivered mails, useful
-	# for testing.
+  # An array to store the delivered mails, useful
+  # for testing.
 
-	cattr_accessor :deliveries; @@deliveries = []
+  cattr_accessor :deliveries; @@deliveries = []
 
-	# Disable deliveries, useful for testing.
+  # Disable deliveries, useful for testing.
 
-	cattr_accessor :disable_deliveries, false
+  cattr_accessor :disable_deliveries, false
 
-	# The root directory where the templates reside
+  # The root directory where the templates reside
 
-	attr_accessor :template_root
+  attr_accessor :template_root
 
-	def initialize(from = nil, to = nil, subject = nil, body = FileTemplate.new)
-		super
-		@charset = @@default_charset.dup
-		@encode_subject = @@encode_subject
-		@template_root = 'public'
-	end
+  def initialize(from = nil, to = nil, subject = nil, body = FileTemplate.new)
+    super
+    @charset = @@default_charset.dup
+    @encode_subject = @@encode_subject
+    @template_root = 'public'
+  end
 
-	class << self 
+  class << self 
 
-		def method_missing(method_symbol, *params) #:nodoc:
-			case method_symbol.id2name
-				when /^create_([_a-z]*)/
-					create_from_method($1, *params)
-				when /^deliver_([_a-z]*)/
-					begin
-						deliver(send("create_" + $1, *params))
-					rescue Object => e
-						raise e # FIXME
-					end
-			end        
-		end
+    def method_missing(method_symbol, *params) #:nodoc:
+      case method_symbol.id2name
+        when /^create_([_a-z]*)/
+          create_from_method($1, *params)
+        when /^deliver_([_a-z]*)/
+          begin
+            deliver(send("create_" + $1, *params))
+          rescue Object => e
+            raise e # FIXME
+          end
+      end        
+    end
 
     def mail(from, to, subject, body, timestamp = nil, headers = {}, encode = @@encode_subject, charset = @@default_charset) #:nodoc:
-			deliver(create(from, to, subject, body, timestamp, headers, charset))
-		end
-
-		def create(from, to, subject, body, timestamp = nil, headers = {}, encode = @@encode_subject, charset = @@default_charset) #:nodoc:
-			m = Mail.new
-			m.to, m.subject, m.body, m.from = to, ( encode ? quoted_printable(subject, charset) : subject ), body, from
-			# m.date = timestamp.respond_to?("to_time") ? timestamp.to_time : (timestamp || Time.now)    
-			# m.set_content_type "text", "plain", { "charset" => charset }
+      deliver(create(from, to, subject, body, timestamp, headers, charset))
+    end
+
+    def create(from, to, subject, body, timestamp = nil, headers = {}, encode = @@encode_subject, charset = @@default_charset) #:nodoc:
+      m = Mail.new
+      m.to, m.subject, m.body, m.from = to, ( encode ? quoted_printable(subject, charset) : subject ), body, from
+      # m.date = timestamp.respond_to?("to_time") ? timestamp.to_time : (timestamp || Time.now)    
+      # m.set_content_type "text", "plain", { "charset" => charset }
       headers.each do |k, v|
-	      m[k] = v
-	    end
+        m[k] = v
+      end
       return m
-		end
-
-		def deliver(mail) #:nodoc:
-			send("perform_delivery_#{delivery_method}", mail) unless disable_deliveries
-		end
-																	
-		def quoted_printable(text, charset) #:nodoc:
-			text = text.gsub( /[^a-z ]/i ) { "=%02x" % $&[0] }.gsub( / /, "_" )
-			"=?#{charset}?Q?#{text}?="
-		end
-															
-		private
-
-		def create_from_method(method_name, *params)
-			mailer = new
-
-			mailer.send(method_name, *params)
-
-			unless mailer.body.is_a?(String)
-				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.cc = mailer.cc if mailer.cc
-			mail.bcc = mailer.bcc if mailer.bcc
-
-			return mail
-		end
-
-		# Render the body by expanfing the template
-		
-		def render_body(method_name, mailer)
-			mailer.body.template_filename = "#{mailer.template_root}/#{method_name.to_s}.xhtml"
-			return mailer.body.process
-		end
-
-		# Deliver emails using SMTP.
-		
-		def perform_delivery_smtp(mail) # :nodoc:
-			c = @@server
-			Net::SMTP.start(c[:address], c[:port], c[:domain], c[:username], c[:password], c[:authentication]) do |smtp|
-				smtp.send_message(mail.encoded, mail.from, mail.to)
-			end
-		end
-
-		# Deliver emails using sendmail.
-		
-		def perform_delivery_sendmail(mail) # :nodoc:
-			IO.popen('/usr/sbin/sendmail -i -t', 'w+') do |sm|
-				sm.print(mail.encoded)
-				sm.flush
-			end																					
-		end
-		
-		# Used for testing, does not actually send the 
-		# mail.
-		
-		def perform_delivery_test(mail) # :nodoc:
-			deliveries << mail
-		end
-	
-	end
+    end
+
+    def deliver(mail) #:nodoc:
+      send("perform_delivery_#{delivery_method}", mail) unless disable_deliveries
+    end
+                                  
+    def quoted_printable(text, charset) #:nodoc:
+      text = text.gsub( /[^a-z ]/i ) { "=%02x" % $&[0] }.gsub( / /, "_" )
+      "=?#{charset}?Q?#{text}?="
+    end
+                              
+    private
+
+    def create_from_method(method_name, *params)
+      mailer = new
+
+      mailer.send(method_name, *params)
+
+      unless mailer.body.is_a?(String)
+        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.cc = mailer.cc if mailer.cc
+      mail.bcc = mailer.bcc if mailer.bcc
+
+      return mail
+    end
+
+    # Render the body by expanfing the template
+    
+    def render_body(method_name, mailer)
+      mailer.body.template_filename = "#{mailer.template_root}/#{method_name.to_s}.xhtml"
+      return mailer.body.process
+    end
+
+    # Deliver emails using SMTP.
+    
+    def perform_delivery_smtp(mail) # :nodoc:
+      c = @@server
+      Net::SMTP.start(c[:address], c[:port], c[:domain], c[:username], c[:password], c[:authentication]) do |smtp|
+        smtp.send_message(mail.encoded, mail.from, mail.to)
+      end
+    end
+
+    # Deliver emails using sendmail.
+    
+    def perform_delivery_sendmail(mail) # :nodoc:
+      IO.popen('/usr/sbin/sendmail -i -t', 'w+') do |sm|
+        sm.print(mail.encoded)
+        sm.flush
+      end                                          
+    end
+    
+    # Used for testing, does not actually send the 
+    # mail.
+    
+    def perform_delivery_test(mail) # :nodoc:
+      deliveries << mail
+    end
+  
+  end
 
 end