radiantcms-couchrest_model 0.1.3 → 0.1.4

data/app/models/radiant/config.rb

@@ -1,77 +1,37 @@
 module Radiant
-
-  class << self
-    def config_definitions
-      @config_definitions ||= {}
-    end
-
-    def config_definitions=(definitions)
-      @config_definitions = definitions
-    end
-  end
-
+  #
+  # The Radiant::Config object emulates a hash with simple bracket methods
+  # which allow you to get and set values in the configuration table:
+  #
+  #   Radiant::Config['setting.name'] = 'value'
+  #   Radiant::Config['setting.name'] #=> "value"
+  #
+  # Currently, there is not a way to edit configuration through the admin
+  # system so it must be done manually. The console script is probably the
+  # easiest way to this:
+  #
+  #   % script/console production
+  #   Loading production environment.
+  #   >> Radiant::Config['setting.name'] = 'value'
+  #   => "value"
+  #   >>
+  #
+  # Radiant currently uses the following settings:
+  #
+  # 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
+  # defaults.page.filter      :: the default filter to use on new page parts
+  # dev.host                  :: the hostname where draft pages are viewable
+  # local.timezone            :: the timezone name (`rake -D time` for full list)
+  #                              used to correct displayed times
+  # page.edit.published_date? :: when true, shows the datetime selector
+  #                              for published date on the page edit screen
   class Config < ActiveRecord::Base
-    #
-    # The Radiant.config model class is stored in the database (and cached) but emulates a hash 
-    # with simple bracket methods that allow you to get and set values like so:
-    #
-    #   Radiant.config['setting.name'] = 'value'
-    #   Radiant.config['setting.name'] #=> "value"
-    #
-    # Config entries can be used freely as general-purpose global variables unless a definition
-    # has been given for that key, in which case restrictions and defaults may apply. The restrictions  
-    # can take the form of validations, requirements, permissions or permitted options. They are 
-    # declared by calling Radiant::Config#define:
-    # 
-    #   # setting must be either 'foo', 'bar' or 'blank'
-    #   define('admin.name', :select_from => ['foo', 'bar'])
-    #
-    #   # setting is (and must be) chosen from the names of currently available layouts
-    #   define('shop.layout', :select_from => lambda { Layout.all.map{|l| [l.name,l.id]} }, :alow_blank => false)
-    #
-    #   # setting cannot be changed at runtime
-    #   define('setting.important', :default => "something", :allow_change => false)
-    #
-    # Which almost always happens in a block like this:
-    #
-    #   Radiant.config do |config|
-    #     config.namespace('user', :allow_change => true) do |user|
-    #       user.define 'allow_password_reset?', :default => true
-    #     end
-    #   end
-    #
-    # and usually in a config/settings.rb file either in radiant itself, in the application directory
-    # or in an extension. Radiant currently defines the following settings and makes them editable by 
-    # admin users on the site configuration page:
-    #
-    # 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
-    # defaults.page.filter      :: the default filter to use on new page parts
-    # defaults.page.fields      :: a comma separated list of the default page fields
-    # dev.host                  :: the hostname where draft pages are viewable
-    # local.timezone            :: the timezone name (`rake -D time` for full list)
-    #                              used to correct displayed times
-    # page.edit.published_date? :: when true, shows the datetime selector
-    #                              for published date on the page edit screen
-    #
-    # Helper methods are defined in ConfigurationHelper that will display config entry values
-    # or edit fields:
-    # 
-    #   # to display label and value, where label comes from looking up the config key in the active locale
-    #   show_setting('admin.name') 
-    #
-    #   # to display an appropriate checkbox, text field or select box with label:
-    #   edit_setting('admin.name)
-    #
-    
     set_table_name "config"
     after_save :update_cache
-    attr_reader :definition
-    
-    class ConfigError < RuntimeError; end
-    
+
     class << self
       def [](key)
         if table_exists?
@@ -87,10 +47,11 @@ module Radiant
       def []=(key, value)
         if table_exists?
           pair = find_or_initialize_by_key(key)
-          pair.value = value
+          pair.update_attributes(:value => value)
+          value
         end
       end
-      
+
       def to_hash
         Hash[ *find(:all).map { |pair| [pair.key, pair.value] }.flatten ]
       end
@@ -122,171 +83,22 @@ module Radiant
       def cache_file
         cache_file = File.join(cache_path,'radiant_config_cache.txt')
       end
-      
-      # A convenient drying method for specifying a prefix and options common to several settings.
-      # 
-      #   Radiant.config do |config| 
-      #     config.namespace('secret', :allow_display => false) do |secret|
-      #       secret.define('identity', :default => 'batman')      # defines 'secret.identity'
-      #       secret.define('lair', :default => 'batcave')         # defines 'secret.lair'
-      #       secret.define('longing', :default => 'vindication')  # defines 'secret.longing'
-      #     end
-      #   end
-      #
-      def namespace(prefix, options = {}, &block)
-        prefix = [options[:prefix], prefix].join('.') if options[:prefix]
-        with_options(options.merge(:prefix => prefix), &block)
-      end
-      
-      # Declares a setting definition that will constrain and support the use of a particular config entry.
-      #
-      #   define('setting.key', options)
-      #
-      # Can take several options:
-      # * :default is the value that will be placed in the database if none has been set already
-      # * :type can be :string, :boolean or :integer. Note that all settings whose key ends in ? are considered boolean.
-      # * :select_from should be a list or hash suitable for passing to options_for_select, or a block that will return such a list at runtime
-      # * :validate_with should be a block that will receive a value and return true or false. Validations are also implied by type or select_from.
-      # * :allow_blank should be false if the config item must not be blank or nil
-      # * :allow_change should be false if the config item can only be set, not changed. Add a default to specify an unchanging config entry.
-      # * :allow_display should be false if the config item should not be showable in radius tags
-      #
-      # From the main radiant config/initializers/radiant_config.rb:
-      #
-      #   Radiant.config do |config|
-      #     config.define 'defaults.locale', :select_from => lambda { Radiant::AvailableLocales.locales }, :allow_blank => true
-      #     config.define 'defaults.page.parts', :default => "Body,Extended"
-      #     ...
-      #   end
-      #
-      # It's also possible to reuse a definition by passing it to define:
-      #
-      #   choose_layout = Radiant::Config::Definition.new(:select_from => lambda {Layout.all.map{|l| [l.name, l.d]}})
-      #   define "my.layout", choose_layout
-      #   define "your.layout", choose_layout
-      #
-      # but at the moment that's only done in testing.
-      #
-      def define(key, options={})
-        if options.is_a? Radiant::Config::Definition
-          definition = options
-        else
-          key = [options[:prefix], key].join('.') if options[:prefix]
-          definition = Radiant::Config::Definition.new(options)
-        end
-
-        raise LoadError, "Configuration invalid: #{key} is already defined" unless definitions[key].nil? || definitions[key].empty?
-        definitions[key] = definition
-
-        if self[key].nil? && !definition.default.nil?
-          begin
-            self[key] = definition.default
-          rescue ActiveRecord::RecordInvalid
-            raise LoadError, "Default configuration invalid: value '#{definition.default}' is not allowed for '#{key}'"
-          end
-        end
-      end
-      
-      def definitions
-        Radiant.config_definitions
-      end
-      
-      def definition_for(key)
-        definitions[key] ||= Radiant::Config::Definition.new(:empty => true)
-      end
-      
-      def clear_definitions!
-        Radiant.config_definitions = {}
-      end
-      
     end
-    
-    # The usual way to use a config item:
-    #
-    #    Radiant.config['key'] = value
-    #
-    # is equivalent to this:
-    #
-    #   Radiant::Config.find_or_create_by_key('key').value = value
-    #
-    # Calling value= also applies any validations and restrictions that are found in the associated definition.
-    # so this will raise a ConfigError if you try to change a protected config entry or a ValidationError if you 
-    # set a value that is not among those permitted.
-    #
+
     def value=(param)
-      newvalue = param.to_s
-      if newvalue != self[:value]
-        raise ConfigError, "#{self.key} cannot be changed" unless settable? || self[:value].blank?
-        if boolean?
-          self[:value] = (newvalue == "0" || newvalue == "false" || newvalue.blank? ) ? "false" : "true"
-        else
-          self[:value] = newvalue
-        end
-        self.save!
-      end
-      self[:value]
+      self[:value] = param.to_s
     end
 
-    # Requesting a config item:
-    #
-    #    key = Radiant.config['key']
-    #
-    # is equivalent to this:
-    #
-    #   key = Radiant::Config.find_or_create_by_key('key').value
-    #
-    # If the config item is boolean the response will be true or false. For items with :type => :integer it will be an integer, 
-    # for everything else a string.
-    # 
     def value
-      if boolean?
-        checked?
+      if key.ends_with? "?"
+        self[:value] == "true"
       else
         self[:value]
       end
     end
-
-    # Returns the definition associated with this config item. If none has been declared this will be an empty definition
-    # that does not restrict use.
-    #
-    def definition
-      @definition ||= self.class.definition_for(self.key)
-    end
-
-    # Returns true if the item key ends with '?' or the definition specifies :type => :boolean.
-    #
-    def boolean?
-      definition.boolean? || self.key.ends_with?("?")
-    end
-    
-    # Returns true if the item is boolean and true.
-    #
-    def checked?
-      return nil if self[:value].nil?
-      boolean? && self[:value] == "true"
-    end
-    
-    # Returns true if the item defintion includes a :select_from parameter that limits the range of permissible options.
-    #
-    def selector?
-      definition.selector?
-    end
-    
-    # Returns a name corresponding to the current setting value, if the setting definition includes a select_from parameter.
-    #
-    def selected_value
-      definition.selected(value)
-    end
     
     def update_cache
       Radiant::Config.initialize_cache
     end
-
-    delegate :default, :type, :allow_blank?, :hidden?, :visible?, :settable?, :selection, :notes, :units, :to => :definition
-
-    def validate
-      definition.validate(self)
-    end
-
   end
 end

data/app/models/radiant/exporter.rb

@@ -0,0 +1,11 @@
+module Radiant
+  class Exporter
+    def self.export
+      hash = {}
+      [Radiant::Config, User, Page, PagePart, Snippet, Layout].each do |klass|
+        hash[klass.name.pluralize] = klass.find(:all).inject({}) { |h, record| h[record.id.to_i] = record.attributes; h }
+      end
+      hash.to_yaml
+    end
+  end
+end

data/app/models/standard_tags.rb

@@ -2,12 +2,9 @@ module StandardTags
 
   include Radiant::Taggable
   include LocalTime
-
-  require "will_paginate/view_helpers"
   include WillPaginate::ViewHelpers
 
   class TagError < StandardError; end
-  class RequiredAttributeError < StandardError; end
 
   desc %{
     Causes the tags referring to a page's attributes to refer to the current page.
@@ -31,12 +28,11 @@ module StandardTags
   end
 
   desc %{
-    Renders the @path@ attribute of the current page.
+    Renders the @url@ attribute of the current page.
   }
-  tag 'path' do |tag|
-    relative_url_for(tag.locals.page.path, tag.globals.page.request)
+  tag 'url' do |tag|
+    relative_url_for(tag.locals.page.url, tag.globals.page.request)
   end
-  alias_method :'tag:url', :'tag:path'
 
   desc %{
     Gives access to a page's children.
@@ -349,29 +345,29 @@ module StandardTags
   end
   
     desc %{
-    Aggregates the children of multiple paths using the @paths@ attribute.
+    Aggregates the children of multiple URLs using the @urls@ attribute.
     Useful for combining many different sections/categories into a single
     feed or listing.
     
     *Usage*:
     
-    <pre><code><r:aggregate paths="/section1; /section2; /section3"> ... </r:aggregate></code></pre>
+    <pre><code><r:aggregate urls="/section1; /section2; /section3"> ... </r:aggregate></code></pre>
   }
   tag "aggregate" do |tag|
-    required_attr(tag, 'paths', 'urls')
-    paths = (tag.attr['paths']||tag.attr["urls"]).split(";").map(&:strip).reject(&:blank?).map { |u| clean_path u }
-    parent_ids = paths.map {|u| Page.find_by_path(u) }.map(&:id)
+    raise "`urls' attribute required" unless tag.attr["urls"]
+    urls = tag.attr["urls"].split(";").map(&:strip).reject(&:blank?).map { |u| clean_url u }
+    parent_ids = urls.map {|u| Page.find_by_url(u) }.map(&:id)
     tag.locals.parent_ids = parent_ids
     tag.expand
   end
   
   desc %{
     Sets the scope to the individual aggregated page allowing you to
-    iterate through each of the listed paths.
+    iterate through each of the listed urls.
     
     *Usage*:
     
-    <pre><code><r:aggregate:each paths="/section1; /section2; /section3"> ... </r:aggregate:each></code></pre>
+    <pre><code><r:aggregate:each urls="/section1; /section2; /section3"> ... </r:aggregate:each></code></pre>
   }
   tag "aggregate:each" do |tag|
     aggregates = []
@@ -411,7 +407,7 @@ module StandardTags
 
     *Usage*:
     
-    <pre><code><r:aggregate paths="/section1; /section2; /section3">
+    <pre><code><r:aggregate urls="/section1; /section2; /section3">
       <r:children:count />
     </r:aggregate></code></pre>
   }  
@@ -430,7 +426,7 @@ module StandardTags
 
     *Usage*:
     
-    <pre><code><r:aggregate paths="/section1; /section2; /section3">
+    <pre><code><r:aggregate urls="/section1; /section2; /section3">
       <r:children:each>
         ...
       </r:children:each>
@@ -455,7 +451,7 @@ module StandardTags
 
     *Usage*:
     
-    <pre><code><r:aggregate paths="/section1; /section2; /section3">
+    <pre><code><r:aggregate urls="/section1; /section2; /section3">
       <r:children:first>
         ...
       </r:children:first>
@@ -476,7 +472,7 @@ module StandardTags
 
     *Usage*:
     
-    <pre><code><r:aggregate paths="/section1; /section2; /section3">
+    <pre><code><r:aggregate urls="/section1; /section2; /section3">
       <r:children:last>
         ...
       </r:children:last>
@@ -501,7 +497,7 @@ module StandardTags
     <pre><code><r:cycle values="first, second, third" [reset="true|false"] [name="cycle"] /></code></pre>
   }
   tag 'cycle' do |tag|
-    required_attr(tag, 'values')
+    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'
@@ -534,14 +530,19 @@ module StandardTags
     else
       rendering_parts[page.id] << part_name
     end
-    inherit = boolean_attr_or_error(tag,'inherit',false)
+    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_or_error(tag,'contextual', true)
+    contextual = boolean_attr['contextual', true]
     part = part_page.part(part_name)
     tag.locals.page = part_page unless contextual
     result = tag.globals.page.render_snippet(part) unless part.nil?
@@ -622,38 +623,36 @@ module StandardTags
   end
 
   desc %{
-    Renders the containing elements only if the page's path matches the regular expression
+    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_path matches="regexp" [ignore_case="true|false"]>...</r:if_path></code></pre>
+    <pre><code><r:if_url matches="regexp" [ignore_case="true|false"]>...</r:if_url></code></pre>
   }
-  tag 'if_path' do |tag|
-    required_attr(tag,'matches')
+  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.path.match(regexp).nil?
+    unless tag.locals.page.url.match(regexp).nil?
        tag.expand
     end
   end
-  alias_method :'tag:if_url', :'tag:if_path'
 
   desc %{
-    The opposite of the @if_path@ tag.
+    The opposite of the @if_url@ tag.
 
     *Usage:*
     
-    <pre><code><r:unless_path matches="regexp" [ignore_case="true|false"]>...</r:unless_path></code></pre>
+    <pre><code><r:unless_url matches="regexp" [ignore_case="true|false"]>...</r:unless_url></code></pre>
   }
-  tag 'unless_path' do |tag|
-    required_attr(tag, 'matches')
+  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.path.match(regexp).nil?
+    if tag.locals.page.url.match(regexp).nil?
         tag.expand
     end
   end
-  alias_method :'tag:unless_url', :'tag:unless_path'
 
   desc %{
     Renders the contained elements if the current contextual page is either the actual page or one of its parents.
@@ -766,7 +765,7 @@ module StandardTags
       case
       when time_attr == 'now'
         Time.zone.now
-      when Page.date_column_names.include?(time_attr)
+      when ['published_at', 'created_at', 'updated_at'].include?(time_attr)
         page[time_attr]
       else
         raise TagError, "Invalid value for 'for' attribute."
@@ -774,9 +773,7 @@ module StandardTags
     else
       page.published_at || page.created_at
     end
-    @i18n_date_format_keys ||= (I18n.config.backend.send(:translations)[I18n.locale][:date][:formats].keys rescue [])
-    format = @i18n_date_format_keys.include?(format.to_sym) ? format.to_sym : format
-    I18n.l date, :format => format
+    date.strftime(format)
   end
 
   desc %{
@@ -802,32 +799,29 @@ module StandardTags
     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('path')}#{anchor}"#{attributes}>#{text}</a>}
+    %{<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 @>@. The boolean nolinks attribute can be specified to render
-    breadcrumbs in plain text, without any links (useful when generating title tag). 
-    Set the noself attribute to 'true' to omit the present page (useful in page headers).
+    breadcrumbs in plain text, without any links (useful when generating title tag).
 
     *Usage:*
 
-    <pre><code><r:breadcrumbs [separator="separator_string"] [nolinks="true"] [noself="true"]/></code></pre>
+    <pre><code><r:breadcrumbs [separator="separator_string"] [nolinks="true"] /></code></pre>
   }
   tag 'breadcrumbs' do |tag|
     page = tag.locals.page
+    breadcrumbs = [page.breadcrumb]
     nolinks = (tag.attr['nolinks'] == 'true')
-    noself = (tag.attr['noself'] == 'true')
-    breadcrumbs = []
-    breadcrumbs << (noself ? '' : page.breadcrumb)
     page.ancestors.each do |ancestor|
       tag.locals.page = ancestor
       if nolinks
         breadcrumbs.unshift tag.render('breadcrumb')
       else
-        breadcrumbs.unshift %{<a href="#{tag.render('path')}">#{tag.render('breadcrumb')}</a>}
+        breadcrumbs.unshift %{<a href="#{tag.render('url')}">#{tag.render('breadcrumb')}</a>}
       end
     end
     separator = tag.attr['separator'] || ' &gt; '
@@ -857,7 +851,7 @@ module StandardTags
         raise TagError.new('snippet not found')
       end
     else
-      required_attr(tag,'name')
+      raise TagError.new("`snippet' tag must contain `name' attribute")
     end
   end
 
@@ -897,18 +891,18 @@ module StandardTags
   end
 
   desc %{
-    Inside this tag all page related tags refer to the page found at the @path@ attribute.
-    @path@s may be relative or absolute paths.
+    Inside this tag all page related tags refer to the page found at the @url@ attribute.
+    @url@s may be relative or absolute paths.
 
     *Usage:*
 
-    <pre><code><r:find path="value_to_find">...</r:find></code></pre>
+    <pre><code><r:find url="value_to_find">...</r:find></code></pre>
   }
   tag 'find' do |tag|
-    required_attr(tag,'path','url')
-    path = tag.attr['path'] || tag.attr['url']
+    url = tag.attr['url']
+    raise TagError.new("`find' tag must contain `url' attribute") unless url
 
-    found = Page.find_by_path(absolute_path_for(tag.locals.page.path, path))
+    found = Page.find_by_url(absolute_path_for(tag.locals.page.url, url))
     if page_found?(found)
       tag.locals.page = found
       tag.expand
@@ -940,13 +934,13 @@ module StandardTags
   end
 
   desc %{
-    Nothing inside a set of hide tags is rendered.
+    Nothing inside a set of comment tags is rendered.
 
     *Usage:*
 
-    <pre><code><r:hide>...</r:hide></code></pre>
+    <pre><code><r:comment>...</r:comment></code></pre>
   }
-  tag 'hide' do |tag|
+  tag 'comment' do |tag|
   end
 
   desc %{
@@ -975,14 +969,14 @@ module StandardTags
   end
 
   desc %{
-    Renders a list of links specified in the @paths@ attribute according to three
+    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 path matches the current
-       page's PATH
+    * @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 path
+       is a child of the specified url
     # @if_last@ renders its contents within a @normal@, @here@ or
       @selected@ tag if the item is the last in the navigation elements
     # @if_first@ renders its contents within a @normal@, @here@ or
@@ -992,10 +986,10 @@ module StandardTags
 
     *Usage:*
 
-    <pre><code><r:navigation paths="[Title: path | Title: path | ...]">
-      <r:normal><a href="<r:path />"><r:title /></a></r:normal>
+    <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:path />"><r:title /></a></strong></r:selected>
+      <r:selected><strong><a href="<r:url />"><r:title /></a></strong></r:selected>
       <r:between> | </r:between>
     </r:navigation>
     </code></pre>
@@ -1005,23 +999,23 @@ module StandardTags
     tag.expand
     raise TagError.new("`navigation' tag must include a `normal' tag") unless hash.has_key? :normal
     result = []
-    pairs = (tag.attr['paths']||tag.attr['urls']).to_s.split('|').map do |pair|
+    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_with_index do |(title, path), i|
-      compare_path = remove_trailing_slash(path)
-      page_path = remove_trailing_slash(self.path)
+    pairs.each_with_index do |(title, url), i|
+      compare_url = remove_trailing_slash(url)
+      page_url = remove_trailing_slash(self.url)
       hash[:title] = title
-      hash[:path] = path
+      hash[:url] = url
       tag.locals.first_child = i == 0
       tag.locals.last_child = i == pairs.length - 1
-      case page_path
-      when compare_path
+      case page_url
+      when compare_url
         result << (hash[:here] || hash[:selected] || hash[:normal]).call
-      when Regexp.compile( '^' + Regexp.quote(path))
+      when Regexp.compile( '^' + Regexp.quote(url))
         result << (hash[:selected] || hash[:normal]).call
       else
         result << hash[:normal].call
@@ -1036,7 +1030,7 @@ module StandardTags
       hash[symbol] = tag.block
     end
   end
-  [:title, :path].each do |symbol|
+  [:title, :url].each do |symbol|
     tag "navigation:#{symbol}" do |tag|
       hash = tag.locals.navigation
       hash[symbol]
@@ -1127,58 +1121,61 @@ module StandardTags
     status
   end
 
-  desc %(
-    Renders the content of the field given in the @name@ attribute.
+  desc %{
+    The namespace for 'meta' attributes.  If used as a singleton tag, both the description
+    and keywords fields will be output as &lt;meta /&gt; tags unless the attribute 'tag' is set to 'false'.
 
     *Usage:*
 
-    <pre><code><r:field name="Keywords" /></code></pre>
-  )
-  tag 'field' do |tag|
-    required_attr(tag,'name')
-    tag.locals.page.field(tag.attr['name']).try(:content)
+    <pre><code> <r:meta [tag="false"] />
+     <r:meta>
+       <r:description [tag="false"] />
+       <r:keywords [tag="false"] />
+     </r:meta>
+    </code></pre>
+  }
+  tag 'meta' do |tag|
+    if tag.double?
+      tag.expand
+    else
+      tag.render('description', tag.attr) +
+      tag.render('keywords', tag.attr)
+    end
   end
 
-  desc %(
-    Renders the contained elements if the field given in the @name@ attribute
-    exists. The tag also takes an optional @equals@ or @matches@ attribute;
-    these will expand the tag if the field's content equals or matches the
-    given string or regex.
+  desc %{
+    Emits the page description field in a meta tag, unless attribute
+    'tag' is set to 'false'.
 
     *Usage:*
 
-    <pre><code><r:if_field name="author" [equals|matches="John"] [ignore_case="true|false"]>...</r:if_field></code></pre>
-  )
-  tag 'if_field' do |tag|
-    required_attr(tag,'name')
-    field = tag.locals.page.field(tag.attr['name'])
-    return '' if field.nil?
-    tag.expand if case
-      when (tag.attr['equals'] and tag.attr['ignore_case'] == 'false') : field.content == tag.attr['equals']
-      when tag.attr['equals'] : field.content.downcase == tag.attr['equals'].downcase
-      when tag.attr['matches'] : field.content =~ build_regexp_for(tag, 'matches')
-      else field
+    <pre><code> <r:meta:description [tag="false"] /> </code></pre>
+  }
+  tag 'meta:description' do |tag|
+    show_tag = tag.attr['tag'] != 'false' || false
+    description = CGI.escapeHTML(tag.locals.page.description)
+    if show_tag
+      "<meta name=\"description\" content=\"#{description}\" />"
+    else
+      description
     end
   end
 
-  desc %(
-    The opposite of @if_field@. Renders the contained elements unless the field
-    given in the @name@ attribute exists. The tag also takes an optional
-    @equals@ or @matches@ attribute; these will expand the tag unless the
-    field's content equals or matches the given string or regex.
+  desc %{
+    Emits the page keywords field in a meta tag, unless attribute
+    'tag' is set to 'false'.
 
     *Usage:*
 
-    <pre><code><r:unless_field name="author" [equals|matches="John"] [ignore_case="true|false"]>...</r:unless_field></code></pre>
-  )
-  tag 'unless_field' do |tag|
-    required_attr(tag,'name')
-    field = tag.locals.page.field(tag.attr['name'])
-    tag.expand unless case
-      when (field and (tag.attr['equals'] and tag.attr['ignore_case'] == 'false')) : field.content == tag.attr['equals']
-      when (field and tag.attr['equals']) : field.content.downcase == tag.attr['equals'].downcase
-      when (field and tag.attr['matches']) : field.content =~ build_regexp_for(tag, 'matches')
-      else field
+    <pre><code> <r:meta:keywords [tag="false"] /> </code></pre>
+  }
+  tag 'meta:keywords' do |tag|
+    show_tag = tag.attr['tag'] != 'false' || false
+    keywords = CGI.escapeHTML(tag.locals.page.keywords)
+    if show_tag
+      "<meta name=\"keywords\" content=\"#{keywords}\" />"
+    else
+      keywords
     end
   end
 
@@ -1249,7 +1246,7 @@ module StandardTags
     def will_paginate_options(tag)
       attr = tag.attr.symbolize_keys
       if attr[:paginated] == 'true'
-        attr.slice(:class, :previous_label, :next_label, :inner_window, :outer_window, :separator, :per_page).merge({:renderer => Radiant::Pagination::LinkRenderer.new(tag.globals.page.path)})
+        attr.slice(:class, :previous_label, :next_label, :inner_window, :outer_window, :separator, :per_page).merge({:renderer => Radiant::Pagination::LinkRenderer.new(tag.globals.page.url)})
       else
         {}
       end
@@ -1300,14 +1297,9 @@ module StandardTags
       values = options[:values].split(',').map!(&:strip)
 
       attribute = (tag.attr[attribute_name] || default).to_s
-      raise TagError.new(%{`#{attribute_name}' attribute of `#{tag.name}' tag must be one of: #{values.join(', ')}}) unless values.include?(attribute)
+      raise TagError.new(%{'#{attribute_name}' attribute of #{tag} tag must be one of: #{values.join(',')}}) unless values.include?(attribute)
       return attribute
     end
-    
-    def required_attr(tag, *attribute_names)
-      attr_collection = attribute_names.map{|a| "`#{a}'"}.join(' or ')
-      raise TagError.new("`#{tag.name}' tag must contain a #{attr_collection} attribute.") if (tag.attr.keys & attribute_names).blank?
-    end
 
     def dev?(request)
       return false if request.nil?