alchemy_cms 4.6.1 → 5.0.0

data/app/models/alchemy/essence_richtext.rb

@@ -8,15 +8,13 @@
 #  body          :text
 #  stripped_body :text
 #  public        :boolean
-#  creator_id    :integer
-#  updater_id    :integer
 #  created_at    :datetime         not null
 #  updated_at    :datetime         not null
 #
 
 module Alchemy
   class EssenceRichtext < BaseRecord
-    acts_as_essence preview_text_column: 'stripped_body'
+    acts_as_essence preview_text_column: "stripped_body"
 
     before_save :strip_content
 

data/app/models/alchemy/essence_select.rb

@@ -8,13 +8,11 @@
 #  value      :string
 #  created_at :datetime         not null
 #  updated_at :datetime         not null
-#  creator_id :integer
-#  updater_id :integer
 #
 
 # Provides a select box that stores string values.
 module Alchemy
   class EssenceSelect < BaseRecord
-    acts_as_essence ingredient_column: 'value'
+    acts_as_essence ingredient_column: "value"
   end
 end

data/app/models/alchemy/essence_text.rb

@@ -11,8 +11,6 @@
 #  link_class_name :string
 #  public          :boolean          default(FALSE)
 #  link_target     :string
-#  creator_id      :integer
-#  updater_id      :integer
 #  created_at      :datetime         not null
 #  updated_at      :datetime         not null
 #

data/app/models/alchemy/folded_page.rb

@@ -17,6 +17,7 @@ module Alchemy
 
     def self.folded_for_user(user)
       return none unless Alchemy.user_class < ActiveRecord::Base
+
       where(user: user, folded: true)
     end
   end

data/app/models/alchemy/language.rb

@@ -20,15 +20,18 @@
 #  locale         :string
 #
 
-require_dependency 'alchemy/site'
+require_dependency "alchemy/site"
 
 module Alchemy
   class Language < BaseRecord
     belongs_to :site
-    has_many :pages
+    has_many :pages, inverse_of: :language
+    has_many :nodes, inverse_of: :language
 
     before_validation :set_locale, if: -> { locale.blank? }
 
+    has_one :root_page, -> { where(parent: nil, layoutpage: false) }, class_name: "Alchemy::Page"
+
     validates :name, presence: true
     validates :page_layout, presence: true
     validates :frontpage_name, presence: true
@@ -54,11 +57,13 @@ module Alchemy
     after_update :unpublish_pages,
       if: :should_unpublish_pages?
 
-    before_destroy :check_for_default
-    after_destroy :delete_language_root_page
+    before_destroy if: -> { pages.any? } do
+      errors.add(:pages, :still_present)
+      throw(:abort)
+    end
 
-    scope :published,       -> { where(public: true) }
-    scope :with_root_page,  -> { joins(:pages).where(Page.table_name => {language_root: true}) }
+    scope :published, -> { where(public: true) }
+    scope :with_root_page, -> { joins(:pages).where(Page.table_name => { language_root: true }) }
 
     class << self
       def on_site(site)
@@ -81,6 +86,8 @@ module Alchemy
 
       # The root page of the current language.
       def current_root_page
+        return unless current
+
         current.pages.language_roots.first
       end
 
@@ -100,16 +107,6 @@ module Alchemy
 
     include Alchemy::Language::Code
 
-    # Root page
-    def root_page
-      @root_page ||= pages.language_roots.first
-    end
-
-    # Layout root page
-    def layout_root_page
-      @layout_root_page ||= Page.layout_root_for(id)
-    end
-
     # All available locales matching this language
     #
     # Matching either the code (+language_code+ + +country_code+) or the +language_code+
@@ -118,10 +115,14 @@ module Alchemy
     #
     def matching_locales
       @_matching_locales ||= ::I18n.available_locales.select do |locale|
-        locale.to_s.split('-')[0] == language_code
+        locale.to_s.split("-")[0] == language_code
       end
     end
 
+    def available_menu_names
+      Alchemy::Node.available_menu_names - nodes.reject(&:parent_id).map(&:menu_type)
+    end
+
     private
 
     def set_locale
@@ -157,36 +158,21 @@ module Alchemy
     def remove_old_default
       lang = Language.on_site(site).default
       return true if lang.nil?
+
       lang.default = false
       lang.save(validate: false)
     end
 
     def should_set_pages_language?
-      if active_record_5_1?
-        saved_change_to_language_code? || saved_change_to_country_code?
-      else
-        language_code_changed? || country_code_changed?
-      end
+      saved_change_to_language_code? || saved_change_to_country_code?
     end
 
     def set_pages_language
       pages.update_all language_code: code
     end
 
-    def check_for_default
-      raise DefaultLanguageNotDeletable if default?
-    end
-
-    def delete_language_root_page
-      root_page.try(:destroy) && layout_root_page.try(:destroy)
-    end
-
     def should_unpublish_pages?
-      if active_record_5_1?
-        saved_changes[:public] == [true, false]
-      else
-        changes[:public] == [true, false]
-      end
+      saved_changes[:public] == [true, false]
     end
 
     def unpublish_pages

data/app/models/alchemy/language/code.rb

@@ -4,7 +4,7 @@ module Alchemy::Language::Code
   extend ActiveSupport::Concern
 
   def code
-    [language_code, country_code].select(&:present?).join('-')
+    [language_code, country_code].select(&:present?).join("-")
   end
 
   def code=(code)
@@ -13,11 +13,11 @@ module Alchemy::Language::Code
 
   module ClassMethods
     def find_by_code(code)
-      codes = code.split('-')
-      codes << '' if codes.length == 1
+      codes = code.split("-")
+      codes << "" if codes.length == 1
       on_current_site.find_by(
         language_code: codes[0],
-        country_code: codes[1]
+        country_code: codes[1],
       )
     end
   end

data/app/models/alchemy/legacy_page_url.rb

@@ -13,7 +13,7 @@
 
 class Alchemy::LegacyPageUrl < ActiveRecord::Base
   belongs_to :page,
-    class_name: 'Alchemy::Page',
+    class_name: "Alchemy::Page",
     required: true
 
   validates :urlname,

data/app/models/alchemy/message.rb

@@ -22,17 +22,17 @@ module Alchemy
 
     attr_accessor :contact_form_id, :ip
 
-    config['fields'].each do |field|
+    config["fields"].each do |field|
       attr_accessor field.to_sym
     end
 
-    config['validate_fields'].each do |field|
+    config["validate_fields"].each do |field|
       validates_presence_of field
 
       case field.to_sym
       when /email/
         validates_format_of field,
-          with: Alchemy::Config.get('format_matchers')['email'],
+          with: Alchemy::Config.get("format_matchers")["email"],
           if: -> { send(field).present? }
       when :email_confirmation
         validates_confirmation_of :email

data/app/models/alchemy/node.rb

@@ -4,13 +4,22 @@ module Alchemy
   class Node < BaseRecord
     VALID_URL_REGEX = /\A(\/|\D[a-z\+\d\.\-]+:)/
 
+    before_destroy :check_if_related_essence_nodes_present
+
     acts_as_nested_set scope: "language_id", touch: true
     stampable stamper_class_name: Alchemy.user_class_name
 
-    belongs_to :site, class_name: "Alchemy::Site"
     belongs_to :language, class_name: "Alchemy::Language"
     belongs_to :page, class_name: "Alchemy::Page", optional: true, inverse_of: :nodes
 
+    has_one :site, through: :language
+
+    has_many :essence_nodes, class_name: "Alchemy::EssenceNode", foreign_key: :node_id, inverse_of: :ingredient_association
+
+    before_validation :translate_root_menu_name, if: -> { root? }
+    before_validation :set_menu_type_from_root, unless: -> { root? }
+
+    validates :menu_type, presence: true
     validates :name, presence: true, if: -> { page.nil? }
     validates :url, format: { with: VALID_URL_REGEX }, unless: -> { url.nil? }
 
@@ -62,11 +71,25 @@ module Alchemy
     end
 
     def to_partial_path
-      "#{view_folder_name}/wrapper"
+      "alchemy/menus/#{menu_type}/node"
+    end
+
+    private
+
+    def check_if_related_essence_nodes_present
+      dependent_essence_nodes = self_and_descendants.flat_map(&:essence_nodes)
+      if dependent_essence_nodes.any?
+        errors.add(:base, :essence_nodes_present, page_names: dependent_essence_nodes.map(&:page).map(&:name).to_sentence)
+        throw(:abort)
+      end
+    end
+
+    def translate_root_menu_name
+      self.name ||= Alchemy.t(menu_type, scope: :menu_names)
     end
 
-    def view_folder_name
-      "alchemy/menus/#{name.parameterize.underscore}"
+    def set_menu_type_from_root
+      self.menu_type = root.menu_type
     end
   end
 end

data/app/models/alchemy/page.rb

@@ -17,7 +17,6 @@
 #  rgt              :integer
 #  parent_id        :integer
 #  depth            :integer
-#  visible          :boolean          default(FALSE)
 #  locked_by        :integer
 #  restricted       :boolean          default(FALSE)
 #  robot_index      :boolean          default(TRUE)
@@ -44,11 +43,10 @@ module Alchemy
 
     DEFAULT_ATTRIBUTES_FOR_COPY = {
       autogenerate_elements: false,
-      visible: false,
       public_on: nil,
       public_until: nil,
       locked_at: nil,
-      locked_by: nil
+      locked_by: nil,
     }
 
     SKIPPED_ATTRIBUTES_ON_COPY = %w(
@@ -78,16 +76,15 @@ module Alchemy
       :tag_list,
       :title,
       :urlname,
-      :visible,
       :layoutpage,
-      :menu_id
+      :menu_id,
     ]
 
-    acts_as_nested_set(dependent: :destroy)
+    acts_as_nested_set(dependent: :destroy, scope: [:layoutpage, :language_id])
 
     stampable stamper_class_name: Alchemy.user_class_name
 
-    belongs_to :language, optional: true
+    belongs_to :language
 
     belongs_to :creator,
       primary_key: Alchemy.user_class_primary_key,
@@ -110,43 +107,33 @@ module Alchemy
     has_one :site, through: :language
     has_many :site_languages, through: :site, source: :languages
     has_many :folded_pages
-    has_many :legacy_urls, class_name: 'Alchemy::LegacyPageUrl'
-    has_many :nodes, class_name: 'Alchemy::Node', inverse_of: :page
+    has_many :legacy_urls, class_name: "Alchemy::LegacyPageUrl"
+    has_many :nodes, class_name: "Alchemy::Node", inverse_of: :page
 
-    validates_presence_of :language, on: :create, unless: :root
-    validates_presence_of :page_layout, unless: :systempage?
-    validates_format_of :page_layout, with: /\A[a-z0-9_-]+\z/, unless: -> { systempage? || page_layout.blank? }
-    validates_presence_of :parent_id, if: proc { Page.count > 1 }
+    before_validation :set_language,
+      if: -> { language.nil? }
+
+    validates_presence_of :page_layout
+    validates_format_of :page_layout, with: /\A[a-z0-9_-]+\z/, unless: -> { page_layout.blank? }
+    validates_presence_of :parent, unless: -> { layoutpage? || language_root? }
 
     before_save :set_language_code,
-      if: -> { language.present? },
-      unless: :systempage?
+      if: -> { language.present? }
 
     before_save :set_restrictions_to_child_pages,
-      if: :restricted_changed?,
-      unless: :systempage?
+      if: :restricted_changed?
 
     before_save :inherit_restricted_status,
-      if: -> { parent && parent.restricted? },
-      unless: :systempage?
+      if: -> { parent && parent.restricted? }
 
     before_save :set_published_at,
-      if: -> { public_on.present? && published_at.nil? },
-      unless: :systempage?
+      if: -> { public_on.present? && published_at.nil? }
 
     before_save :set_fixed_attributes,
       if: -> { fixed_attributes.any? }
 
-    before_create :set_language_from_parent_or_default,
-      if: -> { language_id.blank? },
-      unless: :systempage?
-
     after_update :create_legacy_url,
-      if: :should_create_legacy_url?,
-      unless: -> { definition['redirects_to_external'] }
-
-    after_update :attach_to_menu!,
-      if: :should_attach_to_menu?
+      if: :saved_change_to_urlname?
 
     after_update -> { nodes.update_all(updated_at: Time.current) }
 
@@ -159,26 +146,9 @@ module Alchemy
     # site_name accessor
     delegate :name, to: :site, prefix: true, allow_nil: true
 
-    attr_accessor :menu_id
-
-    deprecate visible: "Page slugs will be visible in URLs of child pages all the time. " \
-      "Please use Menus and Tags instead to re-organize your pages if your page tree does not reflect the URL hierarchy.",
-      deprecator: Alchemy::Deprecation
-
     # Class methods
     #
     class << self
-      # The root page of the page tree
-      #
-      # Internal use only. You wouldn't use this page ever.
-      #
-      # Automatically created when accessed the first time.
-      #
-      def root
-        super || create!(name: 'Root')
-      end
-      alias_method :rootpage, :root
-
       # Used to store the current page previewed in the edit page template.
       #
       def current_preview=(page)
@@ -222,29 +192,12 @@ module Alchemy
         end
       end
 
-      def layout_root_for(language_id)
-        where({parent_id: Page.root.id, layoutpage: true, language_id: language_id}).limit(1).first
-      end
-
-      def find_or_create_layout_root_for(language_id)
-        layoutroot = layout_root_for(language_id)
-        return layoutroot if layoutroot
-        language = Language.find(language_id)
-        Page.create!(
-          name: "Layoutroot for #{language.name}",
-          layoutpage: true,
-          language: language,
-          autogenerate_elements: false,
-          parent_id: Page.root.id
-        )
-      end
-
       def copy_and_paste(source, new_parent, new_name)
         page = copy(source, {
           parent_id: new_parent.id,
           language: new_parent.language,
           name: new_name,
-          title: new_name
+          title: new_name,
         })
         if source.children.any?
           source.copy_children_to(page)
@@ -254,34 +207,29 @@ module Alchemy
 
       def all_from_clipboard(clipboard)
         return [] if clipboard.blank?
-        where(id: clipboard.collect { |p| p['id'] })
+
+        where(id: clipboard.collect { |p| p["id"] })
       end
 
       def all_from_clipboard_for_select(clipboard, language_id, layoutpage = false)
         return [] if clipboard.blank?
+
         clipboard_pages = all_from_clipboard(clipboard)
         allowed_page_layouts = Alchemy::PageLayout.selectable_layouts(language_id, layoutpage)
-        allowed_page_layout_names = allowed_page_layouts.collect { |p| p['name'] }
+        allowed_page_layout_names = allowed_page_layouts.collect { |p| p["name"] }
         clipboard_pages.select { |cp| allowed_page_layout_names.include?(cp.page_layout) }
       end
 
       def link_target_options
-        options = [[Alchemy.t(:default, scope: 'link_target_options'), '']]
+        options = [[Alchemy.t(:default, scope: "link_target_options"), ""]]
         link_target_options = Config.get(:link_target_options)
         link_target_options.each do |option|
-          options << [Alchemy.t(option, scope: 'link_target_options',
-                                default: option.to_s.humanize), option]
+          options << [Alchemy.t(option, scope: "link_target_options",
+                                        default: option.to_s.humanize), option]
         end
         options
       end
 
-      # Returns an array of all pages in the same branch from current.
-      # I.e. used to find the active page in navigation.
-      def ancestors_for(current)
-        return [] if current.nil?
-        current.self_and_ancestors.contentpages
-      end
-
       private
 
       # Aggregates the attributes from given source for copy of page.
@@ -296,7 +244,7 @@ module Alchemy
         differences.stringify_keys!
         attributes = source.attributes.merge(differences)
         attributes.merge!(DEFAULT_ATTRIBUTES_FOR_COPY)
-        attributes['name'] = new_name_for_copy(differences['name'], source.name)
+        attributes["name"] = new_name_for_copy(differences["name"], source.name)
         attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY)
       end
 
@@ -312,7 +260,8 @@ module Alchemy
       #
       def new_name_for_copy(custom_name, source_name)
         return custom_name if custom_name.present?
-        "#{source_name} (#{Alchemy.t('Copy')})"
+
+        "#{source_name} (#{Alchemy.t("Copy")})"
       end
     end
 
@@ -340,13 +289,7 @@ module Alchemy
     #   Use this for your custom element loading logic.
     #
     # @return [ActiveRecord::Relation]
-    def find_elements(options = {}, show_non_public = false)
-      if show_non_public
-        Alchemy::Deprecation.warn "Passing true as second argument to page#find_elements to include" \
-          " invisible elements has been removed. Please implement your own ElementsFinder" \
-          " and pass it with options[:finder]."
-      end
-
+    def find_elements(options = {})
       finder = options[:finder] || Alchemy::ElementsFinder.new(options)
       finder.elements(page: self)
     end
@@ -384,9 +327,10 @@ module Alchemy
     #   only public pages (true), skip public pages (false)
     #
     def previous(options = {})
-      pages = self_and_siblings.where('lft < ?', lft)
+      pages = self_and_siblings.where("lft < ?", lft)
       select_page(pages, options.merge(order: :desc))
     end
+
     alias_method :previous_page, :previous
 
     # Returns the next page on the same level or nil.
@@ -397,9 +341,10 @@ module Alchemy
     #   only public pages (true), skip public pages (false)
     #
     def next(options = {})
-      pages = self_and_siblings.where('lft > ?', lft)
+      pages = self_and_siblings.where("lft > ?", lft)
       select_page(pages, options.merge(order: :asc))
     end
+
     alias_method :next_page, :next
 
     # Locks the page to given user
@@ -445,9 +390,10 @@ module Alchemy
     def copy_children_to(new_parent)
       children.each do |child|
         next if child == new_parent
+
         new_child = Page.copy(child, {
           language_id: new_parent.language_id,
-          language_code: new_parent.language_code
+          language_code: new_parent.language_code,
         })
         new_child.move_to_child_of(new_parent)
         child.copy_children_to(new_child) unless child.children.blank?
@@ -466,22 +412,22 @@ module Alchemy
       update_columns(
         published_at: current_time,
         public_on: already_public_for?(current_time) ? public_on : current_time,
-        public_until: still_public_for?(current_time) ? public_until : nil
+        public_until: still_public_for?(current_time) ? public_until : nil,
       )
     end
 
     # Updates an Alchemy::Page based on a new ordering to be applied to it
     #
     # Note: Page's urls should not be updated (and a legacy URL created) if nesting is OFF
-    # or if a page is external or if the URL is the same
+    # or if the URL is the same
     #
     # @param [TreeNode]
     #   A tree node with new lft, rgt, depth, url, parent_id and restricted indexes to be updated
     #
     def update_node!(node)
-      hash = {lft: node.left, rgt: node.right, parent_id: node.parent, depth: node.depth, restricted: node.restricted}
+      hash = { lft: node.left, rgt: node.right, parent_id: node.parent, depth: node.depth, restricted: node.restricted }
 
-      if Config.get(:url_nesting) && !definition['redirects_to_external'] && urlname != node.url
+      if urlname != node.url
         LegacyPageUrl.create(page_id: id, urlname: urlname)
         hash[:urlname] = node.url
       end
@@ -506,6 +452,7 @@ module Alchemy
     #
     def editable_by?(user)
       return true unless has_limited_editors?
+
       (editor_roles & user.alchemy_roles).any?
     end
 
@@ -531,7 +478,7 @@ module Alchemy
     # does not respond to +#name+ it returns +'unknown'+
     #
     def creator_name
-      creator.try(:name) || Alchemy.t('unknown')
+      creator.try(:name) || Alchemy.t("unknown")
     end
 
     # Returns the name of the last updater of this page.
@@ -540,7 +487,7 @@ module Alchemy
     # does not respond to +#name+ it returns +'unknown'+
     #
     def updater_name
-      updater.try(:name) || Alchemy.t('unknown')
+      updater.try(:name) || Alchemy.t("unknown")
     end
 
     # Returns the name of the user currently editing this page.
@@ -549,7 +496,7 @@ module Alchemy
     # does not respond to +#name+ it returns +'unknown'+
     #
     def locker_name
-      locker.try(:name) || Alchemy.t('unknown')
+      locker.try(:name) || Alchemy.t("unknown")
     end
 
     # Menus (aka. root nodes) this page is attached to
@@ -573,8 +520,8 @@ module Alchemy
         .limit(1).first
     end
 
-    def set_language_from_parent_or_default
-      self.language = parent.language || Language.default
+    def set_language
+      self.language = parent&.language || Language.current
       set_language_code
     end
 
@@ -582,41 +529,13 @@ module Alchemy
       self.language_code = language.code
     end
 
-    def should_create_legacy_url?
-      if active_record_5_1?
-        saved_change_to_urlname?
-      else
-        urlname_changed?
-      end
-    end
-
     # Stores the old urlname in a LegacyPageUrl
     def create_legacy_url
-      if active_record_5_1?
-        former_urlname = urlname_before_last_save
-      else
-        former_urlname = urlname_was
-      end
-      legacy_urls.find_or_create_by(urlname: former_urlname)
+      legacy_urls.find_or_create_by(urlname: urlname_before_last_save)
     end
 
     def set_published_at
       self.published_at = Time.current
     end
-
-    def attach_to_menu!
-      current_site_id = Alchemy::Site.current.id
-      node = Alchemy::Node.find_by!(id: menu_id, site_id: current_site_id)
-      node.children.create!(
-        site_id: current_site_id,
-        language_id: language_id,
-        page_id: id,
-        name: name
-      )
-    end
-
-    def should_attach_to_menu?
-      menu_id.present? && nodes.none?
-    end
   end
 end