alchemy_cms 4.5.0 → 5.0.0.rc1

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

@@ -15,7 +15,6 @@ module Alchemy
   #       fixed_attributes:
   #         - public_on: nil
   #         - public_until: nil
-  #         - visible: false
   #
   class Page::FixedAttributes
     attr_reader :page
@@ -31,7 +30,7 @@ module Alchemy
     # @return Hash
     #
     def attributes
-      @_attributes ||= page.definition.fetch('fixed_attributes', {}).symbolize_keys
+      @_attributes ||= page.definition.fetch("fixed_attributes", {}).symbolize_keys
     end
     alias_method :all, :attributes
 
@@ -52,6 +51,7 @@ module Alchemy
     #
     def fixed?(name)
       return false if name.nil?
+
       attributes.key?(name.to_sym)
     end
 
@@ -59,6 +59,7 @@ module Alchemy
     #
     def [](name)
       return nil if name.nil?
+
       attributes[name.to_sym]
     end
   end

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).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