alchemy_cms 4.6.6 → 5.0.0.beta1

data/app/helpers/alchemy/admin/essences_helper.rb

@@ -3,138 +3,29 @@
 module Alchemy
   module Admin
     module EssencesHelper
-      include Alchemy::EssencesHelper
-      include Alchemy::Admin::ContentsHelper
-
-      # Renders the Content editor partial from the given Content.
-      # For options see -> render_essence
-      # @deprecated
-      def render_essence_editor(content, options = {}, html_options = {})
-        if !options.empty?
-          Alchemy::Deprecation.warn <<~WARN
-            Passing options to `render_essence_editor` is deprecated and will be removed from Alchemy 5.0.
-            Add your static `#{options.keys}` options to the `#{content.name}` content definitions `settings` of `#{content.element&.name}` element.
-            For dynamic options consider adding your own essence class.
-          WARN
-        end
-        if !html_options.empty?
-          Alchemy::Deprecation.warn <<~WARN
-            Passing html_options to `render_essence_editor` is deprecated and will be removed in Alchemy 5.0 without replacement.
-          WARN
-        end
-        render_essence(content, :editor, {for_editor: options}, html_options)
-      end
-      deprecate :render_essence_editor, deprecator: Alchemy::Deprecation
-
-      # Renders the Content editor partial found in views/contents/ for the content with name inside the passed Element.
-      # For options see -> render_essence
-      #
-      # Content creation on the fly:
-      #
-      # If you update the elements.yml file after creating an element this helper displays a error message with an option to create the content.
-      # @deprecated
-      def render_essence_editor_by_name(element, name, options = {}, html_options = {})
-        if element.blank?
-          return warning('Element is nil', Alchemy.t(:no_element_given))
-        end
-        content = element.content_by_name(name)
-        if content.nil?
-          render_missing_content(element, name, options)
-        else
-          render_essence_editor(content, options, html_options)
-        end
-      end
-      deprecate :render_essence_editor_by_name, deprecator: Alchemy::Deprecation
-
-      # Returns all public pages from current language as an option tags string suitable or the Rails +select_tag+ helper.
-      #
-      # @param [Array]
-      #   A collection of pages so it only returns these pages and does not query the database.
-      # @param [String]
-      #   Pass a +Page#name+ or +Page#id+ as selected item to the +options_for_select+ helper.
-      # @param [String]
-      #   Used as prompt message in the select tag
-      # @param [Symbol]
-      #   Method that is called on the page object to get the value that is passed with the params of the form.
-      # @deprecated
-      def pages_for_select(pages = nil, selected = nil, prompt = "Choose page", page_attribute = :id)
-        values = [[Alchemy.t(prompt), ""]]
-        pages ||= begin
-          nested = true
-          Language.current.pages.published.order(:lft)
-        end
-        values += pages_attributes_for_select(pages, page_attribute, nested)
-        options_for_select(values, selected.to_s)
-      end
-      deprecate :pages_for_select, deprecator: Alchemy::Deprecation
-
-      # Renders the missing content partial
-      # @deprecated
-      def render_missing_content(element, name, options)
-        render 'alchemy/admin/contents/missing', {element: element, name: name, options: options}
-      end
-      deprecate :render_missing_content, deprecator: Alchemy::Deprecation
-
       # Renders a thumbnail for given EssencePicture content with correct cropping and size
-      def essence_picture_thumbnail(content, options = {})
+      def essence_picture_thumbnail(content)
         picture = content.ingredient
         essence = content.essence
 
         return if picture.nil?
 
         image_tag(
-          essence.thumbnail_url(options),
+          essence.thumbnail_url,
           alt: picture.name,
-          class: 'img_paddingtop',
-          title: Alchemy.t(:image_name) + ": #{picture.name}"
+          class: "img_paddingtop",
+          title: Alchemy.t(:image_name) + ": #{picture.name}",
         )
       end
 
       # Size value for edit picture dialog
-      def edit_picture_dialog_size(content, options = {})
-        if content.settings_value(:caption_as_textarea, options)
-          content.settings_value(:sizes, options) ? '380x320' : '380x300'
-        else
-          content.settings_value(:sizes, options) ? '380x290' : '380x255'
-        end
-      end
-
-      private
-
-      # Returns an Array with page attributes for select options
-      #
-      # @param [Array]
-      #   The pages
-      # @param [String || Symbol]
-      #   The attribute that is used as value
-      # @param [Boolean] (false)
-      #   Should the name be indented or not
-      #
-      def pages_attributes_for_select(pages, page_attribute, indent = false)
-        pages.map do |page|
-          [
-            page_name_attribute_for_select(page, indent),
-            page.send(page_attribute).to_s
-          ]
-        end
-      end
-      deprecate :pages_attributes_for_select, deprecator: Alchemy::Deprecation
-
-      # Returns the page name for pages_for_select helper
-      #
-      # @param [Alchemy::Page]
-      #   The page
-      # @param [Boolean] (false)
-      #   Should the page be indented or not
-      #
-      def page_name_attribute_for_select(page, indent = false)
-        if indent
-          ("&nbsp;&nbsp;" * (page.depth - 1) + page.name).html_safe
+      def edit_picture_dialog_size(content)
+        if content.settings[:caption_as_textarea]
+          content.settings[:sizes] ? "380x320" : "380x300"
         else
-          page.name
+          content.settings[:sizes] ? "380x290" : "380x255"
         end
       end
-      deprecate :page_name_attribute_for_select, deprecator: Alchemy::Deprecation
     end
   end
 end

data/app/helpers/alchemy/admin/form_helper.rb

@@ -19,7 +19,7 @@ module Alchemy
         options[:remote] = request.xhr?
         options[:html] = {
           id: options.delete(:id),
-          class: ["alchemy", options.delete(:class)].compact.join(' ')
+          class: ["alchemy", options.delete(:class)].compact.join(" "),
         }
         simple_form_for(object, *(args << options), &block)
       end

data/app/helpers/alchemy/admin/navigation_helper.rb

@@ -12,9 +12,9 @@ module Alchemy
       #
       def alchemy_main_navigation_entry(alchemy_module)
         render(
-          'alchemy/admin/partials/main_navigation_entry',
+          "alchemy/admin/partials/main_navigation_entry",
           alchemy_module: alchemy_module,
-          navigation: alchemy_module['navigation']
+          navigation: alchemy_module["navigation"],
         )
       end
 
@@ -36,8 +36,8 @@ module Alchemy
       #
       def navigate_module(navigation)
         [
-          navigation['action'].to_sym,
-          navigation['controller'].to_s.gsub(/\A\//, '').gsub(/\//, '_').to_sym
+          navigation["action"].to_sym,
+          navigation["controller"].to_s.gsub(/\A\//, "").gsub(/\//, "_").to_sym,
         ]
       end
 
@@ -45,9 +45,9 @@ module Alchemy
       #
       def main_navigation_css_classes(navigation)
         [
-          'main_navi_entry',
-          admin_mainnavi_active?(navigation) ? 'active' : nil,
-          navigation.key?('sub_navigation') ? 'has_sub_navigation' : nil
+          "main_navi_entry",
+          admin_mainnavi_active?(navigation) ? "active" : nil,
+          navigation.key?("sub_navigation") ? "has_sub_navigation" : nil,
         ].compact
       end
 
@@ -74,8 +74,8 @@ module Alchemy
       #
       def url_for_module(alchemy_module)
         route_from_engine_or_main_app(
-          alchemy_module['engine_name'],
-          url_options_for_module(alchemy_module)
+          alchemy_module["engine_name"],
+          url_options_for_module(alchemy_module),
         )
       end
 
@@ -91,9 +91,10 @@ module Alchemy
       def url_for_module_sub_navigation(navigation)
         alchemy_module = module_definition_for(navigation)
         return if alchemy_module.nil?
+
         route_from_engine_or_main_app(
-          alchemy_module['engine_name'],
-          url_options_for_navigation_entry(navigation)
+          alchemy_module["engine_name"],
+          url_options_for_navigation_entry(navigation),
         )
       end
 
@@ -105,13 +106,13 @@ module Alchemy
         sorted = []
         not_sorted = []
         alchemy_modules.map do |m|
-          if m['position'].blank?
+          if m["position"].blank?
             not_sorted << m
           else
             sorted << m
           end
         end
-        sorted.sort_by { |m| m['position'] } + not_sorted
+        sorted.sort_by { |m| m["position"] } + not_sorted
       end
 
       private
@@ -137,7 +138,7 @@ module Alchemy
       #   A Alchemy module definition
       #
       def url_options_for_module(alchemy_module)
-        url_options_for_navigation_entry(alchemy_module['navigation'] || {})
+        url_options_for_navigation_entry(alchemy_module["navigation"] || {})
       end
 
       # Returns a url options hash for given navigation entry.
@@ -147,26 +148,26 @@ module Alchemy
       #
       def url_options_for_navigation_entry(entry)
         {
-          controller: entry['controller'],
-          action: entry['action'],
+          controller: entry["controller"],
+          action: entry["action"],
           only_path: true,
-          params: entry['params']
+          params: entry["params"],
         }.delete_if { |_k, v| v.nil? }
       end
 
       # Retrieves the current Alchemy module from controller and index action.
       #
       def current_alchemy_module
-        module_definition_for(controller: params[:controller], action: 'index')
+        module_definition_for(controller: params[:controller], action: "index")
       end
 
       # Returns true if the current controller and action is in a modules navigation definition.
       #
       def admin_mainnavi_active?(navigation)
         # Has the given navigation entry a active sub navigation?
-        has_active_entry?(navigation['sub_navigation'] || []) ||
+        has_active_entry?(navigation["sub_navigation"] || []) ||
           # Has the given navigation entry a active nested navigation?
-          has_active_entry?(navigation['nested'] || []) ||
+          has_active_entry?(navigation["nested"] || []) ||
           # Is the navigation entry active?
           entry_active?(navigation || {})
       end
@@ -174,7 +175,7 @@ module Alchemy
       # Returns true if the given entry's controller is current controller
       #
       def is_entry_controller_active?(entry)
-        entry['controller'].gsub(/\A\//, '') == params[:controller]
+        entry["controller"].gsub(/\A\//, "") == params[:controller]
       end
 
       # Returns true if the given entry's action is current controllers action
@@ -182,8 +183,8 @@ module Alchemy
       # Also checks if given entry has a +nested_actions+ key, if so it checks if one of them is current controller's action
       #
       def is_entry_action_active?(entry)
-        entry['action'] == params[:action] ||
-          entry.fetch('nested_actions', []).include?(params[:action])
+        entry["action"] == params[:action] ||
+          entry.fetch("nested_actions", []).include?(params[:action])
       end
 
       # Returns true if an entry of given entries is active.

data/app/helpers/alchemy/admin/pages_helper.rb

@@ -34,8 +34,8 @@ module Alchemy
         end
       end
 
-      def page_status_checkbox(page, attribute, label: nil)
-        label_text = label || page.class.human_attribute_name(attribute)
+      def page_status_checkbox(page, attribute)
+        label = page.class.human_attribute_name(attribute)
 
         if page.attribute_fixed?(attribute)
           checkbox = check_box(:page, attribute, disabled: true)
@@ -43,11 +43,11 @@ module Alchemy
             Alchemy.t(:attribute_fixed, attribute: attribute)
           end
           content = content_tag(:span, class: "with-hint") do
-            "#{checkbox}\n#{label_text}\n#{hint}".html_safe
+            "#{checkbox}\n#{label}\n#{hint}".html_safe
           end
         else
           checkbox = check_box(:page, attribute)
-          content = "#{checkbox}\n#{label_text}".html_safe
+          content = "#{checkbox}\n#{label}".html_safe
         end
 
         content_tag(:label, class: "checkbox") { content }

data/app/helpers/alchemy/admin/pictures_helper.rb

@@ -5,10 +5,10 @@ module Alchemy
     module PicturesHelper
       def preview_size(size)
         case size
-        when 'small' then '80x60'
-        when 'large' then '240x180'
+        when "small" then "80x60"
+        when "large" then "240x180"
         else
-          '160x120'
+          "160x120"
         end
       end
     end

data/app/helpers/alchemy/admin/tags_helper.rb

@@ -12,17 +12,18 @@ module Alchemy
       #   A HTML string containing <tt><li></tt> tags
       #
       def render_tag_list(class_name)
-        raise ArgumentError, 'Please provide a String as class_name' if class_name.nil?
+        raise ArgumentError, "Please provide a String as class_name" if class_name.nil?
+
         sorted_tags_from(class_name: class_name).map do |tag|
-          content_tag('li', name: tag.name, class: filtered_by_tag?(tag) ? 'active' : nil) do
+          content_tag("li", name: tag.name, class: filtered_by_tag?(tag) ? "active" : nil) do
             link_to(
               "#{tag.name} (#{tag.taggings_count})",
               url_for(
                 search_filter_params.except(:page, :tagged_with).merge(
-                  tagged_with: tags_for_filter(current: tag).presence
-                )
+                  tagged_with: tags_for_filter(current: tag).presence,
+                ),
               ),
-              remote: request.xhr?
+              remote: request.xhr?,
             )
           end
         end.join.html_safe
@@ -43,13 +44,13 @@ module Alchemy
           tags_from_params - Array(current.name)
         else
           tags_from_params.push(current.name)
-        end.uniq.join(',')
+        end.uniq.join(",")
       end
 
       # Returns tags from params
       # @returns [Array]
       def tags_from_params
-        search_filter_params[:tagged_with].to_s.split(',')
+        search_filter_params[:tagged_with].to_s.split(",")
       end
 
       def sorted_tags_from(class_name:)

data/app/helpers/alchemy/base_helper.rb

@@ -27,16 +27,16 @@ module Alchemy
     #
     # @return [String]
     def render_icon(icon_class, options = {})
-      options = {style: 'solid'}.merge(options)
+      options = {style: "solid"}.merge(options)
       classes = [
         "icon fa-fw",
         "fa-#{icon_class}",
         "fa#{options[:style].first}",
         options[:size] ? "fa-#{options[:size]}" : nil,
         options[:transform] ? "fa-#{options[:transform]}" : nil,
-        options[:class]
+        options[:class],
       ].compact
-      content_tag('i', nil, class: classes)
+      content_tag("i", nil, class: classes)
     end
 
     # Returns a div with an icon and the passed content
@@ -64,19 +64,24 @@ module Alchemy
     # @param [Symbol] style The style of this flash. Valid values are +:notice+ (default), +:warn+ and +:error+
     #
     def render_flash_notice(notice, style = :notice)
-      render('alchemy/admin/partials/flash', flash_type: style, message: notice)
+      render("alchemy/admin/partials/flash", flash_type: style, message: notice)
     end
 
     # Checks if the given argument is a String or a Page object.
     # If a String is given, it tries to find the page via page_layout
     # Logs a warning if no page is given.
     def page_or_find(page)
+      unless Language.current
+        warning("No default language set up")
+        return nil
+      end
+
       if page.is_a?(String)
         page = Language.current.pages.find_by(page_layout: page)
       end
       if page.blank?
         warning("No Page found for #{page.inspect}")
-        return
+        nil
       else
         page
       end
@@ -88,9 +93,9 @@ module Alchemy
     # @return [String] The FontAwesome icon name
     def message_icon_class(message_type)
       case message_type.to_s
-      when 'warning', 'warn', 'alert' then 'exclamation'
-      when 'notice' then 'check'
-      when 'error' then 'bug'
+      when "warning", "warn", "alert" then "exclamation"
+      when "notice" then "check"
+      when "error" then "bug"
       else
         message_type
       end

data/app/helpers/alchemy/elements_block_helper.rb

@@ -33,7 +33,7 @@ module Alchemy
         helpers.render(content, {
           content: content,
           options: options,
-          html_options: html_options
+          html_options: html_options,
         })
       end
 
@@ -62,15 +62,6 @@ module Alchemy
       end
     end
 
-    # Block-level helper class for element editors.
-    # @deprecated
-    class ElementEditorHelper < BlockHelper
-      def edit(name, *args)
-        helpers.render_essence_editor_by_name(element, name.to_s, *args)
-      end
-      deprecate :edit, deprecator: Alchemy::Deprecation
-    end
-
     # Block-level helper for element views. Constructs a DOM element wrapping
     # your content element and provides a block helper object you can use for
     # concise access to Alchemy's various helpers.
@@ -116,7 +107,7 @@ module Alchemy
         tag: :div,
         id: element_dom_id(element),
         class: element.name,
-        tags_formatter: ->(tags) { tags.join(" ") }
+        tags_formatter: ->(tags) { tags.join(" ") },
       }.merge(options)
 
       # capture inner template block
@@ -140,25 +131,5 @@ module Alchemy
       # that's it!
       output
     end
-
-    # Block-level helper for element editors. Provides a block helper object
-    # you can use for concise access to Alchemy's various helpers.
-    #
-    # === Example:
-    #
-    #   <%= element_editor_for(element) do |el| %>
-    #     <%= el.edit :title %>
-    #     <%= el.edit :body %>
-    #     <%= el.edit :target_url %>
-    #   <% end %>
-    #
-    # @param [Alchemy::Element] element
-    #   The element to display.
-    #
-    def element_editor_for(element)
-      capture do
-        yield ElementEditorHelper.new(self, element: element) if block_given?
-      end
-    end
   end
 end

data/app/helpers/alchemy/elements_helper.rb

@@ -6,7 +6,6 @@ module Alchemy
   # The most important helper for frontend developers is the {#render_elements} helper.
   #
   module ElementsHelper
-    include Alchemy::EssencesHelper
     include Alchemy::UrlHelper
     include Alchemy::ElementsBlockHelper
 
@@ -92,19 +91,9 @@ module Alchemy
     def render_elements(options = {})
       options = {
         from_page: @page,
-        render_format: 'html'
+        render_format: "html",
       }.update(options)
 
-      if options[:sort_by]
-        Alchemy::Deprecation.warn "options[:sort_by] has been removed without replacement. " \
-          "Please implement your own element sorting by passing a custom finder instance to options[:finder]."
-      end
-
-      if options[:from_cell]
-        Alchemy::Deprecation.warn "options[:from_cell] has been removed without replacement. " \
-          "Please `render element.nested_elements` instead."
-      end
-
       finder = options[:finder] || Alchemy::ElementsFinder.new(options)
       elements = finder.elements(page: options[:from_page])
 
@@ -159,21 +148,10 @@ module Alchemy
     # @note If the view partial is not found
     #   <tt>alchemy/elements/_view_not_found.html.erb</tt> gets rendered.
     #
-    def render_element(*args)
-      if args.length == 4
-        element, _part, options, counter = *args
-        Alchemy::Deprecation.warn "passing a `part` parameter as second argument to `render_element` has been removed without replacement. " \
-          "You can safely remove it."
-      else
-        element, options, counter = *args
-      end
-
-      options ||= {}
-      counter ||= 1
-
+    def render_element(element, options = {}, counter = 1)
       if element.nil?
-        warning('Element is nil')
-        render "alchemy/elements/view_not_found", {name: 'nil'}
+        warning("Element is nil")
+        render "alchemy/elements/view_not_found", {name: "nil"}
         return
       end
 
@@ -182,7 +160,7 @@ module Alchemy
       render element, {
         element: element,
         counter: counter,
-        options: options
+        options: options,
       }.merge(options.delete(:locals) || {})
     rescue ActionView::MissingTemplate => e
       warning(%(
@@ -195,23 +173,20 @@ module Alchemy
     # Returns a string for the id attribute of a html element for the given element
     def element_dom_id(element)
       return "" if element.nil?
+
       "#{element.name}_#{element.id}".html_safe
     end
 
     # Renders the HTML tag attributes required for preview mode.
     def element_preview_code(element)
-      if respond_to?(:tag_options)
-        tag_options(element_preview_code_attributes(element))
-      else
-        # Rails 5.1 uses TagBuilder
-        tag_builder.tag_options(element_preview_code_attributes(element))
-      end
+      tag_builder.tag_options(element_preview_code_attributes(element))
     end
 
     # Returns a hash containing the HTML tag attributes required for preview mode.
     def element_preview_code_attributes(element)
       return {} unless element.present? && @preview_mode && element.page == @page
-      { 'data-alchemy-element' => element.id }
+
+      { "data-alchemy-element" => element.id }
     end
 
     # Returns the element's tags information as a string. Parameters and options
@@ -223,12 +198,7 @@ module Alchemy
     #   HTML tag attributes containing the element's tag information.
     #
     def element_tags(element, options = {})
-      if respond_to?(:tag_options)
-        tag_options(element_tags_attributes(element, options))
-      else
-        # Rails 5.1 uses TagBuilder
-        tag_builder.tag_options(element_tags_attributes(element, options))
-      end
+      tag_builder.tag_options(element_tags_attributes(element, options))
     end
 
     # Returns the element's tags information as an attribute hash.
@@ -244,28 +214,12 @@ module Alchemy
     #
     def element_tags_attributes(element, options = {})
       options = {
-        formatter: lambda { |tags| tags.join(' ') }
+        formatter: lambda { |tags| tags.join(" ") },
       }.merge(options)
 
       return {} if !element.taggable? || element.tag_list.blank?
-      { 'data-element-tags' => options[:formatter].call(element.tag_list) }
-    end
-
-    # Sort given elements by content.
-    # @deprecated
-    # @param [Array] elements - The elements you want to sort
-    # @param [String] content_name - The name of the content you want to sort by
-    # @param [Boolean] reverse - Reverse the sorted elements order
-    #
-    # @return [Array]
-    def sort_elements_by_content(elements, content_name, reverse = false)
-      Alchemy::Deprecation.warn "options[:sort_by] is deprecated. Please implement your own element sorting."
-      sorted_elements = elements.sort_by do |element|
-        content = element.content_by_name(content_name)
-        content ? content.ingredient.to_s : ''
-      end
 
-      reverse ? sorted_elements.reverse : sorted_elements
+      { "data-element-tags" => options[:formatter].call(element.tag_list) }
     end
   end
 end