comfypress 0.1.3

data/app/models/cms/block.rb

@@ -0,0 +1,48 @@
+class Cms::Block < ActiveRecord::Base
+  
+  ComfyPress.establish_connection(self)
+  
+  self.table_name = 'cms_blocks'
+  
+  attr_accessible :identifier,
+                  :content
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :page
+  has_many :files,
+    :autosave   => true,
+    :dependent  => :destroy
+  
+  # -- Callbacks ------------------------------------------------------------
+  before_save :prepare_files
+  
+  # -- Validations ----------------------------------------------------------
+  validates :identifier,
+    :presence   => true,
+    :uniqueness => { :scope => :page_id }
+    
+  # -- Instance Methods -----------------------------------------------------
+  # Tag object that is using this block
+  def tag
+    @tag ||= page.tags(true).detect{|t| t.is_cms_block? && t.identifier == identifier}
+  end
+    
+protected
+  
+  def prepare_files
+    temp_files = [self.content].flatten.select do |f|
+      %w(ActionDispatch::Http::UploadedFile Rack::Test::UploadedFile).member?(f.class.name)
+    end
+    
+    # only accepting one file if it's PageFile. PageFiles will take all
+    single_file = self.tag.is_a?(ComfyPress::Tag::PageFile)
+    temp_files = [temp_files.first].compact if single_file
+    
+    temp_files.each do |file|
+      self.files.collect{|f| f.mark_for_destruction } if single_file
+      self.files.build(:site => self.page.site, :dimensions => self.tag.try(:dimensions), :file => file)
+    end
+    
+    self.content = nil unless self.content.is_a?(String)
+  end
+end

data/app/models/cms/categorization.rb

@@ -0,0 +1,21 @@
+class Cms::Categorization < ActiveRecord::Base
+  
+  ComfyPress.establish_connection(self)
+  
+  self.table_name = 'cms_categorizations'
+  
+  attr_accessible :categorized
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :category
+  belongs_to :categorized,
+    :polymorphic => true
+    
+  # -- Validations ----------------------------------------------------------
+  validates :categorized_type, :categorized_id,
+    :presence   => true
+  validates :category_id,
+    :presence   => true,
+    :uniqueness => { :scope => [:categorized_type, :categorized_id] }
+  
+end

data/app/models/cms/category.rb

@@ -0,0 +1,30 @@
+class Cms::Category < ActiveRecord::Base
+  
+  ComfyPress.establish_connection(self)
+  
+  self.table_name = 'cms_categories'
+  
+  attr_accessible :label,
+                  :categorized_type
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :site
+  has_many :categorizations,
+    :dependent => :destroy
+    
+  # -- Validations ----------------------------------------------------------
+  validates :site_id, 
+    :presence   => true
+  validates :label,
+    :presence   => true,
+    :uniqueness => { :scope => [:categorized_type, :site_id] }
+  validates :categorized_type,
+    :presence   => true
+    
+  # -- Scopes ---------------------------------------------------------------
+  default_scope order(:label)
+  scope :of_type, lambda { |type|
+    where(:categorized_type => type)
+  }
+  
+end

data/app/models/cms/file.rb

@@ -0,0 +1,75 @@
+class Cms::File < ActiveRecord::Base
+  
+  IMAGE_MIMETYPES = %w(gif jpeg pjpeg png svg+xml tiff).collect{|subtype| "image/#{subtype}"}
+  
+  ComfyPress.establish_connection(self)
+    
+  self.table_name = 'cms_files'
+  
+  cms_is_categorized
+  
+  attr_accessor :dimensions
+  
+  attr_accessible :site, :site_id,
+                  :file,
+                  :dimensions,
+                  :label,
+                  :description,
+                  :category_ids,
+                  :position
+  
+  # -- AR Extensions --------------------------------------------------------
+  has_attached_file :file, ComfyPress.config.upload_file_options.merge(
+    # dimensions accessor needs to be set before file assignment for this to work
+    :styles => lambda { |f|
+      if f.respond_to?(:instance) && f.instance.respond_to?(:dimensions)
+        (f.instance.dimensions.blank?? { } : { :original => f.instance.dimensions }).merge(
+          :cms_thumb => '80x60#'
+        )
+      end
+    }
+  )
+  before_post_process :is_image?
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :site
+  belongs_to :block
+  
+  # -- Validations ----------------------------------------------------------
+  validates :site_id, :presence => true
+  validates_attachment_presence :file
+  
+  # -- Callbacks ------------------------------------------------------------
+  before_save   :assign_label
+  before_create :assign_position
+  after_save    :reload_page_cache
+  after_destroy :reload_page_cache
+  
+  # -- Scopes ---------------------------------------------------------------
+  scope :images,      where(:file_content_type => IMAGE_MIMETYPES)
+  scope :not_images,  where('file_content_type NOT IN (?)', IMAGE_MIMETYPES)
+  
+  # -- Instance Methods -----------------------------------------------------
+  def is_image?
+    IMAGE_MIMETYPES.include?(file_content_type)
+  end
+  
+protected
+  
+  def assign_label
+    self.label = self.label.blank?? self.file_file_name.gsub(/\.[^\.]*?$/, '').titleize : self.label
+  end
+  
+  def assign_position
+    max = Cms::File.maximum(:position)
+    self.position = max ? max + 1 : 0
+  end
+  
+  # FIX: Terrible, but no way of creating cached page content overwise
+  def reload_page_cache
+    return unless self.block
+    p = self.block.page
+    Cms::Page.where(:id => p.id).update_all(:content => p.content(true))
+  end
+  
+end

data/app/models/cms/layout.rb

@@ -0,0 +1,99 @@
+class Cms::Layout < ActiveRecord::Base
+  
+  ComfyPress.establish_connection(self)
+    
+  self.table_name = 'cms_layouts'
+  
+  cms_acts_as_tree
+  cms_is_mirrored
+  cms_has_revisions_for :content, :css, :js
+  
+  attr_accessible :label,
+                  :identifier,
+                  :content,
+                  :css,
+                  :js,
+                  :parent, :parent_id,
+                  :app_layout
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :site
+  has_many :pages, :dependent => :nullify
+  
+  # -- Callbacks ------------------------------------------------------------
+  before_validation :assign_label
+  before_create :assign_position
+  after_save    :clear_cached_page_content
+  after_destroy :clear_cached_page_content
+  
+  # -- Validations ----------------------------------------------------------
+  validates :site_id,
+    :presence   => true
+  validates :label,
+    :presence   => true
+  validates :identifier,
+    :presence   => true,
+    :uniqueness => { :scope => :site_id },
+    :format     => { :with => /^\w[a-z0-9_-]*$/i }
+    
+  # -- Scopes ---------------------------------------------------------------
+  default_scope order('cms_layouts.position')
+  
+  # -- Class Methods --------------------------------------------------------
+  # Tree-like structure for layouts
+  def self.options_for_select(site, layout = nil, current_layout = nil, depth = 0, spacer = '. . ')
+    out = []
+    [current_layout || site.layouts.roots].flatten.each do |l|
+      next if layout == l
+      out << [ "#{spacer*depth}#{l.label}", l.id ]
+      l.children.each do |child|
+        out += options_for_select(site, 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|
+      filename.gsub!("#{File.expand_path('app/views/layouts', Rails.root)}/", '')
+      filename.split('/').last[0...1] == '_' ? nil : filename.split('.').first
+    end.compact.sort
+  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.to_s)
+      else
+        content.to_s
+      end
+    else
+      content.to_s
+    end
+  end
+  
+protected
+  
+  def assign_label
+    self.label = self.label.blank?? self.identifier.try(:titleize) : self.label
+  end
+  
+  def assign_position
+    return if self.position.to_i > 0
+    max = self.site.layouts.where(:parent_id => self.parent_id).maximum(:position)
+    self.position = max ? max + 1 : 0
+  end
+  
+  # Forcing page content reload
+  def clear_cached_page_content
+    self.pages.each{ |page| page.save! }
+    self.children.each{ |child_layout| child_layout.clear_cached_page_content }
+  end
+  
+end

data/app/models/cms/menu.rb

@@ -0,0 +1,26 @@
+class Cms::Menu < ActiveRecord::Base
+  
+  attr_accessible :label, :site_id, :identifier
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :site
+  has_many :menu_items,
+    :autosave   => true,
+    :dependent  => :destroy
+    
+  # -- Validations ----------------------------------------------------------
+  validates :site_id, 
+    :presence   => true
+  validates :label, 
+    :presence   => true
+    
+  # -- Class Methods --------------------------------------------------------
+    def self.options_for_select(site)
+      out = []
+      site.menus.each do |amenu|
+        out << [ "#{amenu.label}", amenu.id ]
+      end
+      return out.compact
+    end
+    
+end

data/app/models/cms/menu_item.rb

@@ -0,0 +1,14 @@
+class Cms::MenuItem < ActiveRecord::Base
+  attr_accessible :label, :link, :menu_id, :page_id, :menu_item_type
+  # -- Relationships --------------------------------------------------------
+  belongs_to :menu
+  
+  # -- Validations ----------------------------------------------------------
+  validates :menu_id, 
+    :presence   => true
+  validates :label, 
+    :presence   => true
+#  validates :menu_item_type, 
+#    :presence   => true
+  
+end

data/app/models/cms/page.rb

@@ -0,0 +1,202 @@
+# encoding: utf-8
+
+class Cms::Page < ActiveRecord::Base
+  
+  ComfyPress.establish_connection(self)
+    
+  self.table_name = 'cms_pages'
+  
+  attr_accessible :layout, :layout_id,
+                  :label,
+                  :slug,
+                  :parent, :parent_id,
+                  :blocks_attributes,
+                  :is_published,
+                  :target_page_id, :menu_id,
+                  :category_ids
+  
+  cms_acts_as_tree :counter_cache => :children_count
+  cms_is_categorized
+  cms_is_mirrored
+  cms_has_revisions_for :blocks_attributes
+  
+  attr_accessor :tags,
+                :blocks_attributes_changed
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :site
+  belongs_to :layout
+  belongs_to :target_page,
+    :class_name => 'Cms::Page'
+  has_many :blocks,
+    :autosave   => true,
+    :dependent  => :destroy
+  has_one :menu
+  
+  # -- Callbacks ------------------------------------------------------------
+  before_validation :assigns_label,
+                    :assign_parent,
+                    :escape_slug,
+                    :assign_full_path
+  before_create     :assign_position
+  before_save       :set_cached_content
+  after_save        :sync_child_pages
+  after_find        :unescape_slug_and_path
+  
+  # -- Validations ----------------------------------------------------------
+  validates :site_id, 
+    :presence   => true
+  validates :label,
+    :presence   => true
+  validates :slug,
+    :presence   => true,
+    :uniqueness => { :scope => :parent_id },
+    :unless     => lambda{ |p| p.site && (p.site.pages.count == 0 || p.site.pages.root == self) }
+  validates :layout,
+    :presence   => true
+  validate :validate_target_page
+  validate :validate_format_of_unescaped_slug
+  
+  # -- Scopes ---------------------------------------------------------------
+  default_scope order('cms_pages.position')
+  scope :published, where(:is_published => true)
+  
+  # -- Class Methods --------------------------------------------------------
+  # Tree-like structure for pages
+  def self.options_for_select(site, page = nil, current_page = nil, depth = 0, exclude_self = true, spacer = '. . ')
+    return [] if (current_page ||= site.pages.root) == page && exclude_self || !current_page
+    out = []
+    out << [ "#{spacer*depth}#{current_page.label}", current_page.id ] unless current_page == page
+    current_page.children.each do |child|
+      out += options_for_select(site, page, child, depth + 1, exclude_self, spacer)
+    end
+    return out.compact
+  end
+  
+  # -- Instance Methods -----------------------------------------------------
+  # For previewing purposes sometimes we need to have full_path set. This
+  # full path take care of the pages and its childs but not of the site path
+  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 blocks_attributes(was = false)
+    self.blocks.collect do |block|
+      block_attr = {}
+      block_attr[:identifier] = block.identifier
+      block_attr[:content]    = was ? block.content_was : block.content
+      block_attr
+    end
+  end
+  
+  # Array of block hashes in the following format:
+  #   [
+  #     { :identifier => 'block_1', :content => 'block content' },
+  #     { :identifier => 'block_2', :content => 'block content' }
+  #   ]
+  def blocks_attributes=(block_hashes = [])
+    block_hashes = block_hashes.values if block_hashes.is_a?(Hash)
+    block_hashes.each do |block_hash|
+      block_hash.symbolize_keys! unless block_hash.is_a?(HashWithIndifferentAccess)
+      block = 
+        self.blocks.detect{|b| b.identifier == block_hash[:identifier]} || 
+        self.blocks.build(:identifier => block_hash[:identifier])
+      block.content = block_hash[:content]
+      self.blocks_attributes_changed = self.blocks_attributes_changed || block.content_changed?
+    end
+  end
+  
+  # Processing content will return rendered content and will populate 
+  # self.cms_tags with instances of CmsTag
+  def content(force_reload = false)
+    @content = force_reload ? nil : read_attribute(:content)
+    @content ||= begin
+      self.tags = [] # resetting
+      if layout
+        ComfyPress::Tag.process_content(
+          self,
+          ComfyPress::Tag.sanitize_irb(layout.merged_content)
+        )
+      else
+        ''
+      end
+    end
+  end
+  
+  # Array of cms_tags for a page. Content generation is called if forced.
+  # These also include initialized cms_blocks if present
+  def tags(force_reload = false)
+    self.content(true) if force_reload
+    @tags ||= []
+  end
+  
+  # Full url for a page
+  def url
+    "http://" + "#{self.site.hostname}/#{self.site.path}/#{self.full_path}".squeeze("/")
+  end
+  
+  # Method to collect prevous state of blocks for revisions
+  def blocks_attributes_was
+    blocks_attributes(true)
+  end
+  
+protected
+  
+  def assigns_label
+    self.label = self.label.blank?? self.slug.try(:titleize) : self.label
+  end
+  
+  def assign_parent
+    return unless site
+    self.parent ||= site.pages.root unless self == site.pages.root || site.pages.count == 0
+  end
+  
+  def assign_full_path
+    self.full_path = self.parent ? "#{CGI::escape(self.parent.full_path).gsub('%2F', '/')}/#{self.slug}".squeeze('/') : '/'
+  end
+  
+  def assign_position
+    return unless self.parent
+    return if self.position.to_i > 0
+    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 validate_format_of_unescaped_slug
+    return unless slug.present?
+    unescaped_slug = CGI::unescape(self.slug)
+    errors.add(:slug, :invalid) unless unescaped_slug =~ /^\p{Alnum}[\.\p{Alnum}\p{Mark}_-]*$/i
+  end
+  
+  # NOTE: This can create 'phantom' page blocks as they are defined in the layout. This is normal.
+  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
+
+  # Escape slug unless it's nonexistent (root)
+  def escape_slug
+    self.slug = CGI::escape(self.slug) unless self.slug.nil?
+  end
+
+  # Unescape the slug and full path back into their original forms unless they're nonexistent
+  def unescape_slug_and_path
+    self.slug       = CGI::unescape(self.slug)      unless self.slug.nil?
+    self.full_path  = CGI::unescape(self.full_path) unless self.full_path.nil?
+  end
+  
+end

data/app/models/cms/revision.rb

@@ -0,0 +1,17 @@
+class Cms::Revision < ActiveRecord::Base
+  
+  ComfyPress.establish_connection(self)
+  
+  self.table_name = 'cms_revisions'
+  
+  serialize :data
+  
+  attr_accessible :data
+  
+  # -- Relationships --------------------------------------------------------
+  belongs_to :record, :polymorphic => true
+  
+  # -- Scopes ---------------------------------------------------------------
+  default_scope order('created_at DESC')
+  
+end

data/app/models/cms/site.rb

@@ -0,0 +1,113 @@
+class Cms::Site < ActiveRecord::Base
+  
+  ComfyPress.establish_connection(self)
+  
+  self.table_name = 'cms_sites'
+  
+  attr_accessible :identifier,
+                  :label,
+                  :hostname,
+                  :path,
+                  :locale,
+                  :is_mirrored,
+                  :menu_id
+  
+  # -- Relationships --------------------------------------------------------
+  with_options :dependent => :destroy do |site|
+    site.has_many :layouts
+    site.has_many :pages
+    site.has_many :snippets
+    site.has_many :files
+    site.has_many :categories
+    site.has_many :menus
+    site.has_many :menu_items, :through => :menus
+  end
+  
+  # -- Callbacks ------------------------------------------------------------
+  before_validation :assign_identifier,
+                    :assign_hostname,
+                    :assign_label
+  before_save :clean_path
+  after_save  :sync_mirrors
+  
+  # -- Validations ----------------------------------------------------------
+  validates :identifier,
+    :presence   => true,
+    :uniqueness => true,
+    :format     => { :with => /^\w[a-z0-9_-]*$/i }
+  validates :label,
+    :presence   => true
+  validates :hostname,
+    :presence   => true,
+    :uniqueness => { :scope => :path },
+    :format     => { :with => /^[\w\.\-]+(?:\:\d+)?$/ }
+    
+  # -- Scopes ---------------------------------------------------------------
+  scope :mirrored, where(:is_mirrored => true)
+  
+  # -- Class Methods --------------------------------------------------------
+  # returning the Cms::Site instance based on host and path
+  def self.find_site(host, path = nil)
+    return Cms::Site.first if Cms::Site.count == 1
+    cms_site = nil
+    Cms::Site.find_all_by_hostname(real_host_from_aliases(host)).each do |site|
+      if site.path.blank?
+        cms_site = site
+      elsif "#{path.to_s.split('?')[0]}/".match /^\/#{Regexp.escape(site.path.to_s)}\//
+        cms_site = site
+        break
+      end
+    end
+    return cms_site
+  end
+  
+  # -- Instance Methods -----------------------------------------------------
+  # When removing entire site, let's not destroy content from other sites
+  # Since before_destroy doesn't really work, this does the trick
+  def destroy
+    self.class.update_all({:is_mirrored => false}, :id => self.id) if self.is_mirrored?
+    super
+  end
+
+protected
+  
+  def self.real_host_from_aliases(host)
+    if aliases = ComfyPress.config.hostname_aliases
+      aliases.each do |alias_host, aliases|
+        return alias_host if aliases.include?(host)
+      end
+    end
+    host
+  end
+
+  def assign_identifier
+    self.identifier = self.identifier.blank?? self.hostname.try(:slugify) : self.identifier
+  end
+  
+  def assign_hostname
+    self.hostname ||= self.identifier
+  end
+  
+  def assign_label
+    self.label = self.label.blank?? self.identifier.try(:titleize) : self.label
+  end
+  
+  def clean_path
+    self.path ||= ''
+    self.path.squeeze!('/')
+    self.path.gsub!(/\/$/, '')
+  end
+  
+  # When site is marked as a mirror we need to sync its structure
+  # with other mirrors.
+  def sync_mirrors
+    return unless is_mirrored_changed? && is_mirrored?
+    
+    [self, Cms::Site.mirrored.where("id != #{id}").first].compact.each do |site|
+      (site.layouts(:reload).roots + site.layouts.roots.map(&:descendants)).flatten.map(&:sync_mirror)
+      (site.pages(:reload).roots + site.pages.roots.map(&:descendants)).flatten.map(&:sync_mirror)
+      site.snippets(:reload).map(&:sync_mirror)
+    end
+  end
+  
+end