adva_cms 0.0.1

data/app/models/article.rb

@@ -0,0 +1,40 @@
+class Article < Content
+  # default_scope :order => "#{self.table_name}.published_at DESC"
+
+  filters_attributes :except => [:excerpt, :excerpt_html, :body, :body_html, :cached_tag_list]
+
+  validates_presence_of :title, :body
+  validates_uniqueness_of :permalink, :scope => :section_id
+
+  class << self
+    def locale
+      "en"
+    end
+  end
+
+  def primary?
+    self == section.articles.primary
+  end
+
+  def previous
+    section.articles.published.where(["#{self.class.table_name}.published_at < ?", published_at]).reorder(published_at: :desc).first
+  end
+  alias_method :previous_article, :previous
+
+  def next
+    section.articles.published.where(["#{self.class.table_name}.published_at > ?", published_at]).reorder(published_at: :asc).first
+  end
+  alias_method :next_article, :next
+
+  def has_excerpt?
+    return false if excerpt == "<p>&#160;</p>" # empty excerpt with fckeditor
+    excerpt.present?
+  end
+
+  def full_permalink
+    raise "cannot create full_permalink for an article that belongs to a non-blog section" unless section.is_a?(Blog)
+    # raise "can not create full_permalink for an unpublished article" unless published?
+    date = [:year, :month, :day].map { |key| [key, (published? ? published_at : created_at).send(key)] }.flatten
+    Hash[:permalink, permalink, *date]
+  end
+end

data/app/models/categorization.rb

@@ -0,0 +1,4 @@
+class Categorization < ActiveRecord::Base
+  belongs_to :categorizable, :polymorphic => true
+  belongs_to :category
+end

data/app/models/category.rb

@@ -0,0 +1,60 @@
+class Category < ActiveRecord::Base
+  acts_as_nested_set :scope => :section_id
+  has_permalink :title, :url_attribute => :permalink, :sync_url => true, :only_when_blank => true, :scope => :section_id
+
+  belongs_to :section, :foreign_key => 'section_id'
+  has_many :contents, :through => :categorizations, :source => :categorizable, :source_type => 'Content'
+  has_many :categorizations, :dependent => :delete_all
+
+  before_save  :update_path
+  after_create :update_paths
+
+  validates_presence_of :section, :title
+  validates_uniqueness_of :permalink, :scope => :section_id
+
+  def owners
+    owner.owners << owner
+  end
+
+  def owner
+    section
+  end
+
+  def all_contents
+    Content.by_category(self)
+  end
+
+  protected
+
+    def update_path
+      if permalink_changed?
+        new_path = build_path
+        unless self.path == new_path
+          self.path = new_path
+          @paths_dirty = true
+        end
+      end
+    end
+
+    # FIXME this is not hooked up. same in Section. don't we need to call this anyway?
+    def update_child_paths
+      if @paths_dirty
+        self.all_children.each do |child|
+          child.path = child.build_path
+          child.save
+        end
+        @paths_dirty = false
+      end
+    end
+
+    def build_path
+      self_and_ancestors.map(&:permalink).join('/')
+    end
+
+    def update_paths
+      if parent_id
+        move_to_child_of(parent)
+        section.categories.update_paths!
+      end
+    end
+end

data/app/models/content.rb

@@ -0,0 +1,155 @@
+require 'html_diff'
+
+class Content < ActiveRecord::Base
+  acts_as_nested_set :scope => :section_id
+
+  # TODO is this needed?
+  class Version < ActiveRecord::Base
+    filters_attributes :none => true
+  end
+
+  has_filter :tagged, :categorized,
+             :text  => { :attributes => [:title, :body, :excerpt] },
+             :state => { :states => [:published, :unpublished] }
+
+  acts_as_taggable
+
+  instantiates_with_sti
+  has_permalink :title, :url_attribute => :permalink, :sync_url => true, :only_when_blank => true, :scope => :section_id
+  filtered_column :body, :excerpt
+
+  belongs_to :site
+  belongs_to :section, :touch => true
+  belongs_to_author :validate => true
+
+  has_many :assets, :through => :asset_assignments
+  has_many :asset_assignments # TODO :dependent => :delete_all?
+  has_many :categories, :through => :categorizations
+  has_many :categorizations, -> { includes(:category) }, as: :categorizable, dependent: :destroy
+
+  after_save do
+    categories.each(&:touch)
+  end
+
+  before_validation :set_site
+
+  scope :published, -> {
+    where(['contents.published_at IS NOT NULL AND contents.published_at <= ?', Time.zone.now])
+  }
+
+  scope :drafts, -> {
+    where(published_at: nil)
+  }
+
+  scope :unpublished, -> {
+    drafts
+  }
+
+  scope :by_category, -> (category) {
+    section_type = category.section.class
+    includes([:categories, :section])
+      .where([
+        "categories.lft >= ? AND categories.rgt <= ? AND sections.type = ?",
+        category.lft, category.rgt, section_type.to_s
+      ]).references(:categories, :section)
+  }
+
+  class << self
+    def primary
+      published.first
+    end
+  end
+
+  def to_param
+    permalink
+  end
+
+  def owners
+    owner.owners << owner
+  end
+
+  def owner
+    section
+  end
+
+  def category_titles
+    categories.collect(&:title)
+  end
+
+  attr_accessor :draft
+  def published_at=(published_at)
+    write_attribute(:published_at, draft.to_i == 1 ? nil : published_at)
+  end
+
+  def author_id=(author_id)
+    # FIXME this is only needed because belongs_to_cacheable can't be non-polymorphic, yet
+    self.author = User.find(author_id) if author_id
+  end
+
+  def published_year
+    Time.local(published_at.year, 1, 1)
+  end
+
+  def published_month
+    Time.local(published_at.year, published_at.month, 1)
+  end
+
+  def draft?
+    published_at.nil?
+  end
+
+  def pending?
+    !published?
+  end
+
+  def published?
+    !published_at.nil? && published_at <= Time.zone.now
+  end
+
+  def published_at?(date)
+    published? && date == [:year, :month, :day].map { |key| published_at.send(key).to_s }
+  end
+
+  def state
+    pending? ? :pending : :published
+  end
+
+  def just_published?
+    published? && published_at_changed?
+  end
+
+  def diff_against_version(version)
+    # return '(orginal version)' if version == versions.earliest.version
+    version = versions[version]
+    HtmlDiff.diff(version.excerpt_html + version.body_html, excerpt_html + body_html)
+  end
+
+  # def to_param(key)
+  #   value = if self.respond_to?(key)
+  #     self.send(key)
+  #   elsif [:year, :month, :day].include?(key)
+  #     published_at.send(key)
+  #   else
+  #     super()
+  #   end
+  #   value ? value.to_s : nil
+  # end
+
+  protected
+
+    def set_site
+      self.site_id = section.site_id if section
+    end
+
+    def update_categories(category_ids)
+      category_ids = Array(category_ids).reject(&:blank?)
+      return if category_ids.empty?
+
+      categories.each do |category|
+        category_ids.delete(category.id.to_s) || categories.delete(category)
+      end
+      if category_ids.present?
+        categories << Category.find(:all, :conditions => ['id in (?)', category_ids])
+      end
+    end
+end

data/app/models/event.rb

@@ -0,0 +1,34 @@
+class Event
+  cattr_accessor :observers
+  @@observers = []
+
+  attr_reader :type        # what happened
+  attr_reader :object      # the object that the event is about, e.g. payment
+  attr_reader :source      # the origin or the event, e.g. payment processor
+  attr_reader :options     # optional options for the event
+
+  class << self
+    def trigger(type, object, source, options = {})
+      event = Event.new(type, object, source, options)
+      observers.each do |observer|
+        observer = observer.constantize if observer.is_a?(String)
+        callback = :"handle_#{event.type}!"
+
+        if observer.respond_to?(callback)
+          observer.send(callback, event)
+        elsif observer.respond_to?(:handle_event!)
+          observer.handle_event!(event)
+        end
+      end
+    end
+  end
+
+  def initialize(type, object, source, options = {})
+    @type, @object, @source, @options = type, object, source, options
+  end
+
+  def method_missing(name, *args)
+    return @options[name] if @options.has_key?(name)
+    super
+  end
+end

data/app/models/link.rb

@@ -0,0 +1,4 @@
+class Link < Content
+  filters_attributes :except => [:excerpt, :excerpt_html, :body, :body_html, :cached_tag_list]
+  validates_presence_of :title, :body
+end

data/app/models/page.rb

@@ -0,0 +1,36 @@
+class Page < Section
+  has_option :single_article_mode, :default => true, :type => :boolean
+
+  # avoid double destroy hook
+  has_many :articles, -> { order(:lft) }, dependent: :destroy, foreign_key: :section_id
+  has_many :links, -> { order(:lft) }, dependent: :destroy, foreign_key: :section_id
+
+  class << self
+    def content_types
+      %w(Article Link)
+    end
+  end
+
+  def published_at
+    return contents.first.published_at if single_article_mode && contents.first
+    super
+  end
+
+  def published_at=(published_at)
+    if single_article_mode && contents.first
+      contents.first.update_attribute(:published_at, published_at)
+    else
+      super
+    end
+  end
+
+  def published?(parents = false)
+    if single_article_mode
+      # FIXME: duplication with Section class
+      return true if self == site.sections.root
+      return false if parents && !ancestors.reject(&:published?).empty?
+      return contents.first ? contents.first.published? : false
+    end
+    super
+  end
+end

data/app/models/section.rb

@@ -0,0 +1,126 @@
+class Section < ActiveRecord::Base
+  default_scope -> { order(:lft) }
+
+  @@types = ['Page']
+  cattr_reader :types
+
+  serialize :permissions
+
+  has_option :contents_per_page, :default => 15
+  has_permalink :title, :url_attribute => :permalink, :sync_url => true,
+    :only_when_blank => true, :scope => [ :site_id, :parent_id ]
+  acts_as_nested_set :scope => :site_id
+  instantiates_with_sti
+
+  belongs_to :site, :touch => true
+  has_many :categories, -> { order(:lft) }, dependent: :destroy do
+    def update_paths!
+      paths = Hash[*roots.map { |r|
+        r.self_and_descendants.map { |n| [n.id, { 'path' => n.send(:build_path) }] } }.flatten]
+      update(paths.keys, paths.values)
+    end
+  end
+
+  has_many :contents, -> { order(:lft) }, foreign_key: :section_id
+
+  before_save  :update_path
+  before_create :set_as_published
+  after_create :update_paths
+
+  validates_presence_of :title # :site wtf ... this breaks install_controller#index
+  validates_uniqueness_of :permalink, :scope => :site_id
+  validates_numericality_of :contents_per_page, :only_integer => true, :message => :only_integer
+
+  # validates_each :template, :layout do |record, attr, value|
+  #   record.errors.add attr, 'may not contain dots' if value.index('.') # FIXME i18n
+  #   record.errors.add attr, 'may not start with a slahs' if value.index('.') # FIXME i18n
+  # end
+
+  # TODO validates_inclusion_of :contents_per_page, :in => 1..30, :message => "can only be between 1 and 30."
+
+  class << self
+    def register_type(type)
+      @@types << type
+      @@types.uniq!
+    end
+  end
+
+  def to_param
+    permalink
+  end
+
+  def owners
+    owner.owners << owner
+  end
+
+  def owner
+    site
+  end
+
+  def type
+    read_attribute(:type) || 'Section'
+  end
+
+  def tag_counts
+    Content.tag_counts :conditions => "section_id = #{id}"
+  end
+
+  def root_section?
+    self == site.sections.root
+  end
+
+  def state
+    published? ? :published : :pending
+  end
+
+  def published=(published)
+    if published.to_i == 1
+      self.published_at = Time.current if !published_at
+    elsif published.to_i == 0
+      self.published_at = nil
+    end
+  end
+  
+  def published?(parents = false)
+    return true if self == site.sections.root # the root section is always published
+    return false if parents && has_unpublished_ancestor?
+    return false if published_at.nil? || published_at > Time.current
+    return true
+  end
+  alias published published?
+
+  def nav_children
+    contents.roots.published
+  end
+
+  protected
+  
+    def set_as_published
+      self.published_at = published_at || Time.current
+    end
+  
+    def has_unpublished_ancestor?
+      !ancestors.reject(&:published?).empty?
+    end
+
+    def update_path
+      if permalink_changed?
+        new_path = build_path
+        unless self.path == new_path
+          self.path = new_path
+          @paths_dirty = true
+        end
+      end
+    end
+
+    def build_path
+      self_and_ancestors.map(&:permalink).join('/')
+    end
+
+    def update_paths
+      if parent_id
+        move_to_child_of(parent)
+        site.sections.update_paths!
+      end
+    end
+end