trusty-cms 1.0.0

data/app/models/deprecated_tags.rb

@@ -0,0 +1,42 @@
+require 'trusty_cms/taggable'
+module DeprecatedTags
+  include TrustyCms::Taggable
+
+  deprecated_tag "comment", :substitute => "hide", :deadline => '2.0'
+
+  deprecated_tag "meta", :deadline => '2.0' do |tag|
+    if tag.double?
+      tag.expand
+    else
+      tag.render('description', tag.attr) + tag.render('keywords', tag.attr)
+    end
+  end
+
+  deprecated_tag 'meta:description', :deadline => '2.0' do |tag|
+    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
+
+  deprecated_tag 'meta:keywords', :deadline => '2.0' do |tag|
+    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
+
+  deprecated_tag "rfc1123_date", :deadline => '2.0' do |tag|
+    page = tag.locals.page
+    if date = page.published_at || page.created_at
+      CGI.rfc1123_date(date.to_time)
+    end
+  end
+  
+end

data/app/models/file_not_found_page.rb

@@ -0,0 +1,32 @@
+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.
+    
+    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 |tag|
+    CGI.escapeHTML(request.request_uri) unless request.nil?
+  end
+   
+  def virtual?
+    true
+  end
+   
+  def response_code
+    404
+  end
+  
+  def cache?
+    false
+  end
+  
+end

data/app/models/layout.rb

@@ -0,0 +1,15 @@
+class Layout < ActiveRecord::Base
+  
+  # Default Order
+  default_scope :order => "name"
+
+  # Associations
+  has_many :pages
+  belongs_to :created_by, :class_name => 'User'
+  belongs_to :updated_by, :class_name => 'User'
+
+  # Validations
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  validates_length_of :name, :maximum => 100
+end

data/app/models/menu_renderer.rb

@@ -0,0 +1,140 @@
+module MenuRenderer
+
+  def exclude(*type_names)
+    @excluded_class_names ||= []
+    @excluded_class_names.concat(type_names).uniq!
+  end
+  module_function :exclude
+
+  def excluded_class_names
+    MenuRenderer.instance_variable_get(:@excluded_class_names)
+  end
+
+  module_function :excluded_class_names
+  public :excluded_class_names
+
+  def view=(val)
+    @view = val
+  end
+
+  def view
+    @view
+  end
+
+  def additional_menu_features?
+    @additional_menu_features ||= (menu_renderer_module_name != 'MenuRenderer' && Object.const_defined?(menu_renderer_module_name))
+  end
+
+  def menu_renderer_module_name
+    simple_name = self.class_name.to_s.sub('Page','')
+    "#{simple_name}MenuRenderer"
+  end
+
+  def menu_renderer_modules
+    [Object.const_get(menu_renderer_module_name)]
+  end
+
+  def allowed_child_classes
+    (allowed_children_cache.to_s.split(',') - Array(excluded_class_names)).map do |name|
+      begin
+        name.constantize
+      rescue LoadError, NameError => e
+        nil
+      end
+    end.compact
+  end
+
+
+  def default_child_item
+    menu_item(default_child)
+  end
+
+  def separator_item
+    view.content_tag :li, '', :class => 'separator'
+  end
+
+  def child_items
+    (allowed_child_classes - [self.class.default_child]).map do |child|
+      menu_item(child)
+    end
+  end
+
+  def menu_items
+    [default_child_item, separator_item] + child_items
+  end
+
+  def menu_list
+    view.content_tag :ul, menu_items.join, :class => 'menu', :id => "allowed_children_#{id}"
+  end
+
+  def remove_link
+    view.link_to view.image('minus') + ' ' + I18n.t('remove'), view.remove_admin_page_url(self), :class => "action"
+  end
+
+  def remove_option
+    remove_link
+  end
+
+  def add_child_disabled?
+    allowed_child_classes.size == 0
+  end
+
+  def disabled_add_child_link
+    view.content_tag :span, view.image('plus_disabled') + ' ' + I18n.t('add_child'), :class => 'action disabled'
+  end
+
+  def add_child_link
+    view.link_to((view.image('plus') + ' ' + I18n.t('add_child')), view.new_admin_page_child_path(self, :page_class => default_child.name), :class => "action")
+  end
+
+  def add_child_link_with_menu_hook
+    view.link_to((view.image('plus') + ' ' + I18n.t('add_child')), "#allowed_children_#{id}", :class => "action dropdown")
+  end
+
+  def add_child_menu
+    menu_list
+  end
+
+  def add_child_link_with_menu
+    add_child_link_with_menu_hook + add_child_menu
+  end
+
+  def add_child_option
+    if add_child_disabled?
+      disabled_add_child_link
+    else
+      if allowed_child_classes.size == 1
+        add_child_link
+      else
+        add_child_link_with_menu
+      end
+    end
+  end
+
+  private
+
+  def clean_page_description(page_class)
+    page_class.description.to_s.strip.gsub(/\t/,'').gsub(/\s+/,' ')
+  end
+
+  def menu_item(child_class)
+    view.content_tag(:li, menu_link(child_class))
+  end
+
+  def menu_link(child_class)
+    title = clean_page_description(child_class)
+    path = view.new_admin_page_child_path(self, :page_class => child_class.name)
+    text = link_text_for_child_class(child_class.name)
+    view.link_to(text, path, :title => title)
+  end
+  
+  def link_text_for_child_class(given_class_name)
+    translation_key = if given_class_name == 'Page' || given_class_name.blank?
+      'normal_page'
+    else
+      given_class_name.sub('Page','').underscore
+    end
+    fallback = given_class_name == 'Page' ? 'Page' : given_class_name.sub('Page','').titleize
+    I18n.t(translation_key, :default => fallback)
+  end
+end

data/app/models/page.rb

@@ -0,0 +1,377 @@
+require 'acts_as_tree'
+
+class Page < ActiveRecord::Base
+
+  class MissingRootPageError < StandardError
+    def initialize(message = 'Database missing root page'); super end
+  end
+
+  # Callbacks
+  before_save :update_virtual, :update_status, :set_allowed_children_cache
+
+  # Associations
+  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'
+
+  # Validations
+  validates_presence_of :title, :slug, :breadcrumb, :status_id
+
+  validates_length_of :title, :maximum => 255
+  validates_length_of :slug, :maximum => 100
+  validates_length_of :breadcrumb, :maximum => 160
+
+  validates_format_of :slug, :with => %r{^([-_.A-Za-z0-9]*|/)$}
+  validates_uniqueness_of :slug, :scope => :parent_id
+
+  validate :valid_class_name
+
+  include TrustyCms::Taggable
+  include StandardTags
+  include DeprecatedTags
+  include Annotatable
+
+  annotate :description
+  attr_accessor :request, :response, :pagination_parameters
+  class_attribute :default_child
+  self.default_child = self
+
+  set_inheritance_column :class_name
+
+  def layout_with_inheritance
+    unless layout_without_inheritance
+      parent.layout if parent?
+    else
+      layout_without_inheritance
+    end
+  end
+  alias_method_chain :layout, :inheritance
+
+  def description
+    self["description"]
+  end
+
+  def description=(value)
+    self["description"] = value
+  end
+
+  def cache?
+    true
+  end
+
+  def child_path(child)
+    clean_path(path + '/' + child.slug)
+  end
+  alias_method :child_url, :child_path
+
+  def part(name)
+    if new_record? or parts.to_a.any?(&:new_record?)
+      parts.to_a.find {|p| p.name == name.to_s }
+    else
+      parts.find_by_name name.to_s
+    end
+  end
+
+  def has_part?(name)
+    !part(name).nil?
+  end
+
+  def has_or_inherits_part?(name)
+    has_part?(name) || inherits_part?(name)
+  end
+
+  def inherits_part?(name)
+    !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
+  
+  def status=(value)
+    self.status_id = value.id
+  end
+
+  def path
+    if parent?
+      parent.child_path(self)
+    else
+      clean_path(slug)
+    end
+  end
+  alias_method :url, :path
+
+  def process(request, response)
+    @request, @response = request, response
+    set_response_headers(@response)
+    @response.body = render
+    @response.status = response_code
+  end
+
+  def headers
+    # Return a blank hash that child classes can override or merge
+    { }
+  end
+
+  def set_response_headers(response)
+    set_content_type(response)
+    headers.each { |k,v| response.headers[k] = v }
+  end
+  private :set_response_headers
+
+  def set_content_type(response)
+    if layout
+      content_type = layout.content_type.to_s.strip
+      if content_type.present?
+        response.headers['Content-Type'] = content_type
+      end
+    end
+  end
+  private :set_content_type
+
+  def response_code
+    200
+  end
+
+  def render
+    if layout
+      parse_object(layout)
+    else
+      render_part(:body)
+    end
+  end
+
+  def render_part(part_name)
+    part = part(part_name)
+    if part
+      parse_object(part)
+    else
+      ''
+    end
+  end
+
+  def render_snippet(snippet)
+    parse_object(snippet)
+  end
+
+  def find_by_path(path, live = true, clean = true)
+    return nil if virtual?
+    path = clean_path(path) if clean
+    my_path = self.path
+    if (my_path == path) && (not live or published?)
+      self
+    elsif (path =~ /^#{Regexp.quote(my_path)}([^\/]*)/)
+      slug_child = children.find_by_slug($1)
+      if slug_child
+        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(path, live, clean) # TODO: set to find_by_path after deprecation
+        return found if found
+      end
+      file_not_found_types = ([FileNotFoundPage] + FileNotFoundPage.descendants)
+      file_not_found_names = file_not_found_types.collect { |x| x.name }
+      condition = (['class_name = ?'] * file_not_found_names.length).join(' or ')
+      condition = "status_id = #{Status[:published].id} and (#{condition})" if live
+      children.where([condition] + file_not_found_names).first
+    end
+  end
+  alias_method :find_by_url, :find_by_path
+
+  def update_status
+    self.published_at = Time.zone.now if published? && self.published_at == nil
+    
+    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    
+  end
+
+  def to_xml(options={}, &block)
+    super(options.reverse_merge(:include => :parts), &block)
+  end
+
+  def default_child
+    self.class.default_child
+  end
+
+  def allowed_children_lookup
+    [default_child, *Page.descendants.sort_by(&:name)].uniq
+  end
+
+  def set_allowed_children_cache
+    self.allowed_children_cache = allowed_children_lookup.collect(&:name).join(',')
+  end
+
+  class << self
+
+    def root
+      find_by_parent_id(nil)
+    end
+
+    def find_by_path(path, live = true)
+      raise MissingRootPageError unless root
+      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)
+      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
+      @display_name = @display_name + " - not installed" if missing? && @display_name !~ /not installed/
+      @display_name
+    end
+    
+    def display_name=(string)
+      display_name(string)
+    end
+
+    def load_subclasses
+      ([TRUSTY_CMS_ROOT] + TrustyCms::Extension.descendants.map(&:root)).each do |path|
+        Dir["#{path}/app/models/*_page.rb"].each do |page|
+          $1.camelize.constantize if page =~ %r{/([^/]+)\.rb}
+        end
+      end
+      if ActiveRecord::Base.connection.tables.include?('pages') && Page.column_names.include?('class_name') # Assume that we have bootstrapped
+        Page.connection.select_values("SELECT DISTINCT class_name FROM pages WHERE class_name <> '' AND class_name IS NOT NULL").each do |p|
+          begin
+            p.constantize
+          rescue NameError, LoadError
+            eval(%Q{class #{p} < Page; acts_as_tree; def self.missing?; true end end}, TOPLEVEL_BINDING)
+          end
+        end
+      end
+    end
+
+    def new_with_defaults(config = TrustyCms::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
+    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
+
+    def missing?
+      false
+    end
+
+    private
+
+      def default_page_parts(config = TrustyCms::Config)
+        default_parts = config['defaults.page.parts'].to_s.strip.split(/\s*,\s*/)
+        default_parts.map do |name|
+          PagePart.new(:name => name, :filter_id => config['defaults.page.filter'])
+        end
+      end
+
+      def default_page_fields(config = TrustyCms::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
+
+    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_virtual
+      unless self.class == Page.descendant_class(class_name)
+        self.virtual = Page.descendant_class(class_name).new.virtual?
+      else
+        self.virtual = virtual?
+      end
+      true
+    end
+
+    def clean_path(path)
+      "/#{ path.to_s.strip }/".gsub(%r{//+}, '/')
+    end
+    alias_method :clean_url, :clean_path
+
+    def parent?
+      !parent.nil?
+    end
+
+    def lazy_initialize_parser_and_context
+      unless @parser and @context
+        @context = PageContext.new(self)
+        @parser = Radius::Parser.new(@context, :tag_prefix => 'r')
+      end
+      @parser
+    end
+
+    def parse(text)
+      lazy_initialize_parser_and_context.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
+
+end

data/app/models/page_context.rb

@@ -0,0 +1,53 @@
+class PageContext < Radius::Context
+  
+  attr_reader :page
+  
+  def initialize(page)
+    super
+    @page = page
+    globals.page = @page
+    page.tags.each do |name|
+      define_tag(name) { |tag_binding| page.render_tag(name, tag_binding) }
+    end
+  end
+  
+  def dup
+    rv = self.class.new(page)
+    rv.globals = globals.dup
+    rv.definitions = definitions.dup
+    rv
+  end
+ 
+  def render_tag(name, attributes = {}, &block)
+    binding = @tag_binding_stack.last
+    locals = binding ? binding.locals : globals
+    set_process_variables(locals.page)
+    super
+  rescue Exception => e
+    raise e if raise_errors?
+    @tag_binding_stack.pop unless @tag_binding_stack.last == binding
+    render_error_message(e.message)
+  end
+  
+  def tag_missing(name, attributes = {}, &block)
+    super
+  rescue Radius::UndefinedTagError => e
+    raise StandardTags::TagError.new(e.message)
+  end
+  
+  private
+  
+    def render_error_message(message)
+      "<div><strong>#{message}</strong></div>"
+    end
+    
+    def set_process_variables(page)
+      page.request ||= @page.request
+      page.response ||= @page.response
+    end
+    
+    def raise_errors?
+      Rails.env != 'production'
+    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

@@ -0,0 +1,20 @@
+class PagePart < ActiveRecord::Base
+  
+  # Default Order
+  default_scope :order => 'name'
+  
+  # Associations
+  belongs_to :page
+  
+  # Validations
+  validates_presence_of :name
+  validates_length_of :name, :maximum => 100
+  validates_length_of :filter_id, :maximum => 25, :allow_nil => true
+  
+  object_id_attr :filter, TextFilter
+
+  def after_initialize
+    self.filter_id ||= TrustyCms::Config['defaults.page.filter'] if new_record?
+  end
+
+end