crudable-rails 1.3 → 1.5.0

data/lib/crudable/rails/generators/turbo_forms_scaffold_extension.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'turbo_forms_generator_option'
+require_relative '../../../generators/crudable/controller_helpers'
+
+module Crudable
+  module Rails
+    module Generators
+      module TurboFormsScaffoldExtension
+        extend ActiveSupport::Concern
+
+        prepended do
+          include TurboFormsGeneratorOption
+          include ::Crudable::Generators::ControllerHelpers
+        end
+
+        def copy_view_files
+          super
+          return unless options.turbo_forms?
+
+          copy_turbo_forms_view_files
+        end
+
+        private
+
+        def copy_turbo_forms_view_files
+          view_path = File.join('app/views', controller_file_path)
+
+          template 'turbo_forms/_form.html.erb',
+                   File.join(view_path, '_form.html.erb'),
+                   force: true
+
+          %w[new edit].each do |view|
+            template "turbo_forms/#{view}.html.erb",
+                     File.join(view_path, "#{view}.html.erb"),
+                     force: true
+            template "turbo_forms/#{view}.turbo_stream.erb",
+                     File.join(view_path, "#{view}.turbo_stream.erb")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crudable/rails/installer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Crudable
+  module Rails
+    module Installer
+      CALLBACK_ACTIONS_FALSE =
+        /config\.action_controller\.raise_on_missing_callback_actions\s*=\s*false/
+
+      module_function
+
+      def postinstall(root: ::Rails.root)
+        environments_path = root.join('config/environments')
+        return [] unless environments_path.directory?
+
+        environments_path.glob('*.rb').filter_map do |file|
+          update_raise_on_missing_callback_actions(file)
+        end
+      end
+
+      def update_raise_on_missing_callback_actions(file)
+        contents = file.read
+        return unless contents.match?(CALLBACK_ACTIONS_FALSE)
+
+        updated_contents = contents.gsub(
+          CALLBACK_ACTIONS_FALSE,
+          'config.action_controller.raise_on_missing_callback_actions = true'
+        )
+        return if updated_contents == contents
+
+        file.write(updated_contents)
+        file.basename.to_s
+      end
+    end
+  end
+end

data/lib/crudable/rails/nestable.rb

@@ -7,20 +7,89 @@ module Crudable
       extend ActiveSupport::Concern
 
       included do
-        before_action :find_parent, only: %i[index new create]
+        before_action :find_parent
       end
 
       def find_parent
-        params.each do |name, value|
-          next unless name =~ /(.+)_id$/
-
-          object_name = Regexp.last_match(1)
-          object_scope = object_name.classify.constantize
-          object_scope = object_scope.friendly if friendly_finders?
-          instance_variable_set("@#{object_name}", object_scope.find(value))
-          self.class.send(:decorates_assigned, object_name.to_sym) if defined?(Draper)
+        return unless parent_present?
+
+        parent_scope = parent_class
+        parent_scope = parent_class.friendly if parent_friendly_finders?
+        instance_variable_set("@#{parent_var_name}", parent_scope.find(params[parent_id_param]))
+        self.class.send(:decorates_assigned, parent_var_name.to_sym) if defined?(Draper)
+      rescue ActiveRecord::RecordNotFound => e
+        # Only catch and render 404 if we're in a request context
+        # Check if we have a request object (indicates we're in a request context)
+        raise e unless respond_to?(:request, true) && !request.nil?
+
+        render_not_found
+        nil # Explicitly stop execution to prevent further action execution
+      end
+
+      def parent_id_param
+        return nil unless use_parent_as_scope?
+
+        # Prefer route/path params (ordered by the route definition) over merged params
+        # (which may include query params).
+        # If multiple *_id params exist (multi-level nesting), default to the deepest/last one.
+        @parent_id_param ||= begin
+          keys = parent_id_param_keys
+          keys.map(&:to_s).grep(/(.+)_id$/).last
         end
       end
+
+      def parent_class
+        @parent_class ||= parent_var_name.classify.constantize
+      end
+
+      def parent_var_name
+        @parent_var_name ||= parent_id_param.sub(/_id$/, '').underscore
+      end
+
+      def parent_present?
+        !parent_id_param.nil?
+      end
+
+      def parent_resource_association
+        return unless parent_present?
+
+        # Handle case where resource_class is a CollectionProxy (association proxy)
+        # Extract the actual class for comparison
+        actual_resource_class = if resource_class.is_a?(ActiveRecord::Associations::CollectionProxy)
+                                  resource_class.klass
+                                else
+                                  resource_class
+                                end
+
+        association = parent_class.reflect_on_all_associations.find { |assoc| assoc.klass == actual_resource_class }
+        association&.name
+      end
+
+      # By default, if friendly finders are enabled for the resource, we will also attempt to use
+      # friendly finders for the parent (when available).
+      #
+      # Override this in your controller if you want to force parent lookup to use (or not use)
+      # FriendlyId, independently of the resource.
+      def parent_friendly_finders?
+        return false unless defined?(FriendlyId)
+        return false unless parent_class.respond_to?(:friendly)
+
+        friendly_finders?
+      end
+
+      def use_parent_as_scope?
+        true
+      end
+
+      def parent_id_param_keys
+        return request.path_parameters.keys if request_path_parameters_present?
+
+        params&.keys || []
+      end
+
+      def request_path_parameters_present?
+        request.respond_to?(:path_parameters) && request.path_parameters.present?
+      end
     end
   end
 end

data/lib/crudable/rails/resourceable.rb

@@ -31,15 +31,41 @@ module Crudable
       def resource_namespace
         namespaces = self.class.name.split('::')
         namespaces.pop
-        namespaces.map { |n| n.downcase.to_sym }
+        namespaces.map { |n| n.underscore.to_sym }
       end
 
       def authorize_resource(method = action_name)
-        authorize resource_namespace + [authorizable_resource], "#{method}?".to_sym
+        return unless defined?(Pundit)
+        # Check if Pundit::Authorization is included (check class, ancestors, and respond_to)
+        return unless pundit_authorization_available?
+
+        authorize resource_namespace + [authorizable_resource], :"#{method}?"
       end
 
       def authorize_class_action(method = action_name)
-        authorize([*resource_namespace, resource_class], "#{method}?".to_sym)
+        return unless defined?(Pundit)
+        # Check if Pundit::Authorization is included (check class, ancestors, and respond_to)
+        return unless pundit_authorization_available?
+
+        authorize([*resource_namespace, resource_class], :"#{method}?")
+      end
+
+      def pundit_authorization_available?
+        return false unless defined?(Pundit)
+        return false unless defined?(Pundit::Authorization)
+        # Check if included in this class
+        return true if self.class.included_modules.include?(Pundit::Authorization)
+
+        # Check if included in any ancestor (Class or Module)
+        # This handles cases where Pundit::Authorization is included in ApplicationController
+        ancestors_to_check = self.class.ancestors.select { |a| a.is_a?(Class) || a.is_a?(Module) }
+        return true if ancestors_to_check.any? { |ancestor| ancestor.included_modules.include?(Pundit::Authorization) }
+        # Fallback: check if authorize method is available (works in most cases)
+        # Use method_defined? for more reliable check than respond_to?
+        return true if self.class.method_defined?(:authorize) || self.class.private_method_defined?(:authorize)
+
+        # Last resort: respond_to check
+        respond_to?(:authorize, true)
       end
 
       def authorizable_resource

data/lib/crudable/rails/version.rb

@@ -3,6 +3,6 @@
 # Crudable Version
 module Crudable
   module Rails
-    VERSION = '1.3'
+    VERSION = '1.5.0'
   end
 end

data/lib/crudable-rails.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require 'turbo-rails'
 
 require 'crudable/rails/version'
+require 'crudable/rails/installer'
 require 'crudable/rails/engine'
 require 'crudable/rails/controller'
 require 'crudable/rails/base'
@@ -10,7 +13,11 @@ require 'crudable/rails/nestable'
 module Crudable
   module Rails
     def self.deprecator
-      @deprecator ||= ActiveSupport::Deprecation.new("2.0", "Crudable::Rails")
+      @deprecator ||= ActiveSupport::Deprecation.new('2.0', 'Crudable::Rails')
+    end
+
+    def self.postinstall(**)
+      Installer.postinstall(**)
     end
   end
 end

data/lib/generators/crudable/controller/USAGE

@@ -0,0 +1,23 @@
+Description:
+    Generates a Crudable controller with documented override hooks.
+
+    Pass the model name, either CamelCased or under_scored. The controller name
+    is retrieved as a pluralized version of the model name.
+
+    To create a controller within a module, specify the model name as a path like
+    'parent_module/controller_name'.
+
+Example:
+    bin/rails generate crudable:controller Post title:string body:text
+
+    This will create:
+        Controller: app/controllers/posts_controller.rb
+
+Notes:
+    The generated controller includes `crudable` and a `permitted_params` method.
+    All other customization hooks are included as commented examples with their
+    defaults. Uncomment and tailor as needed.
+
+    Nested routing is automatically supported: if a parent `*_id` param is present
+    and an association exists between the parent and resource, collections and
+    resources will be scoped through the parent.

data/lib/generators/crudable/controller/controller_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../controller_helpers'
+
+module Crudable
+  class ControllerGenerator < ::Rails::Generators::NamedBase
+    include ::Rails::Generators::ResourceHelpers
+    include Crudable::Generators::ControllerHelpers
+
+    argument :attributes, type: :array, default: [], banner: 'field:type field:type'
+
+    check_class_collision suffix: 'Controller'
+
+    def create_controller_file
+      template 'crudable_controller.rb',
+               File.join('app/controllers', controller_class_path, "#{controller_file_name}_controller.rb")
+    end
+  end
+end

data/lib/generators/crudable/controller_helpers.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Crudable
+  module Generators
+    module ControllerHelpers
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def crudable_template_root
+          @crudable_template_root ||= File.expand_path('templates', __dir__)
+        end
+      end
+
+      included do
+        source_paths << crudable_template_root
+      end
+
+      private
+
+      def permitted_params_list
+        attachments, others = attributes_names.partition { |name| attachments?(name) }
+        params = others.map { |name| ":#{name}" }
+        params += attachments.map { |name| "#{name}: []" }
+        params.join(', ')
+      end
+
+      def attachments?(name)
+        attribute = attributes.find { |attr| attr.name == name }
+        attribute&.attachments?
+      end
+
+      def reference_attributes
+        attributes.select { |attr| attr.respond_to?(:reference?) && attr.reference? }
+      end
+
+      def form_attributes
+        return attributes if reference_attributes.empty?
+
+        attributes.reject { |attr| attr.respond_to?(:reference?) && attr.reference? }
+      end
+
+      def form_with_model
+        segments = []
+        segments.concat(controller_class_path.map { |namespace| ":#{namespace}" }) if controller_class_path.any?
+
+        reference_attributes.each do |attribute|
+          segments << "@#{attribute.name}"
+        end
+
+        segments << "@#{singular_table_name}"
+
+        return segments.first if segments.size == 1
+
+        "[#{segments.join(', ')}]"
+      end
+    end
+  end
+end

data/lib/generators/crudable/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Installs crudable-rails configuration in the host application.
+
+Example:
+    bin/rails generate crudable:install
+
+    This will set config.action_controller.raise_on_missing_callback_actions
+    to true in any environment file that currently sets it to false.

data/lib/generators/crudable/install/install_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Crudable
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      desc 'Install crudable-rails configuration'
+
+      def postinstall
+        updated = ::Crudable::Rails::Installer.postinstall
+
+        if updated.any?
+          say "Set raise_on_missing_callback_actions to true in: #{updated.join(', ')}", :green
+        else
+          say 'No environment files with raise_on_missing_callback_actions = false were found.', :yellow
+        end
+      end
+    end
+  end
+end

data/lib/generators/crudable/scaffold/USAGE

@@ -0,0 +1,20 @@
+Description:
+    Generates a full Rails scaffold (model, migration, views, routes, tests) with a
+    Crudable controller instead of the default scaffold controller.
+
+    Pass the model name, either CamelCased or under_scored, and optional attributes.
+
+Example:
+    bin/rails generate crudable:scaffold Post title:string body:text
+    bin/rails generate crudable:scaffold Post title:string body:text --turbo-forms
+
+    This will create the same files as `rails generate scaffold`, but the controller
+    will use `crudable` with documented override hooks.
+
+    With --turbo-forms, new and edit views wrap the form partial in a dom_id target
+    and generate matching turbo_stream templates for validation error responses.
+
+Notes:
+    Nested routing is automatically supported: if a parent `*_id` param is present
+    and an association exists between the parent and resource, collections and
+    resources will be scoped through the parent.

data/lib/generators/crudable/scaffold/scaffold_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rails/generators/rails/scaffold/scaffold_generator'
+require_relative '../controller_helpers'
+
+module Crudable
+  class ScaffoldGenerator < ::Rails::Generators::ScaffoldGenerator
+    include Crudable::Generators::ControllerHelpers
+
+    def crudable_controller
+      template 'crudable_controller.rb',
+               File.join('app/controllers', controller_class_path, "#{controller_file_name}_controller.rb"),
+               force: true
+    end
+  end
+end

data/lib/generators/crudable/templates/crudable_controller.rb.tt

@@ -0,0 +1,257 @@
+<% module_namespacing do -%>
+class <%= controller_class_name %>Controller < ApplicationController
+  crudable
+
+  private
+
+  # ---------------------------------------------------------------------------
+  # Optional overrides (self-documenting hooks)
+  #
+  # `crudable` mixes in `Crudable::Rails::Base` (which includes `Resourceable`
+  # and `Nestable`), which provides the REST actions and calls these hooks.
+  # Uncomment and tailor any of the following as needed.
+  # ---------------------------------------------------------------------------
+  #
+  # # Override the model class when it cannot be inferred from the controller name.
+  # def resource_class
+  #   <%= class_name %>
+  # end
+  #
+  # # Customize the record passed to Pundit (e.g. namespaced authorization).
+  # def authorizable_resource
+  #   @<%= singular_table_name %>
+  # end
+  #
+  # # If this resource is singular (e.g. SettingsController), return true.
+  # def singleton?
+  #   false
+  # end
+  #
+  # # Which param key to use when finding a member resource.
+  # def finder_param
+  #   :id
+  # end
+  #
+  # # Enable FriendlyId finders/redirects.
+  # def friendly_finders?
+  #   return false unless defined?(FriendlyId) && resource_class.respond_to?(:friendly)
+  #
+  #   true
+  # end
+  #
+  # # Nested parent lookup: use FriendlyId for the parent when available.
+  # def parent_friendly_finders?
+  #   return false unless defined?(FriendlyId)
+  #   return false unless parent_class.respond_to?(:friendly)
+  #
+  #   friendly_finders?
+  # end
+  #
+  # # Enable pagination (requires Kaminari).
+  # def paginate_resource?
+  #   return false unless defined?(Kaminari)
+  #
+  #   true
+  # end
+  #
+  # # Customize the base scope for index (before HasScope and Pundit).
+  # def find_scope
+  #   if parent_resource_association.present?
+  #     instance_variable_get("@#{parent_var_name}").send(parent_resource_association)
+  #   else
+  #     <%= class_name %>
+  #   end
+  # end
+  #
+  # # Customize the scope used for index. Primary hook for filtering.
+  # # (HasScope is applied automatically if present.)
+  # def authorizable_scope
+  #   scope = find_scope
+  #   return scope.all unless authorize_with_pundit?
+  #   return scope.all unless pundit_authorization_available?
+  #
+  #   policy_scope(resource_namespace + [scope])
+  # end
+  #
+  # # Full scope used for index (after HasScope, Pundit, etc).
+  # def resource_scope
+  #   return apply_scopes(authorizable_scope) if defined?(HasScope)
+  #
+  #   authorizable_scope
+  # end
+  #
+  # # Skip initializing a new instance in create (useful for custom create flows).
+  # def skip_initialize_create?
+  #   false
+  # end
+  #
+  # # Discard/soft-delete support (requires Discard). When true, destroy will
+  # # choose discard vs destroy based on record state and params.
+  # def discard?
+  #   false
+  # end
+  #
+  # # Control whether Pundit authorization should be performed.
+  # def authorize_with_pundit?
+  #   defined?(Pundit)
+  # end
+  #
+  # # Authorization lifecycle hooks (called inside create/update).
+  # def before_authorize_create; end
+  # def after_authorize_create; end
+  # def before_authorize_update; end
+  # def after_authorize_update; end
+  #
+  # # Post-success hooks (side-effects, instrumentation, etc).
+  # def on_successful_create
+  #   flash[:success] = after_create_notice
+  # end
+  #
+  # def on_successful_update
+  #   flash[:success] = after_update_notice
+  # end
+  #
+  # def on_successful_destroy
+  #   flash[:success] = after_destroy_notice
+  # end
+  #
+  # # Failure setup hooks (e.g., rebuild form collections).
+  # def on_failed_create_setup; end
+  # def on_failed_update_setup; end
+  #
+  # def on_failed_destroy
+  #   flash[:alert] = after_failed_destroy_alert
+  # end
+  #
+  # # Customize success redirects/flash messages.
+  # def after_create_redirect_path
+  #   if respond_to?(:parent_present?) && parent_present? && instance_variable_get("@#{parent_var_name}")
+  #     parent = instance_variable_get("@#{parent_var_name}")
+  #     resource_namespace + [parent, :<%= plural_table_name %>]
+  #   else
+  #     resource_namespace + [:<%= plural_table_name %>]
+  #   end
+  # rescue NoMethodError
+  #   resource_namespace + [:<%= plural_table_name %>]
+  # end
+  #
+  # def after_create_notice
+  #   t('crudable.created', model_name: <%= class_name %>.model_name.human)
+  # end
+  #
+  # def after_update_redirect_path
+  #   resource_namespace + [@<%= singular_table_name %>]
+  # end
+  #
+  # def after_update_notice
+  #   t('crudable.updated', model_name: <%= class_name %>.model_name.human)
+  # end
+  #
+  # def after_destroy_redirect_path
+  #   resource_namespace + [:<%= plural_table_name %>]
+  # end
+  #
+  # def after_failed_destroy_redirect_path
+  #   after_destroy_redirect_path
+  # end
+  #
+  # def after_destroy_notice
+  #   t('crudable.destroyed', model_name: <%= class_name %>.model_name.human)
+  # end
+  #
+  # def after_failed_destroy_alert
+  #   t('crudable.not_destroyed', model_name: <%= class_name %>.model_name.human)
+  # end
+  #
+  # # Customize rendering for success/failure outcomes (Turbo/HTML).
+  # def on_successful_create_render
+  #   redirect_to after_create_redirect_path
+  # end
+  #
+  # def on_failed_create_render
+  #   resource = @<%= singular_table_name %>
+  #   @<%= singular_table_name %> = new_instance if resource.nil?
+  #   respond_to do |format|
+  #     format.turbo_stream { render_action(:new) }
+  #     format.html { render :new, status: :unprocessable_content }
+  #   end
+  # end
+  #
+  # def on_successful_update_render
+  #   redirect_to after_update_redirect_path
+  # end
+  #
+  # def on_failed_update_render
+  #   respond_to do |format|
+  #     format.turbo_stream { render_action(:edit) }
+  #     format.html { render :edit, status: :unprocessable_content }
+  #   end
+  # end
+  #
+  # def on_successful_destroy_render
+  #   redirect_to after_destroy_redirect_path
+  # end
+  #
+  # def on_failed_destroy_render
+  #   redirect_to after_failed_destroy_redirect_path
+  # end
+  #
+  # # Customize pagination when enabled.
+  # def paginate_resource
+  #   return unless paginate_resource?
+  #
+  #   @<%= plural_table_name %> = @<%= plural_table_name %>.page(params[:page]).per(params[:per])
+  # end
+  #
+  # # Customize 404 responses.
+  # def render_not_found
+  #   head :not_found
+  # end
+  #
+  # # Nested resources: parent scoping is automatic when a `*_id` param is present.
+  # def use_parent_as_scope?
+  #   true
+  # end
+  #
+  # # Nested resources: customize which `*_id` param is treated as the parent id.
+  # def parent_id_param
+  #   return nil unless use_parent_as_scope?
+  #
+  #   @parent_id_param ||= begin
+  #     keys = parent_id_param_keys
+  #     keys.map(&:to_s).grep(/(.+)_id$/).last
+  #   end
+  # end
+  #
+  # # Override when create and update need different permitted attributes.
+  # def create_params
+  #   resource_params
+  # end
+  #
+  # def update_params
+  #   resource_params
+  # end
+  #
+  # # Strong params API used by `resource_params`.
+  # def param_method
+  #   @param_method ||= ActionController::Parameters.method_defined?(:expect) ? :expect : :require
+  # end
+  #
+  # # def resource_params
+  # #   if param_method == :expect
+  # #     params.expect(<%= singular_table_name %>: permitted_params)
+  # #   else
+  # #     params.require(:<%= singular_table_name %>).permit(*permitted_params)
+  # #   end
+  # # end
+  #
+  # Required: return the attributes permitted for create/update.
+  def permitted_params
+    <%- if attributes_names.empty? -%>
+    []
+    <%- else -%>
+    [<%= permitted_params_list %>]
+    <%- end -%>
+  end
+end
+<% end -%>