lucy_cms 0.0.1

data/app/controllers/cms_admin/snippets_controller.rb

@@ -0,0 +1,62 @@
+class CmsAdmin::SnippetsController < CmsAdmin::BaseController
+  
+  before_filter :check_for_admin
+  before_filter :build_cms_snippet, :only => [:new, :create]
+  before_filter :load_cms_snippet,  :only => [:edit, :update, :destroy]
+  
+  def index
+    return redirect_to :action => :new if @cms_site.cms_snippets.count == 0
+    @cms_snippets = @cms_site.cms_snippets.all(:order => 'label')
+  end
+  
+  def new
+    render
+  end
+  
+  def edit
+    render
+  end
+  
+  def create
+    @cms_snippet.save!
+    flash[:notice] = 'Snippet created'
+    redirect_to :action => :index
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:error] = 'Failed to create snippet'
+    render :action => :new
+  end
+  
+  def update
+    @cms_snippet.update_attributes!(params[:cms_snippet])
+    flash[:notice] = 'Snippet updated'
+    redirect_to :action => :index
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:error] = 'Failed to update snippet'
+    render :action => :edit
+  end
+  
+  def destroy
+    @cms_snippet.destroy
+    flash[:notice] = 'Snippet deleted'
+    redirect_to :action => :index
+  end
+  
+protected
+  def check_for_admin
+    if CmsUser.find_by_admin_and_disabled(true,false).nil?
+      flash[:error] = 'You must create one Active Admin User to continue'
+      redirect_to new_cms_admin_user_path
+    end
+  end
+
+  def build_cms_snippet
+    @cms_snippet = @cms_site.cms_snippets.new(params[:cms_snippet])
+  end
+  
+  def load_cms_snippet
+    @cms_snippet = @cms_site.cms_snippets.find(params[:id])
+  rescue ActiveRecord::RecordNotFound
+    flash[:error] = 'Snippet not found'
+    redirect_to :action => :index
+  end
+end

data/app/controllers/cms_admin/upload_dirs_controller.rb

@@ -0,0 +1,79 @@
+class CmsAdmin::UploadDirsController < CmsAdmin::BaseController
+  
+  before_filter :check_and_set_base_dir, :except => :conflict
+
+  def index
+    return redirect_to :action => :new if @cms_site.cms_upload_dirs.count == 0
+    @cms_upload_dirs = @cms_site.cms_upload_dirs.all(:order => 'label')
+  end 
+
+  def new
+    @cms_upload_dir = @cms_site.cms_upload_dirs.new
+    render
+  end
+  
+  def create
+    @cms_upload_dir = @cms_site.cms_upload_dirs.new(params[:cms_upload_dir])
+    if File::exists?(File.join(@base_dir, @cms_upload_dir.label))
+      flash[:error] = 'There is already a directory named ' + @cms_upload_dir.label
+      render :action => :new
+    else
+      if @cms_upload_dir.save
+        FileUtils.mkdir_p(File.join(@base_dir, @cms_upload_dir.label))
+        flash[:notice] = 'Directory created'
+        redirect_to :action => :index
+      else
+        flash[:error] = 'Not able to create directory'
+        render :action => :new
+      end
+    end
+  end
+  
+  def show
+    @cms_upload_dir = @cms_site.cms_upload_dirs.find(params[:id])
+    @cms_uploads = @cms_upload_dir.cms_uploads.find_all_by_cms_upload_dir_id( params[:id])
+  end
+
+  def uploads
+    @cms_upload_dir = @cms_site.cms_upload_dirs.find(params[:id])
+    @cms_upload_check = @cms_upload_dir.cms_uploads.find_by_cms_upload_dir_id_and_file_file_name( params[:id], params[:file].original_filename)
+    unless @cms_upload_check.nil?
+      @cms_upload_check.destroy
+    end
+    @cms_upload = @cms_upload_dir.cms_uploads.create!(:file => params[:file], :cms_upload_dir_label => @cms_upload_dir.label, :cms_user_id => @cms_current_user.id)
+    render :partial => 'file', :object => @cms_upload
+  rescue ActiveRecord::RecordInvalid
+    render :nothing => true, :status => :bad_request
+  end
+  
+  def uploads_destroy
+    @cms_upload = CmsUpload.find( params[:id])
+    @cms_upload.destroy
+  end
+
+
+  def destroy
+    @cms_upload_dir = @cms_site.cms_upload_dirs.find(params[:id])
+    @cms_upload_dir.destroy
+    if File::exists?(File.join(@base_dir, @cms_upload_dir.label)) && File::directory?(File.join(@base_dir, @cms_upload_dir.label))
+      FileUtils.remove_dir(File.join(@base_dir, @cms_upload_dir.label))
+    end
+      flash[:notice] = 'Directory deleted'
+      redirect_to :action => :index
+  end
+
+  def confilct
+    render
+  end
+
+  protected
+  
+  def check_and_set_base_dir
+    @base_dir = File.join(Rails.public_path,LucyCMS.config.cms_upload_directory)
+    if File::exists?(@base_dir) && !File::directory?(@base_dir)
+      flash[:error] = 'File conflict'
+      redirect_to :action => :conflict
+    end
+  end
+
+end

data/app/controllers/cms_admin/users_controller.rb

@@ -0,0 +1,129 @@
+class CmsAdmin::UsersController < CmsAdmin::BaseController
+
+  before_filter :check_for_admin, :only => :index
+  before_filter :check_admin, :except => :index
+  
+  def index
+    @cms_users = CmsUser.find(:all, :order => 'last_name ASC')
+  end
+
+  def new
+    @cms_user = CmsUser.new
+  end
+
+  def create
+    @cms_user = CmsUser.new(params[:cms_user])
+    if @cms_site.authentication == 'LDAP'
+      username = @cms_user.login
+      ldap = Net::LDAP.new(:host => @cms_site.ldap_hostname, :base => @cms_site.ldap_base_DN)
+      filter = Net::LDAP::Filter.eq(@cms_site.ldap_uid, username)
+      ldap.search(:filter => filter) do |entry|
+        username = entry.dn
+      end
+      if username == @cms_user.login
+        flash[:error] = "Username not in LDAP"
+        render :action => 'new'
+        return
+      end
+    end
+    if CmsUser.find_by_admin_and_disabled(true,false).nil? 
+      if @cms_user.admin == false || @cms_user.disabled == true
+        flash[:error] = 'The first user you create must be an Active Admin'
+        render :action => 'new'
+      else
+        if @cms_user.save
+          flash[:notice] = 'User Created'
+          redirect_to cms_admin_users_path
+        else
+          flash[:error] = 'User could not be created'
+          render :action => 'new'
+        end
+      end
+    else
+      if @cms_user.save
+        flash[:notice] = 'User Created'
+        redirect_to cms_admin_users_path
+      else
+        flash[:error] = 'User could not be created'
+        render :action => 'new'
+      end
+    end
+  end
+  
+  def edit
+    @cms_user = CmsUser.find_by_id(params[:id])
+  end
+
+  def update
+    @cms_user = CmsUser.find(params[:id])
+    @cms_user.attributes = params[:cms_user]
+    if @cms_site.authentication == 'LDAP'
+      username = @cms_user.login
+      ldap = Net::LDAP.new(:host => @cms_site.ldap_hostname, :base => @cms_site.ldap_base_DN)
+      filter = Net::LDAP::Filter.eq(@cms_site.ldap_uid, username)
+      ldap.search(:filter => filter) do |entry|
+        username = entry.dn
+      end
+      if username == @cms_user.login
+        flash[:error] = "Username not in LDAP"
+        render :action => 'edit'
+        return
+      end
+    end
+    if @cms_user.disabled == true && CmsUser.find(:all, :conditions => {:admin => true, :disabled => false}).count == 1 &&  CmsUser.find(:all, :conditions => {:admin => true, :disabled => false}).first.id == @cms_user.id
+      flash[:error] = "You can not disable the only Admin"
+      render :action => 'edit'
+    else
+      if @cms_user.admin == false && CmsUser.find(:all, :conditions => {:admin => true, :disabled => false}).count == 1 && CmsUser.find(:all, :conditions => {:admin => true, :disabled => false}).first.id == @cms_user.id
+        flash[:error] = "You must have one Active Admin User"
+        render :action => 'edit'
+      else
+        if @cms_user.save
+           flash[:notice] = "User was updated"
+           redirect_to cms_admin_users_path
+        else
+          flash[:error] = 'User could not be updated'
+          render :action => 'edit'
+        end
+      end
+    end
+  end
+
+  def change_password
+    @cms_user = CmsUser.find_by_id(params[:id])
+  end
+
+  def update_password
+    @cms_user = CmsUser.find_by_id(params[:id])
+    @cms_user.attributes = params[:cms_user]
+    if @cms_user.password.nil? || @cms_user.password.empty?
+      flash[:error] = 'Password can not be blank'
+      render :action => 'change_password'
+      return
+    end
+    if @cms_user.save
+      flash[:notice] = "Password was updated"
+      redirect_to cms_admin_users_path
+    else
+      flash[:error] = 'User could not be updated'
+      render :action => 'change_password'
+    end
+  end
+
+  protected
+
+  def check_for_admin
+    if CmsUser.find_by_admin_and_disabled(true,false).nil?
+      flash[:error] = 'You must create one Active Admin User to continue'
+      redirect_to new_cms_admin_user_path
+    end
+  end
+
+  def check_admin
+    if CmsUser.count > 0 and !CmsUser.find_by_id(session[:cms_user_id]).admin?
+      flash[:error] = 'You must be an Admin to Create or Edit Users'
+      redirect_to :action => 'index'
+    end
+  end
+
+end

data/app/controllers/cms_content_controller.rb

@@ -0,0 +1,51 @@
+class CmsContentController < ApplicationController
+  
+  before_filter :load_cms_site
+  before_filter :load_cms_page,   :only => :render_html
+  before_filter :load_cms_layout, :only => [:render_css, :render_js]
+  
+  caches_page :render_css, :render_js, :if => LucyCMS.config.enable_caching
+  
+  def render_html(status = 200)
+    layout = @cms_page.cms_layout.app_layout.blank?? false : @cms_page.cms_layout.app_layout
+    render :inline => @cms_page.content, :layout => layout, :status => status
+  end
+  
+  def render_css
+    render :text => @cms_layout.css, :content_type => 'text/css'
+  end
+  
+  def render_js
+    render :text => @cms_layout.js, :content_type => 'text/javascript'
+  end
+  
+protected
+  
+  def load_cms_site
+    @cms_site = CmsSite.first
+    if @cms_site.nil?
+      redirect_to new_cms_admin_site_path
+      flash[:error] = 'To start you must setup your site'
+      return
+    end
+  end
+  
+  def load_cms_page
+    @cms_page = CmsPage.published.load_for_full_path!(@cms_site, "/#{params[:cms_path]}")
+    return redirect_to(@cms_page.target_page.full_path) if @cms_page.target_page
+    
+  rescue ActiveRecord::RecordNotFound
+    if @cms_page = CmsPage.published.load_for_full_path(@cms_site, '/404')
+      render_html(404)
+    else
+      render :text => 'Page Not Found', :status => 404
+    end
+  end
+  
+  def load_cms_layout
+    @cms_layout = CmsLayout.load_for_slug!(@cms_site, params[:id])
+  rescue ActiveRecord::RecordNotFound
+    render :nothing => true, :status => 404
+  end
+  
+end

data/app/models/cms_block.rb

@@ -0,0 +1,28 @@
+class CmsBlock < ActiveRecord::Base
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :cms_page
+  
+  # -- Validations ----------------------------------------------------------
+  validates :label,
+    :presence   => true,
+    :uniqueness => { :scope => :cms_page_id }
+  
+  # -- Class Methods --------------------------------------------------------
+  def self.initialize_or_find(cms_page, label)
+    if block = cms_page.cms_blocks.detect{ |b| b.label == label.to_s }
+      self.new(
+        :record_id  => block.id,
+        :cms_page   => cms_page,
+        :label      => block.label,
+        :content    => block.content
+      )
+    else
+      self.new(
+        :label    => label.to_s,
+        :cms_page => cms_page
+      )
+    end
+  end
+  
+end

data/app/models/cms_layout.rb

@@ -0,0 +1,118 @@
+class CmsLayout < ActiveRecord::Base
+  
+  acts_as_tree
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :cms_site
+  has_many :cms_pages, :dependent => :nullify
+  belongs_to :cms_user
+  
+  # -- Callbacks ------------------------------------------------------------
+  after_save    :clear_cache, :clear_cached_page_content
+  after_destroy :clear_cache, :clear_cached_page_content
+  
+  # -- Validations ----------------------------------------------------------
+  validates :cms_site_id,
+    :presence   => true
+  validates :label,
+    :presence   => true
+  validates :slug,
+    :presence   => true,
+    :uniqueness => { :scope => :cms_site_id },
+    :format     => { :with => /^\w[a-z0-9_-]*$/i }
+  validates :content,
+    :presence   => true
+  validate :check_content_tag_presence
+    
+  # -- Class Methods --------------------------------------------------------
+  # Tree-like structure for layouts
+  def self.options_for_select(cms_site, cms_layout = nil, current_layout = nil, depth = 0, spacer = '. . ')
+    out = []
+    [current_layout || cms_site.cms_layouts.roots].flatten.each do |layout|
+      next if cms_layout == layout
+      out << [ "#{spacer*depth}#{layout.label}", layout.id ]
+      layout.children.each do |child|
+        out += options_for_select(cms_site, cms_layout, child, depth + 1, spacer)
+      end
+    end
+    return out.compact
+  end
+  
+  # List of available application layouts
+  def self.app_layouts_for_select
+    Dir.glob(File.expand_path('app/views/layouts/*.html.*', Rails.root)).collect do |filename|
+      match = filename.match(/\w*.html.\w*$/)
+      app_layout = match && match[0]
+      app_layout.to_s[0...1] == '_' ? nil : app_layout
+    end.compact
+  end
+  
+  # Attempting to initialize layout object from yaml file that is found in config.seed_data_path
+  def self.load_from_file(site, slug)
+    return nil if LucyCMS.config.seed_data_path.blank?
+    file_path = "#{LucyCMS.config.seed_data_path}/#{site.hostname}/layouts/#{slug}.yml"
+    return nil unless File.exists?(file_path)
+    attributes            = YAML.load_file(file_path).symbolize_keys!
+    attributes[:parent]   = CmsLayout.load_from_file(site, attributes[:parent])
+    attributes[:cms_site] = site
+    new(attributes)
+  rescue
+    raise "Failed to load from #{file_path}"  
+  end
+  
+  # Wrapper around load_from_file and find_by_slug
+  # returns layout object if loaded / found
+  def self.load_for_slug!(site, slug)
+    if LucyCMS.configuration.seed_data_path
+      load_from_file(site, slug)
+    else
+      site.cms_layouts.find_by_slug(slug)
+    end || raise(ActiveRecord::RecordNotFound, "CmsLayout with slug: #{slug} cannot be found")
+  end
+  
+  # Non-blowing-up version of the method above
+  def self.load_for_slug(site, slug)
+    load_for_slug!(site, slug) 
+  rescue ActiveRecord::RecordNotFound
+    nil
+  end
+  
+  # -- Instance Methods -----------------------------------------------------
+  # magical merging tag is {cms:page:content} If parent layout has this tag
+  # defined its content will be merged. If no such tag found, parent content
+  # is ignored.
+  def merged_content
+    if parent
+      regex = /\{\{\s*cms:page:content:?(?:(?::text)|(?::rich_text))?\s*\}\}/
+      if parent.merged_content.match(regex)
+        parent.merged_content.gsub(regex, content)
+      else
+        content
+      end
+    else
+      content
+    end
+  end
+  
+protected
+  
+  def check_content_tag_presence
+    CmsTag.process_content((test_page = CmsPage.new), content)
+    if test_page.cms_tags.select{|t| t.class.superclass == CmsBlock}.blank?
+      self.errors.add(:content, 'No cms page tags defined')
+    end
+  end
+  
+  # After saving need to make sure that cached pages for css and js for this
+  # layout and its children are gone. Good enough to avoid using cache sweepers.
+  def clear_cache
+    FileUtils.rm File.expand_path("cms-css/#{self.slug}.css", Rails.public_path), :force => true
+    FileUtils.rm File.expand_path("cms-js/#{self.slug}.js",   Rails.public_path), :force => true
+  end
+  
+  # Forcing page content reload. This will happen in cascade due to #clear_cache mathod above.
+  def clear_cached_page_content
+    self.cms_pages.each{ |page| page.save! }
+  end
+  
+end

data/app/models/cms_page.rb

@@ -0,0 +1,163 @@
+class CmsPage < ActiveRecord::Base
+  
+  # -- AR Extensions --------------------------------------------------------
+  acts_as_tree :counter_cache => :children_count
+  
+  attr_accessor :cms_tags
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :cms_site
+  belongs_to :cms_layout
+  belongs_to :target_page,
+    :class_name => 'CmsPage'
+  has_many :cms_blocks,
+    :dependent  => :destroy
+  accepts_nested_attributes_for :cms_blocks
+  belongs_to :cms_user
+  
+  # -- Callbacks ------------------------------------------------------------
+  before_validation :assign_parent,
+                    :assign_full_path,
+                    :assign_position
+  before_save       :set_cached_content
+  after_save        :sync_child_pages
+  
+  # -- Validations ----------------------------------------------------------
+  validates :cms_site_id, 
+    :presence   => true
+  validates :label,
+    :presence   => true
+  validates :slug,
+    :presence   => true,
+    :format     => /^\w[a-z0-9_-]*$/i,
+    :unless     => lambda{ |p| p == CmsPage.root || CmsPage.count == 0 }
+  validates :cms_layout,
+    :presence   => true
+  validates :full_path,
+    :presence   => true,
+    :uniqueness => { :scope => :cms_site_id }
+  validate :validate_target_page
+  
+  # -- Scopes ---------------------------------------------------------------
+  scope :published, where(:is_published => true)
+  
+  # -- Class Methods --------------------------------------------------------
+  # Tree-like structure for pages
+  def self.options_for_select(cms_site, cms_page = nil, current_page = nil, depth = 0, exclude_self = true, spacer = '. . ')
+    return [] if (current_page ||= cms_site.cms_pages.root) == cms_page && exclude_self || !current_page
+    out = []
+    out << [ "#{spacer*depth}#{current_page.label}", current_page.id ] unless current_page == cms_page
+    current_page.children.each do |child|
+      out += options_for_select(cms_site, cms_page, child, depth + 1, exclude_self, spacer)
+    end
+    return out.compact
+  end
+  
+  # Attempting to initialize page object from yaml file that is found in config.seed_data_path
+  # This file defines all attributes of the page plus all the block information
+  def self.load_from_file(site, path)
+    return nil if LucyCMS.config.seed_data_path.blank?
+    path = (path == '/')? '/index' : path.to_s.chomp('/')
+    file_path = "#{LucyCMS.config.seed_data_path}/#{site.hostname}/pages#{path}.yml"
+    return nil unless File.exists?(file_path)
+    attributes              = YAML.load_file(file_path).symbolize_keys!
+    attributes[:cms_layout] = CmsLayout.load_from_file(site, attributes[:cms_layout])
+    attributes[:parent]     = CmsPage.load_from_file(site, attributes[:parent])
+    attributes[:cms_site]   = site
+    new(attributes)
+  rescue
+    raise "Failed to load from #{file_path}"
+  end
+  
+  # Wrapper around load_from_file and find_by_full_path
+  # returns page object if loaded / found
+  def self.load_for_full_path!(site, path)
+    if LucyCMS.configuration.seed_data_path
+      load_from_file(site, path)
+    else
+      site.cms_pages.find_by_full_path(path)
+    end || raise(ActiveRecord::RecordNotFound, "CmsPage with path: #{path} cannot be found")
+  end
+  
+  # Non-blowing-up version of the method above
+  def self.load_for_full_path(site, path)
+    load_for_full_path!(site, path) 
+  rescue ActiveRecord::RecordNotFound
+    nil
+  end
+  
+  # -- Instance Methods -----------------------------------------------------
+  # For previewing purposes sometimes we need to have full_path set
+  def full_path
+    self.read_attribute(:full_path) || self.assign_full_path
+  end
+  
+  # Transforms existing cms_block information into a hash that can be used
+  # during form processing. That's the only way to modify cms_blocks.
+  def cms_blocks_attributes
+    self.cms_blocks.inject([]) do |arr, block|
+      block_attr = {}
+      block_attr[:label]    = block.label
+      block_attr[:content]  = block.content
+      block_attr[:id]       = block.id
+      arr << block_attr
+    end
+  end
+  
+  # Processing content will return rendered content and will populate 
+  # self.cms_tags with instances of CmsTag
+  def content(force_reload = false)
+    @content = read_attribute(:content)
+    @content = nil if force_reload
+    @content ||= begin
+      self.cms_tags = [] # resetting
+      cms_layout ? CmsTag.process_content(self, cms_layout.merged_content) : ''
+    end
+  end
+  
+  # Array of cms_tags for a page. Content generation is called if forced.
+  # These also include initialized cms_blocks if present
+  def cms_tags(force_reload = false)
+    self.content(true) if force_reload
+    @cms_tags ||= []
+  end
+  
+  # Full url for a page
+  def url
+    "http://#{self.cms_site.hostname}#{self.full_path}"
+  end
+  
+protected
+  
+  def assign_parent
+    self.parent ||= CmsPage.root unless self == CmsPage.root || CmsPage.count == 0
+  end
+  
+  def assign_full_path
+    self.full_path = self.parent ? "#{self.parent.full_path}/#{self.slug}".squeeze('/') : '/'
+  end
+  
+  def assign_position
+    return unless self.parent
+    max = self.parent.children.maximum(:position)
+    self.position = max ? max + 1 : 0
+  end
+  
+  def validate_target_page
+    return unless self.target_page
+    p = self
+    while p.target_page do
+      return self.errors.add(:target_page_id, 'Invalid Redirect') if (p = p.target_page) == self
+    end
+  end
+  
+  def set_cached_content
+    write_attribute(:content, self.content(true))
+  end
+  
+  # Forcing re-saves for child pages so they can update full_paths
+  def sync_child_pages
+    children.each{ |p| p.save! } if full_path_changed?
+  end
+  
+end

data/app/models/cms_site.rb

@@ -0,0 +1,38 @@
+class CmsSite < ActiveRecord::Base
+  
+  # -- Relationships --------------------------------------------------------
+  has_many :cms_layouts,  :dependent => :destroy
+  has_many :cms_pages,    :dependent => :destroy
+  has_many :cms_snippets, :dependent => :destroy
+  has_many :cms_uploads,  :dependent => :destroy
+  has_many :cms_upload_dirs,  :dependent => :destroy
+  
+  # -- Validations ----------------------------------------------------------
+  validates :label,
+    :presence   => true,
+    :uniqueness => true
+  validates :hostname,
+    :presence   => true,
+    :uniqueness => true,
+    :format     => { :with => /^[\w\.\-]+$/ }
+
+  validates :authentication,
+   :presence => true
+
+  validates :ldap_hostname,
+    :presence => true,
+    :unless => :no_ldap
+
+  validates :ldap_base_DN,
+    :presence => true,
+    :unless => :no_ldap
+
+  validates :ldap_uid,
+    :presence => true,
+    :unless => :no_ldap
+
+  def no_ldap
+    self.authentication != 'LDAP'
+  end 
+
+end