b4um_generators 0.2.17 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39e3c318690d26739ba27564ca702e481d33cce273b21a46b8c304a60251d31a
-  data.tar.gz: 657648494cdca9cd40e9aafc9f333ee49967c6c31786ae67fdbc951575ca158a
+  metadata.gz: 167af7d5ad10e01abf428bf058e8d0ebc1b85e7791e43882dd1c53966d1ef89f
+  data.tar.gz: 715da7ed28265ec0f4451684dd35d375c749fbb8eb7f06b915a13e8bbadea26b
 SHA512:
-  metadata.gz: e375a782413296d33953bbe9192657a7e8772ee9095480b2c30c1a4b3d13da6dd3fefe0b04b170f7bc8747939beb43a3728f9b73e018cbcdf1c7ab032421d167
-  data.tar.gz: 9fd996e86f29f3c47a791a2cda1f663c4e465b576ef240cab9c88adea8d572bfe48ab91c833830ae8d27bb924bd71bb0d21d2a74fb0cc3b85436a94f81dcd662
+  metadata.gz: 2478f3db2a6f42ca3ca83158f86d9313676b5263c07b324f69d786b587ed603ab5af6a2319d123e7524e4cab508530431a161c18ed3e5e1deea50cd581f90a4f
+  data.tar.gz: 7c874c56a5057bbb5110b683ae3cdfbfd84c4471f5f40cc96e2f53fb1ca32843df64f8f5dde7ba3614274cad19e3fa33e5e563c217b9d46394f4e5dbbbdb9c16

data/README.de.md

@@ -732,6 +732,86 @@ Die Suche bietet:
 - Kein zusätzliches Such-Gem erforderlich
 - Sichere wiederholte Ausführung des Generators
 
+## Sortable
+
+Füge einer bestehenden Ressource eine dauerhaft gespeicherte Sortierreihenfolge hinzu:
+
+```bash
+bin/rails generate b4um:sortable Product
+bin/rails db:migrate
+```
+
+Der Generator fügt eine `position`-Spalte hinzu und weist bestehenden Datensätzen beim Ausführen der generierten
+Migration automatisch Positionen zu.
+
+Neue Datensätze werden automatisch am Ende der Liste eingefügt.
+
+Standardmäßig wird die bestehende Index-Seite zur sortierbaren Seite:
+
+```text
+/products
+```
+
+Das bestehende Index-Layout wird auf das b4um-Sortable-Layout umgestellt. Die gespeicherte Position wird außerdem als
+Standardsortierung der Ressource verwendet.
+
+Sortable bietet:
+
+- Dauerhaft in der Datenbank gespeicherte ganzzahlige Positionen
+- Automatische Positionierung bestehender Datensätze während der Migration
+- Automatische Positionierung neuer Datensätze am Ende
+- Drag-and-Drop-Sortierung mit Stimulus
+- Direkte Änderung der Position über ein Zahlenfeld
+- Automatisches Verschieben der betroffenen Datensätze
+- Lückenlose Positionen nach dem Verschieben oder Löschen von Datensätzen
+- Serverseitige Sortierung innerhalb einer Datenbanktransaktion
+- CSRF-geschützte Update-Anfragen
+- Integration mit b4um Search und Pagination
+- Kein zusätzliches Sortier-Gem erforderlich
+- Sichere wiederholte Ausführung des Generators
+
+### Separate Sortierseite
+
+Mit `--path` kann eine separate Sortierseite erstellt werden:
+
+```bash
+bin/rails generate b4um:sortable Product --path=sortierung
+bin/rails db:migrate
+```
+
+Dadurch wird die sortierbare Seite genau unter folgender URL erstellt:
+
+```text
+/sortierung
+```
+
+während der normale Ressourcen-Index weiterhin unter
+
+```text
+/products
+```
+
+verfügbar bleibt.
+
+Das bestehende Index-Layout, beispielsweise Bento oder Table, bleibt unverändert. Es verwendet weiterhin die
+gespeicherte `position`-Sortierung.
+
+Die separate Sortierseite verwendet den bestehenden Controller der Ressource. Es wird kein zusätzlicher Controller und
+kein Namespace erzeugt.
+
+Der mit `--path` angegebene Wert bestimmt direkt die URL der separaten Sortierseite. Zum Beispiel:
+
+```bash
+bin/rails generate b4um:sortable Product --path=produktuebersicht
+bin/rails generate b4um:sortable Product --path=verwaltung
+bin/rails generate b4um:sortable Product --path=admin
+```
+
+Dadurch entstehen entsprechend `/produktuebersicht`, `/verwaltung` und `/admin`.
+
+Eine separate Sortierseite ermöglicht außerdem, nur die `sort`-Action durch die Authentifizierung zu schützen, während
+der normale Ressourcen-Index öffentlich bleiben kann.
+
 ## Kommentare
 
 Füge einem bestehenden Modell polymorphe Kommentare hinzu:
@@ -1135,7 +1215,7 @@ wird.
 
 ## Version
 
-Aktuelle Version: `0.2.17`
+Aktuelle Version: `0.3.0`
 
 ## Autor
 

data/README.md

@@ -725,6 +725,81 @@ Search provides:
 - No additional search gem
 - Safe repeated generator runs
 
+## Sortable
+
+Add persistent sortable positioning to an existing resource:
+
+```bash
+bin/rails generate b4um:sortable Product
+bin/rails db:migrate
+```
+
+The generator adds a `position` column and assigns positions to existing records when the generated migration is run.
+
+New records are automatically added at the end of the list.
+
+By default, the existing resource index becomes the sortable page:
+
+```text
+/products
+```
+
+The existing index layout is switched to the b4um sortable layout. The stored position is also used as the default
+ordering for the resource.
+
+Sortable provides:
+
+- Persistent integer positions stored in the database
+- Automatic positioning of existing records during migration
+- Automatic positioning of new records at the end
+- Drag-and-drop sorting with Stimulus
+- Direct position changes using a number field
+- Automatic shifting of affected records
+- Contiguous positions after moving or deleting records
+- Server-side sorting inside a database transaction
+- CSRF-protected update requests
+- Integration with b4um Search and Pagination
+- No additional sorting gem
+- Safe repeated generator runs
+
+### Separate Sortable Page
+
+A separate sortable page can be created with `--path`:
+
+```bash
+bin/rails generate b4um:sortable Product --path=sortierung
+bin/rails db:migrate
+```
+
+This creates the sortable page at exactly:
+
+```text
+/sortierung
+```
+
+while the regular resource index remains available at:
+
+```text
+/products
+```
+
+The existing index layout, such as Bento or Table, remains unchanged. It still uses the stored `position` ordering.
+
+The separate sortable page uses the existing resource controller. No additional controller or namespace is generated.
+
+The value passed to `--path` directly defines the URL of the separate sortable page. For example:
+
+```bash
+bin/rails generate b4um:sortable Product --path=produktuebersicht
+bin/rails generate b4um:sortable Product --path=verwaltung
+bin/rails generate b4um:sortable Product --path=admin
+```
+
+These create `/produktuebersicht`, `/verwaltung`, and `/admin` respectively.
+
+Using a separate sortable page also makes it possible to protect only the `sort` action with authentication while
+keeping the regular resource index public.
+
 ## Comments
 
 Add polymorphic comments to an existing model:
@@ -1124,7 +1199,7 @@ The gem can be tested locally by referencing the repository with `path:` from a
 
 ## Version
 
-Current version: `0.2.17`
+Current version: `0.3.0`
 
 ## Author
 

data/lib/b4um_generators/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module B4umGenerators
-  VERSION = "0.2.17"
+  VERSION = "0.3.0"
 end

data/lib/generators/b4um/help/help_generator.rb

@@ -943,6 +943,72 @@ module B4um
             - No additional search gem required
             - Safe repeated generator runs
 
+          SORTABLE
+
+            bin/rails generate b4um:sortable MODEL
+
+          Adds persistent sortable positioning to an existing resource.
+
+          Example:
+
+            bin/rails generate b4um:sortable Product
+            bin/rails db:migrate
+
+          Existing records receive positions automatically when the
+          generated migration is run.
+
+          New records are automatically added at the end of the list.
+
+          By default, the existing index page becomes the sortable page:
+
+            /products
+
+          The existing index layout is switched to the b4um sortable
+          layout. The stored position is also used as the default
+          ordering for the resource.
+
+          A separate sortable page can be created with --path:
+
+            bin/rails generate b4um:sortable Product --path=sortierung
+            bin/rails db:migrate
+
+          This creates the sortable page at exactly:
+
+            /sortierung
+
+          The existing resource index remains unchanged:
+
+            /products
+
+          The separate page uses the existing resource controller.
+          No additional controller or namespace is generated.
+
+          Other examples:
+
+            --path=produktuebersicht
+            --path=verwaltung
+            --path=admin
+
+          The value passed to --path defines the URL of the separate
+          sortable page.
+
+          Sortable features:
+
+            - Persistent integer positions stored in the database
+            - Existing records receive positions during migration
+            - New records are automatically placed at the end
+            - Drag-and-drop sorting with Stimulus
+            - Positions can also be changed directly with a number field
+            - Moving a record automatically shifts the affected records
+            - Positions remain contiguous after moving or deleting records
+            - Server-side sorting inside a database transaction
+            - CSRF-protected update requests
+            - No additional sorting gem required
+            - Works with b4um Search and Pagination
+            - Stored ordering is reflected by the regular resource index
+            - Optional separate sortable page with --path
+            - Safe repeated generator runs
+
 
           COMMENTS
 

data/lib/generators/b4um/install/templates/b4um/sortable.css

@@ -0,0 +1,158 @@
+/* -------------------------------------------------------
+   Sortable
+------------------------------------------------------- */
+
+.b4um-sortable {
+  display: grid;
+  gap: 0.75rem;
+}
+
+.b4um-sortable__item {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 1.25rem;
+
+  padding: 1rem 1.25rem;
+
+  background: var(--b4um-surface);
+  border: 1px solid var(--b4um-border-light);
+  border-radius: var(--b4um-radius);
+
+  transition:
+    border-color 0.2s ease,
+    box-shadow 0.2s ease,
+    opacity 0.2s ease;
+}
+
+.b4um-sortable__item:hover {
+  border-color: var(--b4um-border-hover);
+}
+
+.b4um-sortable__item--dragging {
+  opacity: 0.5;
+  box-shadow: 0 8px 24px var(--b4um-primary-shadow-soft);
+}
+
+/* -------------------------------------------------------
+   Controls
+------------------------------------------------------- */
+
+.b4um-sortable__controls {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+.b4um-sortable__position {
+  box-sizing: border-box;
+
+  width: 4rem;
+  min-width: 4rem;
+  height: 2.75rem;
+
+  margin: 0;
+  padding: 0.5rem;
+
+  background: var(--b4um-surface);
+  color: var(--b4um-text);
+
+  border: 1px solid var(--b4um-border);
+  border-radius: 10px;
+
+  font: inherit;
+  text-align: center;
+}
+
+.b4um-sortable__position:hover {
+  border-color: var(--b4um-border-hover);
+}
+
+.b4um-sortable__position:focus {
+  border-color: var(--b4um-primary);
+  outline: 3px solid var(--b4um-primary-focus);
+  outline-offset: 1px;
+}
+
+/* -------------------------------------------------------
+   Drag handle
+------------------------------------------------------- */
+
+.b4um-sortable__handle {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+
+  width: 2.75rem;
+  height: 2.75rem;
+
+  margin: 0;
+  padding: 0;
+
+  background: transparent;
+  color: var(--b4um-text-secondary);
+
+  border: 0;
+  border-radius: 10px;
+
+  font: inherit;
+  font-size: 1.2rem;
+  line-height: 1;
+
+  cursor: grab;
+
+  transition:
+    background 0.2s ease,
+    color 0.2s ease;
+}
+
+.b4um-sortable__handle:hover {
+  background: var(--b4um-primary-soft);
+  color: var(--b4um-primary);
+}
+
+.b4um-sortable__handle:active {
+  cursor: grabbing;
+}
+
+/* -------------------------------------------------------
+   Content
+------------------------------------------------------- */
+
+.b4um-sortable__content {
+  min-width: 0;
+}
+
+.b4um-sortable__content .resource {
+  margin: 0;
+}
+
+/* -------------------------------------------------------
+   Actions
+------------------------------------------------------- */
+
+.b4um-sortable__actions {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+}
+
+.b4um-sortable__actions .button {
+  margin: 0;
+  white-space: nowrap;
+}
+
+/* -------------------------------------------------------
+   Responsive
+------------------------------------------------------- */
+
+@media (max-width: 48rem) {
+  .b4um-sortable__item {
+    grid-template-columns: 1fr;
+    gap: 0.75rem;
+  }
+
+  .b4um-sortable__actions {
+    justify-content: flex-start;
+  }
+}

data/lib/generators/b4um/install/templates/b4um.css

@@ -22,6 +22,7 @@
 @import 'b4um/hero.css';
 @import 'b4um/cards.css';
 @import 'b4um/tables.css';
+@import 'b4um/sortable.css';
 @import 'b4um/pagination.css';
 @import 'b4um/badges.css';
 @import 'b4um/callouts.css';

data/lib/generators/b4um/pagination/pagination_generator.rb

@@ -108,20 +108,33 @@ module B4um
         /
           @#{Regexp.escape(plural_table_name)}\s*=\s*
           b4um_search\(\s*
-          #{Regexp.escape(class_name)}\.all,\s*
+          (?<collection>
+            #{Regexp.escape(class_name)}
+            \.(?:all|order\(\s*:position\s*,\s*:id\s*\))
+          )\s*,\s*
           params\[:q\]\s*
           \)
         /x
       end
 
       def paginate_existing_search
+        controller_content = File.read(controller_path)
+        match = controller_content.match(search_pattern)
+
+        unless match
+          raise Thor::Error,
+                "Could not find the search collection in app/controllers/#{plural_table_name}_controller.rb"
+        end
+
+        collection = match[:collection]
+
         gsub_file(
           controller_path,
           search_pattern,
           [
             "@#{plural_table_name}, @pagination = b4um_paginate(",
             "      b4um_search(",
-            "        #{class_name}.all,",
+            "        #{collection},",
             "        params[:q]",
             "      ),",
             "      per_page: #{options[:per_page]}",
@@ -131,19 +144,33 @@ module B4um
       end
 
       def paginate_plain_collection(controller_content)
-        old_index = "@#{plural_table_name} = #{class_name}.all"
+        plain_collection = "#{class_name}.all"
+        sortable_collection = "#{class_name}.order(:position, :id)"
 
-        unless controller_content.include?(old_index)
+        collection =
+          if controller_content.include?(
+            "@#{plural_table_name} = #{sortable_collection}"
+          )
+            sortable_collection
+          elsif controller_content.include?(
+            "@#{plural_table_name} = #{plain_collection}"
+          )
+            plain_collection
+          end
+
+        unless collection
           raise Thor::Error,
                 "Could not find the index collection in app/controllers/#{plural_table_name}_controller.rb"
         end
 
+        old_index = "@#{plural_table_name} = #{collection}"
+
         gsub_file(
           controller_path,
           old_index,
           [
             "@#{plural_table_name}, @pagination = b4um_paginate(",
-            "      #{class_name}.all,",
+            "      #{collection},",
             "      per_page: #{options[:per_page]}",
             "    )"
           ].join("\n")

data/lib/generators/b4um/search/search_generator.rb

@@ -92,19 +92,33 @@ module B4um
           return
         end
 
-        old_index = "@#{file_name.pluralize} = #{class_name}.all"
+        plain_collection = "#{class_name}.all"
+        sortable_collection = "#{class_name}.order(:position, :id)"
 
-        unless controller_content.include?(old_index)
+        collection =
+          if controller_content.include?(
+            "@#{file_name.pluralize} = #{sortable_collection}"
+          )
+            sortable_collection
+          elsif controller_content.include?(
+            "@#{file_name.pluralize} = #{plain_collection}"
+          )
+            plain_collection
+          end
+
+        unless collection
           raise Thor::Error,
                 "Could not find the index collection in #{controller_path}"
         end
 
-        search_code = <<~RUBY.chomp
-          @#{file_name.pluralize} = b4um_search(
-            #{class_name}.all,
-            params[:q]
-          )
-        RUBY
+        old_index = "@#{file_name.pluralize} = #{collection}"
+
+        search_code = [
+          "@#{file_name.pluralize} = b4um_search(",
+          "      #{collection},",
+          "      params[:q]",
+          "    )"
+        ].join("\n")
 
         gsub_file(
           controller_path,

data/lib/generators/b4um/sortable/sortable_generator.rb

@@ -0,0 +1,529 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/named_base"
+
+module B4um
+  module Generators
+    class SortableGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :path,
+                   type: :string,
+                   default: nil,
+                   desc: "Creates a separate sortable page under the given path."
+
+      class << self
+        def desc(_description = nil)
+          "Adds sortable positioning to an existing B4UM resource."
+        end
+      end
+
+      def validate_model
+        return if File.exist?(model_path)
+
+        raise Thor::Error,
+              "Model not found: app/models/#{file_name}.rb"
+      end
+
+      def validate_controller
+        return if File.exist?(controller_path)
+
+        raise Thor::Error,
+              "Controller not found: app/controllers/#{plural_table_name}_controller.rb"
+      end
+
+      def validate_index_view
+        return if File.exist?(index_view_path)
+
+        raise Thor::Error,
+              "Index view not found: app/views/#{plural_table_name}/index.html.erb"
+      end
+
+      def create_position_migration
+        return if position_column_exists?
+
+        migration_template(
+          "add_position_migration.rb.tt",
+          "db/migrate/add_position_to_#{plural_table_name}.rb"
+        )
+      end
+
+      def update_model
+        model_content = File.read(model_path)
+
+        return if model_content.include?("before_create :b4um_set_sortable_position")
+
+        inject_into_class(
+          model_path,
+          class_name,
+          <<~RUBY.indent(2)
+            before_create :b4um_set_sortable_position
+            after_destroy :b4um_compact_sortable_positions
+
+            def b4um_set_sortable_position
+              return if position.present?
+
+              self.position = self.class.maximum(:position).to_i + 1
+            end
+
+            def b4um_compact_sortable_positions
+              self.class
+                  .where("position > ?", position)
+                  .update_all("position = position - 1")
+            end
+          RUBY
+        )
+
+        say_status(
+          :sortable,
+          "#{class_name} now assigns sortable positions",
+          :green
+        )
+      end
+
+      def update_controller
+        controller_content = File.read(controller_path)
+
+        update_index_order(controller_content)
+        add_sort_action
+      end
+
+      def add_sort_route
+        routes_path = File.join(
+          destination_root,
+          "config/routes.rb"
+        )
+
+        unless File.exist?(routes_path)
+          raise Thor::Error,
+                "Routes not found: config/routes.rb"
+        end
+
+        routes = File.read(routes_path)
+
+        if options[:path].present?
+          add_separate_sort_routes(routes)
+          return
+        end
+
+        return if sort_route_exists?(routes)
+        return if separate_sort_route_exists?(routes)
+
+        add_sort_route_to_resources(routes)
+      end
+
+      def create_sortable_controller
+        copy_file(
+          File.expand_path(
+            "templates/sortable_controller.js",
+            __dir__
+          ),
+          "app/javascript/controllers/sortable_controller.js"
+        )
+      end
+
+      def create_sortable_partial
+        template(
+          "_sortable.html.erb.tt",
+          File.join(
+            "app/views",
+            plural_table_name,
+            "_sortable.html.erb"
+          )
+        )
+      end
+
+      def create_sortable_view
+        return unless options[:path].present?
+
+        template(
+          "sort.html.erb.tt",
+          File.join(
+            "app/views",
+            plural_table_name,
+            "sort.html.erb"
+          )
+        )
+      end
+
+      def update_index_layout
+        return unless File.exist?(index_path)
+
+        index = File.read(index_path)
+
+        if options[:path].present?
+          restore_index_layout(index)
+        else
+          use_sortable_index_layout(index)
+        end
+      end
+
+      def self.next_migration_number(_dirname)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      private
+
+      def use_sortable_index_layout(index)
+        updated_index = index.sub(
+          /render\s+["'](?:bento|table|list|alternating|sortable)["']/,
+          'render "sortable"'
+        )
+
+        return if updated_index == index
+
+        File.write(index_path, updated_index)
+      end
+
+      def restore_index_layout(index)
+        return unless index.match?(
+          /render\s+["']sortable["']/
+        )
+
+        layout = original_index_layout
+
+        return unless layout
+
+        updated_index = index.sub(
+          /render\s+["']sortable["']/,
+          %(render "#{layout}")
+        )
+
+        File.write(index_path, updated_index)
+      end
+
+      def original_index_layout
+        %w[bento table list alternating].find do |layout|
+          File.exist?(
+            File.join(
+              destination_root,
+              "app/views",
+              plural_table_name,
+              "_#{layout}.html.erb"
+            )
+          )
+        end
+      end
+
+      def index_path
+        File.join(
+          destination_root,
+          "app/views",
+          plural_table_name,
+          "index.html.erb"
+        )
+      end
+
+      def model_path
+        File.join(
+          destination_root,
+          "app/models",
+          "#{file_name}.rb"
+        )
+      end
+
+      def controller_path
+        File.join(
+          destination_root,
+          "app/controllers",
+          "#{plural_table_name}_controller.rb"
+        )
+      end
+
+      def index_view_path
+        File.join(
+          destination_root,
+          "app/views",
+          plural_table_name,
+          "index.html.erb"
+        )
+      end
+
+      def update_index_order(controller_content)
+        return if controller_content.include?(
+          "#{class_name}.order(:position, :id)"
+        )
+
+        old_scope = "#{class_name}.all"
+
+        unless controller_content.include?(old_scope)
+          raise Thor::Error,
+                "Could not find #{class_name}.all in app/controllers/#{plural_table_name}_controller.rb"
+        end
+
+        gsub_file(
+          controller_path,
+          old_scope,
+          "#{class_name}.order(:position, :id)"
+        )
+      end
+
+      def add_sort_action
+        controller_content = File.read(controller_path)
+
+        if controller_content.match?(/^\s*def\s+sort\b/)
+          add_sort_page_support(controller_content)
+          return
+        end
+
+        get_handling =
+          if options[:path].present?
+            <<~RUBY
+              if request.get?
+                @#{plural_table_name} = #{class_name}.order(:position, :id)
+                return
+              end
+
+            RUBY
+          else
+            ""
+          end
+
+        action = <<~RUBY.indent(2)
+          def sort
+          #{get_handling.indent(2)}  record = #{class_name}.find_by(id: params[:id])
+            target_position = params[:position].to_i
+            maximum_position = #{class_name}.count
+
+            unless record &&
+                   target_position.between?(1, maximum_position)
+              head :unprocessable_content
+              return
+            end
+
+            if target_position == record.position
+              head :no_content
+              return
+            end
+
+            old_position = record.position
+
+            #{class_name}.transaction do
+              if target_position < old_position
+                #{class_name}
+                  .where(position: target_position...old_position)
+                  .where.not(id: record.id)
+                  .update_all("position = position + 1")
+              elsif target_position > old_position
+                #{class_name}
+                  .where(position: (old_position + 1)..target_position)
+                  .where.not(id: record.id)
+                  .update_all("position = position - 1")
+              end
+
+              record.update_columns(
+                position: target_position,
+                updated_at: Time.current
+              )
+            end
+
+            head :no_content
+          end
+
+        RUBY
+
+        private_marker = "\n  private\n"
+
+        if controller_content.include?(private_marker)
+          insert_into_file(
+            controller_path,
+            action,
+            before: private_marker
+          )
+        else
+          controller_end = /\nend\s*\z/
+
+          unless controller_content.match?(controller_end)
+            raise Thor::Error,
+                  "Could not find the end of app/controllers/#{plural_table_name}_controller.rb"
+          end
+
+          insert_into_file(
+            controller_path,
+            "\n#{action}",
+            before: controller_end
+          )
+        end
+      end
+
+      def add_sort_page_support(controller_content)
+        return unless options[:path].present?
+        return if controller_content.include?("if request.get?")
+
+        sort_action =
+          /^(\s*)def sort\s*$/
+
+        unless controller_content.match?(sort_action)
+          raise Thor::Error,
+                "Could not find sort action in app/controllers/#{plural_table_name}_controller.rb"
+        end
+
+        gsub_file(
+          controller_path,
+          sort_action
+        ) do |match|
+          indentation = match[/\A\s*/]
+
+          <<~RUBY.chomp
+            #{match}
+            #{indentation}  if request.get?
+            #{indentation}    @#{plural_table_name} = #{class_name}.order(:position, :id)
+            #{indentation}    return
+            #{indentation}  end
+          RUBY
+        end
+      end
+
+      def add_separate_sort_routes(routes)
+        path = options[:path].to_s
+
+        remove_default_sort_route(routes)
+
+        routes = File.read(
+          File.join(
+            destination_root,
+            "config/routes.rb"
+          )
+        )
+
+        get_route =
+          %(get "#{path}", to: "#{plural_table_name}#sort")
+
+        patch_route =
+          %(patch "#{path}", to: "#{plural_table_name}#sort", as: :sort_#{plural_table_name})
+
+        routes_to_add = []
+
+        routes_to_add << get_route unless routes.include?(get_route)
+
+        routes_to_add << patch_route unless routes.include?(patch_route)
+
+        return if routes_to_add.empty?
+
+        routes_end = /^end\s*\z/
+
+        unless routes.match?(routes_end)
+          raise Thor::Error,
+                "Could not find the end of config/routes.rb"
+        end
+
+        route_code = <<~RUBY
+
+          #{routes_to_add.join("\n  ")}
+        RUBY
+
+        insert_into_file(
+          "config/routes.rb",
+          route_code,
+          before: routes_end
+        )
+      end
+
+      def remove_default_sort_route(routes)
+        return unless sort_route_exists?(routes)
+
+        gsub_file(
+          "config/routes.rb",
+          /^(\s*)patch :sort, on: :collection\s*\n/,
+          ""
+        )
+      end
+
+      def sort_route_exists?(routes)
+        resource_block = sortable_resource_block(routes)
+
+        resource_block&.match?(
+          /^\s*patch\s+:sort,\s+on:\s+:collection\s*$/
+        ) || false
+      end
+
+      def separate_sort_route_exists?(routes)
+        routes.match?(
+          /^\s*patch\s+["'][^"']+["'],\s+to:\s+["']#{Regexp.escape(plural_table_name)}#sort["']/
+        )
+      end
+
+      def sortable_resource_block(routes)
+        pattern = /
+          ^(?<indent>\s*)
+          resources\s+:#{Regexp.escape(plural_table_name)}\s+do\s*$
+          (?<body>.*?)
+          ^\k<indent>end\s*$
+        /mx
+
+        routes[pattern]
+      end
+
+      def add_sort_route_to_resources(routes)
+        block_pattern =
+          /^(\s*)resources :#{Regexp.escape(plural_table_name)} do\s*$/
+
+        plain_pattern =
+          /^(\s*)resources :#{Regexp.escape(plural_table_name)}\s*$/
+
+        if routes.match?(block_pattern)
+          gsub_file(
+            "config/routes.rb",
+            block_pattern
+          ) do |match|
+            indentation = match[/\A\s*/]
+
+            [
+              match,
+              "#{indentation}  patch :sort, on: :collection"
+            ].join("\n")
+          end
+        elsif routes.match?(plain_pattern)
+          gsub_file(
+            "config/routes.rb",
+            plain_pattern
+          ) do |match|
+            indentation = match[/\A\s*/]
+
+            [
+              "#{indentation}resources :#{plural_table_name} do",
+              "#{indentation}  patch :sort, on: :collection",
+              "#{indentation}end"
+            ].join("\n")
+          end
+        else
+          raise Thor::Error,
+                "Could not find resources :#{plural_table_name} in config/routes.rb"
+        end
+      end
+
+      def position_column_exists?
+        migration_contains_position? ||
+          schema_contains_position?
+      end
+
+      def migration_contains_position?
+        Dir.glob(
+          File.join(
+            destination_root,
+            "db/migrate/*_add_position_to_#{plural_table_name}.rb"
+          )
+        ).any?
+      end
+
+      def schema_contains_position?
+        schema_path = File.join(destination_root, "db/schema.rb")
+
+        return false unless File.exist?(schema_path)
+
+        schema = File.read(schema_path)
+
+        table_pattern = /
+          create_table\s+"#{Regexp.escape(plural_table_name)}".*?^  end
+        /mx
+
+        table = schema[table_pattern]
+
+        table&.match?(/t\.integer\s+"position"/) || false
+      end
+    end
+  end
+end

data/lib/generators/b4um/sortable/templates/_sortable.html.erb.tt

@@ -0,0 +1,40 @@
+<div class="b4um-sortable"
+     data-controller="sortable"
+     data-sortable-update-url-value="<%%= sort_<%= plural_table_name %>_path %>">
+
+  <%% <%= plural_table_name %>.each do |<%= singular_table_name %>| %>
+    <div class="b4um-sortable__item"
+          data-sortable-id="<%%= <%= singular_table_name %>.id %>"
+          data-action="dragover->sortable#dragOver drop->sortable#drop">
+
+      <div class="b4um-sortable__controls">
+        <input type="number"
+                class="b4um-sortable__position"
+                value="<%%= <%= singular_table_name %>.position %>"
+                min="1"
+                aria-label="Position"
+                data-action="change->sortable#positionChanged keydown->sortable#positionKeydown">
+
+        <button type="button"
+                class="b4um-sortable__handle"
+                draggable="true"
+                aria-label="Move <%= singular_table_name.humanize.downcase %>"
+                data-action="dragstart->sortable#dragStart dragend->sortable#dragEnd">
+          &#9776;
+        </button>
+      </div>
+
+      <div class="b4um-sortable__content">
+        <%%= render <%= singular_table_name %>,
+                    compact: true,
+                    preview_length: 100 %>
+      </div>
+
+      <div class="b4um-sortable__actions">
+        <%%= link_to "Show",
+                    <%= singular_table_name %>,
+                    class: "button button--secondary" %>
+      </div>
+    </div>
+  <%% end %>
+</div>

data/lib/generators/b4um/sortable/templates/add_position_migration.rb.tt

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class AddPositionTo<%= class_name.pluralize %> < ActiveRecord::Migration[8.0]
+  def up
+    add_column :<%= plural_table_name %>, :position, :integer
+
+    sortable_record = Class.new(ActiveRecord::Base) do
+      self.table_name = "<%= plural_table_name %>"
+    end
+
+    sortable_record.reset_column_information
+
+    sortable_record.order(:id).find_each.with_index(1) do |record, position|
+      record.update_columns(position: position)
+    end
+
+    change_column_null :<%= plural_table_name %>, :position, false
+
+    add_index :<%= plural_table_name %>, :position
+  end
+
+  def down
+    remove_index :<%= plural_table_name %>, :position
+    remove_column :<%= plural_table_name %>, :position
+  end
+end

data/lib/generators/b4um/sortable/templates/sort.html.erb.tt

@@ -0,0 +1,3 @@
+<h1><%= class_name.pluralize %> sortieren</h1>
+
+<%%= render "sortable", <%= plural_table_name %>: @<%= plural_table_name %> %>

data/lib/generators/b4um/sortable/templates/sortable_controller.js

@@ -0,0 +1,166 @@
+import { Controller } from '@hotwired/stimulus'
+
+export default class extends Controller {
+  static values = {
+    updateUrl: String
+  }
+
+  connect() {
+    this.draggedItem = null
+    this.draggedFromPosition = null
+  }
+
+  dragStart(event) {
+    const item = event.currentTarget.closest('[data-sortable-id]')
+
+    if (!item) return
+
+    this.draggedItem = item
+    this.draggedFromPosition = this.positionFor(item)
+
+    event.dataTransfer.effectAllowed = 'move'
+    event.dataTransfer.setData('text/plain', item.dataset.sortableId)
+
+    item.classList.add('b4um-sortable__item--dragging')
+  }
+
+  dragEnd() {
+    if (this.draggedItem) {
+      this.draggedItem.classList.remove('b4um-sortable__item--dragging')
+    }
+
+    this.draggedItem = null
+    this.draggedFromPosition = null
+  }
+
+  dragOver(event) {
+    event.preventDefault()
+
+    if (!this.draggedItem) return
+
+    const target = event.currentTarget
+
+    if (target === this.draggedItem) return
+
+    const bounds = target.getBoundingClientRect()
+    const insertAfter = event.clientY > bounds.top + bounds.height / 2
+
+    if (insertAfter) {
+      target.after(this.draggedItem)
+    } else {
+      target.before(this.draggedItem)
+    }
+  }
+
+  drop(event) {
+    event.preventDefault()
+
+    if (!this.draggedItem) return
+
+    const item = this.draggedItem
+    const position = this.positionAfterDrop(item)
+
+    if (!position) {
+      window.location.reload()
+      return
+    }
+
+    this.persist(item.dataset.sortableId, position)
+  }
+
+  positionKeydown(event) {
+    if (event.key !== 'Enter') return
+
+    event.preventDefault()
+    event.currentTarget.blur()
+  }
+
+  positionChanged(event) {
+    const input = event.currentTarget
+    const item = input.closest('[data-sortable-id]')
+
+    if (!item) return
+
+    const position = Number.parseInt(input.value, 10)
+
+    if (Number.isNaN(position) || position < 1) {
+      window.location.reload()
+      return
+    }
+
+    this.persist(item.dataset.sortableId, position)
+  }
+
+  positionFor(item) {
+    const input = item.querySelector('.b4um-sortable__position')
+
+    if (!input) return null
+
+    const position = Number.parseInt(input.value, 10)
+
+    return Number.isNaN(position) ? null : position
+  }
+
+  positionAfterDrop(item) {
+    const previousItem = item.previousElementSibling
+    const nextItem = item.nextElementSibling
+
+    if (previousItem?.matches('[data-sortable-id]')) {
+      const previousPosition = this.positionFor(previousItem)
+
+      if (previousPosition) {
+        if (this.draggedFromPosition && this.draggedFromPosition < previousPosition) {
+          return previousPosition
+        }
+
+        return previousPosition + 1
+      }
+    }
+
+    if (nextItem?.matches('[data-sortable-id]')) {
+      const nextPosition = this.positionFor(nextItem)
+
+      if (nextPosition) {
+        if (this.draggedFromPosition && this.draggedFromPosition > nextPosition) {
+          return nextPosition
+        }
+
+        return Math.max(1, nextPosition - 1)
+      }
+    }
+
+    return this.draggedFromPosition
+  }
+
+  async persist(id, position) {
+    if (!this.hasUpdateUrlValue || !this.updateUrlValue) return
+
+    try {
+      const response = await fetch(this.updateUrlValue, {
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+          'X-CSRF-Token': this.csrfToken()
+        },
+        body: JSON.stringify({
+          id,
+          position
+        })
+      })
+
+      if (!response.ok) {
+        throw new Error(`Sortable update failed: ${response.status}`)
+      }
+
+      window.location.reload()
+    } catch (error) {
+      console.error(error)
+      window.location.reload()
+    }
+  }
+
+  csrfToken() {
+    return document.querySelector('meta[name="csrf-token"]')?.content || ''
+  }
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: b4um_generators
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.3.0
 platform: ruby
 authors:
 - Alexander Baum
@@ -115,6 +115,7 @@ files:
 - lib/generators/b4um/install/templates/b4um/pagination.css
 - lib/generators/b4um/install/templates/b4um/resources.css
 - lib/generators/b4um/install/templates/b4um/search.css
+- lib/generators/b4um/install/templates/b4um/sortable.css
 - lib/generators/b4um/install/templates/b4um/tables.css
 - lib/generators/b4um/install/templates/b4um/theme-switcher.css
 - lib/generators/b4um/install/templates/b4um/theme.css
@@ -145,6 +146,11 @@ files:
 - lib/generators/b4um/search/search_generator.rb
 - lib/generators/b4um/search/templates/search.rb
 - lib/generators/b4um/search/templates/search_form.html.erb.tt
+- lib/generators/b4um/sortable/sortable_generator.rb
+- lib/generators/b4um/sortable/templates/_sortable.html.erb.tt
+- lib/generators/b4um/sortable/templates/add_position_migration.rb.tt
+- lib/generators/b4um/sortable/templates/sort.html.erb.tt
+- lib/generators/b4um/sortable/templates/sortable_controller.js
 - lib/generators/b4um/table/table_generator.rb
 - lib/generators/b4um/table/templates/_table.html.erb.tt
 - lib/generators/b4um/trix/templates/b4um_rich_text_helper.rb