RubyGems - radiant - Versions diffs - 0.5.2 → 0.6.0 - Mend

radiant 0.5.2 → 0.6.0

Potentially problematic release.

This version of radiant might be problematic. Click here for more details.

Files changed (1442) hide show

data/app/{behaviors/env_behavior.rb → models/env_dump_page.rb} RENAMED

@@ -1,6 +1,4 @@
-class EnvDumpBehavior < Behavior::Base
-  register "Env Dump"
+class EnvDumpPage < Page
   description %{
     Instead of rendering a page in the normal fashion the Env Dump
@@ -8,11 +6,12 @@ class EnvDumpBehavior < Behavior::Base
     request. This is occasionally useful for debugging.
   }
-  def render_page
-    %{<html><body><pre>#{ @request.env.collect { |k,v| "#{k} => #{v}\n" } }</pre></body></html>}
+  def render
+    %{<html><body><pre>#{ request.env.collect { |k,v| "#{k} => #{v}\n" } }</pre></body></html>}
   end
-  def cache_page?
+  def cache?
     false
   end
 end

data/app/models/file_not_found_page.rb ADDED

@@ -0,0 +1,28 @@
+class FileNotFoundPage < Page
+  description %{
+    A "File Not Found" page can be used to override the default error
+    page in the event that a page is not found among a page's children.
+    To create a "File Not Found" error page for an entire Web site, create
+    a page that is a child of the root page and assign it "File Not Found"
+    page type.
+  }
+  tag "attempted_url" do
+    request.request_uri unless request.nil?
+  end
+  def virtual?
+    true
+  end
+  def headers
+    { 'Status' => '404 Not Found' }
+  end
+  def cache?
+    false
+  end
+end

data/app/models/layout.rb CHANGED

@@ -1,4 +1,7 @@
 class Layout < ActiveRecord::Base
+  # Default Order
+  order_by 'name'
   # Associations
   has_many :pages
@@ -10,4 +13,4 @@ class Layout < ActiveRecord::Base
   validates_uniqueness_of :name, :message => 'name already in use'
   validates_length_of :name, :maximum => 100, :message => '%d-character limit'
-end
+end

data/app/models/page.rb CHANGED

@@ -1,5 +1,3 @@
-require_dependency 'advanced_delegation'
 class Page < ActiveRecord::Base
   class MissingRootPageError < StandardError
@@ -11,8 +9,8 @@ class Page < ActiveRecord::Base
   # Associations
   acts_as_tree :order => 'virtual DESC, title ASC'
-  has_many :parts, :class_name => 'PagePart', :dependent => :destroy
-  belongs_to :layout
+  has_many :parts, :class_name => 'PagePart', :order => 'id', :dependent => :destroy
+  belongs_to :_layout, :class_name => 'Layout', :foreign_key => 'layout_id'
   belongs_to :created_by, :class_name => 'User', :foreign_key => 'created_by'
   belongs_to :updated_by, :class_name => 'User', :foreign_key => 'updated_by'
@@ -22,70 +20,235 @@ class Page < ActiveRecord::Base
   validates_length_of :title, :maximum => 255, :message => '%d-character limit'
   validates_length_of :slug, :maximum => 100, :message => '%d-character limit'
   validates_length_of :breadcrumb, :maximum => 160, :message => '%d-character limit'
-  validates_length_of :behavior_id, :maximum => 25, :allow_nil => true, :message => '%d-character limit'
   validates_format_of :slug, :with => %r{^([-_.A-Za-z0-9]*|/)$}, :message => 'invalid format'
   validates_uniqueness_of :slug, :scope => :parent_id, :message => 'slug already in use for child of parent'
   validates_numericality_of :id, :status_id, :parent_id, :allow_nil => true, :only_integer => true, :message => 'must be a number'
-  delegate_to :behavior, :url => :page_url, :cache? => :cache_page?, :find_by_url => :find_page_by_url,
-     :render => :render_page, :virtual? => :page_virtual?
+  validate :valid_class_name
-  delegate_to :behavior, :process, :child_url
+  include Radiant::Taggable
+  include StandardTags
+  include Annotatable
-  def after_initialize
-    class << self
-      define_method(:layout) do |*params|
-        super || (parent and parent.layout)
-      end
+  annotate :description
+  attr_accessor :request, :response
+  set_inheritance_column :class_name
+  def layout
+    unless _layout
+      parent.layout if parent?
+    else
+      _layout
     end
   end
+  def cache?
+    true
+  end
+  def child_url(child)
+    clean_url(url + '/' + child.slug)
+  end
+  def headers
+    { 'Status' => ActionController::Base::DEFAULT_RENDER_STATUS_CODE }
+  end
   def part(name)
     parts.find_by_name name.to_s
   end
+  def published?
+    status == Status[:published]
+  end
   def status
     Status.find(self.status_id)
   end
   def status=(value)
     self.status_id = value.id
   end
-  def published?
-    status == Status[:published]
+  def virtual
+    !(read_attribute('virtual').to_s =~ /^(false|f|0|)$/)
   end
-  def behavior
-    if @behavior.nil? or (@old_behavior_id != behavior_id)
-      @old_behavior_id = behavior_id
-      @behavior = Behavior[behavior_id].new(self)
+  def url
+    if parent?
+      parent.child_url(self)
     else
-      @behavior
+      clean_url(slug)
     end
   end
-  def self.find_by_url(url, live = true)
-    root = find_by_parent_id(nil)
-    raise MissingRootPageError unless root
-    root.find_by_url(url, live)
+  def process(request, response)
+    @request, @response = request, response
+    if layout
+      content_type = layout.content_type.to_s.strip
+      @response.headers['Content-Type'] = content_type unless content_type.empty?
+    end
+    headers.each { |k,v| @response.headers[k] = v }
+    @response.body = render
+    @request, @response = nil, nil
   end
-  def virtual
-    !(read_attribute('virtual').to_s =~ /^(false|f|0|)$/)
+  def render
+    lazy_initialize_parser_and_context
+    if layout
+      parse_object(layout)
+    else
+      render_part(:body)
+    end
+  end
+  def render_part(part_name)
+    lazy_initialize_parser_and_context
+    part = part(part_name)
+    if part
+      parse_object(part)
+    else
+      ''
+    end
+  end
+  def render_snippet(snippet, actual_page = nil)
+    lazy_initialize_parser_and_context
+    @context.globals.actual_page = actual_page if actual_page
+    parse_object(snippet)
+  end
+  def render_text(text)
+    lazy_initialize_parser_and_context
+    parse(text)
+  end
+  def find_by_url(url, live = true, clean = true)
+    url = clean_url(url) if clean
+    if (self.url == url) && (not live or published?)
+      self
+    else
+      children.each do |child|
+        if (url =~ Regexp.compile( '^' + Regexp.quote(child.url))) and (not child.virtual?)
+          found = child.find_by_url(url, live, clean)
+          return found if found
+        end
+      end
+      children.find(:first, :conditions => "class_name = 'FileNotFoundPage'")
+    end
+  end
+  class << self
+    def find_by_url(url, live = true)
+      root = find_by_parent_id(nil)
+      raise MissingRootPageError unless root
+      root.find_by_url(url, live)
+    end
+    def display_name(string = nil)
+      if string
+        @display_name = string
+      else
+        @display_name ||= begin
+          n = name.to_s
+          n.sub!(/^(.+?)Page$/, '\1')
+          n.gsub!(/([A-Z])/, ' \1')
+          n.strip
+        end
+      end
+    end
+    def display_name=(string)
+      display_name(string)
+    end
+    def load_subclasses
+      Dir["#{RADIANT_ROOT}/app/models/*_page.rb"].each do |page|
+        $1.camelize.constantize if page =~ %r{/([^/]+)\.rb}
+      end
+    end
+    def new_with_defaults(config = Radiant::Config)
+      default_parts = config['defaults.page.parts'].to_s.strip.split(/\s*,\s*/)
+      page = new
+      default_parts.each do |name|
+        page.parts << PagePart.new(:name => name)
+      end
+      default_status = config['defaults.page.status']
+      page.status = Status[default_status] if default_status
+      page
+    end
+    def is_descendant_class_name?(class_name)
+      (Page.descendants.map(&:to_s) + [nil, "", "Page"]).include?(class_name)
+    end
+    def descendant_class(class_name)
+      raise ArgumentError.new("argument must be a valid descendant of Page") unless is_descendant_class_name?(class_name)
+      if ["", nil, "Page"].include?(class_name)
+        Page
+      else
+        class_name.constantize
+      end
+    end
   end
   private
+    def valid_class_name
+      unless Page.is_descendant_class_name?(class_name)
+        errors.add :class_name, "must be set to a valid descendant of Page"
+      end
+    end
+    def attributes_protected_by_default
+      super - [self.class.inheritance_column]
+    end
     def update_published_at
       write_attribute('published_at', Time.now) if (status_id.to_i == Status[:published].id) and published_at.nil?
       true
     end
     def update_virtual
-      write_attribute('virtual', virtual?)
+      if self.class != Page.descendant_class(class_name)
+        write_attribute('virtual', Page.descendant_class(class_name).new.virtual?)
+      else
+        write_attribute('virtual', virtual?)
+      end
       true
     end
+    def clean_url(url)
+      "/#{ url.strip }/".gsub(%r{//+}, '/')
+    end
+    def parent?
+      !parent.nil?
+    end
+    def lazy_initialize_parser_and_context
+      unless @context and @parser
+        @context = PageContext.new(self)
+        @parser = Radius::Parser.new(@context, :tag_prefix => 'r')
+      end
+    end
+    def parse(text)
+      @parser.parse(text)
+    end
+    def parse_object(object)
+      text = object.content
+      text = parse(text)
+      text = object.filter.filter(text) if object.respond_to? :filter_id
+      text
+    end
+    def tag(*args, &block)
+      @context.define_tag(*args, &block)
+    end
-end
+end
+Page.load_subclasses

data/app/models/page_context.rb CHANGED

@@ -1,5 +1,4 @@
 class PageContext < Radius::Context
-  class TagError < StandardError; end
   attr_reader :page
@@ -8,489 +7,23 @@ class PageContext < Radius::Context
     @page = page
     globals.page = @page
-    # <r:page>...</r:page>
-    #
-    # Causes the tags referring to a page's attributes to refer to the current page.
-    #
-    define_tag 'page' do |tag|
-      tag.locals.page = tag.globals.page
-      tag.expand
-    end
-    #
-    # <r:url />
-    # <r:title />
-    # etc...
-    #
-    ((@page.attributes.symbolize_keys.keys + [:url]) - [:created_by, :updated_by]).each do |method|
-      define_tag(method.to_s) do |tag|
-        tag.locals.page.send(method)
-      end
-    end
-    #
-    # <r:children>...</r:children>
-    #
-    # Gives access to a page's children.
-    #
-    define_tag 'children' do |tag|
-      tag.locals.children = tag.locals.page.children
-      tag.expand
-    end
-    #
-    # <r:children:count />
-    #
-    # Renders the total number of children.
-    #
-    define_tag 'children:count' do |tag|
-      tag.locals.children.count
-    end
-    #
-    # <r:children:first>...<r:children:first>
-    #
-    # Returns the first child. Inside this tag all page attribute tags are mapped to
-    # the first child.
-    #
-    define_tag 'children:first' do |tag|
-      children = tag.locals.children
-      if first = children.first
-        tag.locals.page = first
-        tag.expand
-      end
-    end
-    #
-    # <r:children:last>...</r:children:last>
-    #
-    # Returns the last child. Inside this tag all page attribute tags are mapped to
-    # the last child.
-    #
-    define_tag 'children:last' do |tag|
-      children = tag.locals.children
-      if last = children.last
-        tag.locals.page = last
-        tag.expand
-      end
-    end
-    #
-    # <r:children:each [offset="number"] [limit="number"] [by="attribute"] [order="asc|desc"]
-    #   [status="draft|reviewed|published|hidden|all"]>
-    # ...
-    # </r:children:each>
-    #
-    # Cycles through each of the children. Inside this tag all page attribute tags
-    # are mapped to the current child page.
-    #
-    define_tag "children:each" do |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 @page.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
-      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
-    #
-    # <r:child>...</r:child>
-    #
-    # Page attribute tags inside of this tag refer to the current child. Not needed in
-    # most cases.
-    #
-    define_tag 'children:each:child' do |tag|
-      tag.locals.page = tag.locals.child
-      tag.expand
-    end
-    #
-    # <header [name="header_name"] [restart="name1[;name2;...]"]>...</r:header>
-    #
-    # 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.
-    #
-    define_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
-    #
-    # <r:content [part="part_name"] [inherit="true|false"] [contextual="true|false"] />
-    #
-    # 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 false.
-    #
-    define_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.behavior.render_snippet(part) unless part.nil?
-      else
-        part_page.behavior.render_page_part(part_name)
-      end
-    end
-    #
-    # <r:if_content [part="part_name"]>...</r:if_content>
-    #
-    # Renders the containing elements only if the part exists on a page. By default the
-    # 'part' attribute is set 'body'.
-    #
-    define_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
-    #
-    # <r:unless_content [part="part_name"]>...</r:unless_content>
-    #
-    # The opposite of the 'if_content' tag.
-    #
-    define_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
-    #
-    # <r:if_url matches="regexp" [ignore_case="true|false"]>...</if_url>
-    #
-    # Renders the containing elements only if the page's url matches the regular expression
-    # given in the 'matches' attribute. If the 'ìgnore_case' attribute is set to false, the
-    # match is case sensitive. By default, 'ignore_case' is set to true.
-    #
-    define_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
+    page.tags.each do |name|
+      define_tag(name) { |tag_binding| page.render_tag(name, tag_binding) }
     end
-    #
-    # <r:unless_url matches="regexp" [ignore_case="true|false"]>...</unless_url>
-    #
-    # The opposite of the 'if_url' tag.
-    #
-    define_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
-    #
-    # <r:author />
-    #
-    # Renders the name of the Author of the current page.
-    #
-    define_tag 'author' do |tag|
-      page = tag.locals.page
-      if author = page.created_by
-        author.name
-      end
-    end
-    #
-    # <r:date [format="format_string"] />
-    #
-    # Renders the date that a page was published (or in the event that it has
-    # not ben modified yet, the date that it was 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'.
-    #
-    define_tag 'date' do |tag|
-      page = tag.locals.page
-      format = tag_time_format(tag)
-      if date = page.published_at || page.created_at
-        date.strftime(format)
-      end
-    end
-    #
-    # <r:link [anchor="name"] [other attributes...] />
-    # <r:link>...</r:link>
-    #
-    # 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 inbetween 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 ('#') followed by the value of the attribute to the 'href'
-    # attribute of the HTML 'a' tag--effectively making an HTML anchor.
-    #
-    define_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
-    #
-    # <r:breadcrumbs [separator="separator_string"] />
-    #
-    # 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 ' &gt; '.
-    #
-    define_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
-    #
-    # <r:snippet name="snippet_name" />
-    #
-    # Renders the snippet specified in the 'name' attribute within the context of a page.
-    #
-    define_tag 'snippet' do |tag|
-      if name = tag.attr['name']
-        if snippet = Snippet.find_by_name(name.strip)
-          page = tag.locals.page
-          page.behavior.render_snippet(snippet)
-        else
-          raise TagError.new('snippet not found')
-        end
-      else
-        raise TagError.new("`snippet' tag must contain `name' attribute")
-      end
-    end
-    #
-    # <r:find url="value_to_find">...</r:find>
-    #
-    # Inside this tag all page related tags refer to the tag found at the 'url' attribute.
-    #
-    define_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
-    #
-    # <r:random>
-    #   <r:option>...</r:option>
-    #   <r:option>...</r:option>
-    #   ...
-    # <r:random>
-    #
-    # Randomly renders one of the options specified by the 'option' tags.
-    #
-    define_tag 'random' do |tag|
-      tag.locals.random = []
-      tag.expand
-      options = tag.locals.random
-      option = options[rand(options.size)]
-      option.call if option
-    end
-    define_tag 'random:option' do |tag|
-      items = tag.locals.random
-      items << tag.block
-    end
-    #
-    # <r:comment>...</r:comment>
-    #
-    # Nothing inside a set of comment tags is rendered.
-    #
-    define_tag 'comment' do |tag|
-    end
-    #
-    # <r:escape_html>...</r:escape_html>
-    #
-    # Escapes angle brackets, etc...
-    #
-    define_tag "escape_html" do |tag|
-      CGI.escapeHTML(tag.expand)
-    end
-    #
-    # <r:rfc1123_date />
-    #
-    # Outputs the date using the format mandated by RFC 1123. (Ideal for RSS feeds.)
-    #
-    define_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
-    #
-    # <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>
-    #
-    # 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 inbetween each of the links.
-    #
-    define_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(';').collect 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(@page.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|
-      define_tag "navigation:#{symbol}" do |tag|
-        hash = tag.locals.navigation
-        hash[symbol] = tag.block
-      end
-    end
-    [:title, :url].each do |symbol|
-      define_tag "navigation:#{symbol}" do |tag|
-        hash = tag.locals.navigation
-        hash[symbol]
-      end
-    end
   end
   def render_tag(name, attributes = {}, &block)
     super
   rescue Exception => e
+    raise e if testing?
     render_error_message(e.message)
   end
   def tag_missing(name, attributes = {}, &block)
     super
   rescue Radius::UndefinedTagError => e
-    raise TagError.new(e.message)
+    raise StandardTags::TagError.new(e.message)
   end
   private
@@ -499,28 +32,8 @@ class PageContext < Radius::Context
       "<div><strong>#{message}</strong></div>"
     end
-    def remove_trailing_slash(string)
-      (string =~ %r{^(.*?)/$}) ? $1 : string
+    def testing?
+      RAILS_ENV == 'test'
     end
-    def tag_part_name(tag)
-      tag.attr['part'] || 'body'
-    end
-    def tag_time_format(tag)
-      (tag.attr['format'] || '%A, %B %d, %Y')
-    end
-    def postgres?
-      ActiveRecord::Base.connection.adapter_name =~ /postgres/i
-    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