b4um_generators 0.3.0 → 0.4.2

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

@@ -50,6 +50,89 @@ module B4um
               "#{authentication_class_name} email:string password_digest:string"
       end
 
+      def add_email_presence_validation
+        model_path = File.join(
+          "app/models",
+          "#{authentication_model_name}.rb"
+        )
+
+        full_model_path = File.join(
+          destination_root,
+          model_path
+        )
+
+        model = File.read(full_model_path)
+
+        return if model.include?(
+          "validates :email, presence: true"
+        )
+
+        inject_into_class(
+          model_path,
+          authentication_class_name,
+          "  validates :email, presence: true\n"
+        )
+      end
+
+      def mark_registration_fields_required
+        form_path = File.join(
+          destination_root,
+          "app/views",
+          authentication_model_name.pluralize,
+          "_form.html.erb"
+        )
+
+        return unless File.exist?(form_path)
+
+        model_path = File.join(
+          destination_root,
+          "app/models",
+          "#{authentication_model_name}.rb"
+        )
+
+        model = File.read(model_path)
+        form = File.read(form_path)
+
+        model_required_fields =
+          model
+          .scan(
+            /validates\s+((?::[a-zA-Z_]\w*\s*,?\s*)+),\s*presence:\s+true/
+          )
+          .flat_map do |match|
+            match.first.scan(/:([a-zA-Z_]\w*)/).flatten
+          end
+
+        required_fields = model_required_fields.dup
+
+        if model.match?(/\bhas_secure_password\b/)
+          required_fields.push(
+            "password",
+            "password_confirmation"
+          )
+        end
+
+        required_fields.uniq!
+
+        required_fields.each do |field|
+          label = "#{field.humanize} *"
+
+          plain_label = /
+            form\.label\s+:#{Regexp.escape(field)},
+            \s*class:\s*"form-label"
+          /x
+
+          form.gsub!(
+            plain_label,
+            %(form.label :#{field}, "#{label}", class: "form-label")
+          )
+        end
+
+        File.write(
+          form_path,
+          form
+        )
+      end
+
       def validate_protected_controllers
         protected_controller_names.each do |controller_name|
           controller_path = File.join(
@@ -94,9 +177,15 @@ module B4um
       end
 
       def create_sessions_controller
+        controller_path = "app/controllers/sessions_controller.rb"
+
+        return if File.exist?(
+          File.join(destination_root, controller_path)
+        )
+
         template(
           "sessions_controller.rb.tt",
-          "app/controllers/sessions_controller.rb"
+          controller_path
         )
       end
 
@@ -109,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,
@@ -122,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
@@ -414,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)
@@ -428,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