pages_core 3.4.3 → 3.7.0

data/app/models/page_file.rb

@@ -1,74 +1,50 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-class PageFile < ActiveRecord::Base
-  include Dis::Model
+class PageFile < ApplicationRecord
+  include PagesCore::Sweepable
 
   belongs_to :page
-
-  validates_data_presence
-  validates :content_type, presence: true
-  validates :filename, presence: true
-  validates :content_length, presence: true
+  belongs_to :attachment
 
   acts_as_list scope: :page
 
-  localizable do
-    attribute :description
-  end
+  accepts_nested_attributes_for :attachment
 
-  before_validation :set_name_from_filename
+  localizable
 
-  after_save ThinkingSphinx::RealTime.callback_for(:page_file)
+  delegate :published, to: :page
 
-  class << self
-    def formats
-      {
-        "audio/mpeg"      => :mp3,
-        "image/gif"       => :gif,
-        "image/jpeg"      => :jpg,
-        "image/jpg"       => :jpg,
-        "image/pjpeg"     => :jpg,
-        "image/png"       => :png,
-        "application/pdf" => :pdf
-      }
-    end
+  def attachment
+    super&.localize!(locale)
   end
 
-  def format?
-    content_type && self.class.formats.keys.include?(content_type)
+  def name
+    attachment&.name
   end
 
-  def format
-    self.class.formats[content_type]
-  end
-
-  def filename_extension
-    if filename_extension?
-      filename.match(/\.([^\.]+)$/)[1]
-    else
-      ""
-    end
+  def description
+    attachment&.description
   end
 
-  def filename_extension?
-    filename =~ /\./
+  def filename
+    attachment&.filename
   end
 
-  def to_param
-    if filename_extension?
-      "#{id}.#{filename_extension}"
-    else
-      "#{id}"
-    end
+  def format?
+    attachment&.format?
   end
 
-  def published
-    page.published
+  def format
+    attachment&.format
   end
 
-  private
+  def to_param
+    return id unless attachment
 
-  def set_name_from_filename
-    self.name = File.basename(filename, ".*") if self.filename? && !self.name?
+    if attachment.filename_extension?
+      "#{id}-#{attachment.content_hash}.#{attachment.filename_extension}"
+    else
+      "#{id}-#{attachment.content_hash}"
+    end
   end
 end

data/app/models/page_image.rb

@@ -1,51 +1,23 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+class PageImage < ApplicationRecord
+  include PagesCore::Sweepable
 
-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: %i[page primary]
 
   localizable
 
-  validate do |page_image|
-    if page_image.page && page_image.page.page_images.count < 1
-      page_image.primary = true
-    end
-  end
-
-  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_image.page.update(image_id: page_image.image_id)
-
-      # Clear image_id on the page if primary is toggled off
-      else
-        page_image.page.update(image_id: nil)
-      end
-    end
-  end
-
-  after_destroy do |page_image|
-    page_image.page.update(image_id: nil) if page_image.primary?
-  end
-
   class << self
     def cleanup!
-      all.each do |page_image|
+      all.find_each do |page_image|
         page_image.destroy unless page_image.image
       end
     end
@@ -54,9 +26,4 @@ class PageImage < ActiveRecord::Base
   def image
     super.localize!(locale)
   end
-
-  def to_json(options = {})
-    options = { include: [:image] }.merge(options)
-    super(options)
-  end
 end

data/app/models/page_path.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class PagePath < ApplicationRecord
+  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
+
+      page_path = get_or_create(locale, path, page)
+      page_path.update(page: page) unless page_path.page_id == page.id
+      page_path
+    end
+
+    private
+
+    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,12 +1,14 @@
-class PasswordResetToken < ActiveRecord::Base
+# frozen_string_literal: true
+
+class PasswordResetToken < ApplicationRecord
   belongs_to :user
   before_create :ensure_token
   before_create :ensure_expiration
 
   validates :user_id, presence: true
 
-  scope :active,  -> { where("expires_at >= ?", Time.now) }
-  scope :expired, -> { where("expires_at < ?", Time.now) }
+  scope :active,  -> { where("expires_at >= ?", Time.now.utc) }
+  scope :expired, -> { where("expires_at < ?", Time.now.utc) }
 
   class << self
     def default_expiration
@@ -16,20 +18,16 @@ class PasswordResetToken < ActiveRecord::Base
     def expire!
       expired.delete_all
     end
-
-    def find_by_token(token)
-      active.where(token: token).first
-    end
   end
 
   def expired?
-    expires_at < Time.now
+    expires_at < Time.now.utc
   end
 
   private
 
   def ensure_expiration
-    self.expires_at ||= Time.now + self.class.default_expiration
+    self.expires_at ||= Time.now.utc + self.class.default_expiration
   end
 
   def ensure_token

data/app/models/role.rb

@@ -1,14 +1,16 @@
-class Role < ActiveRecord::Base
-  belongs_to :user
+# 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)
-        fail ArgumentError, "Tried to define role :#{role}, " \
+        raise ArgumentError, "Tried to define role :#{role}, " \
           "but a role by that name already exists"
       else
         roles << OpenStruct.new(
@@ -20,7 +22,7 @@ class Role < ActiveRecord::Base
     end
 
     def roles
-      @roles ||= default_roles
+      @roles ||= default_roles + config_roles
     end
 
     def names
@@ -29,6 +31,20 @@ class Role < ActiveRecord::Base
 
     protected
 
+    def config_file
+      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"],
+                       default: opts["default"])
+      end
+    end
+
     def default_roles
       [
         OpenStruct.new(

data/app/models/tag.rb

@@ -1,40 +1,49 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-class Tag < ActiveRecord::Base
+class Tag < ApplicationRecord
   include PagesCore::HumanizableParam
-  has_many :taggings
+  has_many :taggings, dependent: :destroy
 
   scope :pinned, -> { where(pinned: true) }
   scope :sorted, -> { order("pinned DESC, name ASC") }
 
   class << self
     def tags_and_suggestions_for(taggable, options = {})
-      options = default_options.merge(options)
+      limit = options[:limit] || 100
       tags = (taggable.tags.sorted + pinned.sorted).uniq
-      if tags.count < options[:limit]
-        suggested = suggestions(tags, options)
-        tags = tags.to_a + suggested[0...(options[:limit] - tags.length)]
-      end
-      tags
+
+      return tags unless tags.count < limit
+
+      tags + suggestions(taggable, tags, limit)[0...(limit - tags.length)]
     end
 
     def parse(*tags)
       Array(tags).flatten
-        .map { |tag| tag.is_a?(Tag) ? tag.name : tag }
-        .map { |tag| tag.split(",") }
-        .flatten
-        .map(&:strip)
+                 .map { |tag| tag.is_a?(Tag) ? tag.name : tag }
+                 .map { |tag| tag.split(",") }
+                 .flatten
+                 .map(&:strip)
     end
 
     private
 
-    def suggestions(tags, options = {})
+    def suggestions(taggable, tags, limit)
+      suggestions = taggable_suggestions(taggable, limit).to_a
+      suggestions += all_suggestions(limit) if suggestions.length < limit
+      suggestions.reject { |t| tags.include?(t) }.uniq[0...limit]
+    end
+
+    def taggable_suggestions(taggable, limit)
+      all_suggestions(limit)
+        .where(taggings: { taggable_type: taggable.class.to_s })
+    end
+
+    def all_suggestions(limit)
       Tag.joins(:taggings)
-        .select("`tags`.*, COUNT(`tags`.id) AS counter")
-        .group("`tags`.id")
-        .order("counter DESC")
-        .limit(options[:limit])
-        .reject { |t| tags.include?(t) }
+         .select("tags.*, COUNT(tags.id) AS counter")
+         .group("tags.id")
+         .order("counter DESC")
+         .limit(limit)
     end
 
     def default_options

data/app/models/tagging.rb

@@ -1,13 +1,14 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-class Tagging < ActiveRecord::Base
+class Tagging < ApplicationRecord
   belongs_to :tag
-  belongs_to :taggable, polymorphic: true
+  belongs_to :taggable, polymorphic: true, touch: true
 
-  validates_presence_of :taggable_id, :taggable_type
+  validates :taggable_id, presence: true
+  validates :taggable_type, presence: true
   validates :tag_id,
             presence: true,
-            uniqueness: { scope: [:taggable_type, :taggable_id] }
+            uniqueness: { scope: %i[taggable_type taggable_id] }
 
   def self.tagged_class(taggable)
     ActiveRecord::Base.send(

data/app/models/user.rb

@@ -1,26 +1,31 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-class User < ActiveRecord::Base
+class User < ApplicationRecord
   include PagesCore::HasRoles
 
   attr_accessor :password, :confirm_password
 
-  belongs_to :creator, class_name: "User", foreign_key: "created_by"
-  has_many :created_users, class_name: "User", foreign_key: "created_by"
-  has_many :pages
+  belongs_to(:creator,
+             class_name: "User",
+             foreign_key: "created_by",
+             optional: true,
+             inverse_of: :created_users)
+  has_many(:created_users,
+           class_name: "User",
+           foreign_key: "created_by",
+           dependent: :nullify,
+           inverse_of: :creator)
+  has_many :pages, dependent: :nullify
   has_many :password_reset_tokens, dependent: :destroy
   has_many :roles, dependent: :destroy
   has_many :invites, dependent: :destroy
-  belongs_to_image :image, foreign_key: :image_id
+  belongs_to_image :image, foreign_key: :image_id, optional: true
 
   serialize :persistent_data
 
-  validates :username,
-            presence: true,
-            uniqueness: { case_sensitive: false }
+  validates :username, presence: true, uniqueness: { case_sensitive: false }
 
-  validates :name,
-            presence: true
+  validates :name, presence: true
 
   validates :email,
             presence: true,
@@ -36,41 +41,41 @@ class User < ActiveRecord::Base
   before_validation :hash_password
   before_create :ensure_first_user_has_all_roles
 
-  after_save ThinkingSphinx::RealTime.callback_for(:user)
-
   scope :by_name,     -> { order("name ASC") }
   scope :activated,   -> { by_name.includes(:roles).where(activated: true) }
   scope :deactivated, -> { by_name.includes(:roles).where(activated: false) }
 
   class << self
     def authenticate(email, password:)
-      user = User.find_by_username_or_email(email)
+      user = User.login_name(email)
       user if user.try { |u| u.authenticate!(password) }
     end
 
+    def find_by_email(str)
+      find_by("LOWER(email) = ?", str.to_s.downcase)
+    end
+
     # Finds a user by either username or email address.
-    def find_by_username_or_email(string)
-      where(username: string.to_s).first ||
-        where(email: string.to_s).first
+    def login_name(string)
+      find_by(username: string.to_s) || find_by_email(string)
     end
   end
 
   def authenticate!(password)
-    if can_login? && valid_password?(password)
-      rehash_password!(password) if password_needs_rehash?
-      true
-    else
-      false
-    end
+    return false unless can_login? && valid_password?(password)
+
+    rehash_password!(password) if password_needs_rehash?
+    true
   end
 
   def can_login?
-    self.activated?
+    activated?
   end
 
   def mark_active!
     return if last_login_at && last_login_at > 10.minutes.ago
-    update_columns(last_login_at: Time.now)
+
+    update(last_login_at: Time.now.utc)
   end
 
   def name_and_email
@@ -78,7 +83,7 @@ class User < ActiveRecord::Base
   end
 
   def online?
-    (last_login_at && last_login_at > 15.minutes.ago) ? true : false
+    last_login_at && last_login_at > 15.minutes.ago ? true : false
   end
 
   def realname
@@ -89,6 +94,7 @@ class User < ActiveRecord::Base
 
   def confirm_password_must_match
     return if password.blank? || password == confirm_password
+
     errors.add(:confirm_password, "does not match")
   end
 
@@ -102,14 +108,15 @@ class User < ActiveRecord::Base
 
   def ensure_first_user_has_all_roles
     return if User.any?
+
     self.activated = true
-    Role.roles.each do |role|
-      roles.new(name: role.name)
+    Role.roles.each do |r|
+      roles.new(name: r.name) unless role?(r.name)
     end
   end
 
   def hash_password
-    self.hashed_password = encrypt_password(password) unless password.blank?
+    self.hashed_password = encrypt_password(password) if password.present?
   end
 
   def password_needs_rehash?
@@ -122,10 +129,9 @@ class User < ActiveRecord::Base
 
   def valid_password?(password)
     if hashed_password.length <= 40
-      return true if hashed_password == Digest::SHA1.hexdigest(password)
+      hashed_password == Digest::SHA1.hexdigest(password)
     else
-      return true if BCrypt::Password.new(hashed_password) == password
+      BCrypt::Password.new(hashed_password) == password
     end
-    false
   end
 end