b4um_generators 0.4.0 → 0.4.2

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

@@ -64,6 +64,10 @@ module B4um
             .map(&:strip)
             .reject(&:empty?)
         end
+
+        def revoking?
+          behavior == :revoke
+        end
       end
 
       def validate_editor_options
@@ -181,6 +185,7 @@ module B4um
       end
 
       def add_required_validations
+        return if revoking?
         return if required_fields.empty?
 
         validation = required_fields
@@ -198,6 +203,7 @@ module B4um
       end
 
       def add_secure_password
+        return if revoking?
         return unless attributes.any? { |attribute| attribute.name == "password_digest" }
 
         inject_into_class(
@@ -208,6 +214,7 @@ module B4um
       end
 
       def add_bcrypt
+        return if revoking?
         return unless attributes.any? { |attribute| attribute.name == "password_digest" }
 
         gemfile_path = "Gemfile"
@@ -221,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(
@@ -233,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?
@@ -315,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"
@@ -343,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
@@ -361,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
 
@@ -376,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,
@@ -393,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,
@@ -402,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?
 

data/lib/generators/b4um/sortable/sortable_generator.rb

@@ -51,30 +51,80 @@ module B4um
         )
       end
 
+      def update_fixtures
+        return unless File.exist?(fixture_path)
+
+        fixtures = File.read(fixture_path)
+        position = 0
+
+        updated_fixtures = fixtures.gsub(
+          /^([^\s#][^:\n]*:\s*\n)((?:^[ \t]+.*\n?)*)/
+        ) do
+          fixture_header = Regexp.last_match(1)
+          fixture_body = Regexp.last_match(2)
+
+          next "#{fixture_header}#{fixture_body}" if fixture_header.start_with?("_")
+
+          position += 1
+
+          if fixture_body.match?(/^[ \t]+position:\s+/)
+            fixture_body = fixture_body.sub(
+              /^[ \t]+position:\s+.*$/,
+              "  position: #{position}"
+            )
+
+            "#{fixture_header}#{fixture_body}"
+          else
+            "#{fixture_header}  position: #{position}\n#{fixture_body}"
+          end
+        end
+
+        return if updated_fixtures == fixtures
+
+        File.write(fixture_path, updated_fixtures)
+
+        say_status(
+          :fixture,
+          "#{plural_table_name}.yml now includes sortable positions",
+          :green
+        )
+      end
+
       def update_model
         model_content = File.read(model_path)
 
-        return if model_content.include?("before_create :b4um_set_sortable_position")
+        return if model_content.include?(
+          "before_create :b4um_set_sortable_position"
+        )
 
-        inject_into_class(
-          model_path,
-          class_name,
-          <<~RUBY.indent(2)
-            before_create :b4um_set_sortable_position
-            after_destroy :b4um_compact_sortable_positions
+        existing_model_body = model_content
+                              .lines[1...-1]
+                              .to_a
+                              .any? { |line| line.match?(/\S/) }
 
-            def b4um_set_sortable_position
-              return if position.present?
+        sortable_model_code = <<~RUBY.indent(2)
+          before_create :b4um_set_sortable_position
+          after_destroy :b4um_compact_sortable_positions
 
-              self.position = self.class.maximum(:position).to_i + 1
-            end
+          def b4um_set_sortable_position
+            return if position.present?
 
-            def b4um_compact_sortable_positions
-              self.class
-                  .where("position > ?", position)
-                  .update_all("position = position - 1")
-            end
-          RUBY
+            self.position = self.class.maximum(:position).to_i + 1
+          end
+
+          def b4um_compact_sortable_positions
+            self.class
+                .where("position > ?", position)
+                .update_all("position = position - 1")
+          end
+        RUBY
+
+        sortable_model_code << "\n" if existing_model_body
+
+        inject_into_class(
+          model_path,
+          class_name,
+          sortable_model_code
         )
 
         say_status(
@@ -217,6 +267,14 @@ module B4um
         )
       end
 
+      def fixture_path
+        File.join(
+          destination_root,
+          "test/fixtures",
+          "#{plural_table_name}.yml"
+        )
+      end
+
       def model_path
         File.join(
           destination_root,
@@ -322,15 +380,16 @@ module B4um
 
             head :no_content
           end
-
         RUBY
 
+        action = action.rstrip
+
         private_marker = "\n  private\n"
 
         if controller_content.include?(private_marker)
           insert_into_file(
             controller_path,
-            action,
+            "\n#{action}\n",
             before: private_marker
           )
         else
@@ -341,10 +400,10 @@ module B4um
                   "Could not find the end of app/controllers/#{plural_table_name}_controller.rb"
           end
 
-          insert_into_file(
+          gsub_file(
             controller_path,
-            "\n#{action}",
-            before: controller_end
+            controller_end,
+            "\n\n#{action}\nend\n"
           )
         end
       end
@@ -354,7 +413,7 @@ module B4um
         return if controller_content.include?("if request.get?")
 
         sort_action =
-          /^(\s*)def sort\s*$/
+          /^([ \t]*)def sort[ \t]*$/
 
         unless controller_content.match?(sort_action)
           raise Thor::Error,
@@ -365,15 +424,15 @@ module B4um
           controller_path,
           sort_action
         ) do |match|
-          indentation = match[/\A\s*/]
-
-          <<~RUBY.chomp
-            #{match}
-            #{indentation}  if request.get?
-            #{indentation}    @#{plural_table_name} = #{class_name}.order(:position, :id)
-            #{indentation}    return
-            #{indentation}  end
-          RUBY
+          indentation = match[/\A[ \t]*/]
+
+          [
+            match,
+            "#{indentation}  if request.get?",
+            "#{indentation}    @#{plural_table_name} = #{class_name}.order(:position, :id)",
+            "#{indentation}    return",
+            "#{indentation}  end"
+          ].join("\n")
         end
       end
 
@@ -510,19 +569,28 @@ module B4um
       end
 
       def schema_contains_position?
-        schema_path = File.join(destination_root, "db/schema.rb")
+        schema_path = File.join(
+          destination_root,
+          "db/schema.rb"
+        )
 
         return false unless File.exist?(schema_path)
 
         schema = File.read(schema_path)
 
         table_pattern = /
-          create_table\s+"#{Regexp.escape(plural_table_name)}".*?^  end
+          ^[ \t]*create_table\s+"#{Regexp.escape(plural_table_name)}".*?\n
+          (?<table_body>.*?)
+          ^[ \t]{2}end\s*$
         /mx
 
-        table = schema[table_pattern]
+        match = schema.match(table_pattern)
 
-        table&.match?(/t\.integer\s+"position"/) || false
+        return false unless match
+
+        match[:table_body].match?(
+          /^[ \t]+t\.integer\s+"position"/
+        )
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: b4um_generators
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Alexander Baum