alchemy_cms 4.6.1 → 5.0.0.beta1

data/app/controllers/alchemy/admin/clipboard_controller.rb

@@ -17,10 +17,10 @@ module Alchemy
 
       def insert
         @item = model_class.find(remarkable_params[:remarkable_id])
-        unless @clipboard.detect { |item| item['id'] == remarkable_params[:remarkable_id] }
+        unless @clipboard.detect { |item| item["id"] == remarkable_params[:remarkable_id] }
           @clipboard << {
-            'id' => remarkable_params[:remarkable_id],
-            'action' => params[:remove] ? 'cut' : 'copy'
+            "id" => remarkable_params[:remarkable_id],
+            "action" => params[:remove] ? "cut" : "copy",
           }
         end
         respond_to do |format|
@@ -30,7 +30,7 @@ module Alchemy
 
       def remove
         @item = model_class.find(remarkable_params[:remarkable_id])
-        @clipboard.delete_if { |item| item['id'] == remarkable_params[:remarkable_id] }
+        @clipboard.delete_if { |item| item["id"] == remarkable_params[:remarkable_id] }
         respond_to do |format|
           format.js
         end
@@ -48,6 +48,7 @@ module Alchemy
 
       def model_class
         raise ActionController::BadRequest unless remarkable_type
+
         "alchemy/#{remarkable_type}".classify.constantize
       end
 

data/app/controllers/alchemy/admin/contents_controller.rb

@@ -3,13 +3,12 @@
 module Alchemy
   module Admin
     class ContentsController < Alchemy::Admin::BaseController
-      helper 'alchemy/admin/essences'
+      helper "alchemy/admin/essences"
 
       authorize_resource class: Alchemy::Content
 
       def create
         @content = Content.create(content_params)
-        @html_options = params[:html_options] || {}
       end
 
       private

data/app/controllers/alchemy/admin/dashboard_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'alchemy/version'
+require "net/http"
+require "alchemy/version"
 
 module Alchemy
   module Admin
@@ -28,9 +28,9 @@ module Alchemy
       def update_check
         @alchemy_version = Alchemy.version
         if @alchemy_version < latest_alchemy_version
-          render plain: 'true'
+          render plain: "true"
         else
-          render plain: 'false'
+          render plain: "false"
         end
       rescue UpdateServiceUnavailable => e
         render plain: e, status: 503
@@ -41,7 +41,8 @@ module Alchemy
       # Returns latest alchemy version.
       def latest_alchemy_version
         versions = get_alchemy_versions
-        return '' if versions.blank?
+        return "" if versions.blank?
+
         # reject any non release version
         versions.reject! { |v| v =~ /[a-z]/ }
         versions.max
@@ -53,14 +54,14 @@ module Alchemy
         response = query_rubygems
         if response.code == "200"
           alchemy_versions = JSON.parse(response.body)
-          alchemy_versions.collect { |h| h['number'] }.sort
+          alchemy_versions.collect { |h| h["number"] }.sort
         else
           # rubygems.org not available?
           # then we try github
           response = query_github
           if response.code == "200"
             alchemy_tags = JSON.parse(response.body)
-            alchemy_tags.collect { |h| h['name'].tr('v', '') }.sort
+            alchemy_tags.collect { |h| h["name"].tr("v", "") }.sort
           else
             # no luck at all?
             raise UpdateServiceUnavailable
@@ -70,12 +71,12 @@ module Alchemy
 
       # Query the RubyGems API for Alchemy versions.
       def query_rubygems
-        make_api_request('https://rubygems.org/api/v1/versions/alchemy_cms.json')
+        make_api_request("https://rubygems.org/api/v1/versions/alchemy_cms.json")
       end
 
       # Query the GitHub API for Alchemy tags.
       def query_github
-        make_api_request('https://api.github.com/repos/AlchemyCMS/alchemy_cms/tags')
+        make_api_request("https://api.github.com/repos/AlchemyCMS/alchemy_cms/tags")
       end
 
       # Make a HTTP API request for given request url.

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

@@ -17,7 +17,7 @@ module Alchemy
         @parent_element = Element.find_by(id: params[:parent_element_id])
         @elements = @page.available_elements_within_current_scope(@parent_element)
         @element = @page.elements.build
-        @clipboard = get_clipboard('elements')
+        @clipboard = get_clipboard("elements")
         @clipboard_items = Element.all_from_clipboard_for_page(@clipboard, @page)
       end
 
@@ -30,7 +30,7 @@ module Alchemy
           else
             @element = Element.create(create_element_params)
           end
-          if @page.definition['insert_elements_at'] == 'top'
+          if @page.definition["insert_elements_at"] == "top"
             @insert_at_top = true
             @element.move_to_top
           end
@@ -40,7 +40,7 @@ module Alchemy
         else
           @element.page = @page
           @elements = @page.available_element_definitions
-          @clipboard = get_clipboard('elements')
+          @clipboard = get_clipboard("elements")
           @clipboard_items = Element.all_from_clipboard_for_page(@clipboard, @page)
           render :new
         end
@@ -56,7 +56,7 @@ module Alchemy
           @element_validated = @element.update(element_params)
         else
           @element_validated = false
-          @notice = Alchemy.t('Validation failed')
+          @notice = Alchemy.t("Validation failed")
           @error_message = "<h2>#{@notice}</h2><p>#{Alchemy.t(:content_validations_headline)}</p>".html_safe
         end
       end
@@ -81,7 +81,7 @@ module Alchemy
             Element.where(id: element_id).update_all(
               page_id: params[:page_id],
               parent_element_id: params[:parent_element_id],
-              position: idx + 1
+              position: idx + 1,
             )
           end
           @parent_element.try!(:touch)
@@ -100,20 +100,20 @@ module Alchemy
         [
           {
             contents: {
-              essence: :ingredient_association
-            }
+              essence: :ingredient_association,
+            },
           },
           :tags,
           {
             all_nested_elements: [
               {
                 contents: {
-                  essence: :ingredient_association
-                }
+                  essence: :ingredient_association,
+                },
               },
-              :tags
-            ]
-          }
+              :tags,
+            ],
+          },
         ]
       end
 
@@ -123,20 +123,20 @@ module Alchemy
 
       def element_from_clipboard
         @element_from_clipboard ||= begin
-          @clipboard = get_clipboard('elements')
-          @clipboard.detect { |item| item['id'].to_i == params[:paste_from_clipboard].to_i }
-        end
+            @clipboard = get_clipboard("elements")
+            @clipboard.detect { |item| item["id"].to_i == params[:paste_from_clipboard].to_i }
+          end
       end
 
       def paste_element_from_clipboard
-        @source_element = Element.find(element_from_clipboard['id'])
+        @source_element = Element.find(element_from_clipboard["id"])
         element = Element.copy(@source_element, {
           parent_element_id: create_element_params[:parent_element_id],
-          page_id: @page.id}
-        )
-        if element_from_clipboard['action'] == 'cut'
+          page_id: @page.id,
+        })
+        if element_from_clipboard["action"] == "cut"
           @cut_element_id = @source_element.id
-          @clipboard.delete_if { |item| item['id'] == @source_element.id.to_s }
+          @clipboard.delete_if { |item| item["id"] == @source_element.id.to_s }
           @source_element.destroy
         end
         element

data/app/controllers/alchemy/admin/essence_pictures_controller.rb

@@ -9,9 +9,9 @@ module Alchemy
       before_action :load_essence_picture, only: [:edit, :crop, :update]
       before_action :load_content, only: [:edit, :update, :assign]
 
-      helper 'alchemy/admin/contents'
-      helper 'alchemy/admin/essences'
-      helper 'alchemy/url'
+      helper "alchemy/admin/contents"
+      helper "alchemy/admin/essences"
+      helper "alchemy/url"
 
       def edit
       end
@@ -19,10 +19,8 @@ module Alchemy
       def crop
         if @picture = @essence_picture.picture
           @content = @essence_picture.content
-          options_from_params[:format] ||= (configuration(:image_store_format) || 'png')
-
           @min_size = sizes_from_essence_or_params
-          @ratio = ratio_from_size_or_params
+          @ratio = ratio_from_size_or_settings
           infer_width_or_height_from_ratio
 
           @default_box = @essence_picture.default_mask(@min_size)
@@ -70,26 +68,26 @@ module Alchemy
 
       # Gets the minimum size of the image to be rendered.
       #
-      # The +render_size+ attribute has preference over the +size+ parameter.
+      # The +render_size+ attribute has preference over the contents +size+ setting.
       #
       def sizes_from_essence_or_params
         if @essence_picture.render_size?
           @essence_picture.sizes_from_string(@essence_picture.render_size)
-        elsif options_from_params[:size]
-          @essence_picture.sizes_from_string(options_from_params[:size])
+        elsif @essence_picture.content.settings[:size]
+          @essence_picture.sizes_from_string(@essence_picture.content.settings[:size])
         else
           { width: 0, height: 0 }
         end
       end
 
-      # Infers the aspect ratio from size or parameters. If you don't want a fixed
+      # Infers the aspect ratio from size or contents settings. If you don't want a fixed
       # aspect ratio, don't specify a size or only width or height.
       #
-      def ratio_from_size_or_params
-        if @min_size.value?(0) && options_from_params[:fixed_ratio].to_s =~ FLOAT_REGEX
-          options_from_params[:fixed_ratio].to_f
+      def ratio_from_size_or_settings
+        if @min_size.value?(0) && @essence_picture.content.settings[:fixed_ratio].to_s =~ FLOAT_REGEX
+          @essence_picture.content.settings[:fixed_ratio].to_f
         elsif !@min_size[:width].zero? && !@min_size[:height].zero?
-          @min_size[:width].to_f / @min_size[:height].to_f
+          @min_size[:width].to_f / @min_size[:height]
         else
           false
         end

data/app/controllers/alchemy/admin/languages_controller.rb

@@ -3,21 +3,54 @@
 module Alchemy
   module Admin
     class LanguagesController < ResourcesController
+      before_action :load_current_site, only: %i[index new]
+
       def index
-        @query = Language.on_current_site.ransack(search_filter_params[:q])
+        @query = Language.on_site(@current_site).ransack(search_filter_params[:q])
+        @query.sorts = default_sort_order if @query.sorts.empty?
         @languages = @query.result.page(params[:page] || 1).per(items_per_page)
       end
 
       def new
         @language = Language.new(
-          page_layout: Config.get(:default_language)['page_layout']
+          site: @current_site,
+          page_layout: Config.get(:default_language)["page_layout"],
         )
       end
 
+      def create
+        @language = Alchemy::Language.new(resource_params)
+        if @language.save
+          flash[:notice] = Alchemy.t("Language successfully created")
+          redirect_to alchemy.admin_pages_path(language_id: @language)
+        else
+          render :new
+        end
+      end
+
+      def destroy
+        if @language.destroy
+          flash[:notice] = Alchemy.t("Language successfully removed")
+        else
+          flash[:warning] = @language.errors.full_messages.to_sentence
+        end
+        do_redirect_to alchemy.admin_languages_path
+      end
+
       def switch
         set_alchemy_language(params[:language_id])
         do_redirect_to request.referer || alchemy.admin_dashboard_path
       end
+
+      private
+
+      def load_current_site
+        @current_site = Alchemy::Site.current
+        if @current_site.nil?
+          flash[:warning] = Alchemy.t("Please create a site first.")
+          redirect_to admin_sites_path
+        end
+      end
     end
   end
 end

data/app/controllers/alchemy/admin/layoutpages_controller.rb

@@ -4,16 +4,19 @@ module Alchemy
   module Admin
     class LayoutpagesController < Alchemy::Admin::BaseController
       authorize_resource class: :alchemy_admin_layoutpages
+
+      include Alchemy::Admin::CurrentLanguage
+
       helper Alchemy::Admin::PagesHelper
 
       def index
-        @layout_root = Page.find_or_create_layout_root_for(Language.current.id)
+        @layout_pages = Page.layoutpages.where(language: @current_language)
         @languages = Language.on_current_site
       end
 
       def edit
         @page = Page.find(params[:id])
-        @page_layouts = PageLayout.layouts_with_own_for_select(@page.page_layout, Language.current.id, true)
+        @page_layouts = PageLayout.layouts_with_own_for_select(@page.page_layout, @current_language.id, true)
       end
     end
   end

data/app/controllers/alchemy/admin/nodes_controller.rb

@@ -3,15 +3,16 @@
 module Alchemy
   module Admin
     class NodesController < Admin::ResourcesController
+      include Alchemy::Admin::CurrentLanguage
+
       def index
         @root_nodes = Node.language_root_nodes
       end
 
       def new
         @node = Node.new(
-          site: Alchemy::Site.current,
           parent_id: params[:parent_id],
-          language: Language.current
+          language: @current_language,
         )
       end
 
@@ -19,7 +20,7 @@ module Alchemy
 
       def resource_params
         params.require(:node).permit(
-          :site_id,
+          :menu_type,
           :parent_id,
           :language_id,
           :page_id,
@@ -27,7 +28,7 @@ module Alchemy
           :url,
           :title,
           :nofollow,
-          :external
+          :external,
         )
       end
     end

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

@@ -5,29 +5,31 @@ module Alchemy
     class PagesController < Alchemy::Admin::BaseController
       include OnPageLayout::CallbacksRunner
 
-      helper 'alchemy/pages'
+      helper "alchemy/pages"
+
+      before_action :load_page, except: [:index, :flush, :new, :order, :create, :copy_language_tree, :link, :sort]
+
+      authorize_resource class: Alchemy::Page, except: [:index, :tree]
+
+      before_action only: [:index, :tree, :flush, :new, :order, :create, :copy_language_tree] do
+        authorize! :index, :alchemy_admin_pages
+      end
+
+      include Alchemy::Admin::CurrentLanguage
 
       before_action :set_translation,
         except: [:show]
 
-      before_action :load_page,
-        only: [:show, :info, :unlock, :visit, :publish, :configure, :edit, :update, :destroy, :fold,
-               :tree]
-
       before_action :set_root_page,
         only: [:index, :show, :sort, :order]
 
-      authorize_resource class: Alchemy::Page, except: [:index, :tree]
-
       before_action :run_on_page_layout_callbacks,
         if: :run_on_page_layout_callbacks?,
         only: [:show]
 
       def index
-        authorize! :index, :alchemy_admin_pages
-
         if !@page_root
-          @language = Language.current
+          @language = @current_language
           @languages_with_page_tree = Language.on_current_site.with_root_page
           @page_layouts = PageLayout.layouts_for_select(@language.id)
         end
@@ -36,8 +38,6 @@ module Alchemy
       # Returns all pages as a tree from the root given by the id parameter
       #
       def tree
-        authorize! :tree, :alchemy_admin_pages
-
         render json: serialized_page_tree
       end
 
@@ -48,7 +48,7 @@ module Alchemy
         Page.current_preview = @page
         # Setting the locale to pages language, so the page content has it's correct translations.
         ::I18n.locale = @page.language.locale
-        render(layout: Alchemy::Config.get(:admin_page_preview_layout) || 'application')
+        render(layout: Alchemy::Config.get(:admin_page_preview_layout) || "application")
       end
 
       def info
@@ -56,10 +56,10 @@ module Alchemy
       end
 
       def new
-        @page = Page.new(layoutpage: params[:layoutpage] == 'true', parent_id: params[:parent_id])
-        @page_layouts = PageLayout.layouts_for_select(Language.current.id, @page.layoutpage?)
-        @clipboard = get_clipboard('pages')
-        @clipboard_items = Page.all_from_clipboard_for_select(@clipboard, Language.current.id, @page.layoutpage?)
+        @page ||= Page.new(layoutpage: params[:layoutpage] == "true", parent_id: params[:parent_id])
+        @page_layouts = PageLayout.layouts_for_select(@current_language.id, @page.layoutpage?)
+        @clipboard = get_clipboard("pages")
+        @clipboard_items = Page.all_from_clipboard_for_select(@clipboard, @current_language.id, @page.layoutpage?)
       end
 
       def create
@@ -68,9 +68,7 @@ module Alchemy
           flash[:notice] = Alchemy.t("Page created", name: @page.name)
           do_redirect_to(redirect_path_after_create_page)
         else
-          @page_layouts = PageLayout.layouts_for_select(Language.current.id, @page.layoutpage?)
-          @clipboard = get_clipboard('pages')
-          @clipboard_items = Page.all_from_clipboard_for_select(@clipboard, Language.current.id, @page.layoutpage?)
+          new
           render :new
         end
       end
@@ -82,18 +80,18 @@ module Alchemy
       def edit
         # fetching page via before filter
         if page_is_locked?
-          flash[:warning] = Alchemy.t('This page is locked', name: @page.locker_name)
+          flash[:warning] = Alchemy.t("This page is locked", name: @page.locker_name)
           redirect_to admin_pages_path
         elsif page_needs_lock?
           @page.lock_to!(current_alchemy_user)
         end
+        @preview_url = Alchemy::Admin::PREVIEW_URL.url_for(@page)
         @layoutpage = @page.layoutpage?
       end
 
       # Set page configuration like page names, meta tags and states.
       def configure
-        @page_layouts = PageLayout.layouts_with_own_for_select(@page.page_layout, Language.current.id, @page.layoutpage?)
-        render @page.definition['redirects_to_external'] ? 'configure_external' : 'configure'
+        @page_layouts = PageLayout.layouts_with_own_for_select(@page.page_layout, @current_language.id, @page.layoutpage?)
       end
 
       # Updates page
@@ -105,7 +103,7 @@ module Alchemy
         @old_page_layout = @page.page_layout
         if @page.update(page_params)
           @notice = Alchemy.t("Page saved", name: @page.name)
-          @while_page_edit = request.referer.include?('edit')
+          @while_page_edit = request.referer.include?("edit")
 
           unless @while_page_edit
             @tree = serialized_page_tree
@@ -121,17 +119,17 @@ module Alchemy
           flash[:notice] = Alchemy.t("Page deleted", name: @page.name)
 
           # Remove page from clipboard
-          clipboard = get_clipboard('pages')
-          clipboard.delete_if { |item| item['id'] == @page.id.to_s }
+          clipboard = get_clipboard("pages")
+          clipboard.delete_if { |item| item["id"] == @page.id.to_s }
         end
 
         respond_to do |format|
           format.js do
             @redirect_url = if @page.layoutpage?
-                              alchemy.admin_layoutpages_path
-                            else
-                              alchemy.admin_pages_path
-                            end
+                alchemy.admin_layoutpages_path
+              else
+                alchemy.admin_pages_path
+              end
 
             render :redirect
           end
@@ -171,7 +169,7 @@ module Alchemy
         redirect_to show_page_url(
           urlname: @page.urlname,
           locale: prefix_locale? ? @page.language_code : nil,
-          host: @page.site.host == "*" ? request.host : @page.site.host
+          host: @page.site.host == "*" ? request.host : @page.site.host,
         )
       end
 
@@ -212,24 +210,22 @@ module Alchemy
       end
 
       def flush
-        Language.current.pages.flushables.update_all(published_at: Time.current)
+        @current_language.pages.flushables.update_all(published_at: Time.current)
         # We need to ensure, that also all layoutpages get the +published_at+ timestamp set,
         # but not set to public true, because the cache_key for an element is +published_at+
         # and we don't want the layout pages to be present in +Page.published+ scope.
-        Language.current.pages.flushable_layoutpages.update_all(published_at: Time.current)
+        @current_language.pages.flushable_layoutpages.update_all(published_at: Time.current)
         respond_to { |format| format.js }
       end
 
       private
 
       def copy_of_language_root
-        page_copy = Page.copy(
+        Page.copy(
           language_root_to_copy_from,
           language_id: params[:languages][:new_lang_id],
-          language_code: Language.current.code
+          language_code: @current_language.code,
         )
-        page_copy.move_to_child_of Page.root
-        page_copy
       end
 
       def language_root_to_copy_from
@@ -259,14 +255,14 @@ module Alchemy
       def visit_nodes(nodes, my_left, parent, depth, tree, url, restricted)
         nodes.each do |item|
           my_right = my_left + 1
-          my_restricted = item['restricted'] || restricted
+          my_restricted = item["restricted"] || restricted
           urls = process_url(url, item)
 
-          if item['children']
-            my_right, tree = visit_nodes(item['children'], my_left + 1, item['id'], depth + 1, tree, urls[:children_path], my_restricted)
+          if item["children"]
+            my_right, tree = visit_nodes(item["children"], my_left + 1, item["id"], depth + 1, tree, urls[:children_path], my_restricted)
           end
 
-          tree[item['id']] = TreeNode.new(my_left, my_right, parent, depth, urls[:my_urlname], my_restricted)
+          tree[item["id"]] = TreeNode.new(my_left, my_right, parent, depth, urls[:my_urlname], my_restricted)
           my_left = my_right + 1
         end
 
@@ -295,24 +291,14 @@ module Alchemy
       # This function will add a node's own slug into their ancestor's path
       # in order to create the full URL of a node
       #
-      # NOTE: external and invisible pages are not part of the full path of their children
-      #
       # @param [String]
       #   The node's ancestors path
       # @param [Hash]
       #   A children node
       #
       def process_url(ancestors_path, item)
-        default_urlname = (ancestors_path.blank? ? "" : "#{ancestors_path}/") + item['slug'].to_s
-
-        pair = {my_urlname: default_urlname, children_path: default_urlname}
-
-        if item['external'] == true || item['visible'] == false
-          # children ignore an ancestor in their path if external or invisible
-          pair[:children_path] = ancestors_path
-        end
-
-        pair
+        default_urlname = (ancestors_path.blank? ? "" : "#{ancestors_path}/") + item["slug"].to_s
+        { my_urlname: default_urlname, children_path: default_urlname }
       end
 
       def load_page
@@ -320,19 +306,19 @@ module Alchemy
       end
 
       def pages_from_raw_request
-        request.raw_post.split('&').map do |i|
-          parts = i.split('=')
+        request.raw_post.split("&").map do |i|
+          parts = i.split("=")
           {
-            parts[0].gsub(/[^0-9]/, '') => parts[1]
+            parts[0].gsub(/[^0-9]/, "") => parts[1],
           }
         end
       end
 
       def redirect_path_after_create_page
-        if @page.definition['redirects_to_external'] || !@page.editable_by?(current_alchemy_user)
-          admin_pages_path
-        else
+        if @page.editable_by?(current_alchemy_user)
           params[:redirect_to] || edit_admin_page_path(@page)
+        else
+          admin_pages_path
         end
       end
 
@@ -351,30 +337,32 @@ module Alchemy
       def page_is_locked?
         return false if !@page.locker.try(:logged_in?)
         return false if !current_alchemy_user.respond_to?(:id)
+
         @page.locked? && @page.locker.id != current_alchemy_user.id
       end
 
       def page_needs_lock?
         return true unless @page.locker
+
         @page.locker.try!(:id) != current_alchemy_user.try!(:id)
       end
 
       def paste_from_clipboard
         if params[:paste_from_clipboard]
           source = Page.find(params[:paste_from_clipboard])
-          parent = Page.find_by(id: params[:page][:parent_id]) || Page.root
+          parent = Page.find_by(id: params[:page][:parent_id])
           Page.copy_and_paste(source, parent, params[:page][:name])
         end
       end
 
       def set_root_page
-        @page_root = Language.current_root_page
+        @page_root = @current_language.root_page
       end
 
       def serialized_page_tree
         PageTreeSerializer.new(@page, ability: current_ability,
                                       user: current_alchemy_user,
-                                      full: params[:full] == 'true')
+                                      full: params[:full] == "true")
       end
     end
   end