alchemy_cms 8.3.10 → 8.4.0

data/lib/alchemy/upgrader/eight_four.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class Upgrader
+    module EightFour
+      # Alchemy does not depend on the dragonfly gem anymore.
+      # Apps still using the dragonfly storage adapter need to
+      # declare the gem in their own Gemfile.
+      def add_dragonfly_gem
+        return unless Alchemy.storage_adapter.dragonfly?
+
+        run %(bundle add dragonfly --version "~> 1.4")
+      end
+
+      # The attachment uploader used to accept every file type.
+      def notify_attachment_filetypes_default
+        default = Alchemy::Configurations::Uploader::AllowedFileTypes::DEFAULT_ATTACHMENT_FILE_TYPES
+        current = Alchemy.config.uploader.allowed_filetypes.alchemy_attachments.to_a
+        return unless current == default || current.include?("*")
+
+        closing = if current.include?("*")
+          <<~TEXT.strip
+            Your app configures `["*"]`, so it still accepts every file type.
+            Please consider adopting the new default.
+          TEXT
+        else
+          <<~TEXT.strip
+            Setting it back to `["*"]` restores the old behaviour and disables
+            file type validation entirely.
+          TEXT
+        end
+
+        todo(<<~TODO.strip, "Attachment uploads are now restricted to an allowlist")
+          The `uploader.allowed_filetypes.alchemy_attachments` setting used to
+          default to `["*"]`, which accepts every file type, including
+          executables. It now defaults to a list of document, media and archive
+          formats:
+
+          #{default.each_slice(8).map { |slice| "  #{slice.join(" ")}" }.join("\n")}
+
+          Please check whether your editors upload file types that are not on
+          this list. If they do, add them in `config/initializers/alchemy.rb`:
+
+            config.uploader.allowed_filetypes.alchemy_attachments = %w[#{default.first(3).join(" ")} ...]
+
+          #{closing}
+        TODO
+      end
+
+      def notify_admin_content_security_policy
+        todo(<<~TODO.strip, "The admin can send a Content Security Policy")
+          Alchemy 9.0 will send a Content Security Policy with its admin
+          responses by default. Opt in now to find out what it would block:
+
+            config.admin_content_security_policy = "Alchemy::Admin::ContentSecurityPolicy"
+
+          If you have inline scripts or anything else in your admin that a CSP
+          would block, subclass `Alchemy::Admin::ContentSecurityPolicy`.
+        TODO
+      end
+
+      def notify_picture_format_setting
+        todo(<<~TODO.strip, "Picture ingredients now respects the `format` setting")
+          New formats create new image variants. To generate them upfront instead
+          of on the first request, run the thumbnail task:
+
+            bin/rake alchemy:generate:ingredient_picture_thumbnails
+
+          Set `ELEMENTS=element1,element2` to only generate thumbnails for some
+          elements, and `ASYNC=true` to enqueue them as background jobs
+          (active_storage only). `bin/rake alchemy:generate:thumbnails`
+          generates the thumbnails of the picture library as well.
+        TODO
+      end
+
+      # Element partials that render nested elements through the
+      # +nested_elements+ association issue one database query per parent
+      # element. Rendering through the block helper's +nested_elements+
+      # instead reuses the page version's preloaded element set.
+      def upgrade_nested_elements_rendering
+        rewritten = []
+        manual = []
+        Dir.glob(Rails.root.join("app/views/alchemy/elements/*")).each do |file|
+          next unless File.file?(file)
+
+          content = File.read(file)
+          block_variable = content[/element_view_for\b.*?do\s*\|\s*(\w+)\s*\|/m, 1]
+
+          if block_variable
+            pattern = /render\s+(?!#{block_variable}\b)\w+\.nested_elements(?:\.published)?/
+            if content.match?(pattern)
+              gsub_file(file, pattern, "render #{block_variable}.nested_elements")
+              rewritten << file
+            end
+          elsif content.match?(/render\s+\w+\.nested_elements/)
+            manual << file
+          end
+        end
+
+        list = ->(files) { files.map { |file| "  - #{Pathname.new(file).relative_path_from(Rails.root)}" }.join("\n") }
+
+        if rewritten.any?
+          todo(<<~TODO.strip, "Nested elements are now rendered through the block helper")
+            We rewrote the following element partials to render nested elements
+            through the `element_view_for` block helper instead of the
+            `nested_elements` association, which issues one query per element:
+
+            #{list.call(rewritten)}
+
+            Please review these changes and commit them. Also check your views
+            for other uses of `element.nested_elements` that were not rewritten
+            automatically (for example assigned to a variable first).
+          TODO
+        end
+
+        if manual.any?
+          todo(<<~TODO.strip, "Nested elements rendered outside a block helper")
+            The following element partials render nested elements through the
+            `nested_elements` association but not inside an `element_view_for`
+            block, so we could not rewrite them automatically:
+
+            #{list.call(manual)}
+
+            Please render them through the block helper (`render el.nested_elements`)
+            so nested rendering reuses the preloaded element set instead of
+            querying per parent.
+          TODO
+        end
+      end
+
+      NAVIGATION_PARTIALS = %w[
+        app/views/alchemy/admin/_main_navi.html.erb
+        app/views/alchemy/admin/partials/_main_navigation_entry.html.erb
+        app/views/alchemy/admin/partials/_sub_navigation.html.erb
+      ].freeze
+
+      # +Alchemy::Modules.register_module+ is deprecated in favor of
+      # +Alchemy.config.menu+. Calls with a static literal argument are
+      # rewritten, everything else has to be migrated by hand.
+      def upgrade_menu_config
+        rewritten = []
+        manual = []
+        rewriter = begin
+          require "prism"
+          RegisterModuleRewriter.new
+        rescue LoadError
+          nil
+        end
+
+        Dir.glob(Rails.root.join("config/initializers/**/*.rb")).sort.each do |file|
+          content = File.read(file)
+          next unless content.include?("register_module")
+
+          unless rewriter
+            manual << file
+            next
+          end
+
+          new_content, rewritten_count, manual_count = rewriter.rewrite(content)
+          if rewritten_count > 0
+            File.write(file, new_content)
+            rewritten << file
+          end
+          manual << file if manual_count > 0
+        end
+
+        overridden_partials = NAVIGATION_PARTIALS.map { |partial| Rails.root.join(partial).to_s }.select { |file| File.exist?(file) }
+
+        list = ->(files) { files.map { |file| "  - #{Pathname.new(file).relative_path_from(Rails.root)}" }.join("\n") }
+
+        if rewritten.any?
+          todo(<<~TODO.strip, "`register_module` calls were rewritten to `Alchemy.config.menu.add`")
+            `Alchemy::Modules.register_module` is deprecated and will be removed in
+            Alchemy 9.0. We rewrote its calls in the following initializers to
+            `Alchemy.config.menu.add`:
+
+            #{list.call(rewritten)}
+
+            Please review these changes and commit them.
+          TODO
+        end
+
+        if manual.any?
+          todo(<<~TODO.strip, "The admin main navigation is now configured with `Alchemy.config.menu`")
+            `Alchemy::Modules.register_module` is deprecated and will be removed in
+            Alchemy 9.0. The following initializers call it in a way we could not
+            rewrite automatically:
+
+            #{list.call(manual)}
+
+            Please replace these `register_module` calls with
+            `Alchemy.config.menu.add` in `config/initializers/alchemy.rb`:
+
+              Alchemy.configure do |config|
+                config.menu.add(
+                  name: "events",
+                  title: "Events",
+                  icon: "calendar",
+                  url: -> { main_app.admin_events_path },
+                  condition: -> { can?(:index, :admin_events) },
+                  children: [
+                    {
+                      title: "Locations",
+                      url: -> { main_app.admin_locations_path },
+                      condition: -> { can?(:index, :admin_locations) }
+                    }
+                  ]
+                )
+              end
+
+            `url` and `condition` are evaluated in the view context. The keys of
+            the former `navigation` hash now live on the entry itself, its `name`
+            is now `title`, `sub_navigation` is now `children`, `icon-style` is now
+            `icon_style`, `data: {turbo: false}` is now `turbo: false`, and `params`
+            is no longer supported.
+
+            Call `config.menu.add` once at boot and not inside `to_prepare`, as it
+            does not skip entries that are already present like `register_module`
+            did.
+          TODO
+        end
+
+        if overridden_partials.any?
+          todo(<<~TODO.strip, "The admin main navigation partials have been replaced")
+            Your app overrides the following partials, which have been replaced by
+            the `Alchemy::Admin::MainNavigation` components and are no longer
+            rendered:
+
+            #{list.call(overridden_partials)}
+
+            Please adapt your changes.
+          TODO
+        end
+      end
+    end
+  end
+end

data/lib/alchemy/upgrader/register_module_rewriter.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class Upgrader
+    # Rewrites +Alchemy::Modules.register_module+ calls with a static literal
+    # argument into +Alchemy.config.menu.add+ calls.
+    #
+    # Calls inside a +to_prepare+ block are guarded by the entry's name, because
+    # +Alchemy.config.menu.add+ does not skip entries that are already present.
+    #
+    # Requires Prism, which only ships with Ruby >= 3.3.
+    class RegisterModuleRewriter
+      class NonLiteralError < StandardError; end
+
+      RECEIVERS = ["Alchemy::Modules", "::Alchemy::Modules"].freeze
+
+      KEYS = %w[
+        name title engine_name position icon icon_style image inline_image turbo
+        controller action nested_controllers nested_actions children nested
+      ].freeze
+
+      # @param [String] source
+      # @return [Array(String, Integer, Integer)]
+      #   The new source, the number of rewritten and of untouched calls
+      def rewrite(source)
+        require "prism"
+
+        result = Prism.parse(source)
+        return [source, 0, 1] if result.errors.any?
+
+        replacements = []
+        manual = 0
+        each_register_module_call(result.value) do |call, in_to_prepare|
+          replacement = replacement_for(call, source, in_to_prepare:)
+          if replacement
+            replacements << [call.location.start_offset, call.location.end_offset, replacement]
+          else
+            manual += 1
+          end
+        end
+
+        new_source = source.b
+        replacements.sort_by(&:first).reverse_each do |start_offset, end_offset, replacement|
+          new_source[start_offset...end_offset] = replacement.b
+        end
+
+        [new_source.force_encoding(source.encoding), replacements.size, manual]
+      end
+
+      private
+
+      def each_register_module_call(node, in_to_prepare = false, &block)
+        if node.is_a?(Prism::CallNode) && node.name.to_s == "register_module"
+          yield node, in_to_prepare
+        end
+
+        node.compact_child_nodes.each do |child|
+          child_in_to_prepare = in_to_prepare ||
+            (node.is_a?(Prism::CallNode) && node.name.to_s == "to_prepare" && child.equal?(node.block))
+          each_register_module_call(child, child_in_to_prepare, &block)
+        end
+      end
+
+      def replacement_for(call, source, in_to_prepare:)
+        return unless RECEIVERS.include?(call.receiver&.slice)
+        return if call.block
+
+        arguments = call.arguments&.arguments || []
+        return unless arguments.size == 1
+        return unless arguments.first.is_a?(Prism::HashNode) || arguments.first.is_a?(Prism::KeywordHashNode)
+        return unless heredocs_inside?(arguments.first, call, source)
+
+        item = Alchemy::Configurations::MenuItem.from_legacy_hash(literal(arguments.first))
+        return if in_to_prepare && item.name.blank?
+
+        indent = " " * call.location.start_column
+        if in_to_prepare
+          <<~RUBY.chomp
+            unless Alchemy.config.menu.any? { |item| item.name == #{item.name.inspect} }
+            #{indent}  #{menu_add(item, "#{indent}  ")}
+            #{indent}end
+          RUBY
+        else
+          menu_add(item, indent)
+        end
+      rescue NonLiteralError, Alchemy::Configuration::ConfigurationError
+        nil
+      end
+
+      def menu_add(item, indent)
+        pairs = attributes(item).map do |key, value|
+          if key == "children" || key == "nested"
+            entries = value.map { |entry| "#{indent}    #{inline_hash(entry)}" }
+            "#{indent}  #{key}: [\n#{entries.join(",\n")}\n#{indent}  ]"
+          else
+            "#{indent}  #{key}: #{value.inspect}"
+          end
+        end
+        "Alchemy.config.menu.add(\n#{pairs.join(",\n")}\n#{indent})"
+      end
+
+      def inline_hash(item)
+        pairs = attributes(item).map do |key, value|
+          if key == "children" || key == "nested"
+            "#{key}: [#{value.map { |entry| inline_hash(entry) }.join(", ")}]"
+          else
+            "#{key}: #{value.inspect}"
+          end
+        end
+        "{#{pairs.join(", ")}}"
+      end
+
+      def attributes(item)
+        KEYS.filter_map do |key|
+          value = item.public_send(key)
+          value = value.to_a if value.respond_to?(:to_a) && !value.is_a?(String)
+          next if key == "turbo" && value != false
+          next if value.nil? || value == []
+
+          [key, value]
+        end
+      end
+
+      def literal(node)
+        case node
+        when Prism::StringNode, Prism::SymbolNode
+          node.unescaped
+        # Squiggly heredocs and adjacent string literals are made of static parts
+        when Prism::InterpolatedStringNode
+          node.compact_child_nodes.map do |part|
+            raise NonLiteralError unless part.is_a?(Prism::StringNode)
+
+            part.unescaped
+          end.join
+        when Prism::IntegerNode
+          Integer(node.slice)
+        when Prism::FloatNode
+          Float(node.slice)
+        when Prism::TrueNode
+          true
+        when Prism::FalseNode
+          false
+        when Prism::NilNode
+          nil
+        when Prism::ArrayNode
+          node.elements.map { |element| literal(element) }
+        when Prism::HashNode, Prism::KeywordHashNode
+          node.elements.to_h do |element|
+            raise NonLiteralError unless element.is_a?(Prism::AssocNode)
+            raise NonLiteralError unless element.key.is_a?(Prism::SymbolNode) || element.key.is_a?(Prism::StringNode)
+
+            [element.key.unescaped, literal(element.value)]
+          end
+        else
+          raise NonLiteralError
+        end
+      end
+
+      # A heredoc body starts on the line after its opening, so it is only part
+      # of the call if the call ends on a later line.
+      def heredocs_inside?(node, call, source)
+        heredocs = []
+        collect_heredocs(node, heredocs)
+        heredocs.all? do |heredoc|
+          source.byteslice(heredoc.location.end_offset...call.location.end_offset).include?("\n")
+        end
+      end
+
+      def collect_heredocs(node, heredocs)
+        if (node.is_a?(Prism::StringNode) || node.is_a?(Prism::InterpolatedStringNode)) && node.slice.start_with?("<<")
+          heredocs << node
+        end
+        node.compact_child_nodes.each { |child| collect_heredocs(child, heredocs) }
+      end
+    end
+  end
+end

data/lib/alchemy/upgrader.rb

@@ -13,7 +13,8 @@ module Alchemy
 
     VERSION_MODULE_MAP = {
       "8.0" => "Alchemy::Upgrader::EightZero",
-      "8.1" => "Alchemy::Upgrader::EightOne"
+      "8.1" => "Alchemy::Upgrader::EightOne",
+      "8.4" => "Alchemy::Upgrader::EightFour"
     }
 
     source_root Alchemy::Engine.root.join("lib/generators/alchemy/install")

data/lib/alchemy/version.rb

@@ -3,7 +3,7 @@
 module Alchemy
   extend self
 
-  VERSION = "8.3.10"
+  VERSION = "8.4.0"
 
   def version
     VERSION

data/lib/alchemy.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "alchemy/admin/preview_url"
 require "importmap-rails"
 require "alchemy/configurations/main"
 require "alchemy/config_missing"

data/lib/alchemy_cms.rb

@@ -10,7 +10,6 @@ require "active_model_serializers"
 require "active_storage/engine"
 require "awesome_nested_set"
 require "cancan"
-require "dragonfly"
 require "gutentag"
 require "importmap-rails"
 require "kaminari"
@@ -21,31 +20,19 @@ require "userstamp"
 require "view_component"
 
 # Require globally used Alchemy mixins
-require_relative "alchemy/ability_helper"
-require_relative "alchemy/admin/locale"
-require_relative "alchemy/admin/timezone"
-require_relative "alchemy/admin/preview_time"
-require_relative "alchemy/admin/preview_url"
 require_relative "alchemy/auth_accessors"
 require_relative "alchemy/cache_digests/template_tracker"
-require_relative "alchemy/configuration_methods"
-require_relative "alchemy/controller_actions"
 require_relative "alchemy/deprecation"
-require_relative "alchemy/elements_finder"
 require_relative "alchemy/error_tracking"
 require_relative "alchemy/errors"
-require_relative "alchemy/filetypes"
 require_relative "alchemy/forms/builder"
-require_relative "alchemy/hints"
 require_relative "alchemy/i18n"
 require_relative "alchemy/logger"
 require_relative "alchemy/modules"
-require_relative "alchemy/name_conversions"
 require_relative "alchemy/on_page_layout"
 require_relative "alchemy/on_page_layout/callbacks_runner"
 require_relative "alchemy/paths"
 require_relative "alchemy/tinymce"
-require_relative "alchemy/taggable"
 require_relative "alchemy/version"
 
 # Finally require Alchemy itself

data/lib/generators/alchemy/elements/templates/view.html.erb

@@ -10,7 +10,7 @@
     <%- end -%>
   <%- end -%>
   <%- if @element['nestable_elements'].present? -%>
-    <%%= render <%= @element_name %>.nested_elements.published %>
+    <%%= render el.nested_elements %>
   <%- end -%>
   <%% end -%>
 <%% end -%>

data/lib/generators/alchemy/elements/templates/view.html.haml

@@ -10,5 +10,5 @@
     <%- end -%>
   <%- end -%>
   <%- if @element['nestable_elements'].present? -%>
-    = render <%= @element_name -%>.nested_elements.published
+    = render el.nested_elements
   <%- end -%>

data/lib/generators/alchemy/elements/templates/view.html.slim

@@ -10,5 +10,5 @@
     <%- end -%>
   <%- end -%>
   <%- if @element['nestable_elements'].present? -%>
-    = render <%= @element_name -%>.nested_elements.published
+    = render el.nested_elements
   <%- end -%>

data/lib/generators/alchemy/install/install_generator.rb

@@ -88,16 +88,9 @@ module Alchemy
         copy_file "alchemy.en.yml", app_config_path.join("locales", "alchemy.en.yml")
       end
 
-      def copy_dragonfly_config
-        template(
-          "#{__dir__}/templates/dragonfly.rb.tt",
-          app_config_path.join("initializers", "dragonfly.rb"),
-          skip: options[:auto_accept]
-        )
-      end
-
       def install_gutentag_migrations
-        rake "gutentag:install:migrations"
+        rake "gutentag:install:migrations", abort_on_failure: true
+        generate "gutentag:migration_versions", abort_on_failure: true
       end
 
       def setup_database
@@ -144,10 +137,6 @@ module Alchemy
         puts "  #{something}"
       end
 
-      def gem_config_path
-        @_config_path ||= File.expand_path("../../../../config/alchemy", __dir__)
-      end
-
       def app_config_path
         @_app_config_path ||= app_root.join("config")
       end

data/lib/generators/alchemy/install/templates/alchemy.rb.tt

@@ -28,10 +28,12 @@ Alchemy.configure do |config|
   #
   #   show_root [Boolean] # Show language root page in sitemap?
   #   show_flag [Boolean] # Enables the Checkbox in Page#update overlay. So your customer can set the visibility of pages in the sitemap.
+  #   max_age [Integer]   # How long the sitemap is cached, in seconds. Set to 0 to disable sitemap caching.
   #
   # config.sitemap.tap do |sitemap|
   #   sitemap.show_root = <%= @default_config.sitemap.show_root.inspect %>
   #   sitemap.show_flag = <%= @default_config.sitemap.show_flag.inspect %>
+  #   sitemap.max_age = <%= @default_config.sitemap.max_age.inspect %>
   # end
 
   # === Default items per page in admin views
@@ -164,27 +166,29 @@ Alchemy.configure do |config|
   #   upload_limit       [Integer]    # Set an amount of files upload limit of files which can be uploaded at once. Set 0 for unlimited.
   #   file_size_limit*   [Integer]    # Set a file size limit in mega bytes for a per file limit.
   #
-  # *) Allow filetypes to upload. Pass * to allow all kind of files.
+  # *) Allow filetypes to upload. Passing * disables file type validation and
+  #    allows every kind of file, including executables.
   #
   # config.uploader.tap do |uploader|
   #   uploader.upload_limit = <%= @default_config.uploader.upload_limit.inspect %>
   #   uploader.file_size_limit = <%= @default_config.uploader.file_size_limit.inspect %>
   #   uploader.allowed_filetypes.tap do |file_types|
-  #     file_types.alchemy_attachments = <%= @default_config.uploader.allowed_filetypes.alchemy_attachments.map(&:to_s) %>
+  #     file_types.alchemy_attachments = %w[
+<% @default_config.uploader.allowed_filetypes.alchemy_attachments.each_slice(8) do |extensions| -%>
+  #       <%= extensions.join(" ") %>
+<% end -%>
+  #     ]
   #     file_types.alchemy_pictures = <%= @default_config.uploader.allowed_filetypes.alchemy_pictures.map(&:to_s) %>
   #   end
   # end
 
   # === Link Target Options
   #
-  # Values for the link target selectbox inside the page link overlay.
-  # The value gets attached as a data-link-target attribute to the link.
+  # Values for the link target selectbox inside the link dialog.
   #
-  # == Example:
-  #
-  # Open all links set to overlay inside an jQuery UI Dialog Window.
-  #
-  #   jQuery(a[data-link-target="overlay"]).dialog();
+  # Each value is stored with a leading underscore, so that it can be used as
+  # the link's `target` attribute right away: `blank` is stored as `_blank` and
+  # rendered as `target="_blank"`.
   #
   # config.link_target_options = <%= @default_config.link_target_options.map(&:to_s) %>
 
@@ -252,6 +256,17 @@ Alchemy.configure do |config|
   # Additional stylesheets to be included in the Alchemy admin UI
   # config.admin_stylesheets.add("my_app/admin_extension")
 
+  # === Admin Content Security Policy
+  #
+  # The class building the Content Security Policy Alchemy sends with its own
+  # admin responses. No policy is sent by default, until Alchemy 9.0.
+  #
+  # Alchemy never replaces a policy your application has configured itself.
+  # Your asset host, your admin stylesheets and modules pinned to a CDN are
+  # allowed automatically. Subclass it to allow anything else.
+  #
+  # config.admin_content_security_policy = "Alchemy::Admin::ContentSecurityPolicy"
+
   # Define page publish targets
   #
   # A publish target is a ActiveJob that gets performed

data/lib/generators/alchemy/module/module_generator.rb

@@ -14,6 +14,7 @@ module Alchemy
         @class_name = @module_name.singularize.classify
         @controller_name = @module_name.tableize
         @controller_class = @controller_name.classify.pluralize
+        @index_route = (@controller_name.singularize == @controller_name) ? "#{@controller_name}_index" : @controller_name
       end
 
       def make_route

data/lib/generators/alchemy/module/templates/ability.rb.tt

@@ -2,7 +2,7 @@ class <%= @controller_class %>Ability
   include CanCan::Ability
 
   def initialize(user)
-    if user.present? && user.is_admin?
+    if user&.is_alchemy_admin?
       can :manage, <%= @class_name %>
       can :manage, :admin_<%= @controller_name %>
     end

data/lib/generators/alchemy/module/templates/module_config.rb.tt

@@ -1,19 +1,17 @@
-Rails.application.config.to_prepare do
-  Alchemy::Modules.register_module({
-    name: '<%= @module_name %>',
-    order: 1,
-    navigation: {
-      name: 'modules.<%= @module_name %>',
-      controller: '/admin/<%= @module_name %>',
-      action: 'index',
-      image: 'alchemy/<%= @module_name %>_module.png',
-      sub_navigation: [{
-        name: 'modules.<%= @module_name %>',
-        controller: '/admin/<%= @module_name %>',
-        action: 'index'
-      }]
-    }
-  })
-
-  Alchemy.register_ability(<%= @controller_class %>Ability)
+Alchemy.configure do |config|
+  config.menu.add(
+    name: "<%= @module_name %>",
+    title: "modules.<%= @module_name %>",
+    image: "alchemy/<%= @module_name %>_module.png",
+    url: -> { main_app.admin_<%= @index_route %>_path },
+    condition: -> { can?(:index, :admin_<%= @controller_name %>) },
+    children: [
+      {
+        title: "modules.<%= @module_name %>",
+        url: -> { main_app.admin_<%= @index_route %>_path },
+        condition: -> { can?(:index, :admin_<%= @controller_name %>) }
+      }
+    ]
+  )
+  config.abilities.add("<%= @controller_class %>Ability")
 end