pages_core 3.4.3 → 3.5.1

data/app/models/page.rb

@@ -2,72 +2,41 @@
 
 class Page < ActiveRecord::Base
   include PagesCore::HumanizableParam
-  include PagesCore::PageTree
-  include PagesCore::SearchablePage
   include PagesCore::Sweepable
   include PagesCore::Taggable
-  include PagesCore::Templateable
 
-  belongs_to :author, class_name: "User", foreign_key: :user_id
-
-  has_and_belongs_to_many :categories, join_table: "pages_categories"
-
-  belongs_to_image :image
-  belongs_to_image :meta_image, class_name: "Image"
+  include PagesCore::PageModel::Autopublishable
+  include PagesCore::PageModel::Commentable
+  include PagesCore::PageModel::Images
+  include PagesCore::PageModel::Localizable
+  include PagesCore::PageModel::Pathable
+  include PagesCore::PageModel::Redirectable
+  include PagesCore::PageModel::Searchable
+  include PagesCore::PageModel::Sortable
+  include PagesCore::PageModel::Status
+  include PagesCore::PageModel::Tree
+  include PagesCore::PageModel::Templateable
 
-  has_many :page_images, -> { order("position") }
-
-  has_many :images,
-           -> { where("`page_images`.`primary` = ?", false).order("position") },
-           through: :page_images
+  belongs_to :author, class_name: "User", foreign_key: :user_id
 
-  has_many :comments,
-           class_name: "PageComment",
-           dependent: :destroy
+  has_many :page_categories, dependent: :destroy
+  has_many :categories, through: :page_categories
 
   has_many :page_files,
            -> { order("position ASC") },
            class_name: "PageFile",
            dependent: :destroy
 
-  acts_as_list scope: :parent_page
-
-  localizable do
-    attribute :name
-    attribute :body
-    attribute :excerpt
-    attribute :headline
-    attribute :boxout
-
-    attribute :meta_description
-    attribute :open_graph_title
-    attribute :open_graph_description
-
-    dictionary -> { PagesCore::Templates::TemplateConfiguration.all_blocks }
-  end
-
-  validates_format_of :redirect_to,
-                      with: %r{\A(/|https?://)},
-                      allow_nil: true,
-                      allow_blank: true
-
-  validates_format_of :unique_name,
-                      with: /\A[\w\d_\-]+\z/,
+  validates(:unique_name,
+            format: { with: /\A[\w\d_\-]+\z/,
                       allow_nil: true,
-                      allow_blank: true
-
-  validates_uniqueness_of :unique_name, allow_nil: true, allow_blank: true
+                      allow_blank: true },
+            uniqueness: { allow_nil: true, allow_blank: true })
 
   validates :template, presence: true
-  validates :content_order, presence: true
   validates :published_at, presence: true
 
   before_validation :published_at
-  before_validation :set_autopublish
-  before_validation :set_content_order
-  after_save :ensure_page_images_contains_primary_image
-  after_save :queue_autopublisher
-  after_save ThinkingSphinx::RealTime.callback_for(:page)
 
   scope :by_date,    -> { order("published_at DESC") }
   scope :published,  -> { where(status: 2, autopublish: false) }
@@ -85,69 +54,19 @@ class Page < ActiveRecord::Base
       conditions = (options[:include_hidden]) ? "status IN (2,3)" : "status = 2"
       Page.where(feed_enabled: true).where(conditions).localized(locale)
     end
-
-    def status_labels
-      {
-        0 => "Draft",
-        1 => "Reviewed",
-        2 => "Published",
-        3 => "Hidden",
-        4 => "Deleted"
-      }
-    end
-
-    def order_by_tags(tags)
-      joins(
-        "LEFT JOIN taggings ON taggings.taggable_id = pages.id AND " \
-          "taggable_type = \"Page\"",
-        "LEFT JOIN tags ON tags.id = taggings.tag_id AND tags.id IN (" +
-          tags.map(&:id).join(",") +
-          ")"
-      )
-        .group("pages.id, localizations.id")
-        .reorder("COUNT(tags.id) DESC, position ASC")
-    end
-  end
-
-  def comments_closed_after_time?
-    if PagesCore.config.close_comments_after.nil?
-      false
-    else
-      (Time.now - published_at) > PagesCore.config.close_comments_after
-    end
-  end
-
-  def comments_allowed?
-    if self.comments_closed_after_time?
-      false
-    else
-      self[:comments_allowed]
-    end
-  end
-
-  def extended?
-    excerpt? && body?
   end
 
   def empty?
     !body? && !excerpt?
   end
-  alias_method :blank?, :empty?
+  alias blank? empty?
 
   def excerpt_or_body
     excerpt? ? excerpt : body
   end
 
-  def image
-    super.try { |i| i.localize(locale) }
-  end
-
-  def images
-    super.in_locale(locale)
-  end
-
-  def page_images
-    super.in_locale(locale)
+  def extended?
+    excerpt? && body?
   end
 
   def files
@@ -158,124 +77,23 @@ class Page < ActiveRecord::Base
     headline? ? headline : name
   end
 
-  # Does this page have an image?
-  def image?
-    self.image_id?
-  end
-
-  # Get subpages
-  def pages(_options = nil)
-    if self.locale?
-      subpages.published.localized(locale)
-    else
-      subpages.published
+  def move(parent:, position:)
+    Page.transaction do
+      update(parent: parent) unless self.parent == parent
+      insert_at(position)
     end
   end
 
-  def subpages
-    children.order(pinned_content_order)
-  end
-
-  # Return the status of the page as a string
-  def status_label
-    self.class.status_labels[status]
-  end
-
-  def flag_as_deleted!
-    update(status: 4)
-  end
-
   # Get publication date, which defaults to the creation date
   def published_at
-    if self.created_at?
-      self[:published_at] ||= created_at
-    else
-      self[:published_at] ||= Time.now
-    end
-  end
-
-  # Returns boolean true if page has a valid redirect
-  def redirects?
-    self.redirect_to?
-  end
-
-  def redirect_path(params = {})
-    path = redirect_to.dup
-    if path.start_with? "/"
-      params.each do |key, value|
-        unless value.is_a?(String) || value.is_a?(Symbol)
-          fail "redirect_url param must be a string or a symbol"
-        end
-        path.gsub!("/:#{key}", "/#{value}")
-      end
-    end
-    path
-  end
-
-  # Returns true if this page's children is reorderable
-  def reorderable_children?
-    !self.content_order? || content_order =~ /position/
-  end
-
-  # Returns true if this page is reorderable
-  def reorderable?
-    !parent || !parent.content_order? || parent.content_order =~ /position/
-  end
-
-  def draft?
-    status == 0
-  end
-
-  def reviewed?
-    status == 1
-  end
-
-  def published?
-    status == 2 && !autopublish?
-  end
-
-  def hidden?
-    status == 3
-  end
-
-  def deleted?
-    status == 4
+    self[:published_at] ||= if created_at?
+                              created_at
+                            else
+                              Time.now.utc
+                            end
   end
 
   def to_param
     humanized_param(name)
   end
-
-  def content_order
-    self[:content_order] || "position"
-  end
-
-  private
-
-  def ensure_page_images_contains_primary_image
-    return if !image_id? || !image_id_changed?
-    page_image = page_images.where(image_id: image_id).first
-    if page_image
-      page_image.update(primary: true)
-    else
-      page_images.create(image_id: image_id, primary: true)
-    end
-  end
-
-  def pinned_content_order
-    self.news_page? ? "pages.pinned DESC, #{content_order}" : content_order
-  end
-
-  def set_autopublish
-    self.autopublish = published_at? && published_at > Time.now
-    true
-  end
-
-  def set_content_order
-    self[:content_order] ||= "position"
-  end
-
-  def queue_autopublisher
-    Autopublisher.queue! if self.autopublish?
-  end
 end

data/app/models/page_builder.rb

@@ -30,16 +30,14 @@ class PageBuilder
     @parent = parent
   end
 
-  def page(name, options={}, &block)
+  def page(name, options = {}, &block)
     page = Page.create(
-      { name: name }
-        .merge(default_options)
-        .merge(options)
+      { name: name }.merge(default_options).merge(options)
     )
     if block_given?
       self.class
-        .new(user, locale: locale, parent: page)
-        .run(&block)
+          .new(user, locale: locale, parent: page)
+          .run(&block)
     end
     page
   end

data/app/models/page_category.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+class PageCategory < ActiveRecord::Base
+  belongs_to :page
+  belongs_to :category
+  validates :page_id, :category_id, presence: true
+end

data/app/models/page_comment.rb

@@ -7,7 +7,7 @@ class PageComment < ActiveRecord::Base
   attr_accessor :invalid_captcha
 
   def valid_captcha?
-    (invalid_captcha) ? false : true
+    invalid_captcha ? false : true
   end
 
   after_create do |page_comment|

data/app/models/page_file.rb

@@ -56,19 +56,17 @@ class PageFile < ActiveRecord::Base
 
   def to_param
     if filename_extension?
-      "#{id}.#{filename_extension}"
+      "#{id}-#{content_hash}.#{filename_extension}"
     else
-      "#{id}"
+      "#{id}-#{content_hash}"
     end
   end
 
-  def published
-    page.published
-  end
+  delegate :published, to: :page
 
   private
 
   def set_name_from_filename
-    self.name = File.basename(filename, ".*") if self.filename? && !self.name?
+    self.name = File.basename(filename, ".*") if filename? && !name?
   end
 end

data/app/models/page_image.rb

@@ -4,12 +4,12 @@ class PageImage < ActiveRecord::Base
   belongs_to :page
   belongs_to_image :image
 
-  validates_presence_of :page_id
+  validates :page_id, presence: true
 
   accepts_nested_attributes_for :image
   validates_associated :image
 
-  acts_as_list scope: :page
+  acts_as_list scope: [:page, :primary]
 
   localizable
 
@@ -21,15 +21,14 @@ class PageImage < ActiveRecord::Base
 
   after_save do |page_image|
     if page_image.primary_changed?
-
       # Make sure only one PageImage can be the primary,
       # then update image_id on the page.
       if page_image.primary?
         PageImage.where
         page_image.page
-          .page_images
-          .where("id != ?", page_image.id)
-          .update_all(primary: false)
+                  .page_images
+                  .where("id != ?", page_image.id)
+                  .update_all(primary: false)
         page_image.page.update(image_id: page_image.image_id)
 
       # Clear image_id on the page if primary is toggled off
@@ -45,7 +44,7 @@ class PageImage < ActiveRecord::Base
 
   class << self
     def cleanup!
-      all.each do |page_image|
+      all.find_each do |page_image|
         page_image.destroy unless page_image.image
       end
     end

data/app/models/page_path.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+class PagePath < ActiveRecord::Base
+  class PageNotSavedError < StandardError; end
+  class NoPathError < StandardError; end
+  class NoLocaleError < StandardError; end
+
+  belongs_to :page
+  validates :locale, presence: true
+  validates :path, presence: true, uniqueness: { scope: :locale }
+
+  class << self
+    def build(page)
+      page.locales.each do |locale|
+        localized = page.localize(locale)
+        localized.ensure_path_segment
+        associate(localized) if !localized.deleted? && localized.full_path?
+      end
+      page.children.each { |p| build(p) }
+    end
+
+    def build_all
+      Page.roots.each do |p|
+        build(p)
+      end
+    end
+
+    def get(locale, path)
+      find_by(locale: locale, path: path)
+    end
+
+    def associate(page, locale: nil, path: nil)
+      locale ||= page.locale
+      path ||= page.full_path
+      raise PageNotSavedError unless page.id?
+      raise NoLocaleError unless locale
+      raise NoPathError unless path
+      existing = get(locale, path)
+
+      return create(locale: locale, path: path, page: page) unless existing
+
+      existing.update(page: page) unless existing.page_id == page.id
+      existing
+    end
+  end
+end