maglevcms 2.1.0 → 3.0.0.beta1

data/app/models/concerns/maglev/content/enhanced_value_concern.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    module EnhancedValueConcern
+      def label
+        @label ||= extract_enhanced_value_if do |setting_definition, value|
+          setting_definition.content_label(value)
+        end
+      end
+
+      def label?
+        label.present?
+      end
+
+      def image
+        @image ||= extract_enhanced_value_if do |setting_definition, value|
+          setting_definition.content_image(value)
+        end
+      end
+
+      def image?
+        image.present?
+      end
+
+      private
+
+      def extract_enhanced_value_if
+        definition.settings.each do |setting_definition|
+          value = settings.value_of(setting_definition.id)
+          next if value.blank?
+
+          enhanced_value = yield(setting_definition, value)
+          return enhanced_value if enhanced_value.present?
+        end
+        nil
+      end
+    end
+  end
+end

data/app/models/concerns/maglev/sections_concern.rb

@@ -21,8 +21,35 @@ module Maglev::SectionsConcern
     end
   end
 
+  def position_of_section(section_id)
+    sections.index { |section| section['id'] == section_id }
+  end
+
+  def find_section_by_id(id)
+    sections.find { |section| section['id'] == id }
+  end
+
   def find_sections_by_type(type)
-    sections.select { |section| section['type'] == type }
+    sections&.find_all { |section| section['type'] == type } || []
+  end
+
+  def reorder_sections(sorted_section_ids, lock_version)
+    self.lock_version = lock_version
+    sections_translations_will_change!
+    sections.sort! { |a, b| sorted_section_ids.index(a['id']) <=> sorted_section_ids.index(b['id']) }
+  end
+
+  def delete_section(section_id)
+    sections_translations_will_change!
+    sections.delete_if { |section| section['id'] == section_id }
+  end
+
+  def section_ids
+    sections.map { |section| section['id'] }
+  end
+
+  def find_section_block_by_id(section_id, id)
+    find_section_by_id(section_id)&.dig('blocks')&.find { |block| block['id'] == id }
   end
 
   private
@@ -49,6 +76,8 @@ module Maglev::SectionsConcern
   end
 
   def prepare_settings(theme, section_type, block_type, settings)
+    settings ||= [] # some blocks don't have settings
+
     # NOTE: in the theme definition file, we allow developers to declare
     # default content like this: { <setting_id_1>: <setting_value_1>, ..., <setting_id_n>: <setting_value_n> }
     settings = settings.map { |key, value| { id: key, value: value } } unless settings.is_a?(Array)

data/app/models/concerns/maglev/translatable.rb

@@ -55,8 +55,7 @@ module Maglev
 
       def setup_accessors(attr)
         define_method("#{attr}=") do |value|
-          public_send("#{attr}_translations=",
-                      translations_for(attr).merge(Maglev::I18n.current_locale.to_s => value))
+          public_send("#{attr}_translations=", translations_for(attr).merge(Maglev::I18n.current_locale.to_s => value))
         end
 
         define_method(attr) { translations_for(attr)[Maglev::I18n.current_locale.to_s] }

data/app/models/maglev/asset.rb

@@ -28,14 +28,12 @@ module Maglev
 
     ## class methods ##
 
-    def self.search(keyword, type, page = nil, per_page = nil)
+    def self.search(keyword, type)
       all
         .optimized
         .where(keyword.present? ? arel_table[:filename].matches("%#{keyword}%") : nil)
         .where(arel_table[:content_type].matches("%#{type}%"))
         .order(created_at: :desc)
-        .page(page || 1)
-        .per(per_page || 10)
     end
   end
 end

data/app/models/maglev/content/block_content.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class BlockContent
+      include ActiveModel::Model
+      include Maglev::Content::EnhancedValueConcern
+
+      attr_accessor :id, :type, :settings, :definition, :position, :parent_id, :position_in_parent, :lock_version
+
+      def persisted?
+        true
+      end
+
+      delegate :root?, to: :definition
+
+      def accepted_child_types
+        definition.accept || []
+      end
+
+      def name
+        definition.human_name
+      end
+
+      def self.build(raw_block_content:, definition:, position:)
+        new(
+          id: raw_block_content['id'],
+          definition: definition,
+          type: raw_block_content['type'],
+          settings: Maglev::Content::SettingContent::AssociationProxy.new(raw_block_content['settings']),
+          parent_id: raw_block_content['parent_id'],
+          position: position,
+          lock_version: raw_block_content['lock_version']
+        )
+      end
+
+      def self.build_many(raw_blocks_content:, section_content:)
+        blocks = raw_blocks_content.each_with_index.map do |raw_block_content, index|
+          build(
+            raw_block_content: raw_block_content,
+            definition: section_content.definition.blocks.find(raw_block_content['type']),
+            position: index
+          )
+        end
+        compute_position_in_parent(blocks)
+      end
+
+      def self.compute_position_in_parent(blocks)
+        memo = {} # key: parent_id, value: number of blocks
+        blocks.each do |block|
+          memo[block.parent_id] ||= 0
+          block.position_in_parent = memo[block.parent_id]
+          memo[block.parent_id] += 1
+        end
+        blocks
+      end
+
+      class AssociationProxy
+        include Enumerable
+
+        attr_reader :array
+
+        def initialize(section_content:, raw_blocks_content:)
+          @array = Maglev::Content::BlockContent.build_many(
+            section_content: section_content,
+            raw_blocks_content: raw_blocks_content
+          )
+        end
+
+        def find(id)
+          array.find { |block| block.id == id }
+        end
+
+        def find_all_by_type(type)
+          array.select { |block| block.type == type }
+        end
+
+        def can_add?(type)
+          blocks = find_all_by_type(type)
+
+          return true if blocks.empty?
+
+          definition = blocks.first.definition
+
+          definition.limit == -1 || blocks.size < definition.limit
+        end
+
+        def each(&block)
+          array.each(&block)
+        end
+
+        delegate :empty?, to: :array
+      end
+    end
+  end
+end

data/app/models/maglev/content/editor_link.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class EditorLink
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      validates :link_type, presence: true
+      validates :email, presence: true, if: :email_type?
+      validates :href, presence: true, if: :url_type?
+
+      attribute :link_label, :string, default: nil
+      attribute :link_type, :string
+      attribute :link_id, :string, default: nil
+      attribute :section_id, :string, default: nil
+      attribute :href, :string
+      attribute :email, :string
+      attribute :open_new_window, :boolean, default: false
+
+      %w[email url page static_page].each do |type|
+        define_method(:"#{type}_type?") do
+          link_type == type
+        end
+      end
+
+      def url_href
+        (url_type? && href).presence || ''
+      end
+
+      def url_href=(new_value)
+        self.href = new_value
+      end
+
+      def email=(new_value)
+        self.href = "mailto:#{new_value}"
+        super
+      end
+
+      def persisted?
+        true
+      end
+
+      def to_component_params
+        as_json['attributes'].with_indifferent_access
+      end
+    end
+  end
+end

data/app/models/maglev/content/section_content.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class SectionContent
+      include ActiveModel::Model
+      include Maglev::Content::EnhancedValueConcern
+
+      attr_accessor :id, :type, :settings, :blocks, :definition, :theme_id, :lock_version
+
+      def persisted?
+        true
+      end
+
+      def sticky?
+        definition.viewport_fixed_position?
+      end
+
+      delegate :site_scoped?, to: :definition
+
+      def type_name
+        definition.human_name
+      end
+
+      def blocks?
+        blocks.present?
+      end
+
+      def block_definitions
+        definition.blocks
+      end
+
+      def root_blocks
+        blocks.select(&:root?)
+      end
+
+      # return the definitions of root blocks that can be added
+      def root_block_definitions
+        definition.root_blocks.select { |block_definition| blocks.can_add?(block_definition.type) }
+      end
+
+      # return the definitions of blocks that can be added as children of the given block
+      def child_block_definitions_of(block_id)
+        accepted_block_types = blocks.find(block_id).accepted_child_types
+        definition.blocks.select do |block_definition|
+          accepted_block_types.include?(block_definition.type) && blocks.can_add?(block_definition.type)
+        end
+      end
+
+      def blocks_label
+        definition.human_blocks_label(::I18n.t('maglev.editor.section_blocks.breadcrumb'))
+      end
+
+      def child_blocks_of(block_id)
+        blocks.select { |block| block.parent_id == block_id }
+      end
+
+      def build_blocks(raw_section_content)
+        self.blocks = Maglev::Content::BlockContent::AssociationProxy.new(
+          section_content: self,
+          raw_blocks_content: raw_section_content['blocks']
+        )
+      end
+
+      def self.build_many(theme:, content:)
+        content.map do |raw_section_content|
+          build(theme: theme, raw_section_content: raw_section_content)
+        end
+      end
+
+      def self.build(theme:, raw_section_content:)
+        new(
+          id: raw_section_content['id'],
+          definition: theme.sections.find(raw_section_content['type']),
+          type: raw_section_content['type'],
+          settings: Maglev::Content::SettingContent::AssociationProxy.new(raw_section_content['settings']),
+          theme_id: theme.id,
+          lock_version: raw_section_content['lock_version']
+        ).tap do |section_content|
+          section_content.build_blocks(raw_section_content)
+        end
+      end
+    end
+  end
+end

data/app/models/maglev/content/setting_content.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Maglev
+  module Content
+    class SettingContent
+      include ActiveModel::Model
+
+      attr_accessor :id, :type, :value
+
+      class AssociationProxy
+        include Enumerable
+
+        attr_reader :settings
+
+        def initialize(raw_settings)
+          @settings = raw_settings.map { |raw_setting| Maglev::Content::SettingContent.new(raw_setting) }
+        end
+
+        def [](id)
+          settings.find { |s| s.id == id }
+        end
+
+        def value_of(id)
+          self[id]&.value
+        end
+
+        def each(&block)
+          settings.each(&block)
+        end
+      end
+    end
+  end
+end

data/app/models/maglev/page/path_concern.rb

@@ -25,6 +25,7 @@ module Maglev::Page::PathConcern
 
     ## callbacks ##
     before_validation { path } # force the initialization of a new path if it doesn't exist
+    after_validation :set_path_errors
     before_save :spawn_redirection, if: :spawn_redirection?
   end
 
@@ -88,5 +89,11 @@ module Maglev::Page::PathConcern
 
     current_path.persisted? && current_path.will_save_change_to_value?
   end
+
+  def set_path_errors
+    errors.delete('paths.value')&.each do |message|
+      errors.add(:path, message)
+    end
+  end
 end
 # rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/page/search_concern.rb

@@ -4,12 +4,15 @@
 module Maglev::Page::SearchConcern
   extend ActiveSupport::Concern
 
+  # rubocop:disable Metrics/BlockLength
   class_methods do
-    def search(keyword, locale)
-      return [] if keyword.blank?
-
+    def search(keyword, locale, index_first: true)
       title = search_title_node(locale)
-      query = all.select(Maglev::Page.arel_table[Arel.star], title).distinct.joins(:paths).order(title.asc)
+      query = all.select(select_clause(title,
+                                       index_first)).distinct.joins(:paths).order(order_clause(title, index_first))
+
+      return query if keyword.blank?
+
       matching = "%#{keyword}%"
 
       query.where(
@@ -21,6 +24,21 @@ module Maglev::Page::SearchConcern
 
     protected
 
+    def select_clause(title, index_first)
+      [
+        Maglev::Page.arel_table[Arel.star],
+        title,
+        index_first ? Maglev::PagePath.arel_table[:value].eq('index').as('is_index') : nil
+      ].compact
+    end
+
+    def order_clause(title, index_first)
+      [
+        index_first ? 'is_index DESC' : nil,
+        title.asc
+      ].compact
+    end
+
     def search_title_clause(query, locale)
       search_title_node(locale).matches(query)
     end
@@ -35,5 +53,6 @@ module Maglev::Page::SearchConcern
       translated_arel_attribute(:title, locale)
     end
   end
+  # rubocop:enable Metrics/BlockLength
 end
 # rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/page.rb

@@ -25,6 +25,9 @@ module Maglev
     include Maglev::Page::PathConcern
     include Maglev::Page::SearchConcern
 
+    ## associations ##
+    has_many :sections_content_stores, as: :container, dependent: :destroy
+
     ## translations ##
     translates :title, presence: true
     translates :sections

data/app/models/maglev/section/block.rb

@@ -6,7 +6,7 @@ class Maglev::Section::Block
   include ActiveModel::Model
 
   ## attributes ##
-  attr_accessor :name, :type, :settings, :root, :accept, :limit
+  attr_accessor :name, :type, :settings, :root, :accept, :limit, :section
 
   ## validation ##
   validates :name, :type, presence: true
@@ -14,28 +14,65 @@ class Maglev::Section::Block
 
   ## methods
 
+  def human_name
+    ::I18n.t("#{section.i18n_scope}.blocks.types.#{type}", default: name.humanize)
+  end
+
   def root?
     !!root
   end
 
+  def main_settings
+    settings.reject(&:advanced?)
+  end
+
+  def advanced_settings
+    settings.select(&:advanced?)
+  end
+
+  def as_json
+    super(only: %i[name type settings root accept])
+  end
+
   ## class methods ##
 
-  def self.build(hash)
+  def self.build(hash, section:)
     attributes = hash.slice('name', 'type', 'accept', 'root', 'limit')
     attributes['root'] = true if attributes['root'].nil?
     attributes['limit'] = -1 if attributes['limit'].nil?
 
     new(
-      attributes.merge(
-        settings: Maglev::Section::Setting.build_many(hash['settings'])
+      **attributes.merge(
+        settings: Maglev::Section::Setting.build_many(hash['settings']),
+        section: section
       )
     )
   end
 
-  def self.build_many(list)
+  def self.build_many(list, section:)
     return [] if list.blank?
 
-    list.map { |hash| build(hash) }
+    list.map do |hash_or_object|
+      hash_or_object.is_a?(Hash) ? build(hash_or_object, section: section) : hash_or_object
+    end
+  end
+
+  class Store
+    include Enumerable
+
+    attr_reader :array
+
+    def initialize(blocks, section:)
+      @array = ::Maglev::Section::Block.build_many(blocks, section: section)
+    end
+
+    def find(type)
+      array.find { |block| block.type == type }
+    end
+
+    def each(&block)
+      array.each(&block)
+    end
   end
 end
 # rubocop:enable Style/ClassAndModuleChildren

data/app/models/maglev/section/content_concern.rb

@@ -11,6 +11,19 @@ module Maglev::Section::ContentConcern
     }
   end
 
+  def build_block_content_for(block_type, parent_id = nil)
+    block_definition = blocks.find(block_type)
+
+    raise Maglev::Errors::UnknownBlock unless block_definition
+
+    {
+      id: SecureRandom.urlsafe_base64(8),
+      type: block_definition.type,
+      settings: fallback_build_default_settings_content(block_definition.settings),
+      parent_id: parent_id
+    }.compact
+  end
+
   private
 
   def build_default_settings_content(source = nil, custom_settings = nil)
@@ -35,6 +48,7 @@ module Maglev::Section::ContentConcern
     blocks_content.values.compact
   end
 
+  # block is a hash representing a block content from a section "sample" attribute
   def build_default_block_content(block, memo, parent_id = nil)
     content = core_build_default_block_content(block, parent_id)
     return unless content
@@ -47,7 +61,7 @@ module Maglev::Section::ContentConcern
   end
 
   def core_build_default_block_content(block, parent_id = nil)
-    settings = blocks.find { |bd| bd.type == block[:type] }&.settings
+    settings = blocks.find(block[:type])&.settings
     return unless settings
 
     content = {

data/app/models/maglev/section/setting.rb

@@ -24,10 +24,22 @@ class Maglev::Section::Setting
     end
   end
 
+  def advanced?
+    !!options[:advanced]
+  end
+
   def cast_value(value)
     self.class.registered_types[type.to_s].cast_value(value)
   end
 
+  def content_label(value)
+    self.class.registered_types[type.to_s].content_label(value)
+  end
+
+  def content_image(value)
+    self.class.registered_types[type.to_s].content_image(value)
+  end
+
   # NOTE: any modification to that method must be reflected in the JS editor
   def build_default_content(custom_default = nil)
     default = custom_default.nil? ? self.default : custom_default

data/app/models/maglev/section.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Definition of a section in the theme
+# Don't misunstand it with the content of a section within a page or a site
 module Maglev
   class Section
     include ActiveModel::Model
@@ -23,6 +25,14 @@ module Maglev
 
     ## methods ##
 
+    def human_name
+      ::I18n.t("#{i18n_scope}.name", default: name.humanize)
+    end
+
+    def human_blocks_label(default = nil)
+      ::I18n.t("#{i18n_scope}.blocks.label", default: blocks_label || default)
+    end
+
     def site_scoped?
       !!site_scoped
     end
@@ -31,19 +41,43 @@ module Maglev
       !!singleton
     end
 
+    def root_blocks
+      blocks.select(&:root?)
+    end
+
+    def blocks_tree?
+      blocks_presentation == 'tree'
+    end
+
+    def accepts_blocks?
+      blocks.any? { |block| block.accept.present? }
+    end
+
     def viewport_fixed_position?
-      !!viewport_fixed_position?
+      !!viewport_fixed_position
+    end
+
+    def main_settings
+      settings.reject(&:advanced?)
+    end
+
+    def advanced_settings
+      settings.select(&:advanced?)
     end
 
     def assign_attributes_from_yaml(hash)
       attributes = prepare_default_attributes(hash).merge(
         settings: ::Maglev::Section::Setting.build_many(hash['settings']),
-        blocks: ::Maglev::Section::Block.build_many(hash['blocks'])
+        blocks: ::Maglev::Section::Block::Store.new(hash['blocks'], section: self)
       )
 
       assign_attributes(attributes)
     end
 
+    def i18n_scope
+      "maglev.themes.#{theme.id}.sections.#{id}"
+    end
+
     ## class methods ##
 
     def self.build(hash)
@@ -78,14 +112,28 @@ module Maglev
         @array = array
       end
 
-      def find(id)
-        @array.find { |section| section.id == id }
+      def find(type)
+        @array.find { |section| section.id == type }
+      end
+
+      def find_all_by_type(type)
+        @array.select { |section| section.id == type }
       end
 
       def grouped_by_category
         @array.group_by(&:category)
       end
 
+      def available_for(sections_content)
+        # we don't want to add site_scoped sections or singleton sections that are already present on the page
+        new_array = @array.reject do |section|
+          (section.site_scoped? || section.singleton?) && sections_content.any? do |section_content|
+            section_content.type == section.id
+          end
+        end
+        self.class.new(new_array)
+      end
+
       def as_json(**_options)
         @array.as_json
       end