alchemy_cms 6.0.0.b1 → 6.0.0.pre.b5

data/app/controllers/alchemy/api/elements_controller.rb

@@ -9,21 +9,25 @@ module Alchemy
     # If you want to only load a specific type of element pass ?named=an_element_name
     #
     def index
-      if params[:page_id].present?
-        @page = Page.find(params[:page_id])
-        @elements = @page.elements.not_nested
+      # Fix for cancancan not able to merge multiple AR scopes for logged in users
+      if cannot? :manage, Alchemy::Element
+        @elements = Alchemy::Element.accessible_by(current_ability, :index)
       else
-        @elements = Element.not_nested.joins(:page_version).merge(PageVersion.published)
+        @elements = Alchemy::Element.all
       end
 
-      # Fix for cancancan not able to merge multiple AR scopes for logged in users
-      if cannot? :manage, Alchemy::Element
-        @elements = @elements.accessible_by(current_ability, :index)
+      @elements = @elements.not_nested.joins(:page_version).merge(PageVersion.published)
+
+      if params[:page_id].present?
+        @elements = @elements.includes(:page).where(alchemy_pages: { id: params[:page_id] })
+      else
+        @elements = @elements.includes(*element_includes)
       end
+
       if params[:named].present?
         @elements = @elements.named(params[:named])
       end
-      @elements = @elements.includes(*element_includes).order(:position)
+      @elements = @elements.order(:position)
 
       render json: @elements, adapter: :json, root: "elements"
     end

data/app/controllers/alchemy/api/pages_controller.rb

@@ -7,10 +7,12 @@ module Alchemy
     # Returns all pages as json object
     #
     def index
-      @pages = Language.current&.pages.presence || Alchemy::Page.none
       # Fix for cancancan not able to merge multiple AR scopes for logged in users
       if cannot? :edit_content, Alchemy::Page
-        @pages = @pages.accessible_by(current_ability, :index)
+        @pages = Alchemy::Page.accessible_by(current_ability, :index)
+        @pages = @pages.where(language: Language.current)
+      else
+        @pages = Language.current&.pages.presence || Alchemy::Page.none
       end
       @pages = @pages.includes(*page_includes)
       @pages = @pages.ransack(params[:q]).result

data/app/decorators/alchemy/element_editor.rb

@@ -26,7 +26,7 @@ module Alchemy
     # @return Array<Alchemy::IngredientEditor>
     def ingredients
       element.definition.fetch(:ingredients, []).map do |ingredient|
-        Alchemy::IngredientEditor.new(find_or_create_ingredient(ingredient[:role]))
+        Alchemy::IngredientEditor.new(find_or_create_ingredient(ingredient))
       end
     end
 
@@ -121,9 +121,12 @@ module Alchemy
       Alchemy::Content.create(element: element, name: name)
     end
 
-    def find_or_create_ingredient(role)
-      element.ingredients.find { |i| i.role == role } ||
-        Ingredient.create(element: element, role: role)
+    def find_or_create_ingredient(definition)
+      element.ingredients.detect { |i| i.role == definition[:role] } ||
+        element.ingredients.create!(
+          role: definition[:role],
+          type: Alchemy::Ingredient.normalize_type(definition[:type]),
+        )
     end
   end
 end

data/app/decorators/alchemy/ingredient_editor.rb

@@ -64,8 +64,12 @@ module Alchemy
       "element[ingredients_attributes][#{form_field_counter}][#{column}]"
     end
 
+    # Returns a unique string to be passed to a form field id.
+    #
+    # @param column [String] A Ingredient column_name. Default is 'value'
+    #
     def form_field_id(column = "value")
-      "element_ingredients_attributes_#{form_field_counter}_#{column}"
+      "element_#{element.id}_ingredient_#{id}_#{column}"
     end
 
     # Fixes Rails partial renderer calling to_model on the object

data/app/helpers/alchemy/elements_block_helper.rb

@@ -51,21 +51,23 @@ module Alchemy
       # If the element uses +ingredients+ it returns the +value+ of the ingredient record.
       #
       def ingredient(name)
-        element.ingredient(name).presence || element.ingredient_by_role(name)&.value
+        element.ingredient(name)
       end
 
-      deprecate ingredient: :value, deprecator: Alchemy::Deprecation
-
       # Returns the value of one of the element's ingredients.
       #
       def value(name)
-        element.ingredient_by_role(name)&.value
+        element.value_for(name)
       end
 
-      # Returns true if the given content or ingredient has been filled by the user.
+      # Returns true if the given content or ingredient has a value.
       #
       def has?(name)
-        element.has_ingredient?(name) || element.has_value_for?(name)
+        if element.ingredient_definitions.any?
+          element.has_value_for?(name)
+        else
+          element.has_ingredient?(name)
+        end
       end
 
       # Return's the given content's essence.
@@ -75,6 +77,12 @@ module Alchemy
       end
 
       deprecate essence: "Use `ingredient_by_role` instead", deprecator: Alchemy::Deprecation
+
+      # Return's the ingredient record by given role.
+      #
+      def ingredient_by_role(role)
+        element.ingredient_by_role(role)
+      end
     end
 
     # Block-level helper for element views. Constructs a DOM element wrapping

data/app/models/alchemy/attachment.rb

@@ -35,6 +35,10 @@ module Alchemy
     has_many :elements, through: :contents
     has_many :pages, through: :elements
 
+    scope :by_file_type, ->(file_type) { where(file_mime_type: file_type) }
+    scope :recent, -> { where("#{table_name}.created_at > ?", Time.current - 24.hours).order(:created_at) }
+    scope :without_tag, -> { left_outer_joins(:taggings).where(gutentag_taggings: { id: nil }) }
+
     # We need to define this method here to have it available in the validations below.
     class << self
       # The class used to generate URLs for attachments
@@ -51,6 +55,26 @@ module Alchemy
         @_url_class = klass
       end
 
+      def alchemy_resource_filters
+        [
+          {
+            name: :by_file_type,
+            values: distinct.pluck(:file_mime_type).map { |type| [Alchemy.t(type, scope: "mime_types"), type] }.sort_by(&:first),
+          },
+          {
+            name: :misc,
+            values: %w(recent last_upload without_tag),
+          },
+        ]
+      end
+
+      def last_upload
+        last_id = Attachment.maximum(:id)
+        return Attachment.all unless last_id
+
+        where(id: last_id)
+      end
+
       def searchable_alchemy_resource_attributes
         %w(name file_name)
       end
@@ -58,13 +82,6 @@ module Alchemy
       def allowed_filetypes
         Config.get(:uploader).fetch("allowed_filetypes", {}).fetch("alchemy/attachments", [])
       end
-
-      def file_types_for_select
-        file_types = Alchemy::Attachment.pluck(:file_mime_type).uniq.map do |type|
-          [Alchemy.t(type, scope: "mime_types"), type]
-        end
-        file_types.sort_by(&:first)
-      end
     end
 
     validates_presence_of :file

data/app/models/alchemy/element/element_essences.rb

@@ -5,10 +5,20 @@ module Alchemy
     module ElementEssences
       # Returns the contents essence value (aka. ingredient) for passed content name.
       def ingredient(name)
-        content = content_by_name(name)
-        return nil if content.blank?
+        ing = ingredient_by_role(name)
+        if ing
+          Alchemy::Deprecation.warn <<~WARN
+            Using `element.ingredient` to get the value of an ingredient is deprecated and will change in Alchemy 6.1
+            If you want to read the value of an elements ingredient please use `element.value_for(:ingredient_role)` instead.
+            The next version of Alchemy will return a `Alchemy::Ingredient` record instead.
+          WARN
+          ing.value
+        else
+          content = content_by_name(name)
+          return nil if content.blank?
 
-        content.ingredient
+          content.ingredient
+        end
       end
 
       # True if the element has a content for given name,
@@ -16,6 +26,7 @@ module Alchemy
       def has_ingredient?(name)
         ingredient(name).present?
       end
+      deprecate has_ingredient?: :has_value_for?, deprecator: Alchemy::Deprecation
 
       # Returns all essence errors in the format of:
       #

data/app/models/alchemy/element/element_ingredients.rb

@@ -22,6 +22,11 @@ module Alchemy
         validates_associated :ingredients, on: :update
       end
 
+      # The value of an ingredient of the element by role
+      def value_for(role)
+        ingredient_by_role(role)&.value
+      end
+
       # Find first ingredient from element by given role.
       def ingredient_by_role(role)
         ingredients.detect { |ingredient| ingredient.role == role.to_s }
@@ -87,7 +92,7 @@ module Alchemy
       # True if the element has a ingredient for given name
       # that has a non blank value.
       def has_value_for?(role)
-        ingredient_by_role(role)&.value.present?
+        value_for(role).present?
       end
 
       # Ingredient validation error messages
@@ -167,8 +172,11 @@ module Alchemy
 
       # Builds ingredients for this element as described in the +elements.yml+
       def build_ingredients
-        self.ingredients = ingredient_definitions.map do |attributes|
-          Ingredient.build(role: attributes[:role], element: self)
+        ingredient_definitions.each do |attributes|
+          ingredients.build(
+            role: attributes[:role],
+            type: Alchemy::Ingredient.normalize_type(attributes[:type]),
+          )
         end
       end
     end

data/app/models/alchemy/element/presenters.rb

@@ -46,7 +46,9 @@ module Alchemy
       #   Length of characters after the text will be cut off.
       #
       def preview_text(maxlength = 60)
-        preview_text_from_preview_content(maxlength) || preview_text_from_nested_elements(maxlength)
+        preview_text_from_preview_ingredient(maxlength) ||
+          preview_text_from_preview_content(maxlength) ||
+          preview_text_from_nested_elements(maxlength)
       end
 
       # Generates a preview text containing Element#display_name and Element#preview_text.
@@ -94,6 +96,17 @@ module Alchemy
         @_preview_content ||= contents.detect(&:preview_content?) || contents.first
       end
 
+      # The ingredient that's used for element's preview text.
+      #
+      # It tries to find one of element's ingredients that is defined +as_element_title+.
+      # Takes element's first ingredient if no ingredient is defined +as_element_title+.
+      #
+      # @return (Alchemy::Ingredient)
+      #
+      def preview_ingredient
+        @_preview_ingredient ||= ingredients.detect(&:preview_ingredient?) || ingredients.first
+      end
+
       private
 
       def preview_text_from_nested_elements(maxlength)
@@ -105,6 +118,10 @@ module Alchemy
       def preview_text_from_preview_content(maxlength)
         preview_content.try!(:preview_text, maxlength)
       end
+
+      def preview_text_from_preview_ingredient(maxlength)
+        preview_ingredient&.preview_text(maxlength)
+      end
     end
   end
 end

data/app/models/alchemy/element.rb

@@ -267,20 +267,6 @@ module Alchemy
       "alchemy/elements/#{name}"
     end
 
-    # Returns the key that's taken for cache path.
-    #
-    # Uses the page's +published_at+ value that's updated when the user publishes the page.
-    #
-    # If the page is the current preview it uses the element's updated_at value as cache key.
-    #
-    def cache_key
-      if Page.current_preview == page
-        "alchemy/elements/#{id}-#{updated_at}"
-      else
-        "alchemy/elements/#{id}-#{page.published_at}"
-      end
-    end
-
     # A collection of element names that can be nested inside this element.
     def nestable_elements
       definition.fetch("nestable_elements", [])

data/app/models/alchemy/ingredient.rb

@@ -6,12 +6,13 @@ module Alchemy
 
     include Hints
 
-    self.abstract_class = true
     self.table_name = "alchemy_ingredients"
 
     belongs_to :element, touch: true, class_name: "Alchemy::Element", inverse_of: :ingredients
     belongs_to :related_object, polymorphic: true, optional: true
 
+    before_validation(on: :create) { self.value ||= default_value }
+
     validates :type, presence: true
     validates :role, presence: true
 
@@ -33,32 +34,6 @@ module Alchemy
     scope :videos, -> { where(type: "Alchemy::Ingredients::Video") }
 
     class << self
-      # Builds concrete ingredient class as described in the +elements.yml+
-      def build(attributes = {})
-        element = attributes[:element]
-        raise ArgumentError, "No element given. Please pass element in attributes." if element.nil?
-        raise ArgumentError, "No role given. Please pass role in attributes." if attributes[:role].nil?
-
-        definition = element.ingredient_definition_for(attributes[:role])
-        if definition.nil?
-          raise DefinitionError,
-            "No definition found for #{attributes[:role]}. Please define #{attributes[:role]} on #{element[:name]}."
-        end
-
-        ingredient_class = Ingredient.ingredient_class_by_type(definition[:type])
-        ingredient_class.new(
-          type: Ingredient.normalize_type(definition[:type]),
-          value: default_value(definition),
-          role: definition[:role],
-          element: element,
-        )
-      end
-
-      # Creates concrete ingredient class as described in the +elements.yml+
-      def create(attributes = {})
-        build(attributes).tap(&:save)
-      end
-
       # Defines getter and setter method aliases for related object
       #
       # @param [String|Symbol] The name of the alias
@@ -78,20 +53,6 @@ module Alchemy
         end
       end
 
-      # Returns an ingredient class by type
-      #
-      # Raises ArgumentError if there is no such class in the
-      # +Alchemy::Ingredients+ module namespace.
-      #
-      # If you add custom ingredient class,
-      # put them in the +Alchemy::Ingredients+ module namespace
-      #
-      # @param [String] The ingredient class name to constantize
-      # @return [Class]
-      def ingredient_class_by_type(ingredient_type)
-        Alchemy::Ingredients.const_get(ingredient_type.to_s.classify.demodulize)
-      end
-
       # Modulize ingredient type
       #
       # Makes sure the passed ingredient type is in the +Alchemy::Ingredients+
@@ -112,22 +73,6 @@ module Alchemy
           default: Alchemy.t("ingredient_roles.#{role}", default: role.humanize),
         )
       end
-
-      private
-
-      # Returns the default value from ingredient definition
-      #
-      # If the value is a symbol it gets passed through i18n
-      # inside the +alchemy.default_ingredient_texts+ scope
-      def default_value(definition)
-        default = definition[:default]
-        case default
-        when Symbol
-          Alchemy.t(default, scope: :default_ingredient_texts)
-        else
-          default
-        end
-      end
     end
 
     # Compatibility method for access from element
@@ -173,11 +118,6 @@ module Alchemy
       value.to_s[0..maxlength - 1]
     end
 
-    # Cross DB adapter data accessor that works
-    def data
-      @_data ||= (self[:data] || {}).with_indifferent_access
-    end
-
     # The path to the view partial of the ingredient
     # @return [String]
     def to_partial_path
@@ -210,10 +150,29 @@ module Alchemy
       false
     end
 
+    # @return [Boolean]
+    def preview_ingredient?
+      !!definition[:as_element_title]
+    end
+
     private
 
     def hint_translation_attribute
       role
     end
+
+    # Returns the default value from ingredient definition
+    #
+    # If the value is a symbol it gets passed through i18n
+    # inside the +alchemy.default_ingredient_texts+ scope
+    def default_value
+      default = definition[:default]
+      case default
+      when Symbol
+        Alchemy.t(default, scope: :default_ingredient_texts)
+      else
+        default
+      end
+    end
   end
 end