alchemy_cms 4.1.2 → 4.2.0.rc1

data/db/migrate/20180519204655_add_fixed_to_alchemy_elements.rb

@@ -0,0 +1,6 @@
+class AddFixedToAlchemyElements < ActiveRecord::Migration[5.0]
+  def change
+    add_column :alchemy_elements, :fixed, :boolean, default: false, null: false
+    add_index :alchemy_elements, :fixed
+  end
+end

data/lib/alchemy/admin/locale.rb

@@ -28,7 +28,7 @@ module Alchemy
 
       # Checks if we need to change to locale or not.
       def locale_change_needed?
-        params[:admin_locale].present? || session[:alchemy_locale].blank? || available_locale.nil?
+        params[:admin_locale].present? || session[:alchemy_locale].blank?
       end
 
       # Returns either the most preferred locale that is within the list of available locales or nil

data/lib/alchemy/cache_digests/template_tracker.rb

@@ -14,19 +14,12 @@ module Alchemy
       def dependencies
         case @name.to_s
         when /^alchemy\/pages\/show/
-          PageLayout.all.collect { |p| "alchemy/page_layouts/_#{p['name']}" }
+          PageLayout.all.map { |p| "alchemy/page_layouts/_#{p['name']}" }
         when /^alchemy\/page_layouts\/_(.+)/
-          page_layout = page_layout($1)
-          element_templates(page_layout) +
-            page_layout.fetch('cells', []).map { |name| "alchemy/cells/_#{name}" }
-        when /^alchemy\/cells\/_(.+)/
-          element_templates cell_definition($1)
+          page_layout = PageLayout.get($1)
+          page_layout.fetch('elements', []).map { |name| "alchemy/elements/_#{name}_view" }
         when /alchemy\/elements\/_(.+)_view/
           essences = essence_types($1)
-          element = element_definition($1)
-          if element && element['picture_gallery']
-            essences += ['EssencePicture']
-          end
           essences.map { |name| "alchemy/essences/_#{name.underscore}_view" }.uniq
         else
           ActionView::DependencyTracker::ERBTracker.call(@name, @template)
@@ -35,24 +28,8 @@ module Alchemy
 
       private
 
-      def element_templates(collection)
-        collection.fetch('elements', []).map { |name| "alchemy/elements/_#{name}_view" }
-      end
-
-      def page_layout(name)
-        PageLayout.get(name)
-      end
-
-      def cell_definition(name)
-        Cell.definition_for(name)
-      end
-
-      def element_definition(name)
-        Element.definitions.detect { |e| e['name'] == name }
-      end
-
       def essence_types(name)
-        element = element_definition(name)
+        element = Element.definitions.detect { |e| e['name'] == name }
         return [] unless element
         element.fetch('contents', []).collect { |c| c['type'] }
       end

data/lib/alchemy/elements_finder.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'alchemy/logger'
+
+module Alchemy
+  # Loads elements from given page
+  #
+  # Used by {Alchemy::Page#find_elements} and {Alchemy::ElementsHelper#render_elements} helper.
+  #
+  # If you need custom element loading logic in your views you can create your own finder class and
+  # tell the {Alchemy::ElementsHelper#render_elements} helper or {Alchemy::Page#find_elements}
+  # to use that finder instead of this one.
+  #
+  class ElementsFinder
+    # @option options [Array<String>|String] :only
+    #   A list of element names to load only.
+    # @option options [Array<String>|String] :except
+    #   A list of element names not to load.
+    # @option options [Boolean] :fixed (false)
+    #   Return only fixed elements
+    # @option options [Integer] :count
+    #   The amount of elements to load
+    # @option options [Integer] :offset
+    #   The offset to begin loading elements from
+    # @option options [Boolean] :random (false)
+    #   Randomize the output of elements
+    # @option options [Boolean] :reverse (false)
+    #   Reverse the load order
+    # @option options [Hash] :fallback
+    #   Define elements that are loaded from another page if no element was found on given page.
+    def initialize(options = {})
+      @options = options
+    end
+
+    # @param page [Alchemy::Page|String]
+    #   The page the elements are loaded from. You can pass a page_layout String or a {Alchemy::Page} object.
+    # @return [ActiveRecord::Relation]
+    def elements(page:)
+      elements = find_elements(page)
+
+      if fallback_required?(elements)
+        elements = elements.merge(fallback_elements)
+      end
+
+      if options[:reverse]
+        elements = elements.reverse_order
+      end
+
+      if options[:random]
+        elements = elements.reorder(Arel.sql(random_function))
+      end
+
+      elements.offset(options[:offset]).limit(options[:count])
+    end
+
+    private
+
+    attr_reader :page, :options
+
+    def find_elements(page)
+      elements = Alchemy::Element
+        .where(page_id: page_ids(page))
+        .merge(Alchemy::Element.not_nested)
+        .where(fixed: !!options[:fixed])
+        .order(position: :asc)
+        .available
+
+      if options[:only]
+        elements = elements.named(options[:only])
+      end
+
+      if options[:except]
+        elements = elements.excluded(options[:except])
+      end
+
+      elements
+    end
+
+    def page_ids(page)
+      case page
+      when String
+        Alchemy::Language.current.pages.where(
+          page_layout: page,
+          restricted: false
+        ).pluck("#{Alchemy::Page.table_name}.id")
+      when Alchemy::Page
+        page.id
+      end
+    end
+
+    def fallback_required?(elements)
+      options[:fallback] && elements
+        .where(Alchemy::Element.table_name => {name: options[:fallback][:for]})
+        .none?
+    end
+
+    def fallback_elements
+      find_elements(options[:fallback][:from])
+        .named(options[:fallback][:with] || options[:fallback][:for])
+    end
+
+    def random_function
+      case ActiveRecord::Base.connection_config[:adapter]
+      when 'postgresql', 'sqlite3'
+        then 'RANDOM()'
+      else
+        'RAND()'
+      end
+    end
+  end
+end

data/lib/alchemy/errors.rb

@@ -3,10 +3,6 @@
 # Custom error classes.
 #
 module Alchemy
-  class CellDefinitionError < StandardError
-    # Raised if no cell definition can be found.
-  end
-
   class ContentDefinitionError < StandardError
     # Raised if no content definition can be found.
   end

data/lib/alchemy/modules.rb

@@ -6,25 +6,56 @@ module Alchemy
 
     @@alchemy_modules = YAML.load_file(File.expand_path('../../config/alchemy/modules.yml', __dir__))
 
-    def self.included(base)
-      base.send :helper_method, :alchemy_modules, :module_definition_for
-    end
+    class << self
+      def included(base)
+        base.send :helper_method, :alchemy_modules, :module_definition_for
+      end
 
-    # Register a Alchemy module.
-    #
-    # A module is a Hash that must have at least a name and a navigation key
-    # that has a controller and action name.
-    #
-    # == Example:
-    #
-    #     name: 'module',
-    #     navigation: {
-    #       controller: 'admin/controller_name',
-    #       action: 'index'
-    #     }
-    #
-    def self.register_module(module_definition)
-      @@alchemy_modules << module_definition.deep_stringify_keys
+      # Register a Alchemy module.
+      #
+      # A module is a Hash that must have at least a name and a navigation key
+      # that has a controller and action name.
+      #
+      # == Example:
+      #
+      #     name: 'module',
+      #     navigation: {
+      #       controller: 'admin/controller_name',
+      #       action: 'index'
+      #     }
+      #
+      def register_module(module_definition)
+        definition_hash = module_definition.deep_stringify_keys
+
+        ### Validate controller(s) existence
+        if definition_hash['navigation'].is_a?(Hash)
+          defined_controllers = [definition_hash['navigation']['controller']]
+
+          if definition_hash['navigation']['sub_navigation'].is_a?(Array)
+            defined_controllers.concat(definition_hash['navigation']['sub_navigation'].map{ |x| x['controller'] })
+          end
+
+          validate_controllers_existence(defined_controllers)
+        end
+
+        @@alchemy_modules << definition_hash
+      end
+
+      private
+
+      def validate_controllers_existence(controllers)
+        controllers.each do |controller_val|
+          next if controller_val.blank?
+
+          controller_name = "#{controller_val.camelize}Controller"
+
+          begin
+            controller_name.constantize
+          rescue NameError
+            raise "Error in AlchemyCMS module definition: '#{definition_hash['name']}'. Could not find the matching controller class #{controller_name.sub(/^::/, '')} for the specified controller: '#{controller_val}'"
+          end
+        end
+      end
     end
 
     # Get the module definition for given module name

data/lib/alchemy/tasks/tidy.rb

@@ -5,29 +5,12 @@ module Alchemy
     extend Shell
 
     class << self
-      def create_missing_cells(page_layouts, cells)
-        page_layouts.each do |layout|
-          next if layout['cells'].blank?
-          cells_for_layout = cells.select { |cell| layout['cells'].include? cell['name'] }
-          Alchemy::Page.where(page_layout: layout['name']).each do |page|
-            cells_for_layout.each do |cell_for_layout|
-              cell = Alchemy::Cell.find_or_initialize_by(name: cell_for_layout['name'], page_id: page.id)
-              if cell.new_record?
-                log "Creating cell #{cell.name} for page #{page.name}"
-              else
-                log "Cell #{cell.name} for page #{page.name} already present", :skip
-              end
-            end
-          end
-        end
-      end
-
       def update_element_positions
         Alchemy::Page.all.each do |page|
           if page.elements.any?
             puts "\n## Updating element positions of page `#{page.name}`"
           end
-          page.elements.group_by(&:cell_id).each do |_cell_id, elements|
+          page.elements.group_by(&:parent_element_id).each do |_, elements|
             elements.each_with_index do |element, idx|
               position = idx + 1
               if element.position != position
@@ -46,8 +29,7 @@ module Alchemy
           if element.contents.any?
             puts "\n## Updating content positions of element `#{element.name}`"
           end
-          element.contents.group_by(&:essence_type).each do |essence_type, contents|
-            puts "-> Contents of type `#{essence_type}`"
+          element.contents.group_by(&:element_id).each do |_, contents|
             contents.each_with_index do |content, idx|
               position = idx + 1
               if content.position != position
@@ -61,31 +43,12 @@ module Alchemy
         end
       end
 
-      def remove_orphaned_cells
-        puts "\n## Removing orphaned cells"
-        cells = Alchemy::Cell.unscoped.all
-        if cells.any?
-          orphaned_cells = cells.select do |cell|
-            cell.page.nil? && cell.page_id.present?
-          end
-          if orphaned_cells.any?
-            log "Found #{orphaned_cells.size} orphaned cells"
-            destroy_orphaned_records(orphaned_cells, 'cell')
-          else
-            log "No orphaned cells found", :skip
-          end
-        else
-          log "No cells found", :skip
-        end
-      end
-
       def remove_orphaned_elements
         puts "\n## Removing orphaned elements"
         elements = Alchemy::Element.unscoped.all
         if elements.any?
           orphaned_elements = elements.select do |element|
-            element.page.nil? && element.page_id.present? ||
-              element.cell.nil? && element.cell_id.present?
+            element.page.nil? && element.page_id.present?
           end
           if orphaned_elements.any?
             log "Found #{orphaned_elements.size} orphaned elements"

data/lib/alchemy/test_support/controller_requests.rb

@@ -19,7 +19,7 @@
 #
 # Then, in your controller tests, you can access alchemy routes like this:
 #
-#   require 'spec_helper'
+#   require 'rails_helper'
 #
 #   describe Alchemy::Admin::PagesController do
 #     it "can see all the pages" do

data/lib/alchemy/test_support/essence_shared_examples.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 shared_examples_for "an essence" do
   let(:element) { Alchemy::Element.new }

data/lib/alchemy/test_support/factories/attachment_factory.rb

@@ -2,8 +2,10 @@ require 'factory_bot'
 
 FactoryBot.define do
   factory :alchemy_attachment, class: 'Alchemy::Attachment' do
-    file File.new(Alchemy::Engine.root.join('lib', 'alchemy', 'test_support', 'fixtures', 'image.png'))
-    name 'image'
-    file_name 'image.png'
+    file do
+      File.new(Alchemy::Engine.root.join('lib', 'alchemy', 'test_support', 'fixtures', 'image.png'))
+    end
+    name { 'image' }
+    file_name { 'image.png' }
   end
 end

data/lib/alchemy/test_support/factories/content_factory.rb

@@ -3,18 +3,18 @@ require 'alchemy/test_support/factories/essence_text_factory'
 
 FactoryBot.define do
   factory :alchemy_content, class: 'Alchemy::Content' do
-    name "text"
-    essence_type "Alchemy::EssenceText"
+    name { "text" }
+    essence_type { "Alchemy::EssenceText" }
     association :essence, factory: :alchemy_essence_text
     association :element, factory: :alchemy_element
 
     trait :essence_file do
-      essence_type "Alchemy::EssenceFile"
+      essence_type { "Alchemy::EssenceFile" }
       association :essence, factory: :alchemy_essence_file
     end
 
     trait :essence_picture do
-      essence_type "Alchemy::EssencePicture"
+      essence_type { "Alchemy::EssencePicture" }
       association :essence, factory: :alchemy_essence_picture
     end
   end

data/lib/alchemy/test_support/factories/dummy_user_factory.rb

@@ -3,19 +3,19 @@ require 'factory_bot'
 FactoryBot.define do
   factory :alchemy_dummy_user, class: 'DummyUser' do
     sequence(:email) { |n| "john.#{n}@doe.com" }
-    password 's3cr3t'
-    alchemy_roles ['member']
+    password { 's3cr3t' }
+    alchemy_roles { ['member'] }
 
     trait :as_admin do
-      alchemy_roles ['admin']
+      alchemy_roles { ['admin'] }
     end
 
     trait :as_author do
-      alchemy_roles ['author']
+      alchemy_roles { ['author'] }
     end
 
     trait :as_editor do
-      alchemy_roles ['editor']
+      alchemy_roles { ['editor'] }
     end
   end
 end

data/lib/alchemy/test_support/factories/element_factory.rb

@@ -2,26 +2,31 @@ require 'factory_bot'
 
 FactoryBot.define do
   factory :alchemy_element, class: 'Alchemy::Element' do
-    name 'article'
-    create_contents_after_create false
+    name { 'article' }
+    autogenerate_contents { false }
     association :page, factory: :alchemy_page
 
+    trait :fixed do
+      fixed { true }
+      name { 'right_column' }
+    end
+
     trait :unique do
-      unique true
-      name 'header'
+      unique { true }
+      name { 'header' }
     end
 
     trait :with_nestable_elements do
-      name 'slider'
+      name { 'slider' }
     end
 
     trait :nested do
       association :parent_element, factory: :alchemy_element, name: 'slider'
-      name 'slide'
+      name { 'slide' }
     end
 
     trait :with_contents do
-      create_contents_after_create true
+      autogenerate_contents { true }
     end
   end
 end