active_scaffold_sortable 3.6.1 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf9766e442d18ac678af96e5895eb8b2fdbb73101e172e6a23ca0ec3035d1c7c
-  data.tar.gz: 863d91dda1231bba10acda159fcc41299c46ac2d72c680aab71a81d600404e67
+  metadata.gz: 33121e6e1386e4f3802c52e705127873fae644c4058fbf76de119494c281c8fa
+  data.tar.gz: df471b954ff70f91201355d63deebae589be6410ccd2b518391f7b00dabbfad5
 SHA512:
-  metadata.gz: 5b1ad120ab8befee7d6118f460db72842f33e862d1827697c46ba4ff20bb82337ce102010927c522fd625003f2ec6afa143c8b45dc4f67ce8b9a1875afff4f07
-  data.tar.gz: 91194d042b3d3c7364c06eaeea3d2076ba5f2c0652cd2b05d588a8b155b1987377e3d9cfb8c57777c5266d077a80aa9c4f58ba5691eb0ef03ad385ae45c0a136
+  metadata.gz: 24b658744b23cdec8a02d8312810e9577a8a49aeb5a0456d40e8e6c2d791a032497cf33e82428437383aae37fd4c8ebcea21f8d76096828003169b3920ac22bd
+  data.tar.gz: e3da06ae6819c09b945eaa66eb9d74df23802e06a952a96f4b7847156d8b064de66ff576a6ecbf73136a9cd688118b6295fd5e23f74bd1a18b81543f691d3911

data/README.md

@@ -0,0 +1,267 @@
+# Drag-and-drop sorting for Active Scaffold
+
+`active_scaffold_sortable` adds AJAX drag-and-drop ordering to Active Scaffold
+lists and association subforms.
+
+It supports:
+
+- ordinary ordered lists, including automatic setup for `acts_as_list` models;
+- sortable `has_many` association subforms;
+- sibling ordering in nested-set trees using the `awesome_nested_set` API;
+- sibling ordering in [Ancestry](https://github.com/stefankroes/ancestry)
+  trees;
+- a dedicated drag-handle column, optional list refreshes, and custom DOM
+  selectors for non-standard list markup.
+
+## Requirements
+
+- Ruby 2.0 or newer
+- Active Scaffold 4.4.0 or newer
+- a Rails version supported by the selected Active Scaffold version
+- jQuery UI Sortable on pages that use this plugin
+
+For Rails 3 applications, use an `active_scaffold_sortable` 3.2.x release.
+
+## Installation
+
+Add the gem to the application's `Gemfile`:
+
+```ruby
+gem "active_scaffold_sortable"
+```
+
+Then run:
+
+```console
+bundle install
+```
+
+The engine registers the Active Scaffold action, route, JavaScript,
+stylesheet, and view overrides automatically.
+
+## Ordered lists
+
+### With `acts_as_list`
+
+Add a position column and configure the model with
+[`acts_as_list`](https://github.com/brendon/acts_as_list):
+
+```ruby
+# db/migrate/..._add_position_to_entries.rb
+add_column :entries, :position, :integer
+add_index :entries, :position
+```
+
+```ruby
+class Entry < ApplicationRecord
+  acts_as_list
+end
+```
+
+The plugin detects `acts_as_list`, enables the `:sortable` action, and uses
+the model's configured position column. No Active Scaffold controller
+configuration is needed.
+
+Scopes configured in `acts_as_list` still define the logical lists. A rendered
+Active Scaffold list should contain records from only one scope so that a drag
+does not mix independent lists.
+
+### Without `acts_as_list`
+
+Sorting can use any persisted column that accepts one-based integer positions.
+Enable the action and select the column explicitly:
+
+```ruby
+class EntriesController < ApplicationController
+  active_scaffold :entry do |config|
+    config.actions << :sortable
+    config.sortable.column = :position
+  end
+end
+```
+
+On every drop, the visible records receive consecutive values beginning at
+`1`. Updates are made directly with `update_all`, so validations and model
+callbacks do not run. If the table has an `updated_at` column, it is updated.
+The reorder action uses Active Scaffold's update authorization check.
+
+## Sortable association subforms
+
+A collection association is draggable in a create or update form when the
+associated model's Active Scaffold configuration includes `:sortable`. This
+works whether sorting was enabled automatically by `acts_as_list` or manually:
+
+```ruby
+class TasksController < ApplicationController
+  active_scaffold :task do |config|
+    config.actions << :sortable
+    config.sortable.column = :position
+  end
+end
+```
+
+For example, a `Project` form that renders a `has_many :tasks` subform will
+allow its task rows to be reordered. Dragging updates the hidden position
+fields in the form; the order is persisted when the parent form is submitted,
+not through a separate reorder request. New associated records without a
+position are placed after the highest existing position.
+
+The association must be a collection. Singular associations are not sortable.
+The associated scaffold may exclude the `:list` action when sorting is needed
+only in a subform.
+
+## Tree models
+
+Tree support reorders nodes only among their current siblings. It does not move
+a node to a different parent.
+
+### Nested sets (`awesome_nested_set`)
+
+Models using
+[`awesome_nested_set`](https://github.com/collectiveidea/awesome_nested_set)
+are detected automatically:
+
+```ruby
+class Category < ApplicationRecord
+  acts_as_nested_set
+end
+```
+
+The plugin enables `:sortable`, uses the model's configured left column, and
+calls the nested-set movement methods to preserve valid left and right bounds.
+Root nodes can be reordered as siblings as well.
+
+Detection is API-based rather than gem-name-based. A different nested-set
+implementation may work only if it provides the same API used here:
+`nested_set_scope`, `left_column_name`, `self_and_siblings`, `move_left`, and
+`move_right`. `awesome_nested_set` is the intended integration; no other
+nested-set gem is explicitly supported by this project.
+
+### Ancestry
+
+Ancestry models are recognized during reordering, but they are **not** enabled
+automatically. Add a separate position column and configure sorting manually:
+
+```ruby
+class Category < ApplicationRecord
+  has_ancestry
+end
+```
+
+```ruby
+class CategoriesController < ApplicationController
+  active_scaffold :category do |config|
+    config.actions << :sortable
+    config.sortable.column = :position
+  end
+end
+```
+
+The submitted records are reordered within the first record's sibling set.
+Both root nodes and children are supported. The `ancestry` column itself is a
+path, not a sibling position, and should not be configured as the sortable
+column.
+
+## Configuration
+
+### Drag handle
+
+By default, the whole row is the drag handle. Add a dedicated handle column at
+the beginning or end of the list with:
+
+```ruby
+config.sortable.add_handle_column = :first
+# or
+config.sortable.add_handle_column = :last
+```
+
+Only `:first`, `:last`, and `false`/`nil` are accepted.
+
+### Refresh after reordering
+
+The default response only reapplies alternating row styles. Refresh the entire
+Active Scaffold list after each reorder when other displayed values depend on
+the order:
+
+```ruby
+config.sortable.refresh_list = true
+```
+
+### Advanced DOM options
+
+`config.sortable.options` is merged into the sortable container's `data-*`
+attributes. Supported overrides include:
+
+```ruby
+config.sortable.options = {
+  tag: "> tr",                    # selector for draggable items
+  handle: ".my-drag-handle",      # selector that starts dragging
+  content_selector: ".my-records", # sortable content within the container
+  key: "as_entries-tbody",        # serialized request parameter base
+  format: "^[^_-].*-(.*)-row$",   # extracts the record ID from a row ID
+  with: "scope_id=42"             # extra reorder request parameters
+}
+```
+
+These are integration hooks for custom Active Scaffold markup. They are not a
+general pass-through for every jQuery UI Sortable option. When overriding
+`key`, keep it aligned with the parameter name expected by the reorder action.
+
+The same settings can be used as defaults for every sortable scaffold. Set
+them in an initializer before Active Scaffold configurations are built:
+
+```ruby
+ActiveScaffold::Config::Sortable.add_handle_column = :first
+ActiveScaffold::Config::Sortable.refresh_list = true
+ActiveScaffold::Config::Sortable.options = { handle: ".my-drag-handle" }
+```
+
+### UI adapter support
+
+Sortable list and association-subform wrappers expose the
+`sortable_container` UI element. UI framework adapters can add or replace its
+HTML attributes without overriding either partial:
+
+```ruby
+ActiveScaffold.add_element_attributes :sortable_container,
+                                      class: "overflow-auto"
+```
+
+The plugin keeps the `sortable-container` class and `data-*` attributes used
+by its JavaScript and merges them with attributes supplied by the adapter.
+
+## Effects on the Active Scaffold list
+
+Enabling `:sortable` also:
+
+- disables pagination so all draggable records are present in one list;
+- orders the list ascending by the sortable column;
+- disables sorting by other columns;
+- hides the sortable column from normal action columns and configures its form
+  UI as hidden so subforms can carry positions without displaying the column.
+
+Because the browser submits only rendered rows, filters and nested views update
+only the matching subset. Non-rendered records retain their stored positions,
+which can produce duplicate positions in an ordinary list. Keep each sortable
+view within one logical list or sibling set, and use filtering with care.
+
+## Support
+
+For help, use the
+[Active Scaffold discussion group](https://groups.google.com/group/activescaffold)
+or [open an issue](https://github.com/activescaffold/active_scaffold_sortable/issues).
+
+## Contributing
+
+Fork the [repository](https://github.com/activescaffold/active_scaffold_sortable),
+make the change with tests, and open a pull request.
+
+## License
+
+Released under the [MIT License](LICENSE.txt).
+
+## Authors
+
+- Tim Harper
+- Sergio Cambra
+- Volker Hochstein

data/app/views/active_scaffold_overrides/_form_association.html.erb

@@ -1,6 +1,6 @@
 <% config = active_scaffold_config_for(column.association.klass) %>
 <% if config.actions.include? :sortable %>
-<%= content_tag :div, render(:super), :class => 'sortable-container', :data => sort_params(config).merge(:tag => "##{sub_form_list_id(:association => column.name, :id => parent_record.try(:id) || generated_id(parent_record) || 99999999999)} > .sub-form-record") %>
+<%= as_element :sortable_container, render(:super), class: 'sortable-container', data: sort_params(config).merge(tag: "##{sub_form_list_id(association: column.name, id: parent_record.try(:id) || generated_id(parent_record) || 99999999999)} > .sub-form-record") %>
 <% else %>
 <%= render :super %>
 <% end %>

data/frontends/default/active_scaffold_overrides/_list.html.erb

@@ -1 +1 @@
-<%= content_tag :div, render(:super), :class => 'sortable-container', :data => sort_params %>
+<%= as_element :sortable_container, render(:super), class: 'sortable-container', data: sort_params %>

data/lib/active_scaffold/config/sortable.rb

@@ -17,13 +17,13 @@ module ActiveScaffold::Config
     cattr_accessor :plugin_directory
     @@plugin_directory = File.expand_path(__FILE__).match(%{(^.*)/lib/active_scaffold/config/sortable.rb})[1]
 
-    cattr_accessor :add_handle_column
+    cattr_accessor :add_handle_column, instance_accessor: false
     @@add_handle_column = false
 
-    cattr_accessor :options
+    cattr_accessor :options, instance_accessor: false
     @@options = {}
 
-    cattr_accessor :refresh_list
+    cattr_accessor :refresh_list, instance_accessor: false
 
     self.crud_type = :update
     
@@ -36,7 +36,7 @@ module ActiveScaffold::Config
         @column.form_ui = :hidden
         @column.css_class = 'sortable-handle'
         @column.label = ''
-        @column.weight = -2**(0.size * 8 -2)
+        @column.weight = -(2**(0.size * 8 - 2))
       end
       @column
     end
@@ -50,7 +50,7 @@ module ActiveScaffold::Config
         raise(ArgumentError, "Unknown handle column position: #{where}") unless [:first, :last].include?(where)
         @options[:handle] = 'td.sortable-handle'
         define_handle_column
-        @column.weight = 2**(0.size * 8 -2) -1 unless where == :first
+        @column.weight = (2**(0.size * 8 - 2)) - 1 unless where == :first
         if @core.actions.include? :list
           if where == :first
             @core.list.columns = [:active_scaffold_sortable] + @core.list.columns.to_a unless @core.list.columns.include? :active_scaffold_sortable

data/lib/active_scaffold_sortable/version.rb

@@ -1,8 +1,8 @@
 module ActiveScaffoldSortable
   module Version
     MAJOR = 3
-    MINOR = 6
-    PATCH = 1
+    MINOR = 7
+    PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/lib/active_scaffold_sortable.rb

@@ -22,5 +22,6 @@ module ActiveScaffold
     ActiveScaffold.autoload_subdir('helpers', self, File.dirname(__FILE__))
   end
 end
+ActiveScaffold.set_element_tag(:sortable_container, :div)
 ActiveScaffold.stylesheets << 'active_scaffold_sortable'
 ActiveScaffold.javascripts << 'active_scaffold_sortable'

data/test/attribute_params_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class AttributeParamsTest < Minitest::Test
+  Record = Struct.new(:position)
+  AssociationConfig = Struct.new(:actions, :sortable)
+  SortableConfig = Struct.new(:column)
+  ColumnConfig = Struct.new(:name)
+  Reflection = Struct.new(:name) do
+    def collection?
+      true
+    end
+  end
+  FormColumn = Struct.new(:association)
+
+  class Parent
+    attr_reader :target
+
+    def association(_name)
+      self
+    end
+
+    def target=(records)
+      @target = records
+    end
+  end
+
+  class BaseUpdater
+    attr_accessor :submitted_records
+
+    def update_column_from_params(*)
+      submitted_records
+    end
+  end
+
+  class Updater < BaseUpdater
+    prepend ActiveScaffoldSortable::AttributeParams
+
+    attr_accessor :associated_config
+
+    def active_scaffold_config_for(_klass)
+      associated_config
+    end
+  end
+
+  def test_assigns_missing_subform_positions_and_sorts_the_target
+    updater = Updater.new
+    records = [Record.new(2), Record.new(nil), Record.new(1)]
+    updater.submitted_records = records
+    updater.associated_config = AssociationConfig.new(
+      [:sortable],
+      SortableConfig.new(ColumnConfig.new(:position))
+    )
+    reflection = Reflection.new(:records)
+    reflection.define_singleton_method(:klass) { Record }
+    parent = Parent.new
+
+    result = updater.update_column_from_params(
+      parent,
+      FormColumn.new(reflection),
+      :records
+    )
+
+    assert_same records, result
+    assert_equal [2, 3, 1], records.map(&:position)
+    assert_equal [1, 2, 3], parent.target.map(&:position)
+  end
+end

data/test/auto_models_controller_test.rb

@@ -1,52 +1,61 @@
-require 'test_helper.rb'
+# frozen_string_literal: true
+
+require "test_helper"
 
 class AutoModelsControllerTest < ActionController::TestCase
-  @@sortable_regexp = Regexp.new('Sortable.create\("as_auto_models-tbody", \{format:/\^\[\^_-\]\(\?:\[A-Za-z0-9_-\]\*\)-\(\.\*\)-row\$/, onUpdate:function\(\)\{new Ajax.Request\(\'/auto_models/reorder\', \{asynchronous:true, evalScripts:true, parameters:Sortable.serialize\("as_auto_models-tbody"\) \+ \'&controller=\' \+ encodeURIComponent\(\'auto_models\'\)\}\)\}, tag:\'tr\'\}\)')
-  setup { AutoModel.create :name => 'test', :position => 1 }
-
-  context "reordering" do
-    setup do
-      updates = sequence(:updates)
-      AutoModel.expects(:update_all).with({:position => 1}, 'id' => '2').in_sequence(updates)
-      AutoModel.expects(:update_all).with({:position => 2}, 'id' => '1').in_sequence(updates)
-      xhr :post, :reorder, :'as_auto_models-tbody' => ['2', '1']
-    end
-    should_respond_with :success
-    should_render_template :reorder
-    should "update stripe" do
-      assert_equal 'ActiveScaffold.stripe(\'as_auto_models-tbody\');', @response.body
-    end
+  tests AutoModelsController
+
+  setup do
+    AutoModel.delete_all
+    @first = AutoModel.create!(name: "first", position: 1)
+    @second = AutoModel.create!(name: "second", position: 2)
+  end
+
+  test "reorders records and renders the reorder response" do
+    post :reorder,
+         params: { "as_auto_models-tbody" => [@second.id, @first.id] },
+         xhr: true
+
+    assert_response :success
+    assert_equal 2, @first.reload.position
+    assert_equal 1, @second.reload.position
+    assert_operator @first.updated_at, :>, @first.created_at
+    assert_includes response.body, "ActiveScaffold.stripe('as_auto_models-tbody');"
+  end
+
+  test "renders sortable metadata and a row drag handle" do
+    get :index
+
+    assert_response :success
+    assert_select ".sortable-container[data-reorder-url='/auto_models/reorder']"
+    assert_select ".sortable-container[data-column='position']"
+    assert_select ".records tr.record.sortable-handle", count: 2
   end
 
-  context "listing" do
-    setup { get :index }
-    should "render record with sortable class" do
-      assert_select '.records tr.record.sortable'
-    end
-    should "render sortable script" do
-      assert_select 'script[type=text/javascript]', @@sortable_regexp
-    end
+  test "applies UI adapter attributes to the sortable container" do
+    ActiveScaffold.add_element_attributes(:sortable_container, class: "adapter-container")
+
+    get :index
+
+    assert_response :success
+    assert_select ".sortable-container.adapter-container"
+  ensure
+    ActiveScaffold.set_element(:sortable_container, tag: :div)
   end
 
-  context "creating" do
-    setup { xhr :post, :create, :record => {:name => 'test2', :position => 2} }
-    should_respond_with :success
-    should "insert at top" do
-      assert_match "$(\"as_auto_models-tbody\").insert(\"as_auto_models-list-#{assigns(:record).id}-row\");", @response.body
-    end
-    should "update stripe" do
-      assert_match 'ActiveScaffold.stripe(\'as_auto_models-tbody\');', @response.body
-    end
-    should "update sortable" do
-      assert_match @@sortable_regexp, @response.body
-    end
+  test "keeps sorting active after creating a record" do
+    post :create, params: { record: { name: "third", position: 3 } }, xhr: true
+
+    assert_response :success
+    assert_equal 3, AutoModel.count
+    assert_includes response.body, "ActiveScaffold.sortable('as_auto_models-tbody');"
   end
 
-  context "updating" do
-    setup { xhr :put, :update, :id => 1, :record => {:name => 'test updated'} }
-    should_respond_with :success
-    should "update sortable" do
-      assert_match @@sortable_regexp, @response.body
-    end
+  test "keeps sorting active after updating a record" do
+    put :update, params: { id: @first.id, record: { name: "updated" } }, xhr: true
+
+    assert_response :success
+    assert_equal "updated", @first.reload.name
+    assert_includes response.body, "ActiveScaffold.sortable('as_auto_models-tbody');"
   end
 end

data/test/config_test.rb

@@ -1,15 +1,11 @@
-require 'test_helper.rb'
+# frozen_string_literal: true
 
-class ConfigTest < Test::Unit::TestCase
-  def test_not_enable_sortable
-    assert !ModelsController.active_scaffold_config.actions.include?(:sortable)
-  end
+require "test_helper"
 
-  def test_auto_enable_sortable
+class ConfigTest < Minitest::Test
+  def test_sortable_activation
+    refute ModelsController.active_scaffold_config.actions.include?(:sortable)
     assert AutoModelsController.active_scaffold_config.actions.include?(:sortable)
-  end
-
-  def test_manual_enable_sortable
     assert SortableModelsController.active_scaffold_config.actions.include?(:sortable)
   end
 
@@ -18,42 +14,53 @@ class ConfigTest < Test::Unit::TestCase
     assert_equal :name, SortableModelsController.active_scaffold_config.sortable.column.name
   end
 
-  def test_position_column_not_included
-    assert !AutoModelsController.active_scaffold_config.list.columns.include?(:position)
-    assert !AutoModelsController.active_scaffold_config.update.columns.include?(:position)
-    assert !AutoModelsController.active_scaffold_config.create.columns.include?(:position)
-    assert !AutoModelsController.active_scaffold_config.show.columns.include?(:position)
-    assert !AutoModelsController.active_scaffold_config.subform.columns.include?(:position)
-    assert !AutoModelsController.active_scaffold_config.search.columns.include?(:position)
-
-    assert !SortableModelsController.active_scaffold_config.list.columns.include?(:name)
-    assert !SortableModelsController.active_scaffold_config.update.columns.include?(:name)
-    assert !SortableModelsController.active_scaffold_config.create.columns.include?(:name)
-    assert !SortableModelsController.active_scaffold_config.show.columns.include?(:name)
+  def test_position_column_is_hidden_from_actions
+    config = AutoModelsController.active_scaffold_config
+
+    %i[list update create show search subform].each do |action|
+      refute config.public_send(action).columns.include?(:position), action
+    end
+    assert_equal :hidden, config.columns[:position].form_ui
   end
 
-  def test_sorting
-    assert_equal('"models"."id" ASC', ModelsController.active_scaffold_config.list.sorting.clause)
-    assert ModelsController.active_scaffold_config.columns[:name].sortable?
-    assert ModelsController.active_scaffold_config.columns[:position].sortable?
+  def test_manually_selected_column_is_hidden
+    config = SortableModelsController.active_scaffold_config
 
-    assert_equal('"models"."position" ASC', AutoModelsController.active_scaffold_config.list.sorting.clause)
-    assert !AutoModelsController.active_scaffold_config.columns[:name].sortable?
+    %i[list update create show].each do |action|
+      refute config.public_send(action).columns.include?(:name), action
+    end
+  end
 
-    assert_equal('"models"."name" ASC', SortableModelsController.active_scaffold_config.list.sorting.clause)
-    assert !SortableModelsController.active_scaffold_config.columns[:position].sortable?
+  def test_sorting_configuration
+    regular = ModelsController.active_scaffold_config
+    automatic = AutoModelsController.active_scaffold_config
+    manual = SortableModelsController.active_scaffold_config
+
+    assert_equal [{id: "ASC"}], regular.list.sorting.clause
+    assert regular.columns[:name].sortable?
+    assert regular.columns[:position].sortable?
+
+    assert_equal [{position: "ASC"}], automatic.list.sorting.clause
+    refute automatic.columns[:name].sortable?
+
+    assert_equal [{name: "ASC"}], manual.list.sorting.clause
+    refute manual.columns[:position].sortable?
   end
 
-  def test_pagination
+  def test_sortable_lists_disable_pagination
     assert ModelsController.active_scaffold_config.list.pagination
-    assert !AutoModelsController.active_scaffold_config.list.pagination
-    assert !SortableModelsController.active_scaffold_config.list.pagination
+    refute AutoModelsController.active_scaffold_config.list.pagination
+    refute SortableModelsController.active_scaffold_config.list.pagination
   end
 
-  def test_active_scaffold_paths
-    path = File.join(Rails.root, 'vendor/plugins/active_scaffold_sortable/frontends/default/views')
-    assert !ModelsController.active_scaffold_paths.include?(path)
-    assert AutoModelsController.active_scaffold_paths.include?(path)
-    assert SortableModelsController.active_scaffold_paths.include?(path)
+  def test_sortable_controllers_register_the_plugin_view_path
+    plugin_path = File.join(
+      ActiveScaffold::Config::Sortable.plugin_directory,
+      "frontends/default"
+    )
+
+    refute ModelsController.view_paths.map(&:to_s).include?(plugin_path)
+    assert AutoModelsController.view_paths.map(&:to_s).include?(plugin_path)
+    assert SortableModelsController.view_paths.map(&:to_s).include?(plugin_path)
   end
 end

data/test/controllers/ancestry_models_controller.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class AncestryModelsController < ActionController::Base
+  active_scaffold :ancestry_model do |config|
+    config.actions << :sortable
+    config.sortable.column = :position
+  end
+end

data/test/controllers/auto_models_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AutoModelsController < ActionController::Base
   active_scaffold :auto_model
 end

data/test/controllers/models_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ModelsController < ActionController::Base
   active_scaffold
 end

data/test/controllers/nested_set_models_controller.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class NestedSetModelsController < ActionController::Base
+  active_scaffold :nested_set_model
+end

data/test/controllers/sortable_models_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SortableModelsController < ActionController::Base
   active_scaffold :model do |config|
     config.actions.exclude :search

data/test/dummy/app/assets/config/manifest.js

@@ -0,0 +1 @@
+//= link active_scaffold/manifest.js