radiant 0.5.2 → 0.6.0

data/app/models/page_part.rb

@@ -1,5 +1,8 @@
 class PagePart < ActiveRecord::Base
   
+  # Default Order
+  order_by 'name'
+  
   # Associations
   belongs_to :page
   
@@ -9,5 +12,6 @@ class PagePart < ActiveRecord::Base
   validates_length_of :filter_id, :maximum => 25, :allow_nil => true, :message => '%d-character limit'
   validates_numericality_of :id, :page_id, :allow_nil => true, :only_integer => true, :message => 'must be a number'
   
-  registered_attr :filter, TextFilter
+  object_id_attr :filter, TextFilter
+  
 end

data/app/models/radiant/config.rb

@@ -18,10 +18,11 @@ module Radiant
   #
   # Radiant currently uses the following settings:
   #
-  # admin.title    :: the title of the admin system
-  # admin.subtitle :: the subtitle of the admin system
-  # default.parts  :: a comma separated list of default page parts
-  # dev.host       :: the hostname where draft pages are viewable
+  # admin.title           :: the title of the admin system
+  # admin.subtitle        :: the subtitle of the admin system
+  # defaults.page.parts   :: a comma separated list of default page parts
+  # defaults.page.status  :: a string representation of the default page status
+  # dev.host              :: the hostname where draft pages are viewable
   #
   class Config < ActiveRecord::Base
     set_table_name "config"
@@ -46,7 +47,19 @@ module Radiant
       end
 
       def to_hash
-        Hash[ *find_all.map { |pair| [pair.key, pair.value] }.flatten ]
+        Hash[ *find(:all).map { |pair| [pair.key, pair.value] }.flatten ]
+      end
+    end
+    
+    def value=(param)
+      write_attribute :value, param.to_s
+    end
+    
+    def value
+      if key.ends_with? "?"
+        read_attribute(:value) == "true"
+      else
+        read_attribute(:value)
       end
     end
   end

data/app/models/radiant/extension_meta.rb

@@ -0,0 +1,5 @@
+class Radiant::ExtensionMeta < ActiveRecord::Base
+  set_table_name "extension_meta"
+  validates_presence_of :name
+  validates_uniqueness_of :name
+end

data/app/models/response_cache.rb

@@ -1,20 +1,20 @@
 class ResponseCache
   include ActionController::Benchmarking::ClassMethods
-  include ActionController::Caching::Pages::ClassMethods
   
   @@defaults = {
     :directory => ActionController::Base.page_cache_directory,
     :expire_time => 5.minutes,
     :default_extension => '.yml',
     :perform_caching => true,
-    :logger => ActionController::Base.logger
+    :logger => ActionController::Base.logger,
+    :use_x_sendfile => false
   }
   cattr_accessor :defaults
   
-  attr_accessor :directory, :expire_time, :default_extension, :perform_caching, :logger
+  attr_accessor :directory, :expire_time, :default_extension, :perform_caching, :logger, :use_x_sendfile
   alias :page_cache_directory :directory
   alias :page_cache_extension :default_extension
-  private :expire_page, :cache_page, :caches_page, :benchmark, :silence, :page_cache_directory,
+  private :benchmark, :silence, :page_cache_directory,
     :page_cache_extension 
     
   # Creates a ResponseCache object with the specified options.
@@ -23,9 +23,10 @@ class ResponseCache
   # :directory         :: the path to the temporary cache directory
   # :expire_time       :: the number of seconds a cached response is considered valid (defaults to 5 min)
   # :default_extension :: the extension cached files should use (defaults to '.yml')
-  # :peform_caching    :: boolean value that turns caching on or off (defaults to true)
+  # :perform_caching   :: boolean value that turns caching on or off (defaults to true)
   # :logger            :: the application logging object (defaults to ActionController::Base.logger)
-  #
+  # :use_x_sendfile    :: use X-Sendfile headers to speed up transfer of cached pages (not available on all web servers)
+  # 
   def initialize(options = {})
     options = options.symbolize_keys.reverse_merge(defaults)
     self.directory         = options[:directory]
@@ -33,6 +34,7 @@ class ResponseCache
     self.default_extension = options[:default_extension]
     self.perform_caching   = options[:perform_caching]
     self.logger            = options[:logger]
+    self.use_x_sendfile    = options[:use_x_sendfile]
   end
   
   # Caches a response object for path to disk.
@@ -42,21 +44,31 @@ class ResponseCache
     response
   end
   
-  # If peform_caching is set to true, updates a response object so that it mirrors the
-  # cached version.
-  def update_response(path, response)
+  # If perform_caching is set to true, updates a response object so that it mirrors the
+  # cached version. The request object is required to perform Last-Modified/If-Modified-Since
+  # checks--it is left optional to allow for backwards compatability.
+  def update_response(path, response, request=nil)
     if perform_caching
       path = clean(path)
-      read_response(path, response)
+      read_response(path, response, request)
     end
     response
   end
   
   # Returns true if a response is cached at the specified path.
-  def response_cached?(path)
+  def read_metadata(path)
     path = clean(path)
-    name = page_cache_path(path)
-    File.exists?(name) and not File.directory?(name) and not (File.stat(name).mtime < (Time.now - @expire_time))
+    name = "#{page_cache_path(path)}.yml"
+    if File.exists?(name) and not File.directory?(name)
+      content = File.open(name,"rb") { |f| f.read }
+      metadata = YAML::load(content)
+      if(metadata['expires'] && metadata['expires'] >= Time.now)
+        return metadata
+      end
+    end
+  end
+  def response_cached?(path)
+    !!read_metadata(path)
   end
     
   # Expires the cached response for the specified path.
@@ -78,35 +90,84 @@ class ResponseCache
   end
   
   private
-  
+    # Construct the filename for the file in the cache directory for path    
+    # This DOES NOT include the extension
+    def page_cache_file(path)
+      name = ((path.empty? || path == "/") ? "/index" : URI.unescape(path))
+    end
+    
     # Ensures that path begins with a slash and remove extra slashes.
     def clean(path)
-      path = path.gsub(%{/+}, '/')
+      path = path.gsub(%r{/+}, '/')
       %r{^/?(.*?)/?$}.match(path)
       "/#{$1}"
     end
-    
-    # Reads a cached string from disk.
-    def read_page(path)
-      File.open(page_cache_path(path), "rb") { |f| f.read } if response_cached?(path)
-    end
 
+    
     # Reads a cached response from disk and updates a response object.
-    def read_response(path, response)
-      if content = read_page(path)
-        updates = YAML::load(content)
-        response.headers.merge!(updates['headers'] || {})
-        response.body = updates['body']
+    def read_response(path, response, request)
+      file_path = page_cache_path(path)
+      if metadata = read_metadata(path)
+        response.headers.merge!(metadata['headers'] || {})
+	if client_has_cache?(metadata, request)
+          response.headers.merge!('Status' => '304 Not Modified')
+	elsif use_x_sendfile
+          response.headers.merge!('X-Sendfile' => "#{file_path}.data")
+        else
+          response.body = File.open("#{file_path}.data", "rb") {|f| f.read}
+        end
       end
       response
     end
+
+    def client_has_cache?(metadata, request)
+        return false unless request
+        request_time = Time.rfc2822(request.env["HTTP_IF_MODIFIED_SINCE"]) rescue nil
+        response_time = Time.rfc2822(metadata['headers']['Last-Modified']) rescue nil
+        return request_time && response_time && response_time <= request_time
+    end
     
     # Writes a response to disk.
     def write_response(path, response)
-      content = {
+      if response.cache_timeout
+        if Time === response.cache_timeout
+          expires = response.cache_timeout
+        else
+          expires = Time.now + response.cache_timeout
+        end
+      else
+        expires = Time.now + self.expire_time
+      end
+      response.headers['Last-Modified'] ||= Time.now.httpdate
+      metadata = {
         'headers' => response.headers,
-        'body' => response.body
+        'expires' => expires
       }.to_yaml
-      cache_page(content, path)
+      cache_page(metadata, response.body, path)
+    end
+
+    def page_cache_path(path)
+      page_cache_directory + page_cache_file(path)
+    end
+
+    def expire_page(path)
+      return unless perform_caching
+
+      path = page_cache_path(path)
+      benchmark "Expired page: #{path}" do
+        File.delete("#{path}.yml") if File.exists?("#{path}.yml")
+        File.delete("#{path}.data") if File.exists?("#{path}.data")
+      end
+    end
+
+    def cache_page(metadata, content, path)
+      return unless perform_caching
+
+      path = page_cache_path(path)
+      benchmark "Cached page: #{path}" do
+        FileUtils.makedirs(File.dirname(path))
+        File.open("#{path}.yml", "wb+") { |f| f.write(metadata) }
+        File.open("#{path}.data", "wb+") { |f| f.write(content) }
+      end
     end
 end

data/app/models/snippet.rb

@@ -1,5 +1,8 @@
 class Snippet < ActiveRecord::Base
-
+  
+  # Default Order
+  order_by 'name'
+  
   # Associations
   belongs_to :created_by, :class_name => 'User', :foreign_key => 'created_by'
   belongs_to :updated_by, :class_name => 'User', :foreign_key => 'updated_by'
@@ -11,6 +14,6 @@ class Snippet < ActiveRecord::Base
   validates_format_of :name, :with => %r{^\S*$}, :message => 'cannot contain spaces or tabs'
   validates_uniqueness_of :name, :message => 'name already in use'
   
-  registered_attr :filter, TextFilter
+  object_id_attr :filter, TextFilter
 
 end

data/app/models/standard_tags.rb

@@ -0,0 +1,601 @@
+module StandardTags
+  
+  include Radiant::Taggable
+  
+  class TagError < StandardError; end
+  
+  desc %{
+    Causes the tags referring to a page's attributes to refer to the current page.
+   
+    *Usage:* 
+    <pre><code><r:page>...</r:page></code></pre>
+  }
+  tag 'page' do |tag|
+    tag.locals.page = tag.globals.actual_page || tag.globals.page
+    tag.expand
+  end
+  
+  [:breadcrumb, :slug, :title, :url].each do |method|
+    desc %{      
+      Renders the @#{method}@ attribute of the current page.
+    }    
+    tag(method.to_s) do |tag|
+      tag.locals.page.send(method)
+    end
+  end  
+
+  desc %{  
+    Gives access to a page's children.
+    
+    *Usage:* 
+    <pre><code><r:children>...</r:children></code></pre>
+  }
+  tag 'children' do |tag|
+    tag.locals.children = tag.locals.page.children
+    tag.expand
+  end
+  
+  desc %{
+    Renders the total number of children.
+  }
+  tag 'children:count' do |tag|
+    tag.locals.children.count
+  end
+  
+  desc %{  
+    Returns the first child. Inside this tag all page attribute tags are mapped to
+    the first child. Takes the same ordering options as @<r:children:each>@.
+    
+    *Usage:*
+    <pre><code><r:children:first>...</r:children:first></code></pre>
+  }
+  tag 'children:first' do |tag|
+    options = children_find_options(tag)
+    children = tag.locals.children.find(:all, options)
+    if first = children.first
+      tag.locals.page = first
+      tag.expand
+    end
+  end
+  
+  desc %{
+    Returns the last child. Inside this tag all page attribute tags are mapped to
+    the last child. Takes the same ordering options as @<r:children:each>@.
+    
+    *Usage:*
+    <pre><code><r:children:last>...</r:children:last></code></pre>
+  }
+  tag 'children:last' do |tag|
+    options = children_find_options(tag)
+    children = tag.locals.children.find(:all, options)
+    if last = children.last
+      tag.locals.page = last
+      tag.expand
+    end
+  end
+  
+  desc %{ 
+    Cycles through each of the children. Inside this tag all page attribute tags
+    are mapped to the current child page.
+
+    *Usage:*
+    <pre><code><r:children:each [offset="number"] [limit="number"] [by="attribute"] [order="asc|desc"] 
+     [status="draft|reviewed|published|hidden|all"]>
+     ...
+    </r:children:each>
+    </code></pre>
+  }
+  tag 'children:each' do |tag|
+    options = children_find_options(tag)
+    result = []
+    children = tag.locals.children
+    tag.locals.previous_headers = {}
+    children.find(:all, options).each do |item|
+      tag.locals.child = item
+      tag.locals.page = item
+      result << tag.expand
+    end 
+    result
+  end
+  
+  desc %{
+    Page attribute tags inside of this tag refer to the current child. Not needed in
+    most cases.
+    
+    *Usage:*
+    <pre><code><r:children:each>
+      <r:child>...</r:child>
+    </r:children:each>
+    </code></pre>
+  }
+  tag 'children:each:child' do |tag|
+    tag.locals.page = tag.locals.child
+    tag.expand
+  end
+
+  desc %{  
+    Renders the tag contents only if the contents do not match the previous header. This
+    is extremely useful for rendering date headers for a list of child pages.
+  
+    If you would like to use several header blocks you may use the @name@ attribute to
+    name the header. When a header is named it will not restart until another header of
+    the same name is different.
+  
+    Using the @restart@ attribute you can cause other named headers to restart when the
+    present header changes. Simply specify the names of the other headers in a semicolon
+    separated list.
+   
+    *Usage:*
+    <pre><code><r:children:each>
+      <r:header [name="header_name"] [restart="name1[;name2;...]"]>
+        ...
+      </r:header>
+    </r:children:each>
+    </code></pre>
+  }
+  tag 'children:each:header' do |tag|
+    previous_headers = tag.locals.previous_headers
+    name = tag.attr['name'] || :unnamed
+    restart = (tag.attr['restart'] || '').split(';')
+    header = tag.expand
+    unless header == previous_headers[name]
+      previous_headers[name] = header
+      unless restart.empty?
+        restart.each do |n|
+          previous_headers[n] = nil
+        end
+      end
+      header
+    end
+  end
+
+
+  desc %{
+    Page attribute tags inside this tag refer to the parent of the current page.
+    
+    *Usage:*
+    <pre><code><r:parent>...</r:parent></code></pre>
+  }
+  tag "parent" do |tag|
+    parent = tag.locals.page.parent
+    tag.locals.page = parent
+    tag.expand if parent
+  end
+  
+  desc %{    
+    Renders the contained elements only if the current contextual page has a parent, i.e. 
+    is not the root page.
+    
+    *Usage:*
+    <pre><code><r:if_parent>...</r:if_parent></code></pre>
+  }
+  tag "if_parent" do |tag|
+    parent = tag.locals.page.parent
+    tag.expand if parent
+  end
+  
+  desc %{    
+    Renders the contained elements only if the current contextual page has no parent, i.e. 
+    is the root page.
+  
+    *Usage:*
+    <pre><code><r:unless_parent>...</r:unless_parent></code></pre>
+  }
+  tag "unless_parent" do |tag|
+    parent = tag.locals.page.parent
+    tag.expand unless parent
+  end
+  
+  desc %{ 
+    Renders one of the passed values based on a global cycle counter.  Use the @reset@
+    attribute to reset the cycle to the beginning.  Use the @name@ attribute to track 
+    multiple cycles; the default is @cycle@.
+   
+    *Usage:*
+    <pre><code><r:cycle values="first, second, third" [reset="true|false"] [name="cycle"] /></code></pre>
+  } 
+  tag 'cycle' do |tag|
+    raise TagError, "`cycle' tag must contain a `values' attribute." unless tag.attr['values']
+    cycle = (tag.globals.cycle ||= {})
+    values = tag.attr['values'].split(",").collect(&:strip)
+    cycle_name = tag.attr['name'] || 'cycle'
+    current_index = (cycle[cycle_name] ||=  0)
+    current_index = 0 if tag.attr['reset'] == 'true'
+    cycle[cycle_name] = (current_index + 1) % values.size
+    values[current_index]
+  end
+  
+  desc %{ 
+    Renders the main content of a page. Use the @part@ attribute to select a specific
+    page part. By default the @part@ attribute is set to body. Use the @inherit@
+    attribute to specify that if a page does not have a content part by that name that
+    the tag should render the parent's content part. By default @inherit@ is set to
+    @false@. Use the @contextual@ attribute to force a part inherited from a parent
+    part to be evaluated in the context of the child page. By default 'contextual'
+    is set to true.
+   
+    *Usage:*
+    <pre><code><r:content [part="part_name"] [inherit="true|false"] [contextual="true|false"] /></code></pre>
+  }
+  tag 'content' do |tag|
+    page = tag.locals.page
+    part_name = tag_part_name(tag)
+    boolean_attr = proc do |attribute_name, default|
+      attribute = (tag.attr[attribute_name] || default).to_s
+      raise TagError.new(%{`#{attribute_name}' attribute of `content' tag must be set to either "true" or "false"}) unless attribute =~ /true|false/i
+      (attribute.downcase == 'true') ? true : false
+    end
+    inherit = boolean_attr['inherit', false]
+    part_page = page
+    if inherit
+      while (part_page.part(part_name).nil? and (not part_page.parent.nil?)) do
+        part_page = part_page.parent
+      end
+    end
+    contextual = boolean_attr['contextual', true]
+    if inherit and contextual
+      part = part_page.part(part_name)
+      page.render_snippet(part) unless part.nil?
+    else
+      part_page.render_part(part_name)
+    end
+  end
+  
+  desc %{ 
+    Renders the containing elements only if the part exists on a page. By default the
+    @part@ attribute is set @body@.
+    
+    *Usage:*
+    <pre><code><r:if_content [part="part_name"]>...</r:if_content></code></pre>
+  }
+  tag 'if_content' do |tag|
+    page = tag.locals.page
+    part_name = tag_part_name(tag)
+    unless page.part(part_name).nil?
+      tag.expand
+    end
+  end
+  
+  desc %{
+    The opposite of the @if_content@ tag.
+   
+    *Usage:*
+    <pre><code><r:unless_content [part="part_name"]>...</r:unless_content></code></pre>
+  }
+  tag 'unless_content' do |tag|
+    page = tag.locals.page
+    part_name = tag_part_name(tag)
+    if page.part(part_name).nil?
+      tag.expand
+    end
+  end
+  
+  desc %{  
+    Renders the containing elements only if the page's url matches the regular expression
+    given in the @matches@ attribute. If the @ignore_case@ attribute is set to false, the
+    match is case sensitive. By default, @ignore_case@ is set to true.
+   
+    *Usage:*
+    <pre><code><r:if_url matches="regexp" [ignore_case="true|false"]>...</if_url></code></pre>
+  }
+  tag 'if_url' do |tag|
+    raise TagError.new("`if_url' tag must contain a `matches' attribute.") unless tag.attr.has_key?('matches')
+    regexp = build_regexp_for(tag, 'matches')
+    unless tag.locals.page.url.match(regexp).nil?
+       tag.expand
+    end
+  end
+  
+  desc %{
+    The opposite of the @if_url@ tag.
+   
+    *Usage:*
+    <pre><code><r:unless_url matches="regexp" [ignore_case="true|false"]>...</unless_url></code></pre>
+  }  
+  tag 'unless_url' do |tag|
+    raise TagError.new("`unless_url' tag must contain a `matches' attribute.") unless tag.attr.has_key?('matches')
+    regexp = build_regexp_for(tag, 'matches')
+    if tag.locals.page.url.match(regexp).nil?
+        tag.expand
+    end
+  end
+      
+  desc %{ 
+    Renders the name of the author of the current page.
+  }
+  tag 'author' do |tag|
+    page = tag.locals.page
+    if author = page.created_by
+      author.name
+    end
+  end
+  
+  desc %{ 
+    Renders the date based on the current page (by default when it was published or created). 
+    The format attribute uses the same formating codes used by the Ruby @strftime@ function. By
+    default it's set to @%A, %B %d, %Y@.  The @for@ attribute selects which date to render.  Valid
+    options are @published_at@, @created_at@, @updated_at@, and @now@. @now@ will render the
+    current date/time, regardless of the  page.
+   
+    *Usage:*  
+    <pre><code><r:date [format="%A, %B %d, %Y"] [when="published_at"]/></code></pre>
+  }
+  tag 'date' do |tag|
+    page = tag.locals.page
+    format = (tag.attr['format'] || '%A, %B %d, %Y')
+    time_attr = tag.attr['for']
+    date = if time_attr
+      case
+      when time_attr == 'now'
+        Time.now
+      when ['published_at', 'created_at', 'updated_at'].include?(time_attr)
+        page[time_attr]
+      else
+        raise TagError, "Invalid value for 'when' attribute."
+      end
+    else
+      page.published_at || page.created_at
+    end
+    date.strftime(format) 
+  end
+  
+  desc %{ 
+    Renders a link to the page. When used as a single tag it uses the page's title
+    for the link name. When used as a double tag the part in between both tags will
+    be used as the link text. The link tag passes all attributes over to the HTML
+    @a@ tag. This is very useful for passing attributes like the @class@ attribute
+    or @id@ attribute. If the @anchor@ attribute is passed to the tag it will
+    append a pound sign (<code>#</code>) followed by the value of the attribute to
+    the @href@ attribute of the HTML @a@ tag--effectively making an HTML anchor.
+   
+    *Usage:*
+    <pre><code><r:link [anchor="name"] [other attributes...] /></code></pre>
+    or
+    <pre><code><r:link [anchor="name"] [other attributes...]>link text here</r:link></code></pre>
+  }
+  tag 'link' do |tag|
+    options = tag.attr.dup
+    anchor = options['anchor'] ? "##{options.delete('anchor')}" : ''
+    attributes = options.inject('') { |s, (k, v)| s << %{#{k.downcase}="#{v}" } }.strip
+    attributes = " #{attributes}" unless attributes.empty?
+    text = tag.double? ? tag.expand : tag.render('title')
+    %{<a href="#{tag.render('url')}#{anchor}"#{attributes}>#{text}</a>}
+  end
+
+  desc %{
+    Renders a trail of breadcrumbs to the current page. The separator attribute
+    specifies the HTML fragment that is inserted between each of the breadcrumbs. By
+    default it is set to @>@.
+    
+    *Usage:* 
+    <pre><code><r:breadcrumbs [separator="separator_string"] /></code></pre>
+  }
+  tag 'breadcrumbs' do |tag|
+    page = tag.locals.page
+    breadcrumbs = [page.breadcrumb]
+    page.ancestors.each do |ancestor|
+      breadcrumbs.unshift %{<a href="#{ancestor.url}">#{ancestor.breadcrumb}</a>}
+    end
+    separator = tag.attr['separator'] || ' &gt; '
+    breadcrumbs.join(separator)
+  end
+
+  desc %{     
+    Renders the snippet specified in the @name@ attribute within the context of a page.
+    
+    *Usage:*
+    <pre><code><r:snippet name="snippet_name" /></code></pre>
+  }
+  tag 'snippet' do |tag|
+    if name = tag.attr['name']
+      if snippet = Snippet.find_by_name(name.strip)
+        page = tag.locals.page
+        global_page = tag.globals.actual_page || tag.globals.page
+        page.render_snippet(snippet, global_page)
+      else
+        raise TagError.new('snippet not found')
+      end
+    else
+      raise TagError.new("`snippet' tag must contain `name' attribute")
+    end
+  end
+  
+  desc %{
+    Inside this tag all page related tags refer to the page found at the @url@ attribute.
+    
+    *Usage:*
+    <pre><code><r:find url="value_to_find">...</r:find></code></pre>
+  }
+  tag 'find' do |tag|
+    if url = tag.attr['url']
+      if found = Page.find_by_url(tag.attr['url'])
+        tag.locals.page = found
+        tag.expand
+      end
+    else
+      raise TagError.new("`find' tag must contain `url' attribute")
+    end
+  end
+  
+  desc %{       
+    Randomly renders one of the options specified by the @option@ tags.
+   
+    *Usage:*
+    <pre><code><r:random>
+      <r:option>...</r:option>
+      <r:option>...</r:option>
+      ...
+    <r:random>
+    </code></pre>    
+  }
+  tag 'random' do |tag|
+    tag.locals.random = []
+    tag.expand
+    options = tag.locals.random
+    option = options[rand(options.size)]
+    option.call if option
+  end
+  tag 'random:option' do |tag|
+    items = tag.locals.random
+    items << tag.block
+  end
+  
+  desc %{  
+    Nothing inside a set of comment tags is rendered.
+    
+    *Usage:*
+    <pre><code><r:comment>...</r:comment></code></pre>
+  }
+  tag 'comment' do |tag|
+  end
+  
+  desc %{  
+    Escapes angle brackets, etc. for rendering in an HTML document.
+    
+    *Usage:*
+    <pre><code><r:escape_html>...</r:escape_html></code></pre>
+  }
+  tag "escape_html" do |tag|
+    CGI.escapeHTML(tag.expand)
+  end
+  
+  desc %{
+    Outputs the published date using the format mandated by RFC 1123. (Ideal for RSS feeds.)
+    
+    *Usage:*
+    <pre><code><r:rfc1123_date /></code></pre>
+  }
+  tag "rfc1123_date" do |tag|
+    page = tag.locals.page
+    if date = page.published_at || page.created_at
+      CGI.rfc1123_date(date.to_time)
+    end
+  end
+  
+  desc %{ 
+    Renders a list of links specified in the @urls@ attribute according to three
+    states:
+    
+    * @normal@ specifies the normal state for the link
+    * @here@ specifies the state of the link when the url matches the current
+       page's URL
+    * @selected@ specifies the state of the link when the current page matches
+       is a child of the specified url
+    
+    The @between@ tag specifies what sould be inserted in between each of the links.
+    
+    *Usage:*
+    <pre><code><r:navigation urls="[Title: url | Title: url | ...]">
+      <r:normal><a href="<r:url />"><r:title /></a></r:normal>
+      <r:here><strong><r:title /></strong></r:here>
+      <r:selected><strong><a href="<r:url />"><r:title /></a></strong></r:selected>
+      <r:between> | </r:between>
+    </r:navigation>
+    </code></pre>
+  }
+  tag 'navigation' do |tag|
+    hash = tag.locals.navigation = {}
+    tag.expand
+    raise TagError.new("`navigation' tag must include a `normal' tag") unless hash.has_key? :normal
+    result = []
+    pairs = tag.attr['urls'].to_s.split('|').map do |pair|
+      parts = pair.split(':')
+      value = parts.pop
+      key = parts.join(':')
+      [key.strip, value.strip]
+    end
+    pairs.each do |title, url|
+      compare_url = remove_trailing_slash(url)
+      page_url = remove_trailing_slash(self.url)
+      hash[:title] = title
+      hash[:url] = url
+      case page_url
+      when compare_url
+        result << (hash[:here] || hash[:selected] || hash[:normal]).call
+      when Regexp.compile( '^' + Regexp.quote(url))
+        result << (hash[:selected] || hash[:normal]).call
+      else
+        result << hash[:normal].call
+      end
+    end
+    between = hash.has_key?(:between) ? hash[:between].call : ' '
+    result.join(between)
+  end
+  [:normal, :here, :selected, :between].each do |symbol|
+    tag "navigation:#{symbol}" do |tag|
+      hash = tag.locals.navigation
+      hash[symbol] = tag.block
+    end
+  end
+  [:title, :url].each do |symbol|
+    tag "navigation:#{symbol}" do |tag|
+      hash = tag.locals.navigation
+      hash[symbol]
+    end
+  end
+  
+  private
+  
+    def children_find_options(tag)
+      attr = tag.attr.symbolize_keys
+    
+      options = {}
+      
+      [:limit, :offset].each do |symbol|
+        if number = attr[symbol]
+          if number =~ /^\d{1,4}$/
+            options[symbol] = number.to_i
+          else
+            raise TagError.new("`#{symbol}' attribute of `each' tag must be a positive number between 1 and 4 digits")
+          end
+        end
+      end
+      
+      by = (attr[:by] || 'published_at').strip
+      order = (attr[:order] || 'asc').strip
+      order_string = ''
+      if self.attributes.keys.include?(by)
+        order_string << by
+      else
+        raise TagError.new("`by' attribute of `each' tag must be set to a valid field name")
+      end
+      if order =~ /^(asc|desc)$/i
+        order_string << " #{$1.upcase}"
+      else
+        raise TagError.new(%{`order' attribute of `each' tag must be set to either "asc" or "desc"})
+      end
+      options[:order] = order_string
+      
+      status = (attr[:status] || 'published').downcase
+      unless status == 'all'
+        stat = Status[status]
+        unless stat.nil?
+          options[:conditions] = ["(virtual = ?) and (status_id = ?)", false, stat.id]
+        else
+          raise TagError.new(%{`status' attribute of `each' tag must be set to a valid status})
+        end
+      else
+        options[:conditions] = ["virtual = ?", false]
+      end
+      options
+    end
+    
+    def remove_trailing_slash(string)
+      (string =~ %r{^(.*?)/$}) ? $1 : string
+    end
+    
+    def tag_part_name(tag)
+      tag.attr['part'] || 'body'
+    end
+    
+    def build_regexp_for(tag, attribute_name)
+      ignore_case = tag.attr.has_key?('ignore_case') && tag.attr['ignore_case']=='false' ? nil : true
+      begin
+        regexp = Regexp.new(tag.attr['matches'], ignore_case)
+      rescue RegexpError => e
+        raise TagError.new("Malformed regular expression in `#{attribute_name}' argument of `#{tag.name}' tag: #{e.message}")
+      end
+      return regexp
+    end
+  
+end