pages_core 3.4.3 → 3.7.0

data/app/models/category.rb

@@ -1,23 +1,22 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-class Category < ActiveRecord::Base
-  has_and_belongs_to_many :pages, join_table: "pages_categories"
-  validates_presence_of :name
+class Category < ApplicationRecord
+  has_many :page_categories, dependent: :destroy
+  has_many :pages, through: :page_categories
+  validates :name, presence: true
   acts_as_list
 
   before_save :set_slug
-  after_save ThinkingSphinx::RealTime.callback_for(:pages, [:page])
 
   scope :by_name, -> { order("name ASC") }
 
   private
 
   def set_slug
-    self.slug = name
-      .downcase
-      .gsub(/[^\w\s]/, "")
-      .split(/[^\w\d\-]+/)
-      .compact
-      .join("-")
+    self.slug = name.downcase
+                    .gsub(/[^\w\s]/, "")
+                    .split(/[^\w\d\-]+/)
+                    .compact
+                    .join("-")
   end
 end

data/app/models/concerns/pages_core/has_roles.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module HasRoles
     extend ActiveSupport::Concern
@@ -5,21 +7,20 @@ module PagesCore
     def role?(role_name)
       role_names.include?(role_name.to_s)
     end
-    alias_method :has_role?, :role?
+    alias has_role? role?
 
     def role_names
       roles.map(&:name)
     end
 
     def role_names=(names)
-      new_roles = names.map do |name|
+      self.roles = names.map do |name|
         if role?(name)
-          roles.where(name: name).first
+          roles.find_by(name: name)
         else
           roles.new(name: name)
         end
       end
-      self.roles = new_roles
     end
   end
 end

data/app/models/concerns/pages_core/humanizable_param.rb

@@ -1,17 +1,20 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module PagesCore
   module HumanizableParam
+    include ActiveSupport::Inflector
     extend ActiveSupport::Concern
 
     def humanized_param(slug)
-      return id.to_s unless slug && !slug.blank?
-      "#{id}-" + slug
-        .gsub(/[\[\{]/, "(")
-        .gsub(/[\]\}]/, ")")
-        .gsub(/[^[[:alnum:]]()\-]+/, "-")
-        .gsub(/[\-]{2,}/, "-")
-        .gsub(/(^\-|\-$)/, "")
+      return id.to_s unless slug&.present?
+
+      "#{id}-" + transliterate(slug)
+                 .downcase
+                 .gsub(/[\[{]/, "(")
+                 .gsub(/}\]/, ")")
+                 .gsub(/[^[[:alnum:]]()-]+/, "-")
+                 .gsub(/-{2,}/, "-")
+                 .gsub(/(^-|-$)/, "")
     end
   end
 end

data/app/models/concerns/pages_core/page_model/attachments.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    module Attachments
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :page_files,
+                 -> { order("position ASC") },
+                 class_name: "PageFile",
+                 dependent: :destroy,
+                 inverse_of: :page
+
+        has_many :attachments, through: :page_files
+
+        accepts_nested_attributes_for(
+          :page_files,
+          reject_if: proc { |a| a["attachment_id"].blank? },
+          allow_destroy: true
+        )
+      end
+
+      def attachments
+        super.in_locale(locale)
+      end
+
+      def attachments?
+        attachments.any?
+      end
+
+      def page_files
+        super.in_locale(locale)
+      end
+
+      def files
+        page_files
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/autopublishable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    module Autopublishable
+      extend ActiveSupport::Concern
+
+      included do
+        before_validation :set_autopublish
+        after_save :queue_autopublisher
+      end
+
+      private
+
+      def set_autopublish
+        self.autopublish = published_at? && published_at > Time.now.utc
+        true
+      end
+
+      def queue_autopublisher
+        Autopublisher.queue! if autopublish?
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/dated_page.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    module DatedPage
+      extend ActiveSupport::Concern
+
+      included do
+        before_validation :set_all_day_dates
+        before_validation :ensure_ends_at
+
+        scope :upcoming, -> { where("ends_at > ?", Time.zone.now) }
+        scope :past, -> { where("ends_at <= ?", Time.zone.now) }
+      end
+
+      module ClassMethods
+      end
+
+      # Finds the page's next sibling by date. Returns nil if there
+      # isn't one.
+      def next_sibling_by_date
+        siblings_by_date.where("starts_at >= ?", starts_at)&.first
+      end
+
+      # Finds the page's previous sibling by date. Returns nil if
+      # there isn't one.
+      def previous_sibling_by_date
+        siblings_by_date.where("starts_at < ?", starts_at)&.last
+      end
+
+      def upcoming?
+        return false unless ends_at?
+
+        ends_at > Time.zone.now
+      end
+
+      private
+
+      def ensure_ends_at
+        return unless starts_at?
+
+        self.ends_at = starts_at if !ends_at? || ends_at < starts_at
+      end
+
+      def set_all_day_dates
+        return unless all_day?
+
+        self.starts_at = starts_at.beginning_of_day if starts_at?
+        self.ends_at = ends_at.end_of_day if ends_at?
+      end
+
+      def siblings_by_date
+        siblings.reorder("starts_at ASC, pages.id DESC")
+                .where
+                .not(id: id)
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/images.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    module Images
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to_image :image, optional: true
+        belongs_to_image :meta_image, class_name: "Image", optional: true
+        has_many :page_images, -> { order("position") }, inverse_of: :page
+        has_many(
+          :images,
+          -> { where(page_images: { primary: false }).order("position") },
+          through: :page_images
+        )
+
+        after_save :update_primary_image
+
+        accepts_nested_attributes_for :page_images,
+                                      reject_if: proc { |a|
+                                                   a["image_id"].blank?
+                                                 },
+                                      allow_destroy: true
+      end
+
+      def image?
+        image_id?
+      end
+
+      def image
+        super.try { |i| i.localize(locale) }
+      end
+
+      def images
+        super.in_locale(locale)
+      end
+
+      def page_images
+        super.in_locale(locale)
+      end
+
+      private
+
+      def update_primary_image
+        new_id = page_images.find_by(primary: true)&.image_id
+        update(image_id: new_id) if new_id != image_id
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/localizable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    module Localizable
+      include ActiveSupport::Inflector
+      extend ActiveSupport::Concern
+
+      included do
+        localizable do
+          attribute :name
+          attribute :body
+          attribute :excerpt
+          attribute :headline
+          attribute :boxout
+
+          attribute :path_segment
+          attribute :meta_title
+          attribute :meta_description
+          attribute :open_graph_title
+          attribute :open_graph_description
+
+          dictionary(lambda do
+            PagesCore::Templates::TemplateConfiguration.localized_blocks
+          end)
+        end
+      end
+
+      def transliterated_name
+        prev_locale = I18n.locale
+        I18n.locale = locale.to_sym if locale
+        transliterated = transliterate(name)
+        I18n.locale = prev_locale
+        transliterated
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/pathable.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    module Pathable
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :page_paths, dependent: :destroy
+
+        validates :path_segment, format: { with: /\A[[[:alnum:]]-_]*\z/ }
+        validate :path_segment_cannot_be_routable
+        before_validation :ensure_no_path_segment_on_deletion
+        after_save :ensure_path_segment
+        after_save :associate_page_path
+      end
+
+      def full_path
+        generate_full_path
+      end
+
+      def full_path?
+        path_segment.present? && pathable?
+      end
+
+      def ensure_path_segment
+        return if deleted? || path_segment? || !name?
+
+        segment = generated_path_segment
+        segment = "#{segment}-#{id}" if path_collision?(segment)
+        update(path_segment: segment)
+      end
+
+      def pathable?
+        return true unless parent
+
+        parent.full_path?
+      end
+
+      private
+
+      def associate_page_path
+        return if deleted? || !full_path?
+
+        PagePath.build(self)
+      end
+
+      def ensure_no_path_segment_on_deletion
+        return unless deleted?
+
+        self.path_segment = nil
+      end
+
+      def generate_full_path(last_segment = nil)
+        last_segment ||= path_segment
+        return nil unless last_segment.present? && pathable?
+
+        [parent&.full_path, last_segment].compact.join("/")
+      end
+
+      def generated_path_segment
+        transliterated_name.gsub(/[^[[:alnum:]]-_]+/, "-")
+                           .gsub(/-{2,}/, "-")
+                           .gsub(/(^-|-$)/, "")
+                           .mb_chars
+                           .downcase
+      end
+
+      def page_path_matches_routes?(page_path)
+        [
+          "/#{page_path}",
+          "/#{I18n.default_locale}/#{page_path}"
+        ].map { |p| recognizable_route?(p) }.any?
+      end
+
+      def page_path_route?(route)
+        route[:controller] == "pages" &&
+          route[:action] == "show" &&
+          route[:path].present?
+      end
+
+      def path_collision?(path_segment)
+        sibling_path_segments.include?(path_segment) ||
+          page_path_matches_routes?(generate_full_path(path_segment))
+      end
+
+      def path_segment_cannot_be_routable
+        return unless full_path?
+        return unless page_path_matches_routes?(full_path)
+
+        errors.add(:path_segment, "can't match an existing URL")
+      end
+
+      def recognizable_route?(path)
+        route = Rails.application.routes.recognize_path(path)
+        !page_path_route?(route)
+      rescue ActionController::RoutingError
+        false
+      end
+
+      def sibling_path_segments
+        siblings = if parent
+                     parent.children
+                   else
+                     self.class.roots
+                   end
+        siblings.reject { |p| p == self }
+                .map { |p| p.localize(locale) }
+                .map(&:path_segment)
+                .reject(&:blank?)
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/redirectable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module PageModel
+    class InvalidRedirectUrl < StandardError; end
+
+    module Redirectable
+      extend ActiveSupport::Concern
+
+      included do
+        validates(:redirect_to,
+                  format: { with: %r{\A(/|https?://).+\z},
+                            allow_blank: true })
+      end
+
+      # Returns boolean true if page has a valid redirect
+      def redirects?
+        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)
+              raise InvalidRedirectUrl, "must be a string or a symbol"
+            end
+
+            path.gsub!("/:#{key}", "/#{value}")
+          end
+        end
+        path
+      end
+    end
+  end
+end