pages_core 3.6.0 → 3.8.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module PageModel
     module Sortable
@@ -12,13 +14,12 @@ module PagesCore
         def order_by_tags(tags)
           joins(
             "LEFT JOIN taggings ON taggings.taggable_id = pages.id AND " \
-              "taggable_type = #{ActiveRecord::Base.connection.quote('Page')}",
-            "LEFT JOIN tags ON tags.id = taggings.tag_id AND tags.id IN (" +
-              tags.map(&:id).join(",") +
-              ")"
+            "taggings.tag_id IN (#{tags.map(&:id).join(',')}) AND " \
+            "taggings.taggable_type = " \
+            "#{ActiveRecord::Base.connection.quote('Page')}"
           )
             .group("pages.id, localizations.id")
-            .reorder(Arel.sql("COUNT(tags.id) DESC, position ASC"))
+            .reorder(Arel.sql("COUNT(taggings.id) DESC"))
         end
       end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module PageModel
     module Status

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module PageModel
     module Templateable
@@ -13,6 +15,7 @@ module PagesCore
 
       def template
         return self[:template] if self[:template].present?
+
         inherited_or_default_template
       end
 
@@ -29,15 +32,16 @@ module PagesCore
       def singularized_subtemplate
         singularized = ActiveSupport::Inflector.singularize(base_template)
         return if base_template == singularized
+
         find_template_by_expression(
-          Regexp.new("^" + Regexp.quote(singularized))
+          Regexp.new("^#{Regexp.quote(singularized)}")
         )
       end
 
       def subtemplate_with_postfix
         find_template_by_expression(
           Regexp.new(
-            "^" + Regexp.quote(base_template) + "_?(post|page|subpage|item)"
+            "^#{Regexp.quote(base_template)}_?(post|page|subpage|item)"
           )
         )
       end
@@ -69,6 +73,7 @@ module PagesCore
 
       def inherited_or_default_template
         return parent.default_subtemplate.to_s if parent
+
         (default_template_options[:root] || default_template || :index).to_s
       end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module PageModel
     module Tree
@@ -5,17 +7,17 @@ module PagesCore
 
       included do
         belongs_to :parent,
-                   class_name:  "Page",
+                   class_name: "Page",
                    foreign_key: :parent_page_id,
-                   inverse_of:  :children,
-                   optional:    true,
-                   touch:       true
+                   inverse_of: :children,
+                   optional: true,
+                   touch: true
 
         has_many :children,
-                 class_name:  "Page",
+                 class_name: "Page",
                  foreign_key: :parent_page_id,
-                 inverse_of:  :parent,
-                 dependent:   :destroy
+                 inverse_of: :parent,
+                 dependent: :destroy
 
         # This must be included after the belongs_to call in order
         # to override the .parent method.
@@ -26,19 +28,20 @@ module PagesCore
         def admin_list(locale)
           left_outer_joins(:parent)
             .where("pages.status < 4")
-            .order(
-              Arel.sql(
-                <<-QUERY
-                pages.parent_page_id,
-                parents_pages.news_page,
-                case when parents_pages.news_page
-                  then pages.pinned end desc,
-                case when parents_pages.news_page
-                  then pages.published_at end desc,
-                position asc
-                QUERY
-              )
-            ).in_locale(locale)
+            .order(admin_list_order).in_locale(locale)
+        end
+
+        def admin_list_order
+          Arel.sql(
+            <<-QUERY
+            pages.parent_page_id, parents_pages.news_page,
+            case when parents_pages.news_page
+              then pages.pinned end desc,
+            case when parents_pages.news_page
+              then pages.published_at end desc,
+            position asc
+            QUERY
+          )
         end
 
         # Returns all root pages
@@ -66,17 +69,20 @@ module PagesCore
         # Returns all children, recursively
         def all_subpages
           return nil unless subpages.any?
+
           localized_subpages.map { |p| [p, p.all_subpages] }.flatten.compact
         end
 
         def localized_subpages
           return subpages unless locale?
+
           subpages.localized(locale)
         end
 
         # Finds the page's next sibling. Returns nil if there isn't one.
         def next_sibling
           return unless siblings.any?
+
           siblings[(siblings.to_a.index(self) + 1)...siblings.length]
             .try(&:first)
         end
@@ -94,6 +100,7 @@ module PagesCore
         # Finds the page's next sibling. Returns nil if there isn't one.
         def previous_sibling
           return unless siblings.any?
+
           siblings[0...siblings.to_a.index(self)].try(&:last)
         end
 

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module PagesCore
+  module SearchableDocument
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :search_documents, as: :searchable, dependent: :destroy
+      after_save :update_search_documents!
+    end
+
+    class Indexer
+      attr_reader :record
+
+      def initialize(record)
+        @record = record
+      end
+
+      class << self
+        def index_all!(scope)
+          scope.all.find_each { |r| new(r).index! }
+        end
+      end
+
+      def index!
+        SearchDocument.transaction do
+          record.search_documents.where.not(locale: locales).destroy_all
+          locales.each do |locale|
+            update_index(
+              locale,
+              localized_record(locale).search_document_attributes
+            )
+          end
+        end
+      end
+
+      private
+
+      def locales
+        if record.respond_to?(:locales)
+          record.locales
+        elsif PagesCore.config.locales
+          PagesCore.config.locales.keys
+        else
+          [I18n.default_locale]
+        end
+      end
+
+      def localized_record(locale)
+        return record unless record.respond_to?(:localize)
+
+        record.localize(locale)
+      end
+
+      def update_index(locale, attrs)
+        record.search_documents.create_or_find_by!(locale: locale).update(attrs)
+      end
+    end
+
+    def search_document_attributes
+      return {} unless respond_to?(:localized_attributes)
+
+      content = localized_attributes.keys.map { |a| localizer.get(a) }.join(" ")
+      { content: content }
+    end
+
+    def update_search_documents!
+      PagesCore::SearchableDocument::Indexer.new(self).index!
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PagesCore
   module Sweepable
     extend ActiveSupport::Concern
@@ -12,9 +14,9 @@ module PagesCore
     protected
 
     def sweep_cache!
-      return unless PagesCore::CacheSweeper.enabled
       return if cache_swept
-      PagesCore::SweepCacheJob.perform_later
+
+      PagesCore::StaticCache.handler.sweep!
       self.cache_swept = true
     end
   end

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

@@ -1,26 +1,30 @@
+# frozen_string_literal: true
+
 module PagesCore
   module Taggable
     extend ActiveSupport::Concern
 
+    attr_accessor :new_tags
+
     included do
       has_many :taggings,
                as: :taggable,
                dependent: :destroy,
                inverse_of: :taggable
       has_many :tags, through: :taggings
+      after_save :update_taggings
     end
 
     module ClassMethods
       def tagged_with(*tags)
-        all
-          .includes(:tags)
-          .where("tags.name IN (?)", Tag.parse(tags))
-          .references(:tags)
+        all.includes(:tags)
+           .where(tags: { name: Tag.parse(tags) })
+           .references(:tags)
       end
     end
 
     def serialized_tags
-      tags.order("name ASC").map(&:name).to_json
+      tag_names.to_json
     end
 
     def serialized_tags=(json)
@@ -28,12 +32,11 @@ module PagesCore
     end
 
     def tag_with(*list)
-      Tag.transaction do
-        taggings.destroy_all
-        Tag.parse(list).each do |name|
-          Tag.find_or_create_by(name: name).on(self)
-        end
-      end
+      @new_tags = Tag.parse(list)
+    end
+
+    def tag_with!(*list)
+      update(tag_list: list)
     end
 
     def tag_list=(tag_list)
@@ -41,7 +44,25 @@ module PagesCore
     end
 
     def tag_list
-      tags.order("name ASC").map(&:name).join(", ")
+      tag_names.join(", ")
+    end
+
+    def tag_names
+      @new_tags || tags.by_name.map(&:name)
+    end
+
+    private
+
+    def update_taggings
+      return unless new_tags
+
+      Tag.transaction do
+        taggings.includes(:tag).where.not(tag: { name: new_tags }).destroy_all
+        new_tags.map { |n| Tag.find_or_create_by(name: n) }
+                .each { |t| taggings.create(tag: t) }
+      end
+
+      @new_tags = nil
     end
   end
 end

data/app/models/image.rb

@@ -1,7 +1,11 @@
-class Image < ActiveRecord::Base
+# frozen_string_literal: true
+
+class Image < ApplicationRecord
   include DynamicImage::Model
   include PagesCore::Sweepable
 
+  validate :ensure_max_size, on: :create
+
   localizable do
     attribute :alternative
     attribute :caption
@@ -21,4 +25,13 @@ class Image < ActiveRecord::Base
     ActiveSupport::Deprecation.warn "Image#byline= is deprecated, use #caption="
     self.caption = new_caption
   end
+
+  private
+
+  def ensure_max_size
+    return unless real_width? && real_height?
+    return if real_width * real_height <= 48_000_000
+
+    errors.add(:data, "is too large")
+  end
 end

data/app/models/invite.rb

@@ -1,4 +1,6 @@
-class Invite < ActiveRecord::Base
+# frozen_string_literal: true
+
+class Invite < ApplicationRecord
   include PagesCore::HasRoles
 
   belongs_to :user

data/app/models/invite_role.rb

@@ -1,9 +1,11 @@
-class InviteRole < ActiveRecord::Base
+# frozen_string_literal: true
+
+class InviteRole < ApplicationRecord
   belongs_to :invite
   validates :name,
-            presence:   true,
+            presence: true,
             uniqueness: { scope: :invite_id },
-            inclusion:  { in: proc { Role.roles.map(&:name) } }
+            inclusion: { in: proc { Role.roles.map(&:name) } }
 
   def to_s
     name.humanize

data/app/models/page.rb

@@ -1,5 +1,8 @@
-class Page < ActiveRecord::Base
+# frozen_string_literal: true
+
+class Page < ApplicationRecord
   include PagesCore::HumanizableParam
+  include PagesCore::SearchableDocument
   include PagesCore::Sweepable
   include PagesCore::Taggable
 
@@ -10,6 +13,7 @@ class Page < ActiveRecord::Base
   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
@@ -26,9 +30,8 @@ class Page < ActiveRecord::Base
 
   validates(:unique_name,
             format: { with: /\A[\w\d_\-]+\z/,
-                      allow_nil: true,
                       allow_blank: true },
-            uniqueness: { allow_nil: true, allow_blank: true })
+            uniqueness: { allow_blank: true })
 
   validates :template, presence: true
   validates :published_at, presence: true

data/app/models/page_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # # PageBuilder
 #
 # PageBuilder is a simple DSL for building pages, for use in ie. seeds.rb

data/app/models/page_category.rb

@@ -1,4 +1,6 @@
-class PageCategory < ActiveRecord::Base
+# frozen_string_literal: true
+
+class PageCategory < ApplicationRecord
   belongs_to :page
   belongs_to :category
   validates :page_id, :category_id, presence: true

data/app/models/page_exporter.rb

@@ -1,21 +1,27 @@
+# frozen_string_literal: true
+
 require "fileutils"
 
 class PageExporter
-  attr_reader :base_dir
+  attr_reader :base_dir, :progress_bar
 
-  def initialize(base_dir)
+  def initialize(base_dir, progress_bar: false)
     @base_dir = base_dir
+    @progress_bar = progress_bar
   end
 
   def export
     Page.roots.in_locale(I18n.default_locale).each { |p| export_page(p) }
-    puts
   end
 
   private
 
+  def bar
+    @bar ||= ProgressBar.new(Page.count)
+  end
+
   def export_page(page)
-    print "."
+    bar.increment! if progress_bar
     export_page_contents(page)
     export_images(page)
     export_files(page)
@@ -23,7 +29,7 @@ class PageExporter
   end
 
   def export_files(page)
-    path = page_path(page).join("files")
+    path = page_path(page).join("attachments")
     page.attachments.each do |file|
       write_file(
         path.join([file.content_hash, file.filename].join("-")),
@@ -44,15 +50,22 @@ class PageExporter
 
   def export_page_contents(page)
     path = page_path(page)
-    page.locales.map { |l| page.localize(l) }.each do |p|
-      json = PageExportSerializer.new(p).to_json
-      basename = path.join("#{page_file_name(p)}.#{p.locale}")
-      write_file(path.join("page.#{p.locale}.json"), json)
-      write_file(path.join("page.#{p.locale}.yml"), JSON.parse(json).to_yaml)
+    localized_pages(page).each do |p|
+      export_page_json(path, page)
       write_file(path.join("page.#{p.locale}.txt"), text_page(p))
     end
   end
 
+  def export_page_json(path, page)
+    json = Export::PageResource.new(page).serialize
+    write_file(path.join("page.#{page.locale}.json"), json)
+    write_file(path.join("page.#{page.locale}.yml"), JSON.parse(json).to_yaml)
+  end
+
+  def localized_pages(page)
+    page.locales.map { |l| page.localize(l) }
+  end
+
   def page_path(page)
     base_dir.join(page.self_and_ancestors
                       .reverse

data/app/models/page_file.rb

@@ -1,4 +1,6 @@
-class PageFile < ActiveRecord::Base
+# frozen_string_literal: true
+
+class PageFile < ApplicationRecord
   include PagesCore::Sweepable
 
   belongs_to :page

data/app/models/page_image.rb

@@ -1,11 +1,11 @@
-class PageImage < ActiveRecord::Base
+# frozen_string_literal: true
+
+class PageImage < ApplicationRecord
   include PagesCore::Sweepable
 
   belongs_to :page
   belongs_to_image :image
 
-  validates :page_id, presence: true
-
   accepts_nested_attributes_for :image
   validates_associated :image
 

data/app/models/page_path.rb

@@ -1,6 +1,10 @@
-class PagePath < ActiveRecord::Base
+# frozen_string_literal: true
+
+class PagePath < ApplicationRecord
   class PageNotSavedError < StandardError; end
+
   class NoPathError < StandardError; end
+
   class NoLocaleError < StandardError; end
 
   belongs_to :page
@@ -33,12 +37,16 @@ class PagePath < ActiveRecord::Base
       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
+      page_path = get_or_create(locale, path, page)
+      page_path.update(page: page) unless page_path.page_id == page.id
+      page_path
+    end
+
+    private
 
-      existing.update(page: page) unless existing.page_id == page.id
-      existing
+    def get_or_create(locale, path, page)
+      get(locale, path) || create(locale: locale, path: path, page: page)
     end
   end
 end

data/app/models/password_reset_token.rb

@@ -1,4 +1,6 @@
-class PasswordResetToken < ActiveRecord::Base
+# frozen_string_literal: true
+
+class PasswordResetToken < ApplicationRecord
   belongs_to :user
   before_create :ensure_token
   before_create :ensure_expiration

data/app/models/role.rb

@@ -1,15 +1,17 @@
-class Role < ActiveRecord::Base
+# frozen_string_literal: true
+
+class Role < ApplicationRecord
   belongs_to :user, touch: true
   validates :name,
-            presence:   true,
+            presence: true,
             uniqueness: { scope: :user_id },
-            inclusion:  { in: proc { Role.roles.map(&:name) } }
+            inclusion: { in: proc { Role.roles.map(&:name) } }
 
   class << self
-    def define(name, description, default = false)
+    def define(name, description, default: false)
       if roles.map(&:name).include?(name.to_s)
         raise ArgumentError, "Tried to define role :#{role}, " \
-          "but a role by that name already exists"
+                             "but a role by that name already exists"
       else
         roles << OpenStruct.new(
           name: name.to_s,
@@ -30,11 +32,12 @@ class Role < ActiveRecord::Base
     protected
 
     def config_file
-      Rails.root.join("config", "roles.yml")
+      Rails.root.join("config/roles.yml")
     end
 
     def config_roles
       return [] unless File.exist?(config_file)
+
       YAML.load_file(config_file).map do |key, opts|
         OpenStruct.new(name: key.to_s,
                        description: opts["description"],

data/app/models/search_document.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+class SearchDocument < ApplicationRecord
+  include PgSearch::Model
+
+  belongs_to :searchable, polymorphic: true
+
+  validates :locale, presence: true
+
+  before_validation :configure_dictionary,
+                    :inherit_updated_at
+
+  scope :published, -> { where(published: true) }
+
+  pg_search_scope :full_text_search_scope, lambda { |query, dictionary|
+    { against: %i[name description content tags],
+      using: { tsearch: { prefix: true,
+                          dictionary: dictionary,
+                          tsvector_column: "tsv" },
+               trigram: { only: %i[name] } },
+      ignoring: :accents,
+      order_within_rank: "search_documents.record_updated_at DESC",
+      query: query }
+  }
+
+  class << self
+    def results
+      select(:searchable_id, :searchable_type, :locale)
+        .map(&:localized_searchable)
+    end
+
+    def search(query, locale: nil)
+      locale ||= I18n.locale
+      where(locale: locale)
+        .includes(:searchable)
+        .full_text_search_scope(query, search_configuration(locale))
+    end
+
+    def search_configuration(locale)
+      search_configurations[locale&.to_sym] || "simple_unaccent"
+    end
+
+    def search_configurations
+      # These are the dictionaries PostgreSQL 12 ships with.
+      # Also available in PostgreSQL 13: el: "greek_unaccent",
+      { ar: "arabic_unaccent", da: "danish_unaccent", nl: "dutch_unaccent",
+        en: "english_unaccent", fi: "finnish_unaccent", fr: "french_unaccent",
+        de: "german_unaccent", hu: "hungarian_unaccent",
+        id: "indonesian_unaccent", ga: "irish_unaccent", it: "italian_unaccent",
+        lt: "lithuanian_unaccent", ne: "nepali_unaccent",
+        nb: "norwegian_unaccent", pt: "portuguese_unaccent",
+        rm: "romanian_unaccent", ru: "russian_unaccent", es: "spanish_unaccent",
+        sv: "swedish_unaccent", ta: "tamil_unaccent", tr: "turkish_unaccent" }
+    end
+  end
+
+  def localized_searchable
+    return searchable unless searchable.respond_to?(:localize)
+
+    searchable.localize(locale)
+  end
+
+  private
+
+  def configure_dictionary
+    self.tsv_config = self.class.search_configuration(locale)
+  end
+
+  def inherit_updated_at
+    self.record_updated_at = searchable.updated_at
+  end
+end