page_engine 0.0.1

data/app/controllers/pages_controller.rb

@@ -0,0 +1,20 @@
+class PagesController < ApplicationController
+
+  def index
+    # Find the first published root page
+    @pages = Page.published.shown_in_sitemap.all.group_by(&:parent_id)
+  end
+  
+  def show
+    if @page
+      respond_to do |format|
+        format.html # show.html.erb
+        format.xml  { render :xml => @page }
+      end
+    else
+      raise ActiveRecord::RecordNotFound
+    end
+  end
+
+end
+

data/app/helpers/pages_helper.rb

@@ -0,0 +1,234 @@
+module PagesHelper  
+
+  # Set the page title 
+  def page_title(default_text)
+    if @page
+      replace_title_for(@page)
+    else
+      default_text
+    end
+  end
+  
+  def page_js(options={})
+    default_options = {
+      'with_tags' => true
+    }.merge(options.stringify_keys)
+    
+    if default_options['with_tags']
+      if @page && !@page.js.blank?
+        javascript_tag do 
+          @page.js
+        end
+      end
+    else
+      @page.js
+    end
+  end
+  
+  def page_css(options={})
+    default_options = {
+      'with_tags' => true
+    }.merge(options.stringify_keys)
+  
+    if default_options['with_tags']
+      if @page && !@page.css.blank?
+        content_tag :style do
+          @page.css
+        end
+      end
+    else
+      @page.css
+    end
+  end
+  
+  def page_meta_keywords
+    if @page && !@page.meta_keywords.blank?
+      content_tag :meta, :name => 'keywords' do 
+        @page.meta_keywords
+      end
+    end
+  end
+  
+  def page_meta_description
+    if @page && !@page.meta_description.blank?
+      content_tag :meta, :name => 'description' do 
+        @page.meta_description
+      end
+    end
+  end
+  
+  # Usage:
+  # You can use the attributes of any instance variables and insert them in the title
+  # For example:
+  #   This is a page for {{my_object:my_object_attribute}}
+  # Requires that any object that will be used have a public whitelist method which returns an array 
+  # of legal attributes (as this can be set by a user certain attributes should not be exposed)
+  def replace_title_for(page)
+    return nil unless page
+    page.title.scan(/\{\{(\w+):(\w+)\}\}/).uniq.flatten.in_groups_of(2).each do |klass, attribute|
+      if self.instance_variable_defined? "@#{klass}"
+        obj = self.instance_variable_get "@#{klass}"
+        if obj.class.public_methods.include?(:whitelist) && obj.class.whitelist.is_a?(Array)
+          if obj.class.whitelist.include?(attribute)
+            page.title.gsub!("{{#{klass}:#{attribute}}}", obj.send(attribute).to_s)  
+          else
+            page.title.gsub!("{{#{klass}:#{attribute}}}", "'#{attribute}' not in whitelist for #{obj.class}")
+          end 
+        else
+          page.title.gsub!("{{#{klass}:#{attribute}}}", "Whitelist not defined for #{obj.class}")
+        end   
+      else
+        page.title.gsub!("{{#{klass}:#{attribute}}}", "Not found")     
+      end 
+    end
+    
+    page.title
+  end
+  
+  # Add extra fields for an object in a form, in this case page parts
+  def link_to_add_fields(name, f, association)
+    new_object = f.object.class.reflect_on_association(association).klass.new
+    fields = simple_fields_for(association, new_object, :child_index => "new_#{association}") do |builder|
+      safe_concat(render(association.to_s.singularize + "_fields", :f => builder))
+    end
+    
+    link_to('Add', '#', :onclick => "add_fields(this, \"#{association}\", \"#{escape_javascript(fields)}\")", :class => 'icon add')
+  end  
+  
+  # Return the specified page part content
+  def page_content(options={})
+    default_options = {
+      'page' => @page,
+      'part' => 'body'
+    }.merge!(options.stringify_keys)
+    
+    default_options['page'].page_parts.detect { |p| p.title == default_options['part'].to_s } if default_options['page']
+  end
+  
+  def page_snippet(name, options={})
+    default_options = {
+      'default_text' => 'Page snippet not found',
+      'tag' => nil,
+      'class' => ['page_snippet'],
+      'id' => nil
+    }.merge(options.stringify_keys)
+  
+    page_snippet = PageSnippet.find_by_name(name.to_s)
+    
+    if default_options['tag']
+      content_tag default_options['tag'], :class => default_options['class'], :id => default_options['id'] do 
+        page_snippet ? page_snippet : default_options['default_text']
+      end
+    else
+      page_snippet ? page_snippet : default_options['default_text']
+    end
+  end
+
+  def link_to_page(page, options={})
+    # Arbitrarily chosen url to take precedence over controller and action
+    if page.url.blank?
+      if page.controller.blank? && page.action.blank?
+        link_to replace_title_for(page), "/#{page.permalink}", options
+      else
+        link_to replace_title_for(page), url_for(:controller => '/' + page.controller, :action => page.action), options
+      end
+    else
+      link_to replace_title_for(page), page.url, options
+    end
+  end
+
+  # Takes an array of pages which constitute the ancestors of the current page (page) and displays them in the requested format
+  # Options:
+  # * seperator: The text or character that will seperate the breadcrumbs. Defaults to " » "
+  # * format: choices are "ul" or "inline". "ul" displays the breadcrumb links in an unordered list whilst "inline" displays them inline in a containing div. Defaults to "ul"
+  def breadcrumbs(options={})
+    default_options = {
+      'breadcrumbs' => @breadcrumbs,
+      'page' => @page,
+      'seperator' => ' » ',
+      'format' => 'ul'
+    }.merge!(options.stringify_keys)
+
+    case default_options['format'].to_s
+      when 'inline'
+        content_tag :div, :class => 'breadcrumbs' do
+          links = default_options['breadcrumbs'].collect.with_index { |breadcrumb, i| link_to_page(breadcrumb, :class => "crumb_#{i}") + default_options['seperator'].html_safe }.join().html_safe
+          links += content_tag(:span, replace_title_for(default_options['page']), :class => 'current_page') if default_options['page']
+        end
+        
+      when 'ul'
+        content_tag :ul, :class => 'breadcrumbs' do
+          links = default_options['breadcrumbs'].collect.with_index { |breadcrumb, i| content_tag(:li, link_to_page(breadcrumb, :class => "crumb_#{i}")) }.join().html_safe
+          links += content_tag(:li, replace_title_for(default_options['page']), :class => 'current_page') if default_options['page']
+        end
+        
+      else
+        'Please choose one of \'inline\' or \'ul\' as a format'
+    end
+  end
+
+  # Options:
+  # * current: The current_page if not @page
+  # * depth: The number of levels in the tree to traverse. Defaults to 2
+  # * class: The class of the containing ul. Defaults to ""
+  # * id: The id of the containing id. Defaults to ""
+  # * link_current: Set to true if the current page should have a link. Defaults to false
+  def navigation(permalink, options={})
+    default_options = {
+      'current' => @page,
+      'class' => 'nav', 
+      'id' => '',
+      'include_root' => false,
+      'link_current' => false,
+      'depth' => 2
+    }.merge!(options.stringify_keys)
+
+    current_user = nil unless defined?(current_user)
+
+    root_page = Page.published_or_hidden.viewable_by(current_user)
+    
+    if permalink
+      root_page = root_page.find_by_permalink(permalink.to_s)
+    else
+      root_page = root_page.first
+    end
+    
+    return "<p><em>Error:</em> Root page not found</p>".html_safe unless root_page
+
+    grouped_pages = root_page.self_and_descendants.viewable_by(current_user).shown_in_menu.published.group_by(&:parent_id)
+
+    render 'pages/navigation', :options => default_options, :root_page => root_page, :grouped_pages => grouped_pages, :level => 1
+  end
+  
+  def filter_select(target, options={})
+    default_options = {
+      'builder' => nil,
+      'object' => nil,
+      'attribute' => nil  
+    }.merge!(options.stringify_keys)
+    
+    if default_options['builder']
+      default_options['builder'].select(default_options['attribute'], Page.filters, {}, { :class => 'filter', :rel => target })
+    else
+      select_tag(default_options['object'], default_options['attribute'], Page.filters, {}, { :class => 'filter', :rel => target })
+    end
+  end
+
+  private
+
+    # To add a class to the root of the tree that the current page appears in
+    def mark_as_root_of_current? page
+      if page.root?
+        page == @page
+      else
+        return true if @breadcrumbs.include?(page) || page == @page
+      end
+    end
+
+    def page_menu_class page
+      css_classes = []
+      css_classes << page.menu_css_class unless page.menu_css_class.blank?
+      css_classes << "selected" if mark_as_root_of_current?(page)
+    end
+end
+

data/app/models/page.rb

@@ -0,0 +1,233 @@
+class Page < ActiveRecord::Base
+  acts_as_nested_set
+
+  # Relationships
+#  has_many :descendants, :class_name => "Page", :conditions => proc { "pages.lft between #{self.send(:lft)} and #{self.send(:rgt)}" }
+#  has_many :ancestors, :class_name => "Page", :conditions => proc { "(pages.lft <= #{self.send(:lft)} AND pages.rgt >= #{self.send(:rgt)}) AND (pages.id != #{self.send(:id)})" }, :foreign_key => false
+  has_many :pages, :foreign_key => :parent_id
+  has_many :page_parts, :dependent => :destroy
+  
+  if PageEngine.class_exists?('Role')
+    has_many :page_roles
+    has_many :required_roles, :through => :page_roles, :source => :required_role
+    has_many :excluded_roles, :through => :page_roles, :source => :excluded_role
+  end
+  
+  if PageEngine.class_exists?('Asset')
+    has_assets
+  end
+  
+  if PageEngine.class_exists?('User')
+    belongs_to :user
+  end
+  
+  accepts_nested_attributes_for :page_parts, :allow_destroy => true
+
+  # Filters
+  before_validation :set_permalink
+  before_save :check_publish_window
+  before_save :set_controller_and_action
+
+  # Validations
+  validates :title, :presence => true
+  validates :permalink, :presence => true, :uniqueness => true, :format => { :with => /^[a-z0-9-]+$/, :message => "Must only contain lower case letters, numbers or hyphens" }
+  validates :url, :uniqueness => true, :allow_nil => true, :allow_blank => true
+  validates_associated :page_parts
+
+  # Scopes
+  scope :by_permalink, lambda { |permalink| where(:permalink => permalink) }
+  scope :published, lambda { where(["(status = 'Published' and ? between publish_from and publish_to) or (status = 'Published' and publish_from is null and publish_to is null)", DateTime.now]) }
+  scope :published_or_hidden, lambda { where(["(status = 'Published' and ? between publish_from and publish_to) or (status = 'Published' and publish_from is null and publish_to is null) or status = 'Hidden'", DateTime.now]) }
+  scope :root_only, where(:parent_id => nil)
+  scope :shown_in_sitemap, where({ :display_in_sitemap => true })
+  scope :shown_in_menu, where({ :display_in_menu => true })
+  scope :just_controller_and_actions, select("controller || '|' || action as taken").group('taken')
+
+  attr_accessor :no_publish_window, :controller_action  
+
+  def no_publish_window
+    no_publish_window_set?
+  end
+
+  def controller_action
+    if controller && action
+      "#{controller}|#{action}"
+    end
+  end
+
+  def no_publish_window_set?
+    self.publish_from.nil? && self.publish_to.nil?
+  end
+
+  def published?
+    if self.no_publish_window_set?
+      self.status == "Published"
+    else
+      self.publish_from < DateTime.now && self.publish_to > DateTime.now && self.status == "Published"
+    end
+  end
+
+  def to_param
+    permalink
+  end
+
+  def is_child_of? page
+    self.parent_id == page.id ? true : false
+  end
+
+  def is_parent_of? page
+    self.id == page.parent_id ? true : false
+  end
+
+  def number_of_children
+    (self.rgt - self.lft - 1) / 2
+  end
+
+  def duplicate
+    page = Page.new(self.attributes)
+    page.title += " (copy) #{Time.now.strftime('%Y%m%d_%H%M%S')}"
+    page.permalink = page.permalink + "-copy-#{Time.now.strftime('%Y%m%d-%H%M%S')}"
+    page.save
+    page.move_to_right_of self
+
+    # Duplicate each of the objects associated with the original
+    # Page parts
+    self.page_parts.each do |page_part|
+      page.page_parts << page_part.duplicate
+    end
+
+    # Roles
+    if PageEngine.class_exists?('Role')
+      page.required_roles = self.required_roles 
+      page.excluded_roles = self.excluded_roles
+    end
+
+    # Assets
+    if PageEngine.class_exists?('Asset')
+      self.attachables.each do |attachable|
+        page.attachables << attachable.duplicate
+      end
+    end
+
+    page
+  end
+
+  def is_viewable_by? user
+    if PageEngine.class_exists?('Role')
+      if PageEngine.class_exists?('User') && user
+        return true if self.roles.length == 0
+        self.role_ids.length != (self.role_ids - user.role_ids.uniq).length        
+      else
+        self.roles.length == 0
+      end
+    else
+      true
+    end
+  end
+
+  def move_children_to_parent
+    self.children.each do |child|
+      if self.parent
+        child.move_to_child_of self.parent
+      else
+        child.move_to_root
+      end
+    end
+    self.reload
+  end
+
+  def css_status
+    return "live" if self.published?
+    status.downcase
+  end
+  
+  # Override the protected methods of awesome_nested_set so lft and rgt can be set
+  def lft=(x)
+    self[:lft] = x    
+  end
+  
+  def rgt=(x)
+    self[:rgt] = x
+  end
+
+  class << self
+    attr_accessor :layouts
+    
+    def breadcrumbs_for user, url
+      root = Page.published.viewable_by(user).find_by_url(url)
+      root.nil? ? [] : root.self_and_ancestors
+    end
+
+    def status_values
+      ["Draft", "Published", "Review", "Hidden"]
+    end
+    
+    def default_layout
+      Page.layouts.first
+    end
+
+    def filters
+      %w{ none html textile markdown erb erb+textile }
+    end
+
+    def page_parts
+      %w{ body left right header footer }
+    end
+
+    # Scopes
+
+    def viewable_by(user)
+      if PageEngine.class_exists?('Role') && PageEngine.class_exists?('User')
+        if user
+          # This is a bit of a kludge until I can figure out how to get it to work properly in a single sql query
+          includes(:page_roles).where("pages.id in (?) or (page_roles.required_role_id is null and page_roles.excluded_role_id is null)", PageRole.viewable_page_ids_for(user))
+        else
+          includes(:page_roles).where({ 'page_roles.required_role_id' => nil })
+        end
+      else
+        scoped
+      end      
+    end
+
+    def with_roles roles
+      if Extras.class_exists?('Role')
+        includes(:roles).where([ "roles.id IN (?)", roles.join(',') ])
+      else
+        scoped
+      end
+    end
+
+    def with_url request, params
+      url = request.fullpath
+      url.gsub!(/\?.*/, '') # Strip away anything after the ? as it's not needed
+
+      where(["pages.permalink = ? or url = ? or (controller = ? and action = ?)", params[:permalink], url, params[:controller], params[:action]])
+    end
+
+  end
+
+  private
+
+    def set_permalink
+      self.permalink = self[:permalink].blank? ? self.title.parameterize : self[:permalink].parameterize
+      self.menu_css_class = self.permalink if self[:menu_css_class].blank?
+    end
+
+    def set_controller_and_action
+      if @controller_action
+        controller_and_action = @controller_action.split('|')
+        self.controller = controller_and_action.first
+        self.action = controller_and_action.last
+      else
+        self.controller = nil
+        self.action = nil
+      end
+    end
+
+    def check_publish_window
+      if @no_publish_window == "1"
+        self.publish_to = self.publish_from = nil
+      end
+    end
+end
+

data/app/models/page_part.rb

@@ -0,0 +1,35 @@
+class PagePart < ActiveRecord::Base
+  # Relationships
+  belongs_to :page
+
+  # Validations
+  validates :title, :uniqueness => {:scope => "page_id"}, :presence => true
+
+  def duplicate
+    page_part = PagePart.new(self.attributes)
+    page_part.save
+    page_part
+  end
+
+  def to_s
+    if content
+      case filter
+        when "none"
+          content.html_safe
+        when "textile"
+          RedCloth.new(content).to_html.html_safe
+        when "markdown"
+          BlueCloth.new(content).to_html.html_safe
+        when "erb"
+          require "erb"
+          eval(ERB.new(content).src).html_safe
+        when "erb+textile"
+          require "erb"
+          textilize eval(ERB.new(content).src).html_safe
+        when "html"
+          content.html_safe
+      end      
+    end
+  end
+end
+

data/app/models/page_role.rb

@@ -0,0 +1,15 @@
+class PageRole < ActiveRecord::Base
+  # Relationships
+  belongs_to :required_role, :class_name => 'Role'
+  belongs_to :excluded_role, :class_name => 'Role'
+  
+  # Scopes
+  scope :viewable_by, lambda { |user| where(:required_role_id => user.role_ids) } 
+  scope :not_viewable_by, lambda { |user| where(:excluded_role_id => user.role_ids) }
+  
+  class << self
+    def viewable_page_ids_for(user)
+      PageRole.viewable_by(user).map(&:page_id) - PageRole.not_viewable_by(user).map(&:page_id)
+    end
+  end
+end

data/app/models/page_snippet.rb

@@ -0,0 +1,30 @@
+class PageSnippet < ActiveRecord::Base
+  # Validations
+  validates :name, :presence => true, :uniqueness => true
+  
+  # Relationships
+  if PageEngine.class_exists?('Asset')
+    has_assets
+  end
+
+  def to_s
+    if content
+      case filter
+        when "none"
+          content.html_safe
+        when "textile"
+          RedCloth.new(content).to_html.html_safe
+        when "markdown"
+          BlueCloth.new(content).to_html.html_safe
+        when "erb"
+          require "erb"
+          eval(ERB.new(content).src).html_safe
+        when "erb+textile"
+          require "erb"
+          textilize eval(ERB.new(content).src).html_safe
+        when "html"
+          content.html_safe
+      end      
+    end
+  end
+end

data/app/views/admin/page_snippets/_form.html.haml

@@ -0,0 +1,10 @@
+= simple_form_for [:admin, @page_snippet] do |f|
+  = f.error_notification
+  
+  .inputs
+    = f.input :name
+    = f.input :filter, :collection => Page.filters, :include_blank => false, :class => 'filter', :input_html => { :class => 'filter', :rel => 'page_snippet_content' }
+    = f.input :content, :input_html => { :class => 'editor', 'data-filter' => @page_snippet.filter }
+    
+  .action
+    = f.submit

data/app/views/admin/page_snippets/destroy.js.erb

@@ -0,0 +1,3 @@
+fade_and_remove('#page_snippet_<%= @page_snippet.id %>');
+flash_message('<%= escape_javascript(notice) %>');
+highlight_alt_rows('#page_snippets');

data/app/views/admin/page_snippets/edit.html.haml

@@ -0,0 +1,6 @@
+%h2 Editing Page Snippet
+
+= render 'form'
+
+- if PageEngine.class_exists?('Asset')
+  = render 'admin/assets/assets'

data/app/views/admin/page_snippets/index.html.haml

@@ -0,0 +1,20 @@
+%h2 Page Snippets
+
+%p
+  = link_to('New page snippet', new_admin_page_snippet_path, :class => 'icon_left add')
+
+%table#page_snippets
+  %thead
+    %tr
+      %th Name
+      %th
+      %th
+  %tbody
+    - @page_snippets.each do |page_snippet|
+      %tr{ :id => "page_snippet_#{page_snippet.id}", :class => cycle('odd', 'even')}
+        %td.odd
+          = page_snippet.name
+        %td.even.has_icon
+          = link_to('Edit', edit_admin_page_snippet_path(page_snippet), :class => 'icon edit')
+        %td.odd.has_icon
+          = link_to('Destroy', [:admin, page_snippet], :confirm => 'Are you sure?', :method => :delete, :class => 'icon delete')

data/app/views/admin/page_snippets/new.html.haml

@@ -0,0 +1,6 @@
+%h2 New Page Snippet
+
+= render 'form'
+
+- if PageEngine.class_exists?('Asset')
+  = render 'admin/assets/assets'

data/app/views/admin/page_snippets/show.html.erb

@@ -0,0 +1,20 @@
+<p id="notice"><%= notice %></p>
+
+<p>
+  <b>Title:</b>
+  <%= @page_snippet.title %>
+</p>
+
+<p>
+  <b>Filter:</b>
+  <%= @page_snippet.filter %>
+</p>
+
+<p>
+  <b>Content:</b>
+  <%= @page_snippet.content %>
+</p>
+
+
+<%= link_to 'Edit', edit_admin_page_snippet_path(@page_snippet) %> |
+<%= link_to 'Back', admin_page_snippets_path %>