radiant 0.9.1 → 1.0.0.rc1

data/app/helpers/admin/pages_helper.rb

@@ -18,15 +18,13 @@ module Admin::PagesHelper
     @page.parts.empty? ? "" : @page.parts[0].filter_id
   end
 
-  def homepage
-    @homepage ||= Page.find_by_parent_id(nil)
-  end
-  
   def status_to_display
     @page.status_id = 100 if @page.status_id == 90
-    @display_status = []
-    Status.find_all.each { |s| @display_status <<  [t(s.name.downcase), s.id] unless s.name == 'Scheduled' }
-    return @display_status
+    @display_status = Status.selectable.map{ |s| [I18n.translate(s.name.downcase), s.id] }
+  end
+
+  def clean_page_description(page)
+    page.description.to_s.strip.gsub(/\t/,'').gsub(/\s+/,' ')
   end
 
   def page_edit_javascripts

data/app/helpers/admin/preferences_helper.rb

@@ -1,2 +1,3 @@
 module Admin::PreferencesHelper
+
 end

data/app/helpers/admin/references_helper.rb

@@ -1,6 +1,6 @@
 module Admin::ReferencesHelper
   def tag_reference
-    returning String.new do |output|
+    String.new.tap do |output|
       class_of_page.tag_descriptions.sort.each do |tag_name, description|
         value = t("desc.#{tag_name.gsub(':','-')}").match('desc') ? description : t("desc.#{tag_name.gsub(':','-')}")
         output << render(:partial => "admin/references/tag_reference.haml", 
@@ -34,8 +34,7 @@ module Admin::ReferencesHelper
   
   def filter
     @filter ||= begin
-      filter_name = params[:filter_name]
-      (filter_name.gsub(" ", "") + "Filter").constantize unless filter_name.blank?
+      TextFilter.find_descendant(params[:filter_name])
     end
   end
 

data/app/helpers/application_helper.rb

@@ -1,7 +1,6 @@
 module ApplicationHelper
   include LocalTime
   include Admin::RegionsHelper
-  include Radiant::LegacyRoutes
   
   def config
     Radiant::Config
@@ -158,7 +157,7 @@ module ApplicationHelper
   end
   
   def filter_options_for_select(selected=nil)
-    options_for_select([[t('select.none'), '']] + TextFilter.descendants.map { |s| s.filter_name }.sort, selected)
+    options_for_select([[t('select.none'), '']] + TextFilter.descendants_names, selected)
   end
   
   def body_classes
@@ -228,7 +227,9 @@ module ApplicationHelper
       depagination_limit = options.delete(:max_per_page)                           # supply :max_per_page => false to include the 'show all' link no matter how large the collection
       html = will_paginate(list, will_paginate_options.merge(options))
       if depaginate && list.total_pages > 1 && (!depagination_limit.blank? || list.total_entries <= depagination_limit.to_i)
-        html << content_tag(:div, link_to("show all", :pp => list.total_entries), :class => 'depaginate')
+        html << content_tag(:div, link_to(t('show_all'), :pp => 'all'), :class => 'depaginate')
+      elsif depaginate && list.total_entries > depagination_limit.to_i
+        html = content_tag(:div, link_to("paginate", :p => 1), :class => 'pagination')
       end
       html
     end

data/app/models/deprecated_tags.rb

@@ -0,0 +1,77 @@
+module DeprecatedTags
+  include Radiant::Taggable
+
+  desc %{
+    This is deprecated and will be removed. Plase use @<r:hide>@
+    Nothing inside a set of comment tags is rendered.
+
+    *Usage:*
+
+    <pre><code><r:comment>...</r:comment></code></pre>
+  }
+  tag 'comment' do |tag|
+    ActiveSupport::Deprecation.warn("the <r:comment> tag is no longer encouraged in Radiant 0.9.2+; use <r:hide> instead.", caller)
+  end
+
+  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:meta [tag="false"] />
+     <r:meta>
+       <r:description [tag="false"] />
+       <r:keywords [tag="false"] />
+     </r:meta>
+    </code></pre>
+  }
+  tag 'meta' do |tag|
+    ActiveSupport::Deprecation.warn("r:meta is deprecated. Please use r:field name='field_name' instead.", caller)
+    if tag.double?
+      tag.expand
+    else
+      tag.render('description', tag.attr) +
+      tag.render('keywords', tag.attr)
+    end
+  end
+
+  desc %{
+    Emits the page description field in a meta tag, unless attribute
+    'tag' is set to 'false'.
+
+    *Usage:*
+
+    <pre><code> <r:meta:description [tag="false"] /> </code></pre>
+  }
+  tag 'meta:description' do |tag|
+    ActiveSupport::Deprecation.warn('r:meta:description is deprecated. Please use r:field name="Description" instead.', caller)
+    show_tag = tag.attr['tag'] != 'false' || false
+    description = CGI.escapeHTML(tag.locals.page.field(:description).try(:content))
+    if show_tag
+      "<meta name=\"description\" content=\"#{description}\" />"
+    else
+      description
+    end
+  end
+
+  desc %{
+    Emits the page keywords field in a meta tag, unless attribute
+    'tag' is set to 'false'.
+
+    *Usage:*
+
+    <pre><code> <r:meta:keywords [tag="false"] /> </code></pre>
+  }
+  tag 'meta:keywords' do |tag|
+    ActiveSupport::Deprecation.warn('r:meta:keywords is deprecated. Please use r:field name="Keywords" instead.', caller)
+    show_tag = tag.attr['tag'] != 'false' || false
+    keywords = CGI.escapeHTML(tag.locals.page.field(:keywords).try(:content))
+    if show_tag
+      "<meta name=\"keywords\" content=\"#{keywords}\" />"
+    else
+      keywords
+    end
+  end
+  
+end

data/app/models/file_not_found_page.rb

@@ -1,5 +1,9 @@
 class FileNotFoundPage < Page
   
+  def allowed_children
+    []
+  end
+  
   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.

data/app/models/page.rb

@@ -11,6 +11,8 @@ class Page < ActiveRecord::Base
   acts_as_tree :order => 'virtual DESC, title ASC'
   has_many :parts, :class_name => 'PagePart', :order => 'id', :dependent => :destroy
   accepts_nested_attributes_for :parts, :allow_destroy => true
+  has_many :fields, :class_name => 'PageField', :order => 'id', :dependent => :destroy
+  accepts_nested_attributes_for :fields, :allow_destroy => true
   belongs_to :layout
   belongs_to :created_by, :class_name => 'User'
   belongs_to :updated_by, :class_name => 'User'
@@ -24,16 +26,20 @@ class Page < ActiveRecord::Base
 
   validates_format_of :slug, :with => %r{^([-_.A-Za-z0-9]*|/)$}
   validates_uniqueness_of :slug, :scope => :parent_id
-  validates_numericality_of :id, :status_id, :parent_id, :allow_nil => true, :only_integer => true
 
   validate :valid_class_name
 
   include Radiant::Taggable
   include StandardTags
+  include DeprecatedTags
   include Annotatable
 
   annotate :description
   attr_accessor :request, :response, :pagination_parameters
+  class_inheritable_accessor :in_menu
+  self.in_menu = true
+  class_inheritable_accessor :default_child
+  self.default_child = self
 
   set_inheritance_column :class_name
 
@@ -58,9 +64,10 @@ class Page < ActiveRecord::Base
     true
   end
 
-  def child_url(child)
-    clean_url(url + '/' + child.slug)
+  def child_path(child)
+    clean_path(path + '/' + child.slug)
   end
+  alias_method :child_url, :child_path
 
   def headers
     # Return a blank hash that child classes can override or merge
@@ -87,10 +94,22 @@ class Page < ActiveRecord::Base
     !has_part?(name) && self.ancestors.any? { |page| page.has_part?(name) }
   end
 
+  def field(name)
+    if new_record? or fields.any?(&:new_record?)
+      fields.detect { |f| f.name.downcase == name.to_s.downcase }
+    else
+      fields.find_by_name name.to_s
+    end
+  end
+
   def published?
     status == Status[:published]
   end
   
+  def scheduled?
+    status == Status[:scheduled]
+  end
+  
   def status
    Status.find(self.status_id)
   end
@@ -99,13 +118,14 @@ class Page < ActiveRecord::Base
     self.status_id = value.id
   end
 
-  def url
+  def path
     if parent?
-      parent.child_url(self)
+      parent.child_path(self)
     else
-      clean_url(slug)
+      clean_path(slug)
     end
   end
+  alias_method :url, :path
 
   def process(request, response)
     @request, @response = request, response
@@ -143,20 +163,20 @@ class Page < ActiveRecord::Base
     parse_object(snippet)
   end
 
-  def find_by_url(url, live = true, clean = true)
+  def find_by_path(path, live = true, clean = true)
     return nil if virtual?
-    url = clean_url(url) if clean
-    my_url = self.url
-    if (my_url == url) && (not live or published?)
+    path = clean_path(path) if clean
+    my_path = self.path
+    if (my_path == path) && (not live or published?)
       self
-    elsif (url =~ /^#{Regexp.quote(my_url)}([^\/]*)/)
+    elsif (path =~ /^#{Regexp.quote(my_path)}([^\/]*)/)
       slug_child = children.find_by_slug($1)
       if slug_child
-        found = slug_child.find_by_url(url, live, clean)
+        found = slug_child.find_by_url(path, live, clean) # TODO: set to find_by_path after deprecation
         return found if found
       end
       children.each do |child|
-        found = child.find_by_url(url, live, clean)
+        found = child.find_by_url(path, live, clean) # TODO: set to find_by_path after deprecation
         return found if found
       end
       file_not_found_types = ([FileNotFoundPage] + FileNotFoundPage.descendants)
@@ -166,13 +186,14 @@ class Page < ActiveRecord::Base
       children.find(:first, :conditions => [condition] + file_not_found_names)
     end
   end
+  alias_method :find_by_url, :find_by_path
 
   def update_status
-    self[:published_at] = Time.now if self[:status_id] == Status[:published].id && self[:published_at] == nil
+    self.published_at = Time.zone.now if published? && self.published_at == nil
     
-    if self[:published_at] != nil && (self[:status_id] == Status[:published].id || self[:status_id] == Status[:scheduled].id)
-      self[:status_id] = Status[:scheduled].id if self[:published_at]  > Time.now
-      self[:status_id] = Status[:published].id if self[:published_at] <= Time.now
+    if self.published_at != nil && (published? || scheduled?)
+      self[:status_id] = Status[:scheduled].id if self.published_at  > Time.zone.now
+      self[:status_id] = Status[:published].id if self.published_at <= Time.zone.now
     end
 
     true    
@@ -183,11 +204,31 @@ class Page < ActiveRecord::Base
     super(options.reverse_merge(:include => :parts), &block)
   end
 
+  def default_child
+    self.class.default_child
+  end
+
+  def allowed_children
+    [default_child, *Page.descendants.sort_by(&:name)].select(&:in_menu?)
+  end
+
+
   class << self
-    def find_by_url(url, live = true)
+    alias_method :in_menu?, :in_menu
+    alias_method :in_menu, :in_menu=
+
+    def find_by_path(path, live = true)
       root = find_by_parent_id(nil)
       raise MissingRootPageError unless root
-      root.find_by_url(url, live)
+      root.find_by_path(path, live)
+    end
+    def find_by_url(*args)
+      ActiveSupport::Deprecation.warn("`find_by_url' has been deprecated; use `find_by_path' instead.", caller)
+      find_by_path(*args)
+    end
+
+    def date_column_names
+      self.columns.collect{|c| c.name if c.sql_type =~ /(date|time)/}.compact
     end
 
     def display_name(string = nil)
@@ -204,6 +245,7 @@ class Page < ActiveRecord::Base
       @display_name = @display_name + " - not installed" if missing? && @display_name !~ /not installed/
       @display_name
     end
+    
     def display_name=(string)
       display_name(string)
     end
@@ -219,7 +261,7 @@ class Page < ActiveRecord::Base
           begin
             p.constantize
           rescue NameError, LoadError
-            eval(%Q{class #{p} < Page; def self.missing?; true end end}, TOPLEVEL_BINDING)
+            eval(%Q{class #{p} < Page; acts_as_tree; def self.missing?; true end end}, TOPLEVEL_BINDING)
           end
         end
       end
@@ -228,6 +270,7 @@ class Page < ActiveRecord::Base
     def new_with_defaults(config = Radiant::Config)
       page = new
       page.parts.concat default_page_parts(config)
+      page.fields.concat default_page_fields(config)
       default_status = config['defaults.page.status']
       page.status = Status[default_status] if default_status
       page
@@ -258,6 +301,13 @@ class Page < ActiveRecord::Base
           PagePart.new(:name => name, :filter_id => config['defaults.page.filter'])
         end
       end
+
+      def default_page_fields(config = Radiant::Config)
+        default_fields = config['defaults.page.fields'].to_s.strip.split(/\s*,\s*/)
+        default_fields.map do |name|
+          PageField.new(:name => name)
+        end
+      end
   end
 
   private
@@ -282,9 +332,10 @@ class Page < ActiveRecord::Base
       true
     end
 
-    def clean_url(url)
-      "/#{ url.strip }/".gsub(%r{//+}, '/')
+    def clean_path(path)
+      "/#{ path.to_s.strip }/".gsub(%r{//+}, '/')
     end
+    alias_method :clean_url, :clean_path
 
     def parent?
       !parent.nil?
@@ -303,10 +354,10 @@ class Page < ActiveRecord::Base
     end
 
     def parse_object(object)
-      text = object.content
+      text = object.content || ''
       text = parse(text)
       text = object.filter.filter(text) if object.respond_to? :filter_id
       text
     end
 
-end
+end

data/app/models/page_field.rb

@@ -0,0 +1,3 @@
+class PageField < ActiveRecord::Base
+  validates_presence_of :name
+end

data/app/models/page_part.rb

@@ -10,7 +10,6 @@ class PagePart < ActiveRecord::Base
   validates_presence_of :name
   validates_length_of :name, :maximum => 100
   validates_length_of :filter_id, :maximum => 25, :allow_nil => true
-  validates_numericality_of :id, :page_id, :allow_nil => true, :only_integer => true
   
   object_id_attr :filter, TextFilter
 

data/app/models/radiant/config.rb

@@ -1,37 +1,78 @@
 module Radiant
-  #
-  # 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 << self
+    def config_definitions
+      @config_definitions ||= {}
+    end
+
+    def config_definitions=(definitions)
+      @config_definitions = definitions
+    end
+  end
+
   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
+    # defaults.snippet.filter   :: the default filter to use on new snippets
+    # 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?
@@ -46,12 +87,11 @@ module Radiant
 
       def []=(key, value)
         if table_exists?
-          pair = find_or_initialize_by_key(key)
-          pair.update_attributes(:value => value)
-          value
+          setting = find_or_initialize_by_key(key)
+          setting.value = value
         end
       end
-
+      
       def to_hash
         Hash[ *find(:all).map { |pair| [pair.key, pair.value] }.flatten ]
       end
@@ -83,22 +123,183 @@ module Radiant
       def cache_file
         cache_file = File.join(cache_path,'radiant_config_cache.txt')
       end
-    end
+      
+      def site_settings
+        @site_settings ||= %w{ site.title site.host dev.host local.timezone }
+      end
+      
+      def default_settings
+        @default_settings ||= %w{ defaults.locale defaults.page.filter defaults.page.parts defaults.page.fields defaults.page.status defaults.snippet.filter }
+      end
+      
+      def user_settings
+        @user_settings ||= ['user.allow_password_reset?']
+      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, "Duplicate config definition for '#{key}'. Are you loading something twice?" 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 RecordInvalid if you 
+    # set a value that is not among those permitted.
+    #
     def value=(param)
-      self[:value] = param.to_s
+      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]
     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 key.ends_with? "?"
-        self[:value] == "true"
+      if boolean?
+        checked?
       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