comfortable_mexican_sofa 0.0.18 → 1.0.0

data/app/controllers/cms_admin/snippets_controller.rb

@@ -1,58 +1,50 @@
 class CmsAdmin::SnippetsController < CmsAdmin::BaseController
-  
-  before_filter :load_snippet, :only => [:edit, :update, :destroy]
-  
+  before_filter :build_cms_snippet,
+    :only => [:new, :create]
+  before_filter :load_cms_snippet,
+    :only => [:edit, :update, :destroy]
+    
   def index
-    @snippets = CmsSnippet.paginate :page => params[:page]
+    @cms_snippets = CmsSnippet.all(:order => 'label')
   end
   
   def new
-    # ...
-  end
-  
-  def edit
-    # ...
   end
   
   def create
-    @snippet = CmsSnippet.new(params[:snippet])
-    @snippet.save!
-    
-    flash[:notice] = 'Snippet created'
-    redirect_to :action => :edit, :id => @snippet
-    
+    @cms_snippet.save!
+    flash[:notice] = 'Snippet saved'
+    redirect_to :action => :edit, :id => @cms_snippet
   rescue ActiveRecord::RecordInvalid
     render :action => :new
   end
   
+  def edit
+  end
+  
   def update
-    @snippet.update_attributes!(params[:snippet])
-    
-    flash[:notice] = 'Snippet updated'
-    redirect_to :action => :edit, :id => @snippet
-    
+    @cms_snippet.update_attributes!(params[:cms_snippet])
+    flash[:notice] = 'Snippet saved'
+    redirect_to :action => :edit, :id => @cms_snippet
   rescue ActiveRecord::RecordInvalid
     render :action => :edit
   end
   
   def destroy
-    @snippet.destroy
-    
-    flash[:notice] = 'Snippet removed'
+    @cms_snippet.destroy
+    flash[:notice] = 'Snippet deleted'
     redirect_to :action => :index
   end
-  
-  def reorder
-    params[:snippet_list].each_with_index do |id, position|
-      CmsSnippet.find(id).update_attribute(:position, position)
-    end
-    render :nothing => true
-  end
-  
-protected
 
-  def load_snippet
-    @snippet = CmsSnippet.find_by_id(params[:id])
+protected
+  def build_cms_snippet
+    @cms_snippet = CmsSnippet.new(params[:cms_snippet])
   end
   
+  def load_cms_snippet
+    @cms_snippet = CmsSnippet.find(params[:id])
+  rescue ActiveRecord::RecordNotFound
+    flash[:error] = 'Snippet not found'
+    redirect_to :action => :index
+  end
 end

data/app/controllers/cms_admin/uploads_controller.rb

@@ -0,0 +1,27 @@
+class CmsAdmin::UploadsController < CmsAdmin::BaseController
+  before_filter :load_cms_upload,
+    :only => :destroy
+  
+  def index
+  end
+  
+  def create
+    @cms_upload = CmsUpload.new(:uploaded_file => params[:file])
+    if @cms_upload.save
+      render(:partial => 'cms_admin/uploads/upload', :object => @cms_upload)
+    else
+      render :nothing => true
+    end
+  end
+  
+  def destroy
+    @cms_upload.destroy
+  end
+
+protected
+  def load_cms_upload
+    @cms_upload = CmsUpload.find(params[:id])
+  rescue ActiveRecord::RecordNotFound
+    render :nothing => true
+  end
+end

data/app/controllers/cms_content_controller.rb

@@ -1,30 +1,33 @@
 class CmsContentController < ApplicationController
   
-  include CmsCommon::RenderPage
-  
-  unloadable
+  before_filter :load_cms_page,   :only => :render_html
+  before_filter :load_cms_layout, :only => [:render_css, :render_js]
+    
+  def render_html
+    layout = @cms_page.cms_layout.app_layout.blank?? false : @cms_page.cms_layout.app_layout
+    render :inline => @cms_page.content, :layout => layout
+  end
   
-  before_filter :parse_path, :only => :show
+  def render_css
+    render :text => @cms_layout.merged_css, :content_type => 'text/css'
+  end
   
-  def show
-    @cms_page_slug = params[:path].join('/')
-    @cms_page = CmsPage.published.find_by_full_path(@cms_page_slug)
-    render_page
+  def render_js
+    render :text => @cms_layout.merged_js, :content_type => 'text/javascript'
   end
+
+protected
   
-  def sitemap
-    respond_to do |format|
-      format.xml do
-        @cms_pages = CmsPage.all
-      end
-    end
+  def load_cms_page
+    @cms_page = CmsPage.find_by_full_path!("/#{params[:cms_path]}")
+  rescue ActiveRecord::RecordNotFound
+    render :text => 'Page not found', :status => 404
   end
   
-protected
-
-  def parse_path
-    params[:format] = (params[:path].last && (match = params[:path].last.match(/\.(.*?)$/)) && match[1]) || 'html'
-    params[:path].last && params[:path].last.gsub!(/\.(.*?)$/, '')
+  def load_cms_layout
+    @cms_layout = CmsLayout.find(params[:id])
+  rescue ActiveRecord::RecordNotFound
+    render :nothing => true, :status => 404
   end
   
 end

data/app/models/cms_block.rb

@@ -4,12 +4,26 @@ class CmsBlock < ActiveRecord::Base
   belongs_to :cms_page
   
   # -- Validations ----------------------------------------------------------
-  validates_presence_of :label
-  validates_uniqueness_of :label, :scope => :cms_page_id
+  validates :label,
+    :presence   => true,
+    :uniqueness => { :scope => :cms_page_id }
   
-  # -- Scopes ---------------------------------------------------------------
-  named_scope :with_label, lambda{ |name|{
-    :conditions => {:label => name}
-  }}
+  # -- Class Methods --------------------------------------------------------
+  class << self
+    # making sure that the correct class is initialized based on :type passed
+    # primarily important for form processing
+    def new_with_cast(*args, &block)
+      if (h = args.first).is_a?(Hash) && (type = h[:type] || h['type']) && (klass = type.constantize) != self
+        return klass.new(*args, &block)
+      end
+      new_without_cast(*args, &block)
+    end
+    alias_method_chain :new, :cast
+    
+    def initialize_or_find(cms_page, label)
+      cms_page.cms_blocks.detect{ |b| b.label == label.to_s } ||
+      self.new(:label => label.to_s, :type => self.name, :cms_page => cms_page)
+    end
+  end
   
 end

data/app/models/cms_layout.rb

@@ -1,102 +1,56 @@
 class CmsLayout < ActiveRecord::Base
   
+  acts_as_tree
+  
   # -- Relationships --------------------------------------------------------
-  acts_as_tree :counter_cache => :children_count
   has_many :cms_pages, :dependent => :nullify
   
   # -- Validations ----------------------------------------------------------
-  validates_presence_of :label
-  validates_uniqueness_of :label
-  validate  :validate_block_presence,
-            :validate_proper_relationship
-  
-  # -- AR Callbacks ---------------------------------------------------------
-  before_save :flag_as_extendable,
-              :update_page_blocks
-  
-  # -- Scopes ---------------------------------------------------------------
-  default_scope :order => 'position ASC'
-  named_scope :extendable, :conditions => { :is_extendable => true }
-  
+  validates :label,
+    :presence   => true
+  validates :content,
+    :presence   => true
+    
   # -- Class Methods --------------------------------------------------------
-  def self.options_for_select
-    [['---', nil]] + CmsLayout.all.collect{ |l| [l.label, l.id]}
+  # Tree-like structure for layouts
+  def self.options_for_select(cms_layout = nil, current_layout = nil, depth = 0, spacer = '. . ')
+    out = []
+    [current_layout || CmsLayout.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_layout, child, depth + 1, spacer)
+      end
+    end
+    return out.compact
   end
   
+  # List of available application layouts
   def self.app_layouts_for_select
-    path = "#{RAILS_ROOT}/app/views/layouts"
-    regex = /^([a-z0-9]\w+)\.html/i
-    
-    app_layouts = begin
-      Dir.entries(path).collect{|l| l.match(regex).try(:captures)}.compact.flatten
-    rescue
-      # no app layouts
-    end
-    
-    !app_layouts.blank? ? [['---', nil]] + app_layouts : [['---', nil]]
+    Dir.glob(File.expand_path('app/views/layouts/*.html.*', Rails.root)).collect do |filename|
+      match = filename.match(/\w*.html.\w*$/)
+      match && match[0]
+    end.compact
   end
   
   # -- Instance Methods -----------------------------------------------------
-  def content
+  # 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
-      parent.content.gsub(/\{\{\s*cms_page_block:default:.*?\}\}/, self.read_attribute(:content))
+      c = parent.merged_content.gsub CmsTag::PageText.regex_tag_signature('content'), content
+      c == parent.merged_content ? content : c
     else
-      read_attribute(:content)
+      content
     end
   end
   
-  def app_layout
-    this_layout = read_attribute(:app_layout)
-    if this_layout.blank?
-      parent && parent.app_layout
-    else
-      this_layout
-    end
+  def merged_css
+    self.parent ? self.parent.merged_css + self.css : self.css.to_s
   end
   
-  def extendable_for_select
-    [['---', nil]] + CmsLayout.extendable.all.reject{|l| ([self]+self.descendants).member?(l)}.collect{ |l| [l.label, l.id] }
-  end
-  
-  def tags(options = {})
-    CmsTag::parse_tags(self.content, options)
-  end
-  
-protected
-
-  def validate_block_presence
-    self.errors.add(:content, 'does not have any cms_blocks defined') if self.tags.empty?
-  end
-  
-  def validate_proper_relationship
-    if self.descendants.member?(parent) || self.parent == self
-      self.errors.add(:parent_id, 'layout is invalid') 
-    end
-  end
-  
-  def validate_children_against_extendable
-    # todo
-  end
-  
-  def flag_as_extendable
-    self.is_extendable = !self.tags.select{|t| t.tag_type == 'cms_page_block' && t.label == 'default'}.blank?
-    true
-  end
-  
-  def update_page_blocks
-    return if new_record? || !content_changed?
-    
-    old_tags = CmsTag::parse_tags(content_was).select{|t| ['cms_block', 'cms_page_block'].member?(t.tag_type)}.collect{|t| t.label}
-    new_tags = CmsTag::parse_tags(content).select{|t| ['cms_block', 'cms_page_block'].member?(t.tag_type)}.collect{|t| t.label}
-    
-    # creating new cms_blocks for all pages using this layout
-    labels_for_blocks = new_tags - old_tags
-    if !labels_for_blocks.blank?
-      cms_pages.each do |cms_page|
-        labels_for_blocks.each do |label|
-          cms_page.cms_blocks.create(:label => label)
-        end
-      end
-    end
+  def merged_js
+    self.parent ? self.parent.merged_js + self.js : self.js.to_s
   end
 end

data/app/models/cms_page.rb

@@ -1,125 +1,67 @@
 class CmsPage < ActiveRecord::Base
   
-  attr_accessor :rendered_content
-  
-  # -- Relationships --------------------------------------------------------
+  # -- AR Extensions --------------------------------------------------------
   acts_as_tree :counter_cache => :children_count
-  acts_as_published
-  acts_as_categorized
-  
-  belongs_to  :cms_layout
-  has_many    :cms_blocks,
-    :dependent    => :destroy
-  belongs_to  :redirect_to_page,
-    :class_name   => 'CmsPage',
-    :foreign_key  => :redirect_to_page_id
-  has_one :redirected_from_page,
-    :class_name   => 'CmsPage',
-    :foreign_key  => :redirect_to_page_id
   
-  #-- Validations -----------------------------------------------------------
-  validates_presence_of   :cms_layout_id,
-    :unless => lambda{|p| p.redirect_to_page}
-  validates_presence_of   :label
-  validates_presence_of   :slug,
-    :unless => lambda{|p| CmsPage.count == 0 || p == CmsPage.root}
-  validates_format_of     :slug,
-    :with   => /^\w[a-z0-9_-]*$/i,
-    :unless => lambda{|p| CmsPage.count == 0 || p == CmsPage.root}
-  validates_uniqueness_of :full_path
+  attr_accessor :cms_tags
   
-  validate :validate_redirect_to
+  # -- Relationships --------------------------------------------------------
+  belongs_to :cms_layout
+  has_many :cms_blocks,
+    :dependent  => :destroy
+  accepts_nested_attributes_for :cms_blocks
   
-  # -- AR Callbacks ---------------------------------------------------------
+  # -- Callbacks ------------------------------------------------------------
   before_validation :assign_full_path
-  after_save        :save_blocks,
-                    :sync_child_slugs
+  after_save        :sync_child_pages
+  
+  # -- Validations ----------------------------------------------------------
+  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 => true
   
-  # -- Scopes ---------------------------------------------------------------
-  default_scope :order => 'position ASC'
-  named_scope :sections,
-    :conditions => {:is_section => true}
-    
   # -- Class Methods --------------------------------------------------------
-  def self.[](slug)
-    CmsPage.find_by_slug!(slug)
-  end
-    
-  # -- Instance Methods -----------------------------------------------------
-  def content
-    # TODO: Add column to cache the render output. pointless to run it all the time
-    render_content
-  end
-  
-  # FIX: Recursive Tag/Content Replacement
-  # Works, but potentionally dangerous and not particularly efficient
-  def render_content(content = nil)
-    content = cms_layout.content.dup if !content
-    while (!(tags = CmsTag::parse_tags(content, :page => self).sort_by{|t| t.class.render_priority}).blank?)
-      tags.each do |tag|
-        content.gsub!(tag.regex) { tag.render }
-      end
-    end
-    content
-  end
-  
-  def blocks=(blocks)
-    blocks.each do |label, params|
-      if !self.new_record? && !(block = self.cms_blocks.select{|b| b.label == label}.first).blank?
-        block.attributes = params
-      else
-        self.cms_blocks.build({:label => label}.merge(params))
-      end
+  # Tree-like structure for pages
+  def self.options_for_select(cms_page = nil, current_page = nil, depth = 0, spacer = '. . ')
+    return [] if (current_page ||= CmsPage.root) == cms_page || !current_page
+    out = [[ "#{spacer*depth}#{current_page.label}", current_page.id ]]
+    current_page.children.each do |child|
+      out += options_for_select(cms_page, child, depth + 1, spacer)
     end
+    return out.compact
   end
   
-  def pages_for_select(page = CmsPage.root, level = 0, exclude_self = false)
-    page ||= CmsPage.root
-    return [] if !page || (page == self && exclude_self)
-    out = [["#{". . " * level} #{page.label}", page.id]]
-    page.children.each do |child|
-      if child.children.count > 0
-        out += pages_for_select(child, level + 1, exclude_self)
-      else
-        unless (child == self && exclude_self)
-          out += [["#{". . " * (level + 1)} #{child.label}", child.id]]
-        end
-      end
-    end
-    out
-  end
-  
-  def full_path
-    "/#{read_attribute(:full_path)}"
+  # -- Instance Methods -----------------------------------------------------
+  # Processing content will return rendered content and will populate 
+  # self.cms_tags with instances of CmsTag
+  def content
+    cms_layout ? CmsTag.process_content(self, cms_layout.merged_content) : ''
   end
   
-  def cms_block_content(label, content)
-    self.cms_blocks.select{|b| b.label.to_s == label.to_s}.first.try(content)
+  # 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 = false)
+    self.content if force
+    @cms_tags ||= []
   end
   
 protected
   
   def assign_full_path
-    self.full_path = (self.ancestors.reverse.collect{|p| p.slug}.compact + [self.slug]).join('/')
+    self.full_path = self.parent ? "#{self.parent.full_path}/#{self.slug}".squeeze('/') : '/'
   end
   
-  def validate_redirect_to
-    if self.redirect_to_page && (self == self.redirect_to_page || self.redirect_to_page.redirect_to_page)
-      self.errors.add(:redirect_to_page_id) 
-    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
   
-  def save_blocks
-    self.cms_blocks.each do |b|
-      b.save! if b.changed?
-    end
-  end
-  
-  def sync_child_slugs
-    if slug_changed?
-      children.each do |child|
-        child.save!
-      end
-    end
-  end
-end
+end