alchemy_cms 4.1.2 → 4.2.0.rc1

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

@@ -3,29 +3,6 @@
 module Alchemy
   module Admin
     module PicturesHelper
-      def create_or_assign_url(picture_to_assign, options)
-        if @content.nil?
-          {
-            controller: :contents,
-            action: :create,
-            picture_id: picture_to_assign.id,
-            content: {
-              essence_type: "Alchemy::EssencePicture",
-              element_id: @element.id
-            },
-            options: options
-          }
-        else
-          {
-            controller: :essence_pictures,
-            action: :assign,
-            picture_id: picture_to_assign.id,
-            content_id: @content.id,
-            options: options
-          }
-        end
-      end
-
       def preview_size(size)
         case size
         when 'small' then '80x60'

data/app/helpers/alchemy/elements_helper.rb

@@ -10,7 +10,7 @@ module Alchemy
     include Alchemy::UrlHelper
     include Alchemy::ElementsBlockHelper
 
-    # Renders all elements from current page
+    # Renders elements from given page
     #
     # == Examples:
     #
@@ -29,12 +29,6 @@ module Alchemy
     #     <%= render_elements from_page: 'footer' %>
     #   </footer>
     #
-    # === Render elements from cell:
-    #
-    #   <aside>
-    #     <%= render_elements from_cell: 'sidebar' %>
-    #   </aside>
-    #
     # === Fallback to elements from global page:
     #
     # You can use the fallback option as an override for elements that are stored on another page.
@@ -51,69 +45,85 @@ module Alchemy
     #     with: 'contact_teaser'
     #   }) %>
     #
-    # @param [Hash] options
-    #   Additional options.
+    # === Custom elements finder:
+    #
+    # Having a custom element finder class:
+    #
+    #   class MyCustomNewsArchive
+    #     def elements(page:)
+    #       news_page.elements.available.named('news').order(created_at: :desc)
+    #     end
+    #
+    #     private
+    #
+    #     def news_page
+    #       Alchemy::Page.where(page_layout: 'news-archive')
+    #     end
+    #   end
     #
+    # In your view:
+    #
+    #   <div class="news-archive">
+    #     <%= render_elements finder: MyCustomNewsArchive.new %>
+    #   </div>
+    #
+    # @option options [Alchemy::Page|String] :from_page (@page)
+    #   The page the elements are rendered from. You can pass a page_layout String or a {Alchemy::Page} object.
+    # @option options [Array<String>|String] :only
+    #   A list of element names only to be rendered.
+    # @option options [Array<String>|String] :except
+    #   A list of element names not to be rendered.
     # @option options [Number] :count
     #   The amount of elements to be rendered (begins with first element found)
-    # @option options [Array or String] :except ([])
-    #   A list of element names not to be rendered.
+    # @option options [Number] :offset
+    #   The offset to begin loading elements from
     # @option options [Hash] :fallback
     #   Define elements that are rendered from another page.
-    # @option options [Alchemy::Cell or String] :from_cell
-    #   The cell the elements are rendered from. You can pass a {Alchemy::Cell} name String or a {Alchemy::Cell} object.
-    # @option options [Alchemy::Page or String] :from_page (@page)
-    #   The page the elements are rendered from. You can pass a page_layout String or a {Alchemy::Page} object.
-    # @option options [Array or String] :only ([])
-    #   A list of element names only to be rendered.
-    # @option options [Boolean] :random
+    # @option options [Boolean] :random (false)
     #   Randomize the output of elements
-    # @option options [Boolean] :reverse
+    # @option options [Boolean] :reverse (false)
     #   Reverse the rendering order
-    # @option options [String] :sort_by
-    #   The name of a {Alchemy::Content} to sort the elements by
     # @option options [String] :separator
-    #   A string that will be used to join the element partials. Default nil
+    #   A string that will be used to join the element partials.
+    # @option options [Class] :finder (Alchemy::ElementsFinder)
+    #   A class instance that will return elements that get rendered.
+    #   Use this for your custom element loading logic in views.
     #
     def render_elements(options = {})
       options = {
         from_page: @page,
-        render_format: 'html',
-        reverse: false
+        render_format: 'html'
       }.update(options)
 
-      pages = pages_holding_elements(options.delete(:from_page))
+      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 pages.blank?
-        warning('No page to get elements from was found')
-        return
+      if options[:from_cell]
+        Alchemy::Deprecation.warn "options[:from_cell] has been removed without replacement. " \
+          "Please `render element.nested_elements.available` instead."
       end
 
-      elements = collect_elements_from_pages(pages, options)
+      finder = options[:finder] || Alchemy::ElementsFinder.new(options)
+      elements = finder.elements(page: options[:from_page])
 
-      if options[:sort_by].present?
-        elements = sort_elements_by_content(
-          elements,
-          options.delete(:sort_by),
-          options[:reverse]
-        )
+      buff = []
+      elements.each_with_index do |element, i|
+        buff << render_element(element, options, i + 1)
       end
-
-      render_element_view_partials(elements, options)
+      buff.join(options[:separator]).html_safe
     end
 
-    # This helper renders a {Alchemy::Element} partial.
-    #
-    # A element has always two partials:
+    # This helper renders a {Alchemy::Element} view partial.
     #
-    # 1. A view partial (This is the view presented to the website visitor)
-    # 2. A editor partial (This is the form presented to the website editor while in page edit mode)
+    # A element view partial is the html snippet presented to the website visitor.
     #
-    # The partials are located in <tt>app/views/alchemy/elements</tt>.
+    # The partial is located in <tt>app/views/alchemy/elements</tt>.
     #
     # == View partial naming
     #
-    # The partials have to be named after the name of the element as defined in the <tt>elements.yml</tt> file and has to be suffixed with the partial part.
+    # The partial has to be named after the name of the element as defined in the <tt>elements.yml</tt> file and has to be suffixed with <tt>_view</tt>.
     #
     # === Example
     #
@@ -125,10 +135,9 @@ module Alchemy
     #     - name: text
     #       type: EssenceText
     #
-    # Then your element view partials has to be named like:
+    # Then your element view partial has to be named like:
     #
-    #   app/views/alchemy/elements/_headline_editor.html.erb
-    #   app/views/alchemy/elements/_headline_view.html.erb
+    #   app/views/alchemy/elements/_headline_view.html.{erb|haml|slim}
     #
     # === Element partials generator
     #
@@ -142,41 +151,45 @@ module Alchemy
     #
     # @param [Alchemy::Element] element
     #   The element you want to render the view for
-    # @param [Symbol] part
-    #   The type of element partial (<tt>:editor</tt> or <tt>:view</tt>) you want to render
     # @param [Hash] options
     #   Additional options
     # @param [Number] counter
     #   a counter
     #
-    # @note If the view partial is not found <tt>alchemy/elements/_view_not_found.html.erb</tt>
-    #   or <tt>alchemy/elements/_editor_not_found.html.erb</tt> gets rendered.
+    # @note If the view partial is not found
+    #   <tt>alchemy/elements/_view_not_found.html.erb</tt> gets rendered.
     #
-    def render_element(element, part = :view, options = {}, counter = 1)
+    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
+
       if element.nil?
         warning('Element is nil')
-        render "alchemy/elements/#{part}_not_found", {name: 'nil'}
+        render "alchemy/elements/view_not_found", {name: 'nil'}
         return
       end
 
-      options = {
+      element.store_page(@page)
+
+      render element, {
         element: element,
         counter: counter,
-        options: options,
-        locals: options.delete(:locals) || {}
-      }
-
-      element.store_page(@page) if part.to_sym == :view
-      render "alchemy/elements/#{element.name}_#{part}", options
+        options: options
+      }.merge(options.delete(:locals) || {})
     rescue ActionView::MissingTemplate => e
       warning(%(
-        Element #{part} partial not found for #{element.name}.\n
+        Element view partial not found for #{element.name}.\n
         #{e}
       ))
-      render "alchemy/elements/#{part}_not_found", {
-        name: element.name,
-        error: "Element #{part} partial not found.<br>Use <code>rails generate alchemy:elements</code> to generate it."
-      }
+      render "alchemy/elements/view_not_found", name: element.name
     end
 
     # Returns a string for the id attribute of a html element for the given element
@@ -239,14 +252,14 @@ module Alchemy
     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 : ''
@@ -254,58 +267,5 @@ module Alchemy
 
       reverse ? sorted_elements.reverse : sorted_elements
     end
-
-    private
-
-    def pages_holding_elements(page)
-      case page
-      when String
-        Language.current.pages.where(
-          page_layout: page,
-          restricted: false
-        ).to_a
-      when Page
-        page
-      end
-    end
-
-    def collect_elements_from_pages(page, options)
-      if page.is_a? Array
-        elements = page.collect { |p| p.find_elements(options) }.flatten
-      else
-        elements = page.find_elements(options)
-      end
-      if fallback_required?(elements, options)
-        elements += fallback_elements(options)
-      end
-      elements
-    end
-
-    def fallback_required?(elements, options)
-      options[:fallback] && elements.detect { |e| e.name == options[:fallback][:for] }.nil?
-    end
-
-    def fallback_elements(options)
-      fallback_options = options.delete(:fallback)
-      case fallback_options[:from]
-      when String
-        page = Language.current.pages.find_by(
-          page_layout: fallback_options[:from],
-          restricted: false
-        )
-      when Page
-        page = fallback_options[:from]
-      end
-      return [] if page.blank?
-      page.elements.not_trashed.named(fallback_options[:with].presence || fallback_options[:for])
-    end
-
-    def render_element_view_partials(elements, options = {})
-      buff = []
-      elements.each_with_index do |element, i|
-        buff << render_element(element, :view, options, i + 1)
-      end
-      buff.join(options[:separator]).html_safe
-    end
   end
 end

data/app/helpers/alchemy/pages_helper.rb

@@ -294,30 +294,11 @@ module Alchemy
       "#{@page.robot_index? ? '' : 'no'}index, #{@page.robot_follow? ? '' : 'no'}follow"
     end
 
-    # Renders the partial for the cell with the given name of the current page.
-    # Cell partials are located in +app/views/cells/+ of your project.
-    #
-    # === Options are:
-    #
-    #   from_page: Alchemy::Page     # Alchemy::Page object from which the elements are rendered from.
-    #   locals: Hash                 # Hash of variables that will be available in the partial. Example: {user: var1, product: var2}
-    #
-    def render_cell(name, options = {})
-      default_options = {
-        from_page: @page,
-        locals: {}
-      }
-      options = default_options.merge(options)
-      cell = options[:from_page].cells.find_by_name(name)
-      return "" if cell.blank?
-      render partial: "alchemy/cells/#{name}", locals: {cell: cell}.merge(options[:locals])
-    end
-
-    # Returns true or false if no elements are in the cell found by name.
-    def cell_empty?(name)
-      cell = @page.cells.find_by_name(name)
-      return true if cell.blank?
-      cell.elements.not_trashed.empty?
+    # @deprecated
+    def render_cell(name, _options = {})
+      render_elements(only: name, fixed: true)
     end
+    deprecate render_cell: 'Use render_elements(only: <cell-name>, fixed: true) instead',
+      deprecator: Alchemy::Deprecation
   end
 end

data/app/models/alchemy/content.rb

@@ -45,7 +45,6 @@ module Alchemy
     scope :essence_htmls,     -> { where(essence_type: "Alchemy::EssenceHtml") }
     scope :essence_links,     -> { where(essence_type: "Alchemy::EssenceLink") }
     scope :essence_pictures,  -> { where(essence_type: "Alchemy::EssencePicture") }
-    scope :gallery_pictures,  -> { essence_pictures.where("#{table_name}.name LIKE 'essence_picture_%'") }
     scope :essence_richtexts, -> { where(essence_type: "Alchemy::EssenceRichtext") }
     scope :essence_selects,   -> { where(essence_type: "Alchemy::EssenceSelect") }
     scope :essence_texts,     -> { where(essence_type: "Alchemy::EssenceText") }

data/app/models/alchemy/content/factory.rb

@@ -11,19 +11,21 @@ module Alchemy
 
       # Builds a new content as descriped in the elements.yml file.
       #
-      # @param [Alchemy::Element]
-      #   The element the content is for
       # @param [Hash]
       #   The content definition used for finding the content in +elements.yml+ file
       #
-      def build(element, essence_hash)
-        definition = content_definition(element, essence_hash)
+      def new(attributes = {})
+        element = attributes[:element] || Element.find_by(id: attributes[:element_id])
+        return super if attributes.empty? || element.nil?
+
+        definition = element.content_definition_for(attributes[:name])
         if definition.blank?
-          raise ContentDefinitionError, "No definition found in elements.yml for #{essence_hash.inspect} and #{element.inspect}"
-        else
-          new(name: definition['name'], element_id: element.id)
+          raise ContentDefinitionError, "No definition found in elements.yml for #{attributes.inspect} and #{element.inspect}"
         end
+        super(name: definition['name'], element_id: element.id)
       end
+      alias_method :build, :new
+      deprecate build: :new, deprecator: Alchemy::Deprecation
 
       # Creates a new content from elements definition in the +elements.yml+ file.
       #
@@ -32,12 +34,20 @@ module Alchemy
       #
       # @return [Alchemy::Content]
       #
-      def create_from_scratch(element, essence_hash)
-        if content = build(element, essence_hash)
-          content.create_essence!(essence_hash[:essence_type])
+      def create(*args)
+        attributes = args.last || {}
+        if args.length > 1
+          Alchemy::Deprecation.warn 'Passing an element as first argument to Alchemy::Content.create is deprecated! Pass an attribute hash with element inside instead.'
+          element = args.first
+        else
+          element = attributes[:element]
+        end
+        new(attributes.merge(element: element)).tap do |content|
+          content.create_essence!(attributes[:essence_type])
         end
-        content
       end
+      alias_method :create_from_scratch, :create
+      deprecate create_from_scratch: :create, deprecator: Alchemy::Deprecation
 
       # Creates a copy of source and also copies the associated essence.
       #
@@ -50,60 +60,26 @@ module Alchemy
       #
       def copy(source, differences = {})
         new_content = Content.new(
-          source.attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY).merge(differences)
+          source.attributes.
+            except(*SKIPPED_ATTRIBUTES_ON_COPY).
+            merge(differences.with_indifferent_access)
         )
-
-        new_essence = new_content.essence.class.create!(
-          new_content.essence.attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY)
+        new_essence = source.essence.class.create!(
+          source.essence.attributes.
+            except(*SKIPPED_ATTRIBUTES_ON_COPY)
         )
-
-        new_content.update!(essence_id: new_essence.id)
-        new_content
-      end
-
-      # Returns the content definition for building a content.
-      #
-      # 1. It looks in the element's contents definition
-      # 2. It builds a definition hash from essence type, if the the name key is not present
-      #
-      def content_definition(element, essence_hash)
-        # No name given. We build the content from essence type.
-        if essence_hash[:name].blank? && essence_hash[:essence_type].present?
-          content_definition_from_essence_type(element, essence_hash[:essence_type])
-        else
-          element.content_definition_for(essence_hash[:name])
+        new_content.tap do |content|
+          content.essence = new_essence
+          content.save
         end
       end
 
-      # Returns a hash for building a content from essence type.
-      #
-      # @param [Alchemy::Element]
-      #   The element the content is for.
-      # @param [String]
-      #   The essence type the content is from
-      #
-      def content_definition_from_essence_type(element, essence_type)
-        {
-          'type' => essence_type,
-          'name' => content_name_from_element_and_essence_type(element, essence_type)
-        }
-      end
-
-      # A name for content from its essence type and amount of same essences in element.
-      #
-      # Example:
-      #
-      #   essence_picture_1
-      #
-      def content_name_from_element_and_essence_type(element, essence_type)
-        essences_of_same_type = element.contents.where(essence_type: normalize_essence_type(essence_type))
-        "#{essence_type.classify.demodulize.underscore}_#{essences_of_same_type.count + 1}"
-      end
-
       # Returns all content definitions from elements.yml
       #
       def definitions
-        Element.definitions.collect { |e| e['contents'] }.flatten.compact
+        definitions = Element.definitions.flat_map { |e| e['contents'] }
+        definitions.compact!
+        definitions
       end
 
       # Returns a normalized Essence type