b4um_generators 0.3.0 → 0.4.2

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
 

data/lib/generators/b4um/readable/readable_generator.rb

@@ -39,14 +39,17 @@ module B4um
                 "#{class_name} already defines to_param."
         end
 
+        readable_method = [
+          "  def to_param",
+          "    \"\#{id} \#{#{attribute}}\".parameterize",
+          "  end",
+          ""
+        ].join("\n")
+
         inject_into_class(
           model_path,
           class_name,
-          <<~RUBY
-            def to_param
-              "\#{id} \#{#{attribute}}".parameterize
-            end
-          RUBY
+          readable_method
         )
 
         say_status(

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

@@ -33,6 +33,43 @@ module B4um
                    type: :string,
                    desc: "Renders a field as radio buttons. Example: condition:new=Neu,used=Gebraucht"
 
+      class_option :required,
+                   type: :string,
+                   desc: "Adds presence validation to fields. Example: name,email"
+
+      def initialize(args, options, config)
+        super
+
+        validate_required_fields
+      end
+
+      no_tasks do
+        def validate_required_fields
+          return if required_fields.empty?
+
+          attribute_names = attributes.map(&:name)
+
+          unknown_fields = required_fields - attribute_names
+
+          return if unknown_fields.empty?
+
+          raise Thor::Error,
+                "Unknown required field: #{unknown_fields.first}"
+        end
+
+        def required_fields
+          options[:required]
+            .to_s
+            .split(",")
+            .map(&:strip)
+            .reject(&:empty?)
+        end
+
+        def revoking?
+          behavior == :revoke
+        end
+      end
+
       def validate_editor_options
         configurations = {
           select: select_configuration,
@@ -147,7 +184,26 @@ module B4um
         )
       end
 
+      def add_required_validations
+        return if revoking?
+        return if required_fields.empty?
+
+        validation = required_fields
+                     .map { |field| ":#{field}" }
+                     .join(", ")
+
+        inject_into_class(
+          File.join(
+            "app/models",
+            "#{singular_table_name}.rb"
+          ),
+          class_name,
+          "  validates #{validation}, presence: true\n"
+        )
+      end
+
       def add_secure_password
+        return if revoking?
         return unless attributes.any? { |attribute| attribute.name == "password_digest" }
 
         inject_into_class(
@@ -158,6 +214,7 @@ module B4um
       end
 
       def add_bcrypt
+        return if revoking?
         return unless attributes.any? { |attribute| attribute.name == "password_digest" }
 
         gemfile_path = "Gemfile"
@@ -171,6 +228,7 @@ module B4um
       end
 
       def update_password_params
+        return if revoking?
         return unless attributes.any? { |attribute| attribute.name == "password_digest" }
 
         controller_path = File.join(
@@ -183,74 +241,41 @@ module B4um
           ":password_digest",
           ":password, :password_confirmation"
         )
+
+        update_password_test_params
       end
 
       def update_multiple_attachments
-        attachment_attributes = attributes.select do |attribute|
-          attribute.type == :attachments
-        end
+        return if revoking?
+
+        attachment_names = multiple_attachment_names
 
-        return if attachment_attributes.empty?
+        return if attachment_names.empty?
 
         controller_path = File.join(
           "app/controllers",
           "#{plural_table_name}_controller.rb"
         )
 
-        attachment_names = attachment_attributes.map(&:name)
-
-        setup_lines = attachment_names.map do |name|
-          [
-            "    new_#{name} = update_params.delete(\"#{name}\")",
-            "    remove_#{name}_ids = update_params.delete(\"remove_#{name}_ids\")"
-          ]
-        end.flatten.join("\n")
-
-        attachment_lines = attachment_names.map do |name|
-          [
-            "        @#{singular_table_name}.#{name}.attach(new_#{name}) if new_#{name}.present?",
-            "",
-            "        if remove_#{name}_ids.present?",
-            "          @#{singular_table_name}.#{name}.attachments",
-            "            .where(id: remove_#{name}_ids)",
-            "            .find_each(&:purge)",
-            "        end"
-          ]
-        end.flatten.join("\n")
-
-        gsub_file(
+        add_multiple_attachment_setup(
           controller_path,
-          "  def update\n    respond_to do |format|\n",
-          [
-            "  def update",
-            "    update_params = #{singular_table_name}_params",
-            setup_lines,
-            "",
-            "    respond_to do |format|",
-            ""
-          ].join("\n")
+          attachment_names
         )
 
-        gsub_file(
+        add_multiple_attachment_handling(
           controller_path,
-          "      if @#{singular_table_name}.update(#{singular_table_name}_params)\n",
-          [
-            "      if @#{singular_table_name}.update(update_params)",
-            attachment_lines,
-            ""
-          ].join("\n")
+          attachment_names
         )
 
-        attachment_names.each do |name|
-          gsub_file(
-            controller_path,
-            "#{name}: []",
-            "#{name}: [], remove_#{name}_ids: []"
-          )
-        end
+        add_multiple_attachment_removal_params(
+          controller_path,
+          attachment_names
+        )
       end
 
       def add_readable_param
+        return if revoking?
+
         param_name = options[:param]
 
         return if param_name.blank?
@@ -265,18 +290,24 @@ module B4um
           return
         end
 
+        readable_method = [
+          "  def to_param",
+          "    \"\#{id} \#{#{param_name}}\".parameterize",
+          "  end",
+          "",
+          ""
+        ].join("\n")
+
         inject_into_class(
           File.join("app/models", "#{singular_table_name}.rb"),
           class_name,
-          <<~RUBY
-            def to_param
-              "\#{id} \#{#{param_name}}".parameterize
-            end
-          RUBY
+          readable_method
         )
       end
 
       def update_destroy_flash
+        return if revoking?
+
         controller_path = File.join(
           "app/controllers",
           "#{plural_table_name}_controller.rb"
@@ -293,16 +324,16 @@ module B4um
           gsub_file(
             controller_path,
             /
-              format\.html\ \{\ redirect_to\ ([^,]+),
+              ^([ \t]*)format\.html\ \{\ redirect_to\ ([^,]+),
               \ notice:\ ("[^"]*\ was\ successfully\ destroyed\."),
               \ status:\ :see_other\ \}
             /x,
-            <<~RUBY.chomp
-              format.html do
-                flash[:deleted] = \\2
-                redirect_to \\1, status: :see_other
-              end
-            RUBY
+            [
+              "\\1format.html do",
+              "\\1  flash[:deleted] = \\3",
+              "\\1  redirect_to \\2, status: :see_other",
+              "\\1end"
+            ].join("\n")
           )
 
           return
@@ -311,11 +342,11 @@ module B4um
         # Rails-Scaffold ohne respond_to
         gsub_file(
           controller_path,
-          /redirect_to ([^,]+), notice: ("[^"]* was successfully destroyed\."), status: :see_other/,
-          <<~RUBY.chomp
-            flash[:deleted] = \\2
-            redirect_to \\1, status: :see_other
-          RUBY
+          /^([ \t]*)redirect_to ([^,]+), notice: ("[^"]* was successfully destroyed\."), status: :see_other/,
+          [
+            "\\1flash[:deleted] = \\3",
+            "\\1redirect_to \\2, status: :see_other"
+          ].join("\n")
         )
       end
 
@@ -326,15 +357,8 @@ module B4um
         return unless File.exist?(full_navigation_path)
 
         navigation = File.read(full_navigation_path)
-
-        return if navigation.include?(
-          "controller: :#{plural_table_name}"
-        )
-
         marker = "<%# B4UM_NAVIGATION_LINKS %>"
 
-        return unless navigation.include?(marker)
-
         navigation_link = <<~ERB
           <%= navigation_link_to "#{plural_table_name.humanize}",
                                  #{plural_route_name}_path,
@@ -343,6 +367,34 @@ module B4um
             #{marker}
         ERB
 
+        if revoking?
+          generated_link = navigation_link.chomp
+
+          return unless navigation.include?(generated_link)
+
+          File.write(
+            full_navigation_path,
+            navigation.sub(
+              generated_link,
+              marker
+            )
+          )
+
+          say_status(
+            :remove,
+            "#{plural_table_name.humanize} navigation link",
+            :red
+          )
+
+          return
+        end
+
+        return if navigation.include?(
+          "controller: :#{plural_table_name}"
+        )
+
+        return unless navigation.include?(marker)
+
         gsub_file(
           navigation_path,
           marker,
@@ -352,6 +404,94 @@ module B4um
 
       private
 
+      def multiple_attachment_names
+        attributes
+          .select { |attribute| attribute.type == :attachments }
+          .map(&:name)
+      end
+
+      def add_multiple_attachment_setup(
+        controller_path,
+        attachment_names
+      )
+        setup_lines = attachment_names.flat_map do |name|
+          [
+            "    new_#{name} = update_params.delete(\"#{name}\")",
+            "    remove_#{name}_ids = update_params.delete(\"remove_#{name}_ids\")"
+          ]
+        end.join("\n")
+
+        gsub_file(
+          controller_path,
+          "  def update\n    respond_to do |format|\n",
+          [
+            "  def update",
+            "    update_params = #{singular_table_name}_params",
+            setup_lines,
+            "",
+            "    respond_to do |format|",
+            ""
+          ].join("\n")
+        )
+      end
+
+      def add_multiple_attachment_handling(
+        controller_path,
+        attachment_names
+      )
+        attachment_lines = attachment_names.flat_map do |name|
+          [
+            "        @#{singular_table_name}.#{name}.attach(new_#{name}) if new_#{name}.present?",
+            "",
+            "        if remove_#{name}_ids.present?",
+            "          @#{singular_table_name}.#{name}.attachments",
+            "            .where(id: remove_#{name}_ids)",
+            "            .find_each(&:purge)",
+            "        end"
+          ]
+        end.join("\n")
+
+        gsub_file(
+          controller_path,
+          "      if @#{singular_table_name}.update(#{singular_table_name}_params)\n",
+          [
+            "      if @#{singular_table_name}.update(update_params)",
+            attachment_lines,
+            ""
+          ].join("\n")
+        )
+      end
+
+      def add_multiple_attachment_removal_params(
+        controller_path,
+        attachment_names
+      )
+        attachment_names.each do |name|
+          gsub_file(
+            controller_path,
+            "#{name}: []",
+            "#{name}: [], remove_#{name}_ids: []"
+          )
+        end
+      end
+
+      def update_password_test_params
+        test_path = File.join(
+          "test/controllers",
+          "#{plural_table_name}_controller_test.rb"
+        )
+
+        return unless File.exist?(
+          File.join(destination_root, test_path)
+        )
+
+        gsub_file(
+          test_path,
+          "password_digest: @#{singular_table_name}.password_digest",
+          'password: "password", password_confirmation: "password"'
+        )
+      end
+
       def validate_editor_configuration(option_name, configuration)
         return unless options[option_name].present?