alchemy_cms 4.6.7 → 5.0.0.beta1

data/app/models/alchemy/page/page_elements.rb

@@ -9,37 +9,37 @@ module Alchemy
 
       has_many :all_elements,
         -> { order(:position) },
-        class_name: 'Alchemy::Element',
+        class_name: "Alchemy::Element",
         inverse_of: :page
       has_many :elements,
         -> { order(:position).not_nested.unfixed.available },
-        class_name: 'Alchemy::Element',
+        class_name: "Alchemy::Element",
         inverse_of: :page
       has_many :trashed_elements,
         -> { Element.trashed.order(:position) },
-        class_name: 'Alchemy::Element',
+        class_name: "Alchemy::Element",
         inverse_of: :page
       has_many :fixed_elements,
         -> { order(:position).fixed.available },
-        class_name: 'Alchemy::Element',
+        class_name: "Alchemy::Element",
         inverse_of: :page
       has_many :dependent_destroyable_elements,
         -> { not_nested },
-        class_name: 'Alchemy::Element',
+        class_name: "Alchemy::Element",
         dependent: :destroy
       has_many :contents, through: :elements
       has_and_belongs_to_many :to_be_swept_elements, -> { distinct },
-        class_name: 'Alchemy::Element',
+        class_name: "Alchemy::Element",
         join_table: ElementToPage.table_name
 
       after_create :generate_elements,
-        unless: -> { systempage? || autogenerate_elements == false }
+        unless: -> { autogenerate_elements == false }
 
       after_update :trash_not_allowed_elements!,
-        if: :has_page_layout_changed?
+        if: :saved_change_to_page_layout?
 
       after_update :generate_elements,
-        if: :has_page_layout_changed?
+        if: :saved_change_to_page_layout?
     end
 
     module ClassMethods
@@ -53,7 +53,7 @@ module Alchemy
         source_elements = source.all_elements.not_nested.not_trashed
         source_elements.order(:position).map do |source_element|
           Element.copy(source_element, {
-            page_id: target.id
+            page_id: target.id,
           }).tap(&:move_to_bottom)
         end
       end
@@ -81,11 +81,11 @@ module Alchemy
     #
     def available_element_definitions(only_element_named = nil)
       @_element_definitions ||= if only_element_named
-        definition = Element.definition_by_name(only_element_named)
-        element_definitions_by_name(definition['nestable_elements'])
-      else
-        element_definitions
-      end
+          definition = Element.definition_by_name(only_element_named)
+          element_definitions_by_name(definition["nestable_elements"])
+        else
+          element_definitions
+        end
 
       return [] if @_element_definitions.blank?
 
@@ -100,20 +100,20 @@ module Alchemy
     # All names of elements that can actually be placed on current page.
     #
     def available_element_names
-      @_available_element_names ||= available_element_definitions.map { |e| e['name'] }
+      @_available_element_names ||= available_element_definitions.map { |e| e["name"] }
     end
 
     # Available element definitions excluding nested unique elements.
     #
     def available_elements_within_current_scope(parent)
       @_available_elements = if parent
-        parents_unique_nested_elements = parent.nested_elements.where(unique: true).pluck(:name)
-        available_element_definitions(parent.name).reject do |e|
-          parents_unique_nested_elements.include? e['name']
+          parents_unique_nested_elements = parent.nested_elements.where(unique: true).pluck(:name)
+          available_element_definitions(parent.name).reject do |e|
+            parents_unique_nested_elements.include? e["name"]
+          end
+        else
+          available_element_definitions
         end
-      else
-        available_element_definitions
-      end
     end
 
     # All element definitions defined for page's page layout
@@ -129,10 +129,10 @@ module Alchemy
     #
     def descendent_element_definitions
       definitions = element_definitions_by_name(element_definition_names)
-      definitions.select { |d| d.key?('nestable_elements') }.each do |d|
-        definitions += element_definitions_by_name(d['nestable_elements'])
+      definitions.select { |d| d.key?("nestable_elements") }.each do |d|
+        definitions += element_definitions_by_name(d["nestable_elements"])
       end
-      definitions.uniq { |d| d['name'] }
+      definitions.uniq { |d| d["name"] }
     end
 
     # All names of elements that are defined in the page definition.
@@ -145,10 +145,8 @@ module Alchemy
     #     elements: [headline, contactform]
     #
     def element_definition_names
-      definition['elements'] || []
+      definition["elements"] || []
     end
-    alias_method :element_names_from_definition, :element_definition_names
-    deprecate element_names_from_definition: :element_definition_names, deprecator: Alchemy::Deprecation
 
     # Element definitions with given name(s)
     #
@@ -163,7 +161,7 @@ module Alchemy
       if names.to_s == "all"
         Element.definitions
       else
-        Element.definitions.select { |e| names.include? e['name'] }
+        Element.definitions.select { |e| names.include? e["name"] }
       end
     end
 
@@ -176,14 +174,14 @@ module Alchemy
     #     feed_elements: [element_name, element_2_name]
     #
     def feed_elements
-      elements.named(definition['feed_elements'])
+      elements.named(definition["feed_elements"])
     end
 
     # Returns an array of all EssenceRichtext contents ids from not folded elements
     #
     def richtext_contents_ids
       Alchemy::Content.joins(:element)
-        .where(Element.table_name => {page_id: id, folded: false})
+        .where(Element.table_name => { page_id: id, folded: false })
         .select(&:has_tinymce?)
         .collect(&:id)
     end
@@ -197,8 +195,9 @@ module Alchemy
     def generate_elements
       existing_elements = all_elements.not_nested.not_trashed
       existing_element_names = existing_elements.pluck(:name).uniq
-      definition.fetch('autogenerate', []).each do |element_name|
+      definition.fetch("autogenerate", []).each do |element_name|
         next if existing_element_names.include?(element_name)
+
         Element.create(page: self, name: element_name)
       end
     end
@@ -207,24 +206,16 @@ module Alchemy
     def trash_not_allowed_elements!
       not_allowed_elements = elements.where([
         "#{Element.table_name}.name NOT IN (?)",
-        element_definition_names
+        element_definition_names,
       ])
       not_allowed_elements.to_a.map(&:trash!)
     end
 
-    def has_page_layout_changed?
-      if active_record_5_1?
-        saved_change_to_page_layout?
-      else
-        page_layout_changed?
-      end
-    end
-
     # Deletes unique and already present definitions from @_element_definitions.
     #
     def delete_unique_element_definitions!
       @_element_definitions.delete_if do |element|
-        element['unique'] && @_existing_element_names.include?(element['name'])
+        element["unique"] && @_existing_element_names.include?(element["name"])
       end
     end
 
@@ -232,8 +223,8 @@ module Alchemy
     #
     def delete_outnumbered_element_definitions!
       @_element_definitions.delete_if do |element|
-        outnumbered = @_existing_element_names.select { |name| name == element['name'] }
-        element['amount'] && outnumbered.count >= element['amount'].to_i
+        outnumbered = @_existing_element_names.select { |name| name == element["name"] }
+        element["amount"] && outnumbered.count >= element["amount"].to_i
       end
     end
   end

data/app/models/alchemy/page/page_naming.rb

@@ -9,29 +9,22 @@ module Alchemy
     included do
       before_validation :set_urlname,
         if: :renamed?,
-        unless: -> { systempage? || definition['redirects_to_external'] || name.blank? }
+        unless: -> { name.blank? }
 
       validates :name,
         presence: true
       validates :urlname,
-        uniqueness: {scope: [:language_id, :layoutpage], if: -> { urlname.present? }},
-        exclusion:  {in: RESERVED_URLNAMES},
-        length:     {minimum: 3, if: -> { urlname.present? }},
-        format:     {with: /\A[:\.\w\-+_\/\?&%;=]*\z/, if: -> { definition['redirects_to_external'] }}
-      validates :urlname,
-        on: :update,
-        presence: {if: -> { definition['redirects_to_external'] }}
+        uniqueness: { scope: [:language_id, :layoutpage], if: -> { urlname.present? } },
+        exclusion: { in: RESERVED_URLNAMES },
+        length: { minimum: 3, if: -> { urlname.present? } }
 
       before_save :set_title,
-        unless: -> { systempage? || definition['redirects_to_external'] },
         if: -> { title.blank? }
 
       after_update :update_descendants_urlnames,
-        if: :should_update_descendants_urlnames?
+        if: :saved_change_to_urlname?
 
-      after_move :update_urlname!,
-        if: -> { Config.get(:url_nesting) },
-        unless: -> { definition['redirects_to_external'] }
+      after_move :update_urlname!
     end
 
     # Returns true if name or urlname has changed.
@@ -42,7 +35,7 @@ module Alchemy
     # Makes a slug of all ancestors urlnames including mine and delimit them be slash.
     # So the whole path is stored as urlname in the database.
     def update_urlname!
-      new_urlname = nested_url_name(slug)
+      new_urlname = nested_url_name
       if urlname != new_urlname
         legacy_urls.create(urlname: urlname)
         update_column(:urlname, new_urlname)
@@ -51,56 +44,21 @@ module Alchemy
 
     # Returns always the last part of a urlname path
     def slug
-      urlname.to_s.split('/').last
-    end
-
-    # Returns an urlname prefixed with http://, if no protocol is given
-    def external_urlname
-      return urlname if urlname =~ /\A(\/|[a-z]+:\/\/)/
-      "http://#{urlname}"
-    end
-
-    # Returns an array of visible/non-language_root ancestors.
-    def visible_ancestors
-      return [] unless parent
-      if new_record?
-        parent.visible_ancestors.tap do |base|
-          base.push(parent) if parent.visible?
-        end
-      else
-        ancestors.visible.contentpages.where(language_root: [nil, false]).to_a
-      end
+      urlname.to_s.split("/").last
     end
 
     private
 
-    def should_update_descendants_urlnames?
-      return false if !Config.get(:url_nesting)
-      if active_record_5_1?
-        saved_change_to_urlname? || saved_change_to_visible?
-      else
-        urlname_changed? || visible_changed?
-      end
-    end
-
     def update_descendants_urlnames
       reload
-      descendants.each do |descendant|
-        next if descendant.definition['redirects_to_external']
-        descendant.update_urlname!
-      end
+      descendants.each(&:update_urlname!)
     end
 
     # Sets the urlname to a url friendly slug.
     # Either from name, or if present, from urlname.
-    # If url_nesting is enabled the urlname contains the whole path.
+    # The urlname contains the whole path including parent urlnames.
     def set_urlname
-      if Config.get(:url_nesting)
-        value = slug
-      else
-        value = urlname
-      end
-      self[:urlname] = nested_url_name(value)
+      self[:urlname] = nested_url_name
     end
 
     def set_title
@@ -112,25 +70,17 @@ module Alchemy
     # Names shorter than 3 will be filled up with dashes,
     # so it does not collidate with the language code.
     #
-    def convert_url_name(value)
-      url_name = convert_to_urlname(value.blank? ? name : value)
-      if url_name.length < 3
-        ('-' * (3 - url_name.length)) + url_name
-      else
-        url_name
-      end
-    end
-
-    def nested_url_name(value)
-      (ancestor_slugs << convert_url_name(value)).join('/')
+    def converted_url_name
+      url_name = convert_to_urlname(slug.blank? ? name : slug)
+      url_name.rjust(3, "-")
     end
 
-    # Slugs of all visible/non-language_root ancestors.
-    # Returns [], if there is no parent, the parent is
-    # the root page itself, or url_nesting is off.
-    def ancestor_slugs
-      return [] if !Config.get(:url_nesting) || parent.nil? || parent.root?
-      visible_ancestors.map(&:slug).compact
+    def nested_url_name
+      if parent&.language_root?
+        converted_url_name
+      else
+        [parent&.urlname, converted_url_name].compact.join("/")
+      end
     end
   end
 end

data/app/models/alchemy/page/page_natures.rb

@@ -14,20 +14,16 @@ module Alchemy
     end
 
     def taggable?
-      definition['taggable'] == true
+      definition["taggable"] == true
     end
 
     def rootpage?
       !new_record? && parent_id.blank?
     end
 
-    def systempage?
-      return true if Page.count.zero?
-      rootpage? || (parent_id == Page.root.id && !language_root?)
-    end
-
     def folded?(user_id)
       return unless Alchemy.user_class < ActiveRecord::Base
+
       folded_pages.where(user_id: user_id, folded: true).any?
     end
 
@@ -51,46 +47,22 @@ module Alchemy
 
     def editor_roles
       return unless has_limited_editors?
-      definition["editable_by"]
-    end
-
-    # Returns true or false if the pages definition for config/alchemy/page_layouts.yml contains redirects_to_external: true
-    # @deprecated Please use a menu node with an external url instead.
-    def redirects_to_external?
-      !!definition["redirects_to_external"]
-    end
-    deprecate redirects_to_external?: 'Please use a menu node with an external url instead.', deprecator: Alchemy::Deprecation
 
-    # @deprecated
-    def has_controller?
-      !PageLayout.get(page_layout).nil? && !PageLayout.get(page_layout)["controller"].blank?
+      definition["editable_by"]
     end
-    deprecate :has_controller?, deprecator: Alchemy::Deprecation
 
     # True if page locked_at timestamp and locked_by id are set
     def locked?
       locked_by? && locked_at?
     end
 
-    # @deprecated Please use a menu node with an url pointing to your controller path instead.
-    def controller_and_action
-      if definition['controller']
-        {
-          controller: definition["controller"].gsub(/(^\b)/, "/#{$1}"),
-          action: definition["action"]
-        }
-      end
-    end
-    deprecate controller_and_action: 'Please use a menu node with an url pointing to your controller path instead.', deprecator: Alchemy::Deprecation
-
     # Returns a Hash describing the status of the Page.
     #
     def status
       {
         public: public?,
-        visible: visible?,
         locked: locked?,
-        restricted: restricted?
+        restricted: restricted?,
       }
     end
 
@@ -116,7 +88,7 @@ module Alchemy
     # Page layout names are defined inside the config/alchemy/page_layouts.yml file.
     # Translate the name in your config/locales language yml file.
     def layout_display_name
-      Alchemy.t(page_layout, scope: 'page_layout_names')
+      Alchemy.t(page_layout, scope: "page_layout_names")
     end
 
     # Returns the name for the layout partial
@@ -174,8 +146,9 @@ module Alchemy
     #
     def cache_page?
       return false unless caching_enabled?
+
       page_layout = PageLayout.get(self.page_layout)
-      page_layout['cache'] != false && page_layout['searchresults'] != true
+      page_layout["cache"] != false && page_layout["searchresults"] != true
     end
 
     private

data/app/models/alchemy/page/page_scopes.rb

@@ -21,20 +21,17 @@ module Alchemy
 
       # All pages locked by given user
       #
-      scope :locked_by, ->(user) {
-        if user.class.respond_to? :primary_key
-          locked.where(locked_by: user.send(user.class.primary_key))
-        end
-      }
+      scope :locked_by,
+        ->(user) {
+          if user.class.respond_to? :primary_key
+            locked.where(locked_by: user.send(user.class.primary_key))
+          end
+        }
 
       # All not locked pages
       #
       scope :not_locked, -> { where(locked_at: nil, locked_by: nil) }
 
-      # All visible pages
-      #
-      scope :visible, -> { where(visible: true) }
-
       # All not restricted pages
       #
       scope :not_restricted, -> { where(restricted: false) }
@@ -45,29 +42,27 @@ module Alchemy
 
       # All pages that are a published language root
       #
-      scope :public_language_roots, -> {
-        published.language_roots.where(
-          language_code: Language.published.pluck(:language_code)
-        )
-      }
+      scope :public_language_roots,
+        -> {
+          published.language_roots.where(
+            language_code: Language.published.pluck(:language_code),
+          )
+        }
 
       # Last 5 pages that where recently edited by given user
       #
-      scope :all_last_edited_from, ->(user) {
-        where(updater_id: user.id).order('updated_at DESC').limit(5)
-      }
+      scope :all_last_edited_from,
+        ->(user) {
+          where(updater_id: user.id).order("updated_at DESC").limit(5)
+        }
 
       # Returns all pages that have the given +language_id+
       #
-      scope :with_language, ->(language_id) {
-        where(language_id: language_id)
-      }
+      scope :with_language, ->(language_id) { where(language_id: language_id) }
 
       # Returns all content pages.
       #
-      scope :contentpages, -> {
-        where(layoutpage: [false, nil]).where.not(parent_id: nil)
-      }
+      scope :contentpages, -> { where(layoutpage: [false, nil]) }
 
       # Returns all public contentpages that are not locked.
       #
@@ -79,9 +74,7 @@ module Alchemy
       #
       # Used for flushing all pages caches at once.
       #
-      scope :flushable_layoutpages, -> {
-        not_locked.layoutpages.where.not(parent_id: Page.unscoped.root.id)
-      }
+      scope :flushable_layoutpages, -> { not_locked.layoutpages }
 
       # All searchable pages
       #
@@ -89,9 +82,10 @@ module Alchemy
 
       # All pages from +Alchemy::Site.current+
       #
-      scope :from_current_site, -> {
-        where(Language.table_name => {site_id: Site.current || Site.default}).joins(:language)
-      }
+      scope :from_current_site,
+        -> {
+          where(Language.table_name => { site_id: Site.current || Site.default }).joins(:language)
+        }
 
       # All pages for xml sitemap
       #

data/app/models/alchemy/page/url_path.rb

@@ -29,8 +29,6 @@ module Alchemy
       end
 
       def call
-        return @page.urlname if @page.definition["redirects_to_external"]
-
         if @page.language_root?
           language_root_path
         elsif @site.languages.select(&:public?).length > 1