b4um_generators 0.4.0 → 0.5.0

data/lib/generators/b4um/authentication/authentication_generator.rb

@@ -198,7 +198,10 @@ module B4um
 
       def add_authentication_helpers
         controller_path = "app/controllers/application_controller.rb"
-        full_controller_path = File.join(destination_root, controller_path)
+        full_controller_path = File.join(
+          destination_root,
+          controller_path
+        )
 
         unless File.exist?(full_controller_path)
           raise Thor::Error,
@@ -211,31 +214,52 @@ module B4um
           "helper_method :#{current_authentication_method}, :logged_in?"
         )
 
-        inject_into_file(
-          controller_path,
-          before: /^end\s*$/
-        ) do
-          <<~RUBY
-
-            helper_method :#{current_authentication_method}, :logged_in?
+        authentication_helpers = [
+          "",
+          "  helper_method :#{current_authentication_method}, :logged_in?",
+          "",
+          "  private",
+          "",
+          "  def #{current_authentication_method}",
+          "    @#{current_authentication_method} ||= " \
+          "#{authentication_class_name}.find_by(" \
+          "id: session[:#{authentication_model_name}_id])",
+          "  end",
+          "",
+          "  def logged_in?",
+          "    #{current_authentication_method}.present?",
+          "  end",
+          "",
+          "  def require_login",
+          "    return if logged_in?",
+          "",
+          '    redirect_to login_path, alert: "Please log in first."',
+          "  end",
+          ""
+        ].join("\n")
+
+        class_end_position = controller.rindex(/^end\s*$/)
 
-            private
-
-            def #{current_authentication_method}
-              @#{current_authentication_method} ||= #{authentication_class_name}.find_by(id: session[:#{authentication_model_name}_id])
-            end
+        unless class_end_position
+          raise Thor::Error,
+                "Could not find the end of ApplicationController."
+        end
 
-            def logged_in?
-              #{current_authentication_method}.present?
-            end
+        controller.insert(
+          class_end_position,
+          authentication_helpers
+        )
 
-            def require_login
-              return if logged_in?
+        File.write(
+          full_controller_path,
+          controller
+        )
 
-              redirect_to login_path, alert: "Please log in first."
-            end
-          RUBY
-        end
+        say_status(
+          :insert,
+          controller_path,
+          :green
+        )
       end
 
       def update_in_place_helper
@@ -503,6 +527,12 @@ module B4um
         end
       end
 
+      def update_controller_tests
+        update_authentication_fixtures
+        update_authentication_resource_controller_tests
+        update_protected_controller_tests
+      end
+
       def protect_show_actions
         protected_controller_names.each do |controller_name|
           protect_show_actions_for(controller_name)
@@ -517,6 +547,300 @@ module B4um
 
       private
 
+      def update_authentication_fixtures
+        fixture_path = File.join(
+          destination_root,
+          "test/fixtures",
+          "#{authentication_model_name.pluralize}.yml"
+        )
+
+        return unless File.exist?(fixture_path)
+
+        fixtures = File.read(fixture_path)
+
+        fixture_name = nil
+
+        updated_fixtures = fixtures.lines.map do |line|
+          if (match = line.match(/^([a-zA-Z0-9_-]+):\s*$/))
+            fixture_name = match[1]
+            line
+          elsif line.match?(/^\s+email:\s*/)
+            fixture_label =
+              fixture_name
+              .to_s
+              .tr("_", "-")
+
+            indentation = line[/^\s*/]
+
+            "#{indentation}email: " \
+              "#{authentication_model_name}-#{fixture_label}@example.com\n"
+          elsif line.match?(/^\s+password_digest:\s*/)
+            indentation = line[/^\s*/]
+
+            "#{indentation}" \
+              'password_digest: <%= BCrypt::Password.create("password") %>' \
+              "\n"
+          else
+            line
+          end
+        end.join
+
+        return if updated_fixtures == fixtures
+
+        File.write(
+          fixture_path,
+          updated_fixtures
+        )
+      end
+
+      def update_authentication_resource_controller_tests
+        test_path = File.join(
+          "test/controllers",
+          "#{authentication_model_name.pluralize}_controller_test.rb"
+        )
+
+        full_test_path = File.join(
+          destination_root,
+          test_path
+        )
+
+        return unless File.exist?(full_test_path)
+
+        test = File.read(full_test_path)
+
+        update_authentication_test_password_params(
+          test_path,
+          test
+        )
+
+        test = File.read(full_test_path)
+
+        update_authentication_index_test(
+          test_path,
+          test
+        )
+
+        test = File.read(full_test_path)
+
+        add_authentication_sessions_to_resource_tests(
+          test_path,
+          test
+        )
+
+        test = File.read(full_test_path)
+
+        update_authentication_destroy_redirect_test(
+          test_path,
+          test
+        )
+      end
+
+      def update_protected_controller_tests
+        protected_controller_names.each do |controller_name|
+          test_path = File.join(
+            "test/controllers",
+            "#{controller_name.underscore}_controller_test.rb"
+          )
+
+          full_test_path = File.join(
+            destination_root,
+            test_path
+          )
+
+          next unless File.exist?(full_test_path)
+
+          add_login_to_protected_controller_test(
+            test_path,
+            controller_name
+          )
+        end
+      end
+
+      def update_authentication_test_password_params(test_path, test)
+        return unless test.include?(
+          "password_digest: @#{authentication_model_name}.password_digest"
+        )
+
+        gsub_file(
+          test_path,
+          "password_digest: @#{authentication_model_name}.password_digest",
+          'password: "password", password_confirmation: "password"'
+        )
+      end
+
+      def update_authentication_index_test(test_path, test)
+        resource_name = authentication_model_name
+        plural_name = resource_name.pluralize
+        test_name = Regexp.escape("should get index")
+
+        pattern = /
+          ^[ \t]*test\s+"#{test_name}"\s+do
+          \s+get\s+#{Regexp.escape(plural_name)}_url
+          \s+assert_response\s+:success
+          \s+end
+        /x
+
+        return unless test.match?(pattern)
+
+        replacement = [
+          "  test \"should get index\" do",
+          "    log_in_as(@#{resource_name})",
+          "",
+          "    get #{plural_name}_url",
+          "",
+          "    assert_redirected_to " \
+          "#{resource_name}_url(@#{resource_name})",
+          "  end"
+        ].join("\n")
+
+        gsub_file(
+          test_path,
+          pattern,
+          replacement
+        )
+      end
+
+      def add_authentication_sessions_to_resource_tests(test_path, test)
+        %w[show edit update destroy].each do |action|
+          test_name =
+            if action == "edit"
+              "should get edit"
+            else
+              "should #{action} #{authentication_model_name}"
+            end
+
+          pattern = /
+            (test\s+"#{Regexp.escape(test_name)}"\s+do\n)
+            (?!\s*log_in_as\(@#{Regexp.escape(authentication_model_name)}\))
+          /x
+
+          next unless test.match?(pattern)
+
+          gsub_file(test_path, pattern) do |match|
+            "#{match}    log_in_as(@#{authentication_model_name})\n"
+          end
+
+          test = File.read(
+            File.join(destination_root, test_path)
+          )
+        end
+
+        add_login_helper_to_controller_test(test_path)
+      end
+
+      def add_login_helper_to_controller_test(test_path)
+        full_test_path = File.join(
+          destination_root,
+          test_path
+        )
+
+        test = File.read(full_test_path)
+
+        return if test.include?("def log_in_as(user)")
+
+        final_end = test.rindex(/^end$/)
+        return unless final_end
+
+        helper =
+          "\n  private\n\n  " \
+          "def log_in_as(user)\n    " \
+          'user.update!(password: "password", password_confirmation: "password")' \
+          "\n    " \
+          'post login_url, params: { email: user.email, password: "password" }' \
+          "\n  " \
+          "end\n"
+
+        updated_test =
+          test.dup.insert(final_end, helper)
+
+        File.write(
+          full_test_path,
+          updated_test
+        )
+      end
+
+      def update_authentication_destroy_redirect_test(test_path, test)
+        plural_name = authentication_model_name.pluralize
+
+        old_redirect =
+          "assert_redirected_to #{plural_name}_url"
+
+        return unless test.include?(old_redirect)
+
+        gsub_file(
+          test_path,
+          old_redirect,
+          "assert_redirected_to root_url"
+        )
+      end
+
+      def add_login_to_protected_controller_test(
+        test_path,
+        controller_name
+      )
+        full_test_path = File.join(
+          destination_root,
+          test_path
+        )
+
+        test = File.read(full_test_path)
+
+        add_authentication_fixture_to_test(
+          test_path,
+          test
+        )
+
+        test = File.read(full_test_path)
+
+        protected_test_actions_for(controller_name).each do |test_name|
+          pattern = /
+            (test\s+"#{Regexp.escape(test_name)}"\s+do\n)
+            (?!\s*log_in_as\(@authentication_user\))
+          /x
+
+          next unless test.match?(pattern)
+
+          gsub_file(test_path, pattern) do |match|
+            "#{match}    log_in_as(@authentication_user)\n"
+          end
+
+          test = File.read(full_test_path)
+        end
+
+        add_login_helper_to_controller_test(test_path)
+      end
+
+      def add_authentication_fixture_to_test(test_path, test)
+        fixture_assignment =
+          "@authentication_user = " \
+          "#{authentication_model_name.pluralize}(:one)"
+
+        return if test.include?(fixture_assignment)
+
+        setup_pattern = /
+          (setup\s+do\n)
+        /x
+
+        return unless test.match?(setup_pattern)
+
+        gsub_file(test_path, setup_pattern) do |match|
+          "#{match}    #{fixture_assignment}\n"
+        end
+      end
+
+      def protected_test_actions_for(controller_name)
+        singular_name =
+          controller_name.underscore.singularize
+
+        [
+          "should get new",
+          "should create #{singular_name}",
+          "should get edit",
+          "should update #{singular_name}",
+          "should destroy #{singular_name}"
+        ]
+      end
+
       def add_register_navigation_link(navigation_path, navigation)
         return if navigation.include?(
           'navigation_link_to "Register",'

data/lib/generators/b4um/comments/comments_generator.rb

@@ -169,20 +169,50 @@ module B4um
         routes = File.read(full_routes_path)
         resource_name = commentable.to_s.underscore.pluralize
 
-        return if routes.include?(
-          "resources :#{resource_name} do\n    resources :comments"
-        )
+        resource_block = /
+          ^(?<indent>[ \t]*)resources\s+:#{Regexp.escape(resource_name)}\s+do[ \t]*\n
+          (?<body>.*?)
+          ^\k<indent>end[ \t]*$
+        /mx
+
+        if (match = routes.match(resource_block))
+          return if match[:body].include?(
+            "resources :comments, only: %i[create destroy]"
+          )
+
+          updated_block = [
+            "#{match[:indent]}resources :#{resource_name} do",
+            match[:body].rstrip,
+            "#{match[:indent]}  resources :comments, only: %i[create destroy]",
+            "#{match[:indent]}end"
+          ].reject(&:empty?).join("\n")
+
+          gsub_file(
+            routes_path,
+            match[0],
+            updated_block
+          )
+
+          return
+        end
+
+        simple_resource =
+          /^([ \t]*)resources\s+:#{Regexp.escape(resource_name)}[ \t]*$/
+
+        return unless routes.match?(simple_resource)
 
         gsub_file(
           routes_path,
-          "  resources :#{resource_name}\n",
+          simple_resource
+        ) do |resource_line|
+          indentation = resource_line[/\A[ \t]*/]
+
           [
-            "  resources :#{resource_name} do",
-            "    resources :comments, only: %i[create destroy]",
-            "  end",
-            ""
+            "#{indentation}resources :#{resource_name} do",
+            "#{indentation}  resources :comments, only: %i[create destroy]",
+            "#{indentation}end"
           ].join("\n")
-        )
+        end
       end
 
       def add_comments_to_show_view

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

@@ -1172,6 +1172,95 @@ module B4um
             - Safe repeated generator runs
 
 
+          TODO
+
+            bin/rails generate b4um:todo MODEL
+
+          Generates a complete Todo application for Rails.
+
+          Example:
+
+            bin/rails generate b4um:todo Task
+            bin/rails db:migrate
+
+          By default, the Todo list is shared across the application.
+          Tasks are not assigned to individual users.
+
+          To create personal Todo lists, use --owner:
+
+            bin/rails generate b4um:todo Task --owner=User
+            bin/rails db:migrate
+
+          The owner model must already exist.
+
+          For user-specific Todo lists, b4um authentication can be
+          installed first:
+
+            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
+
+          The owner option supports other authentication models:
+
+            --owner=User
+            --owner=Member
+            --owner=Customer
+
+          The generated controller uses the corresponding
+          current owner helper, for example:
+
+            current_user
+            current_member
+            current_customer
+
+          With an owner, each account has its own Todo list.
+
+          Tasks are loaded through the current owner's association.
+          Users cannot access tasks belonging to another account.
+
+          Unauthenticated requests to owner-specific Todo actions
+          receive HTTP 401 Unauthorized.
+
+          Todo features:
+
+            - 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 the task input
+            - Automatic input reset after successful creation
+            - b4um floating labels
+            - Responsive b4um card layout
+            - Light and dark mode support
+            - Optional owner association with --owner
+            - Owner-specific task access protection
+
+          The generator creates:
+
+            - Task model and database migration
+            - Tasks controller
+            - Resource routes
+            - Index view
+            - Task partial
+            - Progress partial
+            - Todo stylesheet
+            - Stimulus controller
+
+          After generating the Todo application, run:
+
+            bin/rails db:migrate
+
+          With the default Task model, the Todo list is available at:
+
+            /tasks
+
+
           COMMENTS
 
             bin/rails generate b4um:comments MODEL

data/lib/generators/b4um/in_place/in_place_generator.rb

@@ -137,9 +137,48 @@ module B4um
       end
 
       def add_edit_actions
-        fields.each do |field|
-          add_edit_action(field)
-        end
+        controller_path = File.join(
+          "app/controllers",
+          "#{plural_table_name}_controller.rb"
+        )
+
+        full_controller_path = File.join(
+          destination_root,
+          controller_path
+        )
+
+        controller = File.read(full_controller_path)
+
+        fields_to_insert =
+          prepare_in_place_edit_actions(controller)
+
+        create_comment =
+          extract_create_comment(controller)
+
+        create_match =
+          find_create_action(controller, controller_path)
+
+        replacement = build_edit_actions_block(
+          fields_to_insert,
+          create_match[1],
+          create_comment
+        )
+
+        controller.sub!(
+          /\n*^[ \t]*def[ \t]+create[ \t]*$/,
+          replacement
+        )
+
+        File.write(
+          full_controller_path,
+          controller
+        )
+
+        say_status(
+          :gsub,
+          controller_path,
+          :green
+        )
       end
 
       def add_edit_actions_to_set_product
@@ -216,6 +255,77 @@ module B4um
 
       private
 
+      def prepare_in_place_edit_actions(controller)
+        fields.filter_map do |field|
+          empty_edit_action = /
+            ^[ \t]*def[ \t]+edit_#{Regexp.escape(field)}[ \t]*\n
+            ^[ \t]*end[ \t]*\n?
+          /x
+
+          removed_empty_action =
+            controller.gsub!(empty_edit_action, "")
+
+          custom_action =
+            controller.match?(
+              /^[ \t]*def[ \t]+edit_#{Regexp.escape(field)}[ \t]*$/
+            )
+
+          field unless custom_action && !removed_empty_action
+        end
+      end
+
+      def extract_create_comment(controller)
+        create_comment_pattern =
+          %r{^[ \t]*# POST /#{Regexp.escape(plural_table_name)} or /#{Regexp.escape(plural_table_name)}\.json[ \t]*\n?}
+
+        create_comment =
+          controller[create_comment_pattern]&.rstrip
+
+        controller.gsub!(
+          create_comment_pattern,
+          ""
+        )
+
+        create_comment
+      end
+
+      def find_create_action(controller, controller_path)
+        create_match =
+          controller.match(
+            /^([ \t]*)def[ \t]+create[ \t]*$/
+          )
+
+        return create_match if create_match
+
+        raise Thor::Error,
+              "Could not find create action in #{controller_path}"
+      end
+
+      def build_edit_actions_block(
+        fields_to_insert,
+        indentation,
+        create_comment
+      )
+        edit_actions = fields_to_insert.flat_map do |field|
+          [
+            "#{indentation}def edit_#{field}",
+            "#{indentation}end",
+            ""
+          ]
+        end
+
+        replacement = [
+          "",
+          "",
+          *edit_actions
+        ]
+
+        replacement << create_comment if create_comment
+        replacement << "#{indentation}def create"
+
+        replacement.join("\n")
+      end
+
       def ensure_flash_render_in_layout
         layout_path = "app/views/layouts/application.html.erb"
         full_layout_path = File.join(destination_root, layout_path)
@@ -581,11 +691,26 @@ module B4um
           /^\s*def edit_#{Regexp.escape(field)}\s*$/
         )
 
-        inject_into_file(
+        create_action = /^([ \t]*)def create\s*$/
+
+        unless controller.match?(create_action)
+          raise Thor::Error,
+                "Could not find create action in #{controller_path}"
+        end
+
+        gsub_file(
           controller_path,
-          before: /^\s*def create\s*$/
-        ) do
-          "  def edit_#{field}\n  end\n\n"
+          /\n*[ \t]*def create\s*$/
+        ) do |match|
+          indentation = match[/[ \t]*(?=def create)/]
+
+          [
+            "",
+            "#{indentation}def edit_#{field}",
+            "#{indentation}end",
+            "",
+            "#{indentation}def create"
+          ].join("\n")
         end
       end