turbo_turbo 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54f42ce2e6f7ed159b2d7aec601352045eecc86b5619f528fc85c8e091f47d76
+  data.tar.gz: ea4af57484afb31fe80efc194f48db5104b8edd487378244848799ef7a30542e
+SHA512:
+  metadata.gz: '08e33ca5a2884173f62eaad731be0a9a0db1f95e7478ceb22c5dbaf008ef929b6070e91e75009176e3a932196e9394985a476edecd65bca587f9c44c79a7a1f7'
+  data.tar.gz: 80fcff79f36604c58899de2433d3b88315565b4b4f081c446c56f698c37235d1554a2296b99495c82b6fb1965f173b287301c019037586ac1554a02df554f9fb

data/.claude/settings.local.json

@@ -0,0 +1,14 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git tag:*)",
+      "Bash(gem build:*)",
+      "Bash(gem push:*)",
+      "Bash(mv:*)",
+      "Bash(ls:*)",
+      "Bash(bundle exec:*)",
+      "Bash(git add:*)"
+    ],
+    "deny": []
+  }
+}

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,96 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.3.6
+  Exclude:
+    - 'bin/**/*'
+    - 'log/**/*'
+    - 'tmp/**/*'
+    - 'vendor/**/*'
+    - 'node_modules/**/*'
+
+# Exclude generator files from complex metrics since they are one-time setup code
+Metrics/ClassLength:
+  Exclude:
+    - 'lib/generators/**/*'
+    - 'spec/**/*'
+
+Metrics/MethodLength:
+  Exclude:
+    - 'lib/generators/**/*'
+    - 'spec/**/*'
+    - 'lib/turbo_turbo/form_helper.rb'
+    - 'lib/turbo_turbo/controller_helpers.rb'
+
+Metrics/AbcSize:
+  Exclude:
+    - 'lib/generators/**/*'
+    - 'spec/**/*'
+    - 'lib/turbo_turbo/form_helper.rb'
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - 'lib/generators/**/*'
+    - 'spec/**/*'
+    - 'lib/turbo_turbo/form_helper.rb'
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    - 'lib/generators/**/*'
+    - 'spec/**/*'
+    - 'lib/turbo_turbo/form_helper.rb'
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+    - '*.gemspec'
+    - 'lib/turbo_turbo/standard_actions.rb'
+
+Metrics/ModuleLength:
+  Exclude:
+    - 'spec/**/*'
+    - 'lib/turbo_turbo/controller_helpers.rb'
+
+Layout/LineLength:
+  Max: 120
+  Exclude:
+    - 'lib/generators/**/*'
+    - 'spec/**/*'
+    - 'lib/turbo_turbo/form_helper.rb'
+
+# ViewComponent `initialize` methods don't need to call super
+# This is a false positive - ViewComponent handles initialization differently
+Lint/MissingSuper:
+  Exclude:
+    - 'app/components/**/*'
+
+# Allow constants in blocks for specs
+Lint/ConstantDefinitionInBlock:
+  Exclude:
+    - 'spec/**/*'
+
+# Specs can use predicate methods without ?
+Naming/PredicateMethod:
+  Exclude:
+    - 'spec/**/*'
+
+# Allow getter/setter methods in specs
+Naming/AccessorMethodName:
+  Exclude:
+    - 'spec/**/*'
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+# Allow boolean parameters in specs
+Style/OptionalBooleanParameter:
+  Exclude:
+    - 'spec/**/*'
+
+# Allow string concatenation in specs
+Style/StringConcatenation:
+  Exclude:
+    - 'spec/**/*'
+
+# Documentation is handled in README for this gem
+Style/Documentation:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2025-01-23
+
+### Fixed
+- Renamed routes file from `turbo_turbo.rb` to `turbo_turbo_routes.rb` to prevent loading issues
+- Updated install generator to use the new routes filename
+- Fixed routes configuration to use `draw(:turbo_turbo_routes)` instead of `draw(:turbo_turbo)`
+
+### Added
+- Routes spec to ensure routes file loads properly
+
+## [0.1.0] - 2025-01-15
+
+### Added
+- Initial release of TurboTurbo gem
+- Controller helpers for standardized Turbo Stream responses
+- Modal management system with JavaScript controller
+- Flash message handling with auto-dismiss functionality
+- ViewComponent alert components (Success, Error, Warning, Info, Alert)
+- Rails generator for easy installation with automatic configuration
+- Complete test suite with RSpec
+- Comprehensive documentation and usage examples
+- Enhanced install generator with automatic ApplicationController setup
+- Automatic CSS import handling
+- Custom layout generator for multi-layout applications
+- Form helper for standardized modal forms with builder support
+- Parameter sanitization with `sanitize_for_model` method
+- `turbo_actions` DSL for convention-based CRUD operations
+- Test helpers for system and integration testing
+
+### Features
+- `process_turbo_response` for handling CRUD operations
+- `render_turbo_modal` for modal workflows
+- `turbo_success_response` and `turbo_error_response` for custom responses
+- `turbo_form_for` form helper with SimpleForm, form_with, and form_for support
+- `turbo_actions` DSL supporting :create, :update, :destroy, :show, :new, :edit
+- Automatic flash message generation with proper grammar and I18n support
+- Modal controller with remote content loading
+- Flash controller with fade-out animations
+- Parameter sanitization with boolean conversion and string trimming
+- Smart install generator that configures ApplicationController and imports CSS
+- Rails 7+ compatibility
+- Turbo-rails integration
+- ViewComponent integration

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dan Brown
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,498 @@
+# TurboTurbo
+
+A simplified DSL for responding in common ways to common controller actions so you can write as little code in CRUD routes as possible. TurboTurbo provides a set of controller helpers that streamline Turbo Stream responses, modal management, and flash message handling in Rails applications.
+
+## Features
+
+- **Convention-based DSL** - Eliminate CRUD boilerplate with `turbo_actions :create, :update, :destroy`
+- **Modal form abstraction** - Transform 10+ lines of form boilerplate into 3 lines
+- **Smart parameter sanitization** - Automatic boolean conversion and string trimming with `sanitize_for_model`
+- **Simplified Turbo Stream responses** - Standardized patterns for all CRUD operations
+- **Modal management** - Complete modal system with namespaced Stimulus controllers
+- **Flash message handling** - Automatic flash message generation with I18n support
+- **ViewComponent integration** - Pre-built alert and modal components
+- **Configurable action groups** - Customize Turbo Stream behaviors by action type
+- **Rails 7+ compatible** - Built for modern Rails applications
+- **Zero dependencies** - No external template engines or SVG processors required
+- **Test helpers included** - Built-in helpers for system/integration testing
+
+## Quick Start
+
+### 1. Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'turbo_turbo'
+```
+
+And then execute:
+
+```bash
+bundle install
+rails generate turbo_turbo:install
+```
+
+**⚠️ Important: Restart your Rails server after installation for the gem's helpers to be available.**
+
+### 2. Start using the DSL
+
+```ruby
+class MessagesController < ApplicationController
+  turbo_actions :create, :update, :destroy, :show, :new, :edit
+
+  private
+
+  def message_params
+    params.require(:message)
+          .permit(:content, :title)
+          .sanitize_for_model(:message)
+  end
+end
+```
+
+## What the Installer Does
+
+The installer automatically:
+- **Copies namespaced JavaScript controllers** to `app/javascript/controllers/turbo_turbo/`
+- **Registers controllers** (`turbo-turbo--modal`, `turbo-turbo--flash`) in Stimulus index.js
+- **Configures ApplicationController** with `TurboTurbo::ControllerHelpers` and flash types
+- **Copies TurboTurbo CSS** to `app/assets/stylesheets/turbo_turbo/` (includes component CSS files and base.css, which just imports the component CSS files)
+- **Imports TurboTurbo CSS** into your main stylesheet
+- **Copies layout partials** for modal background and flashes to `app/views/turbo_turbo/`
+- **Intelligently modifies your layout file** to include required components
+- **ViewComponents work directly from the gem** (no copying required)
+
+### Automatic Layout Setup
+
+The installer automatically modifies your `app/views/layouts/application.html.erb` or `application.html.slim` to:
+
+✅ **Add `turbo-turbo--modal` controller** to existing `data-controller` attribute, or create it if missing  
+✅ **Insert flash messages render** after the body tag  
+✅ **Insert modal background render** after flashes  
+✅ **Append TurboTurbo::ModalComponent** at the end of the body  
+✅ **Configure ApplicationController** with TurboTurbo helpers and flash types  
+✅ **Copy TurboTurbo CSS** to `app/assets/stylesheets/turbo_turbo/` (all CSS files)
+✅ **Import TurboTurbo CSS** into your main stylesheet  
+
+**Before:**
+```erb
+<body data-controller="navigation search">
+  <%= yield %>
+</body>
+```
+
+**After installation:**
+```erb
+<body data-controller="navigation search turbo-turbo--modal">
+  <%= render 'turbo_turbo/flashes' %>
+  <%= render 'turbo_turbo/modal_background' %>
+  <%= yield %>
+  <%= render TurboTurbo::ModalComponent.new %>
+</body>
+```
+
+### Custom Layout Installation
+
+For custom layouts (admin, dashboard, etc.):
+
+```bash
+# Basic usage - adds all components to admin layout
+rails generate turbo_turbo:layout admin
+
+# Skip flash-related components only
+rails generate turbo_turbo:layout admin --skip-flash
+
+# Skip modal-related components only  
+rails generate turbo_turbo:layout admin --skip-modal
+
+# Skip everything - prints warning and exits
+rails generate turbo_turbo:layout admin --skip-flash --skip-modal
+```
+
+## Core Features
+
+### 1. Convention-Based DSL
+
+**Before (traditional approach):**
+```ruby
+class MessagesController < ApplicationController
+  def create
+    @message = Message.new(message_params)
+    process_turbo_response(@message, @message.save)
+  end
+
+  def update
+    @message = Message.find(params[:id])
+    process_turbo_response(@message, @message.update(message_params))
+  end
+
+  def destroy
+    @message = Message.find(params[:id])
+    process_turbo_response(@message, @message.destroy)
+  end
+
+  # ... more CRUD actions
+end
+```
+
+**After (with TurboTurbo DSL):**
+```ruby
+class MessagesController < ApplicationController
+  turbo_actions :create, :update, :destroy, :show, :new, :edit
+
+  private
+
+  def message_params
+    params.require(:message).permit(:content, :title)
+  end
+end
+```
+
+**Supported Actions:**
+- `:create` - Creates new model instance and calls `process_turbo_response`
+- `:update` - Finds and updates model instance
+- `:destroy` - Finds and destroys model instance  
+- `:show` - Finds model instance and renders modal
+- `:new` - Creates new model instance and renders modal
+- `:edit` - Finds model instance and renders modal
+
+**Requirements:**
+- Controller must follow Rails naming conventions (`MessagesController` → `Message` model)
+- Must define a params method (e.g., `message_params`)
+- Works with any model that responds to `save`, `update`, and `destroy`
+
+**Advanced Customization:**
+```ruby
+class MessagesController < ApplicationController
+  turbo_actions :create, :update, :destroy
+
+  private
+
+  # Custom params for create vs update
+  def create_params
+    params.require(:message).permit(:content, :title, :author_id)
+  end
+
+  def message_params
+    params.require(:message).permit(:content, :title)
+  end
+
+  # Custom eager loading per action
+  def model_instance_for_show
+    Message.includes(:author, :comments).find(params[:id])
+  end
+end
+```
+
+### 2. Modal Form Abstraction
+
+**Before (what you had to write):**
+```erb
+<%= simple_form_for service_provider, url: [:admin, service_provider], 
+    data: { 
+      turbo_turbo__modal_target: "form", 
+      action: "turbo:submit-end->turbo-turbo--modal#closeOnSuccess" 
+    } do |form| %>
+  <div class="ModalContent-turbo-turbo">
+    <div id="error_message_turbo_turbo"></div>
+    <!-- your form fields -->
+  </div>
+<% end %>
+```
+
+**After (with TurboTurbo form helper):**
+```erb
+<%= turbo_form_for(service_provider, url: [:admin, service_provider]) do |form| %>
+  <!-- just your form fields -->
+<% end %>
+```
+
+**Form Builder Support:**
+```erb
+<!-- SimpleForm (default) -->
+<%= turbo_form_for(object) do |form| %>
+  <%= form.input :name %>
+<% end %>
+
+<!-- Rails form_with -->
+<%= turbo_form_for(object, builder: :form_with) do |form| %>
+  <%= form.text_field :name %>
+<% end %>
+
+<!-- Rails form_for -->
+<%= turbo_form_for(object, builder: :form_for) do |form| %>
+  <%= form.text_field :name %>
+<% end %>
+```
+
+**Customization Options:**
+```erb
+<%= turbo_form_for(object,
+    url: custom_path,                        # Custom form URL
+    data: { custom: "attribute" }            # Additional data attributes
+) do |form| %>
+  <!-- fields -->
+<% end %>
+```
+
+**The form helper automatically:**
+- Wraps your form in the proper modal structure
+- Sets up Turbo Stream integration for modal closing
+- Handles error message containers
+- Integrates with all major Rails form builders
+
+### 3. Parameter Sanitization
+
+TurboTurbo extends `ActionController::Parameters` with a powerful `sanitize_for_model` method that automatically:
+
+- **Converts boolean fields** from strings (\"true\"/\"false\", \"1\"/\"0\") to actual booleans based on your model schema
+- **Trims whitespace** from all string inputs
+- **Cleans arrays** by trimming strings and removing empty values
+
+```ruby
+class MessagesController < ApplicationController
+  private
+
+  def message_params
+    params.require(:message)
+          .permit(:title, :content, :active, :priority, tags: [])
+          .sanitize_for_model(:message)
+  end
+end
+```
+
+**Before sanitization:**
+```ruby
+params = {
+  title: "  My Message  ",
+  content: "  Hello world  ",
+  active: "true",           # String from HTML form
+  priority: "1",            # String from HTML form
+  tags: ["  ruby  ", "", "  rails  ", nil]
+}
+```
+
+**After sanitization:**
+```ruby
+{
+  title: "My Message",      # Trimmed
+  content: "Hello world",   # Trimmed
+  active: true,             # Converted to boolean
+  priority: true,           # Converted to boolean (if priority is boolean column)
+  tags: ["ruby", "rails"]   # Trimmed and cleaned
+}
+```
+
+The method is **model-aware** - it only converts fields that are actually boolean columns in your database schema, leaving other fields (like integer `priority`) unchanged.
+
+### 4. Modal Workflows
+
+Create modal forms that integrate seamlessly with Turbo:
+
+```erb
+<!-- Trigger modal with remote content -->
+<%= link_to "New Message",
+    new_message_path,
+    data: {
+      action: "turbo-turbo--modal#setRemoteSource",
+      url: new_message_path,
+      title: "Create New Message",
+      subtitle: "Fill out the form below"
+    },
+    class: "btn btn-primary" %>
+
+<!-- Modal will automatically open and load the form -->
+```
+
+For custom behavior, you can still use the helper methods directly:
+
+```ruby
+class MessagesController < ApplicationController
+  def create
+    message = Message.new(message_params)
+    process_turbo_response(message, message.save)
+  end
+
+  def update
+    message = Message.find(params[:id])
+    process_turbo_response(message, message.update(message_params))
+  end
+
+  def destroy
+    message = Message.find(params[:id])
+    process_turbo_response(message, message.destroy)
+  end
+end
+```
+
+## ViewComponents
+
+TurboTurbo includes several pre-built ViewComponents that work directly from the gem, all properly namespaced under the `TurboTurbo` module:
+
+### Modal Components
+
+**TurboTurbo::ModalComponent**
+- Main modal wrapper component
+- Options: `show_close: true/false` - Controls visibility of close button
+- Usage: `<%= render TurboTurbo::ModalComponent.new(show_close: true) %>`
+
+**TurboTurbo::ModalFooterComponent**
+- Modal footer with cancel button and content area
+- Options: `skip_close: true/false`, `close_label: "Custom Cancel Text"`
+- Usage: `<%= render TurboTurbo::ModalFooterComponent.new(close_label: "Close") { content } %>`
+
+### Alert Components
+
+TurboTurbo includes pre-styled alert components, all namespaced under `TurboTurbo::Alerts`:
+
+- `TurboTurbo::Alerts::SuccessComponent`
+- `TurboTurbo::Alerts::ErrorComponent`
+- `TurboTurbo::Alerts::WarningComponent`
+- `TurboTurbo::Alerts::InfoComponent`
+- `TurboTurbo::Alerts::AlertComponent` (base component)
+
+All alert components support:
+- Custom headers and messages
+- Array of messages for lists
+- Dismissible functionality
+- Consistent styling
+
+Example usage:
+```erb
+<%= render TurboTurbo::Alerts::SuccessComponent.new({ header: "Success!", message: "Operation completed" }) %>
+<%= render TurboTurbo::Alerts::ErrorComponent.new({ message: ["Error 1", "Error 2"] }) %>
+```
+
+## Customization
+
+### ViewComponents Customization
+
+To customize ViewComponents, copy them to your application:
+
+```bash
+rails generate turbo_turbo:views
+```
+
+This copies all ViewComponent classes and templates to your `app/components/turbo_turbo/` directory for customization. Components in your app directory will override the gem versions.
+
+### I18n Flash Messages
+
+TurboTurbo supports I18n for flash messages. Add to your locale files:
+
+```yaml
+# config/locales/en.yml
+en:
+  turbo_turbo:
+    flash:
+      success:
+        create: "%{resource} created successfully!"
+        destroy: "%{resource} deleted!"
+        archive: "%{resource} archived!"
+        # Add custom actions...
+      error:
+        default: "We encountered an error trying to %{action} %{resource}."
+```
+
+### Action Groups Configuration
+
+Customize which actions trigger different Turbo Stream behaviors:
+
+```ruby
+# In an initializer or controller
+TurboTurbo::ControllerHelpers.turbo_response_actions[:remove] << "archive"
+TurboTurbo::ControllerHelpers.error_response_actions[:validation_errors] << "upload"
+```
+
+Available action groups:
+- **turbo_response_actions**: `:prepend`, `:replace`, `:remove`
+- **error_response_actions**: `:validation_errors`, `:flash_errors`
+
+## Architecture
+
+### Namespacing
+
+TurboTurbo uses namespaced controllers and CSS to prevent conflicts:
+
+- **Stimulus Controllers**: `turbo-turbo--modal`, `turbo-turbo--flash` (installed to `app/javascript/controllers/turbo_turbo/`)
+- **CSS Files**: Served from gem at `turbo_turbo/*.css`
+- **ViewComponents**: All namespaced under `TurboTurbo::` and `TurboTurbo::Alerts::`
+- **Layout Partials**: Installed to `app/views/turbo_turbo/`
+- **No conflicts** with your existing controllers or styles
+
+### Component Architecture
+
+- **Modal Controller**: Added to body tag, manages global modal behavior
+- **Flash Controllers**: Added to individual flash messages for auto-fade and dismiss
+- **ViewComponents**: Served directly from gem, optionally copyable for customization
+- **CSS**: Served from gem asset pipeline, automatically imported
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+bundle install
+rspec
+```
+
+## Test Helpers
+
+TurboTurbo includes test helpers for system/integration testing:
+
+```ruby
+# In your system specs
+RSpec.describe "Modal functionality", type: :system, js: true do
+  include TurboTurbo::TestHelpers
+
+  it "creates a record via modal" do
+    visit some_path
+    
+    click_new_button("user")           # Clicks #new_user button
+    fill_in "Name", with: "John"
+    submit_modal                       # Submits TurboTurbo modal form
+    
+    expect(page).to have_content("John")
+    expect(modal_closed?).to be true
+  end
+  
+  it "edits a record via modal" do
+    user = create(:user)
+    visit users_path
+    
+    click_on_row_link(user, "edit")    # Clicks edit button in user's table row
+    fill_in "Name", with: "Jane"
+    submit_modal
+    
+    user.reload
+    expect(user.name).to eq("Jane")
+  end
+end
+```
+
+**Available Helpers:**
+- `submit_modal` - Submit a TurboTurbo modal form
+- `click_new_button(resource)` - Click new button for resource type
+- `click_on_row_link(resource, action, confirm: false)` - Click action link in table row
+- `close_modal` - Close modal and verify it's closed
+- `modal_open?` - Check if modal is currently open
+- `modal_closed?` - Check if modal is currently closed
+- `table_row(resource)` - Get DOM selector for resource's table row
+
+To install this gem onto your local machine:
+
+```bash
+bundle exec rake install
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]