alchemy_cms 4.6.2 → 5.0.0.beta1

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