turbo_turbo 0.2.0

data/lib/generators/turbo_turbo/templates/turbo_turbo/modal_controller.js

@@ -0,0 +1,114 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Connects to data-controller="turbo-turbo--modal"
+export default class extends Controller {
+  static targets = [ "background", "modalBackdrop", "title", "subtitle", "body", "modal", "footer", "form", "submitButton", "cancelButton" ]
+
+  connect() {
+    this.modalTarget.addEventListener('click', this.stopClickPropagation);
+  }
+
+  appendSubmitAndCancelButtons() {
+    if (this.hasSubmitButtonTarget) {
+      return;
+    }
+    this.footerTarget.appendChild(this.generateSubmitButton(this.dataset?.submitText || "Submit"));
+    this.footerTarget.prepend(this.generateCancelButton(this.dataset?.cancelText || "Cancel"));
+  }
+
+  submitForm() {
+    this.formTarget.requestSubmit();
+  }
+
+  disconnect() {
+    this.modalTarget.removeEventListener('click', this.stopClickPropagation);
+  }
+
+  stopClickPropagation(event) {
+    event.stopPropagation();
+  }
+
+  closeOnSuccess(){
+    if (event.detail.success)
+      this.closeModal()
+  }
+
+  async setRemoteSource() {
+    event.preventDefault()
+    const url = event.currentTarget.dataset.url;
+    const title = event.currentTarget.dataset.title
+    const subtitle = event.currentTarget.dataset.subtitle || ""
+    const response = await fetch(url, {
+      headers: { "Accept": "text/vnd.turbo-stream.html" }
+    });
+
+    const text = await response.text();
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(text, "text/html");
+    const stream = doc.querySelector("turbo-stream");
+    if (title) {
+      this.titleTarget.innerText = title;
+    } else {
+      document.getElementById("modal_title_bar_turbo_turbo").classList.add("hidden")
+    }
+    this.subtitleTarget.innerText = subtitle;
+    this.bodyTarget.innerHTML = stream.querySelector("template").innerHTML;
+    if (this.hasFormTarget) {
+      this.appendSubmitAndCancelButtons();
+    }
+  }
+
+  open() {
+    this.backgroundTarget.classList.add("show");
+    document.getElementById("modal_title_bar_turbo_turbo").classList.remove("hidden")
+    this.backgroundTarget.addEventListener('transitionend', () => {
+       this.modalBackdropTarget.classList.add("show");
+    }, { once: true });
+    document.body.classList.add("overflow-hidden")
+  }
+
+  close() {
+    if (!event.target.closest('.Modal-turbo-turbo')) {
+      this.closeModal()
+    }
+  }
+
+  closeModal(){
+    event.preventDefault()
+    document.body.classList.remove("overflow-hidden")
+    this.modalBackdropTarget.classList.remove("show");
+    this.modalBackdropTarget.addEventListener('transitionend', () => {
+      this.backgroundTarget.classList.remove("show");
+      this.titleTarget.innerText = "";
+      this.subtitleTarget.innerText = "";
+      this.bodyTarget.innerHTML = "";
+      if (this.hasSubmitButtonTarget) {
+        this.submitButtonTarget.remove();
+      }
+      if (this.hasCancelButtonTarget) {
+        this.cancelButtonTarget.remove();
+      }
+    }, { once: true });
+  }
+
+  generateCancelButton(cancelText){
+    const button = document.createElement("button");
+    button.classList.add("font-semibold", "leading-6", "text-gray-900");
+    button.setAttribute("data-action", "turbo-turbo--modal#closeModal");
+    button.setAttribute("data-turbo-turbo--modal-target", "cancelButton");
+    button.textContent = cancelText
+
+    return button
+  }
+
+  generateSubmitButton(submitText){
+    const button = document.createElement("button");
+    button.classList.add("rounded-md", "bg-primary-600", "px-3", "py-2", "text-sm", "font-semibold", "text-white", "shadow-sm", "hover:bg-primary-500", "focus-visible:outline", "focus-visible:outline-2", "focus-visible:outline-offset-2", "focus-visible:outline-primary-600");
+    button.setAttribute("data-action", "turbo-turbo--modal#submitForm");
+    button.setAttribute("data-turbo-turbo--modal-target", "submitButton");
+    button.textContent = submitText
+
+    return button
+  }
+}
+

data/lib/generators/turbo_turbo/views_generator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module TurboTurbo
+  module Generators
+    class ViewsGenerator < Rails::Generators::Base
+      desc "Copy TurboTurbo views for customization"
+      source_root File.expand_path("../../..", __dir__)
+
+      def copy_view_components
+        empty_directory "app/components/turbo_turbo"
+        empty_directory "app/components/turbo_turbo/alerts"
+        copy_file "app/components/turbo_turbo/alerts/alert_component.rb",
+                  "app/components/turbo_turbo/alerts/alert_component.rb"
+        copy_file "app/components/turbo_turbo/alerts/success_component.rb",
+                  "app/components/turbo_turbo/alerts/success_component.rb"
+        copy_file "app/components/turbo_turbo/alerts/error_component.rb",
+                  "app/components/turbo_turbo/alerts/error_component.rb"
+        copy_file "app/components/turbo_turbo/alerts/info_component.rb",
+                  "app/components/turbo_turbo/alerts/info_component.rb"
+        copy_file "app/components/turbo_turbo/alerts/warning_component.rb",
+                  "app/components/turbo_turbo/alerts/warning_component.rb"
+        copy_file "app/components/turbo_turbo/modal_component.rb", "app/components/turbo_turbo/modal_component.rb"
+        copy_file "app/components/turbo_turbo/modal_footer_component.rb",
+                  "app/components/turbo_turbo/modal_footer_component.rb"
+      end
+
+      def copy_view_templates
+        copy_file "app/components/turbo_turbo/alerts/alert_component.html.erb",
+                  "app/components/turbo_turbo/alerts/alert_component.html.erb"
+        copy_file "app/components/turbo_turbo/alerts/success_component.html.erb",
+                  "app/components/turbo_turbo/alerts/success_component.html.erb"
+        copy_file "app/components/turbo_turbo/alerts/error_component.html.erb",
+                  "app/components/turbo_turbo/alerts/error_component.html.erb"
+        copy_file "app/components/turbo_turbo/alerts/info_component.html.erb",
+                  "app/components/turbo_turbo/alerts/info_component.html.erb"
+        copy_file "app/components/turbo_turbo/alerts/warning_component.html.erb",
+                  "app/components/turbo_turbo/alerts/warning_component.html.erb"
+        copy_file "app/components/turbo_turbo/modal_component.html.erb",
+                  "app/components/turbo_turbo/modal_component.html.erb"
+        copy_file "app/components/turbo_turbo/modal_footer_component.html.erb",
+                  "app/components/turbo_turbo/modal_footer_component.html.erb"
+      end
+
+      def display_instructions
+        say "\n\nTurboTurbo views have been copied for customization!", :green
+        say "\nThe following files have been copied to your application:"
+        say "• Alert ViewComponents (turbo_turbo/alerts/)"
+        say "• Modal ViewComponents (turbo_turbo/)"
+        say "• All component templates (.html.erb)"
+        say "\nYou can now customize these components as needed."
+        say "Note: Components in your app/ directory will override the gem versions."
+      end
+    end
+  end
+end

data/lib/turbo_turbo/controller_helpers.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module TurboTurbo
+  module ControllerHelpers
+    extend ActiveSupport::Concern
+    include StandardActions
+    include FormHelper
+
+    included do
+      # Configuration for turbo response action groups
+      mattr_accessor :turbo_response_actions, default: {
+        prepend: %w[create],
+        replace: %w[update email_modal],
+        remove: %w[destroy archive restore toggle_resolved]
+      }
+
+      mattr_accessor :error_response_actions, default: {
+        validation_errors: %w[create update upload],
+        flash_errors: %w[destroy archive restore]
+      }
+    end
+
+    # ========================================
+    # Main Response Methods
+    # ========================================
+
+    def process_turbo_response(object, event, flash_naming_attribute: nil)
+      if event
+        turbo_success_response(object, flash_naming_attribute)
+      else
+        turbo_error_response(object, flash_naming_attribute)
+      end
+    end
+
+    def turbo_success_response(object, flash_naming_attribute)
+      render turbo_stream: [
+        turbo_behavior_for_success(object),
+        replace_turbo_flashes(flash_reference(object, flash_naming_attribute))
+      ].compact_blank
+    end
+
+    def turbo_error_response(object, flash_naming_attribute = nil)
+      if validation_error_action?
+        render turbo_stream: turbo_stream.update(
+          :error_message_turbo_turbo,
+          partial: "turbo_turbo/error_message",
+          locals: { message: validation_error_messages(object) }
+        ), status: :unprocessable_entity
+      elsif flash_error_action?
+        render turbo_stream: turbo_stream.replace(
+          :flashes_turbo_turbo,
+          partial: "turbo_turbo/flashes",
+          locals: { flash: turbo_flash_error_message(flash_reference(object, flash_naming_attribute)) }
+        )
+      end
+    end
+
+    def render_turbo_modal(locals = default_locals, partial = default_partial)
+      render turbo_stream: turbo_stream.update(:modal_body, partial:, locals:)
+    end
+
+    # ========================================
+    # Turbo Stream Behavior Methods
+    # ========================================
+
+    def turbo_behavior_for_success(object, partial: default_partial)
+      if prepend_action?
+        turbo_stream.prepend(:search_results, partial:, locals: { "#{default_object_key}": object })
+      elsif replace_action?
+        turbo_stream.replace(object, partial:, locals: { "#{default_object_key}": object })
+      elsif remove_action?
+        turbo_stream.remove(object)
+      end
+    end
+
+    # ========================================
+    # Flash Message Methods (I18n-ready)
+    # ========================================
+
+    def replace_turbo_flashes(flash_reference)
+      turbo_stream.replace(:flashes_turbo_turbo, partial: "turbo_turbo/flashes",
+                                                 locals: { flash: turbo_flash_success_message(flash_reference) })
+    end
+
+    def turbo_flash_error_message(flash_reference)
+      action_verb = action_name == "destroy" ? "delete" : action_name
+
+      { error: I18n.t("turbo_turbo.flash.error.default",
+                      action: action_verb,
+                      resource: flash_reference,
+                      default: "We encountered an error trying to %<action>s %<resource>s.") }
+    end
+
+    def turbo_flash_success_message(flash_reference)
+      message = I18n.t("turbo_turbo.flash.success.#{action_name}",
+                       resource: flash_reference,
+                       action: action_name,
+                       default: I18n.t("turbo_turbo.flash.success.default",
+                                       resource: flash_reference,
+                                       action: action_name,
+                                       default: "#{flash_reference} #{action_name}d!"))
+
+      { success: message }
+    end
+
+    def validation_error_messages(object)
+      bulleted_errors = object.errors.full_messages.map { |e| "<li class='text-red-700'>#{e}</li>" }.join
+      "<ul>#{bulleted_errors}</ul>"
+    end
+
+    # ========================================
+    # Action Group Helper Methods
+    # ========================================
+
+    def prepend_action?
+      turbo_response_actions[:prepend].include?(action_name)
+    end
+
+    def replace_action?
+      turbo_response_actions[:replace].include?(action_name)
+    end
+
+    def remove_action?
+      turbo_response_actions[:remove].include?(action_name)
+    end
+
+    def validation_error_action?
+      error_response_actions[:validation_errors].include?(action_name)
+    end
+
+    def flash_error_action?
+      error_response_actions[:flash_errors].include?(action_name)
+    end
+
+    # ========================================
+    # Utility/Helper Methods
+    # ========================================
+
+    def flash_reference(object, flash_naming_attribute)
+      flash_naming_attribute ? object.send(flash_naming_attribute).titleize : object.class.name.titleize
+    end
+
+    def default_partial
+      action = %w[create update].include?(action_name) ? controller_name.singularize : action_name
+      "#{controller_path}/#{action}"
+    end
+
+    def default_locals
+      key = default_object_key
+      { "#{key}": send(key) }
+    end
+
+    def default_object_key
+      controller_name.singularize.to_sym
+    end
+  end
+end

data/lib/turbo_turbo/engine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module TurboTurbo
+  class Engine < ::Rails::Engine
+    isolate_namespace TurboTurbo
+
+    initializer "turbo_turbo.setup" do |_app|
+      ActiveSupport.on_load(:action_controller_base) do
+        include TurboTurbo::ControllerHelpers
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        include TurboTurbo::FormHelper
+      end
+    end
+  end
+end

data/lib/turbo_turbo/form_helper.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module TurboTurbo
+  # FormHelper provides a standardized way to create turbo-enabled modal forms
+  # that integrate seamlessly with the TurboTurbo modal system.
+  #
+  # == Basic Usage
+  #
+  # Instead of writing:
+  #   = 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|
+  #     .ModalContent-turbo-turbo
+  #       #error_message_turbo_turbo
+  #       [user-specific fields here]
+  #
+  # You can now write:
+  #   <%= turbo_form_for(service_provider, url: [:admin, service_provider]) do |form| %>
+  #     <!-- just the form fields -->
+  #   <% end %>
+  #
+  # == Form Builder Support
+  #
+  # The helper supports multiple form builders:
+  #   - SimpleForm (default): turbo_form_for(object, builder: :simple_form)
+  #   - Rails form_with: turbo_form_for(object, builder: :form_with)
+  #   - Rails form_for: turbo_form_for(object, builder: :form_for)
+  #
+  # == Customization Options
+  #
+  #   turbo_form_for(object,
+  #     url: custom_path,
+  #     builder: :form_with,              # Form builder to use
+  #     data: { custom_attr: "value" }    # Additional data attributes
+  #   )
+  #
+  module FormHelper
+    extend ActiveSupport::Concern
+
+    # Main method for creating turbo-enabled modal forms
+    #
+    # @param object [ActiveRecord::Base] The object for the form
+    # @param options [Hash] Form options including url, method, etc.
+    # @option options [Symbol] :builder (:simple_form) Form builder to use (:simple_form, :form_with, :form_for)
+    # @option options [String] :url The form submission URL
+    # @option options [Symbol] :method HTTP method for the form
+    # @option options [Hash] :data Additional data attributes to merge
+    # @option options [Hash] :html Additional HTML attributes for the form
+    # @yield [form] Form builder object
+    def turbo_form_for(object, options = {}, &)
+      # Extract and set defaults
+      builder_type = options.delete(:builder) || :simple_form
+
+      # Build default data attributes for turbo modal integration
+      default_data = {
+        turbo_turbo__modal_target: "form"
+      }
+
+      # Add auto-close action if enabled
+      default_data[:action] = "turbo:submit-end->turbo-turbo--modal#closeOnSuccess"
+
+      # Merge user-provided data attributes
+      user_data = options.delete(:data) || {}
+      merged_data = default_data.merge(user_data)
+
+      # Set up form options
+      form_options = options.merge(data: merged_data)
+
+      # Ensure URL is set if not provided
+      unless form_options[:url]
+        if object.respond_to?(:persisted?) && object.persisted?
+          form_options[:url] = object
+        else
+          # Try to infer URL from object class
+          object.class.model_name
+          form_options[:url] = [:admin, object] if defined?(controller) && controller.class.name.include?("Admin")
+        end
+      end
+
+      # Generate the form based on builder type
+      form_html = case builder_type
+                  when :simple_form
+                    build_simple_form(object, form_options, &)
+                  when :form_with
+                    build_form_with(object, form_options, &)
+                  when :form_for
+                    build_form_for(object, form_options, &)
+                  else
+                    raise ArgumentError,
+                          "Unknown form builder: #{builder_type}. Supported builders: :simple_form, :form_with, :form_for"
+                  end
+
+      # Wrap the form in modal content structure
+      content_tag(:div, class: "ModalContent-turbo-turbo") do
+        concat content_tag(:div, "", id: "error_message_turbo_turbo")
+        concat form_html
+      end
+    end
+
+    # Convenience method for SimpleForm (most common case)
+    def turbo_simple_form_for(object, options = {}, &)
+      turbo_form_for(object, options.merge(builder: :simple_form), &)
+    end
+
+    # Convenience method for Rails form_with
+    def turbo_form_with(model:, **options, &)
+      turbo_form_for(model, options.merge(builder: :form_with), &)
+    end
+
+    private
+
+    def build_simple_form(object, options, &)
+      unless defined?(SimpleForm) && respond_to?(:simple_form_for)
+        raise "SimpleForm is not available. Install the simple_form gem or use a different builder."
+      end
+
+      simple_form_for(object, options, &)
+    end
+
+    def build_form_with(object, options, &)
+      # Convert object-based options to form_with format
+      form_with_options = options.dup
+      form_with_options[:model] = object
+      form_with_options.delete(:url) if form_with_options[:url] == object
+
+      form_with(**form_with_options, &)
+    end
+
+    def build_form_for(object, options, &)
+      form_for(object, options, &)
+    end
+  end
+end

data/lib/turbo_turbo/parameter_sanitizer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module TurboTurbo
+  module ParameterSanitizer
+    extend ActiveSupport::Concern
+
+    # Sanitizes parameters based on the model schema
+    # Converts boolean fields and trims string inputs
+    #
+    # Usage:
+    #   params.require(:user).permit(:name, :active).sanitize_for_model(:user)
+    #
+    # @param model_key [Symbol] The key to deduce the model from (e.g., :user for User model)
+    # @return [ActionController::Parameters] The sanitized parameters
+    def sanitize_for_model(model_key)
+      model = model_from_key(model_key)
+      convert_boolean_params(model)
+      trim_input_strings
+      self
+    end
+
+    private
+
+    # Converts string boolean values to actual booleans based on model schema
+    def convert_boolean_params(model)
+      boolean_columns = columns_for(model, [:boolean])
+      each { |k, v| self[k] = convert_to_boolean(v) if boolean_columns.include?(k.to_s) }
+    end
+
+    # Trims whitespace from strings and cleans arrays
+    def trim_input_strings
+      each do |k, v|
+        if v.is_a?(Array)
+          self[k] = v.map { |item| item.is_a?(String) ? item.strip : item }.select(&:present?)
+        elsif v.is_a?(String)
+          self[k] = v.strip
+        end
+      end
+    end
+
+    # Gets columns of specified types from the model
+    def columns_for(model, types)
+      model.columns_hash.select { |_, column| types.include?(column.type) }.keys
+    end
+
+    # Deduces the model class from a symbol key
+    def model_from_key(key)
+      model_name = key.to_s.classify.safe_constantize
+      raise ArgumentError, "Model could not be deduced from symbol (#{key})" unless model_name
+
+      model_name
+    end
+
+    # Converts string boolean values to actual booleans
+    def convert_to_boolean(field)
+      case field
+      when "false", "0"
+        false
+      when "true", "1"
+        true
+      else
+        field
+      end
+    end
+  end
+end
+
+# Extend ActionController::Parameters with the sanitization methods
+ActionController::Parameters.include(TurboTurbo::ParameterSanitizer)

data/lib/turbo_turbo/standard_actions.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module TurboTurbo
+  module StandardActions
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # DSL method to automatically generate standard CRUD actions
+      #
+      # Usage:
+      #   class MessagesController < ApplicationController
+      #     turbo_actions :create, :update, :destroy
+      #
+      #     private
+      #
+      #     def message_params
+      #       params.require(:message).permit(:content, :title)
+      #     end
+      #   end
+      def turbo_actions(*actions)
+        actions.each do |action|
+          unless %i[
+            create update destroy show new edit
+          ].include?(action)
+            raise ArgumentError,
+                  "Unknown action: #{action}. Supported actions: :create, :update, :destroy, :show, :new, :edit"
+          end
+
+          send(:"define_turbo_#{action}_action")
+        end
+      end
+
+      private
+
+      def define_turbo_create_action
+        define_method :create do
+          model_instance = model_class.new(create_params)
+          process_turbo_response(model_instance, model_instance.save)
+        end
+      end
+
+      def define_turbo_update_action
+        define_method :update do
+          process_turbo_response(model_instance, model_instance.update(send(model_params_method)))
+        end
+      end
+
+      def define_turbo_destroy_action
+        define_method :destroy do
+          process_turbo_response(model_instance, model_instance.destroy)
+        end
+      end
+
+      %i[show new edit].each do |action|
+        define_method :"define_turbo_#{action}_action" do
+          define_method action do
+            render_turbo_modal({ model_name: send("model_instance_for_#{action}") })
+          end
+        end
+      end
+    end
+
+    # Instance methods - can be overridden in controllers
+    def create_params
+      send(model_params_method)
+    end
+
+    def model_params_method
+      "#{model_name}_params"
+    end
+
+    def model_instance_for_show
+      model_instance
+    end
+
+    def model_instance_for_edit
+      model_instance
+    end
+
+    def model_instance_for_new
+      model_class.new
+    end
+
+    def model_instance
+      model_class.find(params[:id])
+    end
+
+    def model_class
+      self.class.controller_name.classify.constantize
+    end
+
+    def model_name
+      self.class.controller_name.singularize
+    end
+  end
+end