b4um_generators 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15fb9392677d61fa44d0d18bfa6fa71f8cde33202c1d3ab846eeded8cc255240
-  data.tar.gz: 07256f3c068de795270adf8e1376f155f657c6a13b4d356ce414a289c6456be2
+  metadata.gz: 32be49cb4a38e8c75eba464939aa99d73d45784f0434d3aa75f0b4d7fd57862f
+  data.tar.gz: a3af1d5dcb53dd3aa945f92f05ec84bdb271c0a6ffc14fb1c99c96232d7a6407
 SHA512:
-  metadata.gz: c2c4efca4c04e8e8ef528e246d16c2e536c1b54e6dd356c284e96659664756edeacdfcb93d135cbebdf39ace19f869c5ca49dafbfe5ad9867c3703c92228bb8b
-  data.tar.gz: af333b2df50d0530cfbf701b3fa040a80ba5d716cae4a67909be39d1f59d5c1bad6795b9a39691284e6cce2e867ed512ec7cf047f72bdff579db3741e8349ee6
+  metadata.gz: c00cf8cab52aa8f5edf31b01ac68e948c2f8019ba2978542546be8daa79a138c40673b421c82ba5933e51553b781fbd700fcac3857d973b3da13816904e20b90
+  data.tar.gz: d9b452a787712782c27a4a02799cac27b0ee2566bb97bb8e14875fe521e89a17eb2632873a5c772385e78264abf0204a3dba696b37c830e20d911c01ae17b220

data/.rubocop.yml

@@ -15,14 +15,14 @@ Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
 
 Metrics/MethodLength:
-  Max: 1050
+  Max: 1200
 
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*'
 
 Metrics/ClassLength:
-  Max: 1050
+  Max: 1200
 
 Metrics/AbcSize:
   Max: 100

data/CHANGELOG.md

@@ -4,6 +4,75 @@ All notable changes to b4um Generators will be documented in this file.
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-10-14
+
+### Added
+
+- Added complete Todo application generator with `b4um:todo`
+- Added task creation, completion, reopening and deletion
+- Added separate lists for open and completed tasks
+- Added automatic task counters and progress tracking
+- Added progress bar with completion percentage
+- Added Turbo Stream updates without full page reloads
+- Added Stimulus controller for task input handling
+- Added automatic input reset after successful task creation
+- Added responsive Todo layout with b4um cards and floating labels
+- Added light and dark mode support for Todo components
+- Added optional `--owner=MODEL` support for personal Todo lists
+- Added integration with b4um authentication and current account helpers
+- Added owner-specific task access protection
+- Added HTTP 401 responses for unauthenticated owner-specific Todo requests
+- Added 35 RSpec examples for the Todo generator
+
+### Changed
+
+- Extended `b4um:help` with Todo generator documentation
+- Extended Help generator RSpec coverage for Todo
+- Updated English and German README documentation
+- Updated the generator overview to include `b4um:todo`
+
+## [0.4.2] - 2026-10-13
+
+### Fixed
+
+- Fixed indentation of generated `to_param` methods in the Readable generator
+- Fixed `--param` formatting in generated scaffold models
+- Fixed scaffold revoke behavior so generated model, controller and navigation changes are removed cleanly
+- Fixed scaffold navigation cleanup during revoke
+- Fixed Sortable migration detection when another database table already contains a `position` column
+- Fixed Sortable model formatting when adding position callbacks
+- Fixed Sortable fixture generation for `NOT NULL` position columns
+- Fixed partially positioned Sortable fixtures while preserving fixture metadata
+- Fixed Comments routing when the target resource already uses a block
+- Fixed Authentication helper formatting in `ApplicationController`
+- Fixed Admin helper and blocked-session formatting
+- Fixed Admin revoke handling for generated authentication and route changes
+- Fixed In-Place generator integration and formatting edge cases
+
+### Changed
+
+- Improved generator idempotency and revoke behavior
+- Improved integration between Scaffold, Authentication, Admin, Comments, Sortable and In-Place generators
+- Expanded regression coverage for generator formatting, routing, fixtures and revoke behavior
+- Increased RuboCop line-length configuration for the generator source
+- Verified the complete generator suite with 466 RSpec examples and 0 failures
+- Verified generated applications with Rails 8.1.4
+
+## [0.4.1] - 2026-10-13
+
+### Fixed
+
+- Fixed scaffold password tests for bcrypt-backed authentication
+- Fixed generated destroy formatting
+- Fixed generated fixtures for authentication models with unique email addresses
+- Fixed generated authentication tests for protected actions
+
+### Changed
+
+- Improved Authentication integration with generated scaffold tests
+- Improved generated test setup for authenticated resources
+- Improved bcrypt integration in generated applications
+
 ## [0.4.0] - 2026-10-12
 
 ### Added

data/README.de.md

@@ -6,8 +6,8 @@ b4um Generators ist eine Sammlung wiederverwendbarer Rails-Generatoren, Template
 für b4um-Rails-Projekte.
 
 Das Gem bietet eine einheitliche Grundlage für Rails-Anwendungen und enthält Generatoren für Scaffolds, Controller,
-Bento-Layouts, Tabellen, Pagination, Infinite Scroll, Suche, Kommentare, Authentifizierung, Administration, Gastzugänge,
-Attachments und Rich-Text-Bearbeitung.
+Bento-Layouts, Tabellen, Pagination, Infinite Scroll, Suche, Sortierung, Todo-Listen, Kommentare, Authentifizierung,
+Administration, Gastzugänge, Attachments und Rich-Text-Bearbeitung.
 
 Die generierten Komponenten verwenden ein gemeinsames b4um-Styling und sind darauf ausgelegt, miteinander zu
 funktionieren.
@@ -24,7 +24,7 @@ b4um Generators wird während der Entwicklung derzeit als lokales Gem verwendet.
 Füge das Gem zur `Gemfile` der Rails-Anwendung hinzu:
 
 ```ruby
-gem "b4um_generators", "~> 0.4.0", path: "/pfad/zu/b4um_generators"
+gem "b4um_generators", "~> 0.5.0", path: "/pfad/zu/b4um_generators"
 ```
 
 Führe anschließend aus:
@@ -82,6 +82,7 @@ b4um:pagination
 b4um:infinite_scroll
 b4um:search
 b4um:sortable
+b4um:todo
 b4um:comments
 b4um:in_place
 b4um:authentication
@@ -1146,6 +1147,119 @@ 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.
 
+## Todo
+
+Erzeuge eine vollständige Todo-Anwendung mit Turbo Streams, Stimulus und dem einheitlichen b4um-Styling:
+
+```bash
+bin/rails generate b4um:todo Task
+bin/rails db:migrate
+```
+
+Der Generator erstellt eine sofort verwendbare Aufgabenliste, ohne dass ein zusätzliches Todo-Gem erforderlich ist.
+
+Standardmäßig werden Aufgaben gemeinsam innerhalb der Anwendung verwaltet und sind keinem einzelnen Benutzer zugeordnet.
+
+Die generierte Todo-Anwendung ist erreichbar unter:
+
+```text
+/tasks
+```
+
+### Funktionen
+
+Der Todo-Generator bietet:
+
+- Neue Aufgaben erstellen
+- Aufgaben als erledigt markieren
+- Erledigte Aufgaben wieder öffnen
+- Aufgaben löschen
+- Getrennte Listen für offene und erledigte Aufgaben
+- Automatische Aufgabenzähler
+- Fortschrittsbalken mit prozentualer Anzeige
+- Aktualisierungen mit Turbo Streams ohne vollständiges Neuladen der Seite
+- Stimulus-Controller für die Aufgabeneingabe
+- Automatisches Zurücksetzen des Eingabefeldes nach erfolgreicher Erstellung
+- b4um Floating Labels
+- Responsives b4um-Kartenlayout
+- Unterstützung für Light Mode und Dark Mode
+- Optionale Zuordnung zu einem Benutzerkonto
+- Zugriffsschutz für benutzerspezifische Aufgaben
+
+### Persönliche Todo-Listen
+
+Todo-Listen können optional einem Authentifizierungsmodell zugeordnet werden.
+
+Mit `--owner` werden Aufgaben einzelnen Benutzern zugewiesen:
+
+```bash
+bin/rails generate b4um:todo Task --owner=User
+bin/rails db:migrate
+```
+
+Das angegebene Benutzer- beziehungsweise Eigentümermodell muss bereits existieren.
+
+Wird ein Eigentümermodell angegeben, erhält jedes angemeldete Benutzerkonto seine eigene Todo-Liste.
+
+Die Aufgaben werden über die Verknüpfung des aktuell angemeldeten Kontos geladen. Dadurch können Benutzer nicht auf
+Aufgaben anderer Konten zugreifen.
+
+Nicht authentifizierte Anfragen an benutzerspezifische Todo-Aktionen erhalten den HTTP-Status `401 Unauthorized`.
+
+### Integration mit der Authentifizierung
+
+Der Todo-Generator arbeitet mit dem bestehenden b4um-Authentifizierungssystem zusammen.
+
+Ein vollständiges Beispiel:
+
+```bash
+bin/rails generate b4um:scaffold User name:string email:string password_digest:string
+bin/rails db:migrate
+
+bin/rails generate b4um:authentication User
+
+bin/rails generate b4um:todo Task --owner=User
+bin/rails db:migrate
+```
+
+Die Passwort-Authentifizierung benötigt bcrypt. Dieses kann über `b4um:install` installiert werden.
+
+Die Option `--owner` unterstützt auch andere Authentifizierungsmodelle:
+
+```bash
+bin/rails generate b4um:todo Task --owner=Member
+bin/rails generate b4um:todo Task --owner=Customer
+```
+
+Der generierte Controller verwendet automatisch den zum Modell passenden Helper für das aktuell angemeldete Konto:
+
+```ruby
+current_user
+current_member
+current_customer
+```
+
+### Generierte Dateien
+
+Für das standardmäßige `Task`-Modell erstellt der Generator folgende Komponenten:
+
+- Task-Modell und Datenbankmigration
+- Tasks-Controller
+- Ressourcen-Routen
+- Todo-Index-View
+- Task-Partial
+- Fortschritts-Partial
+- Todo-Stylesheet
+- Stimulus-Controller
+
+Nach dem Generieren muss die Datenbankmigration ausgeführt werden:
+
+```bash
+bin/rails db:migrate
+```
+
+Anschließend kann die Todo-Anwendung verwendet werden.
+
 ## Kommentare
 
 Füge einem bestehenden Modell polymorphe Kommentare hinzu:
@@ -1549,7 +1663,7 @@ wird.
 
 ## Version
 
-Aktuelle Version: `0.4.0`
+Aktuelle Version: `0.5.0`
 
 ## Autor
 

data/README.md

@@ -6,8 +6,8 @@ b4um Generators is a collection of reusable Rails generators, templates, compone
 Rails projects.
 
 The gem provides a consistent starting point for Rails applications and includes generators for scaffolds, controllers,
-Bento layouts, tables, pagination, infinite scrolling, search, sorting, comments, authentication, administrator
-management, guest access, attachments and rich-text editing.
+Bento layouts, tables, pagination, infinite scrolling, search, sorting, Todo lists, comments, authentication,
+administrator management, guest access, attachments and rich-text editing.
 
 Generated components share the same b4um styling and are designed to work together.
 
@@ -23,7 +23,7 @@ b4um Generators is currently used as a local gem during development.
 Add the gem to the Rails application's `Gemfile`:
 
 ```ruby
-gem "b4um_generators", "~> 0.4.0", path: "/path/to/b4um_generators"
+gem "b4um_generators", "~> 0.5.0", path: "/path/to/b4um_generators"
 ```
 
 Then run:
@@ -80,6 +80,7 @@ b4um:pagination
 b4um:infinite_scroll
 b4um:search
 b4um:sortable
+b4um:todo
 b4um:comments
 b4um:in_place
 b4um:authentication
@@ -1125,6 +1126,119 @@ 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.
 
+## Todo
+
+Generate a complete Todo application with Turbo Streams, Stimulus and b4um styling:
+
+```bash
+bin/rails generate b4um:todo Task
+bin/rails db:migrate
+```
+
+The generator creates a ready-to-use Todo list without requiring an additional Todo gem.
+
+By default, tasks are shared across the application and are not assigned to individual users.
+
+The generated Todo application is available at:
+
+```text
+/tasks
+```
+
+### Features
+
+The Todo generator provides:
+
+- Create new tasks
+- Mark tasks as completed
+- Reopen completed tasks
+- Delete tasks
+- Separate lists for open and completed tasks
+- Automatic task counters
+- Progress bar with completion percentage
+- Turbo Stream updates without full page reloads
+- Stimulus controller for task input handling
+- Automatic input reset after successful creation
+- b4um floating labels
+- Responsive b4um card layout
+- Light and dark mode support
+- Optional owner association
+- Owner-specific task access protection
+
+### Personal Todo Lists
+
+Todo lists can optionally be associated with an authentication model.
+
+Use `--owner` to assign tasks to individual users:
+
+```bash
+bin/rails generate b4um:todo Task --owner=User
+bin/rails db:migrate
+```
+
+The owner model must already exist.
+
+When an owner is configured, each authenticated account has its own Todo list.
+
+Tasks are loaded through the current owner's association, preventing users from accessing tasks belonging to another
+account.
+
+Unauthenticated requests to owner-specific Todo actions receive HTTP `401 Unauthorized`.
+
+### Authentication Integration
+
+The Todo generator integrates with the existing b4um authentication system.
+
+A complete example:
+
+```bash
+bin/rails generate b4um:scaffold User name:string email:string password_digest:string
+bin/rails db:migrate
+
+bin/rails generate b4um:authentication User
+
+bin/rails generate b4um:todo Task --owner=User
+bin/rails db:migrate
+```
+
+Password authentication requires bcrypt, which can be installed through `b4um:install`.
+
+The owner option also supports other authentication models:
+
+```bash
+bin/rails generate b4um:todo Task --owner=Member
+bin/rails generate b4um:todo Task --owner=Customer
+```
+
+The generated controller uses the corresponding current account helper:
+
+```ruby
+current_user
+current_member
+current_customer
+```
+
+### Generated Files
+
+For the default `Task` model, the generator creates the following components:
+
+- Task model and database migration
+- Tasks controller
+- Resource routes
+- Todo index view
+- Task partial
+- Progress partial
+- Todo stylesheet
+- Stimulus controller
+
+After generation, run:
+
+```bash
+bin/rails db:migrate
+```
+
+The Todo application is then ready to use.
+
 ## Comments
 
 Add polymorphic comments to an existing model:
@@ -1524,7 +1638,7 @@ The gem can be tested locally by referencing the repository with `path:` from a
 
 ## Version
 
-Current version: `0.4.0`
+Current version: `0.5.0`
 
 ## Author
 

data/lib/b4um_generators/version.rb

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

data/lib/generators/b4um/admin/admin_generator.rb

@@ -146,6 +146,27 @@ module B4um
 
         controller = File.read(full_controller_path)
 
+        require_admin = [
+          "",
+          "  def require_admin",
+          "    return if logged_in? && #{current_authentication_method}.admin?",
+          "",
+          '    redirect_to root_path, alert: "Access denied."',
+          "  end",
+          ""
+        ].join("\n")
+
+        if behavior == :revoke
+          return unless controller.include?(require_admin)
+
+          File.write(
+            full_controller_path,
+            controller.sub(require_admin, "")
+          )
+
+          return
+        end
+
         return if controller.include?("def require_admin")
 
         class_end_position = controller.rindex(/^end\s*$/)
@@ -155,16 +176,6 @@ module B4um
                 "Could not find the end of ApplicationController."
         end
 
-        require_admin = <<~RUBY
-
-          def require_admin
-            return if logged_in? && #{current_authentication_method}.admin?
-
-            redirect_to root_path, alert: "Access denied."
-          end
-
-        RUBY
-
         controller.insert(
           class_end_position,
           require_admin
@@ -227,6 +238,27 @@ module B4um
                 "Routes not found: #{routes_path}"
         end
 
+        if behavior == :revoke
+          routes = File.read(full_routes_path)
+
+          routes.gsub!(
+            /^  #{Regexp.escape(admin_root_route)}\n?/,
+            ""
+          )
+
+          routes.gsub!(
+            /^#{Regexp.escape(indented_admin_users_route)}\n?/,
+            ""
+          )
+
+          File.write(
+            full_routes_path,
+            routes
+          )
+
+          return
+        end
+
         admin_users_route_status =
           upgrade_existing_admin_users_route(
             routes_path,
@@ -261,33 +293,77 @@ module B4um
 
         controller = File.read(full_controller_path)
 
-        return if controller.include?("if @#{current_authentication_method}&.blocked?")
-
         current_user_assignment =
           "@#{current_authentication_method} ||= " \
           "#{authentication_class_name}.find_by(" \
           "id: session[:#{authentication_model_name}_id])"
 
-        unless controller.include?(current_user_assignment)
+        blocked_session_block = [
+          current_user_assignment,
+          "",
+          "if @#{current_authentication_method}&.blocked?",
+          "  session.delete(:#{authentication_model_name}_id)",
+          "  @#{current_authentication_method} = nil",
+          "end",
+          "",
+          "@#{current_authentication_method}"
+        ]
+
+        if behavior == :revoke
+          blocked_pattern = /
+            ^(?<indent>[ \t]*)#{Regexp.escape(current_user_assignment)}\n
+            \n
+            ^\k<indent>if\ @#{Regexp.escape(current_authentication_method)}&\.blocked\?\n
+            ^\k<indent>\ \ session\.delete\(:#{Regexp.escape(authentication_model_name)}_id\)\n
+            ^\k<indent>\ \ @#{Regexp.escape(current_authentication_method)}\ =\ nil\n
+            ^\k<indent>end\n
+            \n
+            ^\k<indent>@#{Regexp.escape(current_authentication_method)}$
+          /x
+
+          match = controller.match(blocked_pattern)
+
+          return unless match
+
+          replacement =
+            "#{match[:indent]}#{current_user_assignment}"
+
+          File.write(
+            full_controller_path,
+            controller.sub(
+              blocked_pattern,
+              replacement
+            )
+          )
+
+          return
+        end
+
+        return if controller.include?(
+          "if @#{current_authentication_method}&.blocked?"
+        )
+
+        assignment_match = controller.match(
+          /^([ \t]*)#{Regexp.escape(current_user_assignment)}$/
+        )
+
+        unless assignment_match
           raise Thor::Error,
                 "Could not find the current authentication method " \
                 "in #{controller_path}"
         end
 
-        replacement = <<~RUBY.chomp
-          #{current_user_assignment}
+        indentation = assignment_match[1]
 
-          if @#{current_authentication_method}&.blocked?
-            session.delete(:#{authentication_model_name}_id)
-            @#{current_authentication_method} = nil
-          end
-
-          @#{current_authentication_method}
-        RUBY
+        replacement = blocked_session_block
+                      .map do |line|
+                        line.empty? ? line : "#{indentation}#{line}"
+                      end
+                      .join("\n")
 
         gsub_file(
           controller_path,
-          current_user_assignment,
+          /^#{Regexp.escape(indentation)}#{Regexp.escape(current_user_assignment)}$/,
           replacement
         )
       end
@@ -307,14 +383,52 @@ module B4um
 
         controller = File.read(full_controller_path)
 
-        return if controller.include?(
-          "if #{authentication_model_name}.blocked?"
-        )
-
         session_assignment =
           "session[:#{authentication_model_name}_id] = " \
           "#{authentication_model_name}.id"
 
+        login_redirect =
+          'redirect_to root_path, notice: "Successfully logged in."'
+
+        if behavior == :revoke
+          blocked_login_pattern = /
+            ^(?<indent>[ \t]*)if\ #{Regexp.escape(authentication_model_name)}\.blocked\?\n
+            ^\k<indent>\ \ flash\.now\[:alert\]\ =\ "Account\ is\ blocked\."\n
+            ^\k<indent>\ \ render\ :new,\ status:\ :unprocessable_content\n
+            ^\k<indent>else\n
+            ^\k<indent>\ \ #{Regexp.escape(session_assignment)}\n
+            \n
+            ^\k<indent>\ \ #{Regexp.escape(login_redirect)}\n
+            ^\k<indent>end$
+          /x
+
+          match = controller.match(blocked_login_pattern)
+
+          return unless match
+
+          indentation = match[:indent]
+
+          replacement = [
+            "#{indentation}#{session_assignment}",
+            "",
+            "#{indentation}#{login_redirect}"
+          ].join("\n")
+
+          File.write(
+            full_controller_path,
+            controller.sub(
+              blocked_login_pattern,
+              replacement
+            )
+          )
+
+          return
+        end
+
+        return if controller.include?(
+          "if #{authentication_model_name}.blocked?"
+        )
+
         session_match = controller.match(
           /^(\s*)#{Regexp.escape(session_assignment)}$/
         )
@@ -342,9 +456,6 @@ module B4um
           replacement
         )
 
-        login_redirect =
-          'redirect_to root_path, notice: "Successfully logged in."'
-
         controller = File.read(full_controller_path)
 
         redirect_match = controller.match(