b4um_generators 0.1.0

data/lib/generators/b4um/pagination/pagination_generator.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/named_base"
+
+module B4um
+  module Generators
+    class PaginationGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :per_page,
+                   type: :numeric,
+                   default: 20,
+                   desc: "Number of records per page"
+
+      class << self
+        def desc(_description = nil)
+          "Adds B4UM pagination to an existing resource."
+        end
+      end
+
+      def validate_model
+        return if File.exist?(model_path)
+
+        raise Thor::Error,
+              "Model not found: app/models/#{file_name}.rb"
+      end
+
+      def validate_controller
+        return if File.exist?(controller_path)
+
+        raise Thor::Error,
+              "Controller not found: app/controllers/#{plural_table_name}_controller.rb"
+      end
+
+      def validate_index_view
+        return if File.exist?(index_view_path)
+
+        raise Thor::Error,
+              "Index view not found: app/views/#{plural_table_name}/index.html.erb"
+      end
+
+      def validate_per_page
+        return if options[:per_page].positive?
+
+        raise Thor::Error,
+              "--per-page must be greater than 0"
+      end
+
+      def create_pagination_concern
+        template(
+          "pagination.rb",
+          "app/controllers/concerns/b4um_pagination.rb"
+        )
+      end
+
+      def create_pagination_partial
+        template(
+          "_pagination.html.erb.tt",
+          "app/views/shared/_pagination.html.erb"
+        )
+      end
+
+      def update_controller
+        controller_content = File.read(controller_path)
+
+        unless controller_content.include?("include B4umPagination")
+          inject_into_class(
+            controller_path,
+            "#{class_name.pluralize}Controller",
+            "  include B4umPagination\n\n"
+          )
+
+          controller_content = File.read(controller_path)
+        end
+
+        return if controller_content.include?(paginated_collection)
+
+        if controller_content.match?(search_pattern)
+          paginate_existing_search
+          return
+        end
+
+        paginate_plain_collection(controller_content)
+      end
+
+      def update_index_view
+        index_content = File.read(index_view_path)
+
+        return if index_content.include?('render "shared/pagination"')
+
+        append_to_file(
+          index_view_path,
+          <<~ERB
+
+            <%= render "shared/pagination", pagination: @pagination %>
+          ERB
+        )
+      end
+
+      private
+
+      def paginated_collection
+        "@#{plural_table_name}, @pagination = b4um_paginate("
+      end
+
+      def search_pattern
+        /
+          @#{Regexp.escape(plural_table_name)}\s*=\s*
+          b4um_search\(\s*
+          #{Regexp.escape(class_name)}\.all,\s*
+          params\[:q\]\s*
+          \)
+        /x
+      end
+
+      def paginate_existing_search
+        gsub_file(
+          controller_path,
+          search_pattern,
+          [
+            "@#{plural_table_name}, @pagination = b4um_paginate(",
+            "      b4um_search(",
+            "        #{class_name}.all,",
+            "        params[:q]",
+            "      ),",
+            "      per_page: #{options[:per_page]}",
+            "    )"
+          ].join("\n")
+        )
+      end
+
+      def paginate_plain_collection(controller_content)
+        old_index = "@#{plural_table_name} = #{class_name}.all"
+
+        unless controller_content.include?(old_index)
+          raise Thor::Error,
+                "Could not find the index collection in app/controllers/#{plural_table_name}_controller.rb"
+        end
+
+        gsub_file(
+          controller_path,
+          old_index,
+          [
+            "@#{plural_table_name}, @pagination = b4um_paginate(",
+            "      #{class_name}.all,",
+            "      per_page: #{options[:per_page]}",
+            "    )"
+          ].join("\n")
+        )
+      end
+
+      def model_path
+        File.join(
+          destination_root,
+          "app/models",
+          "#{file_name}.rb"
+        )
+      end
+
+      def controller_path
+        File.join(
+          destination_root,
+          "app/controllers",
+          "#{plural_table_name}_controller.rb"
+        )
+      end
+
+      def index_view_path
+        File.join(
+          destination_root,
+          "app/views",
+          plural_table_name,
+          "index.html.erb"
+        )
+      end
+    end
+  end
+end

data/lib/generators/b4um/pagination/templates/_pagination.html.erb.tt

@@ -0,0 +1,48 @@
+<%% if pagination.total_pages > 1 %>
+  <nav class="b4um-pagination" aria-label="Pagination">
+    <div class="b4um-pagination__previous">
+      <%% if pagination.previous_page %>
+        <%%= link_to "Previous",
+                    url_for(request.query_parameters.merge(page: pagination.previous_page)),
+                    class: "button button--secondary" %>
+      <%% end %>
+    </div>
+
+    <div class="b4um-pagination__pages">
+      <%% pages = (1..pagination.total_pages).select do |page| %>
+        <%% page == 1 ||
+           page == pagination.total_pages ||
+           (page - pagination.current_page).abs <= 2 %>
+      <%% end %>
+
+      <%% previous_page = nil %>
+
+      <%% pages.each do |page| %>
+        <%% if previous_page && page > previous_page + 1 %>
+          <span class="b4um-pagination__ellipsis" aria-hidden="true">…</span>
+        <%% end %>
+
+        <%% if page == pagination.current_page %>
+          <span class="b4um-pagination__current"
+                aria-current="page">
+            <%%= page %>
+          </span>
+        <%% else %>
+          <%%= link_to page,
+                      url_for(request.query_parameters.merge(page: page)),
+                      class: "b4um-pagination__page" %>
+        <%% end %>
+
+        <%% previous_page = page %>
+      <%% end %>
+    </div>
+
+    <div class="b4um-pagination__next">
+      <%% if pagination.next_page %>
+        <%%= link_to "Next",
+                    url_for(request.query_parameters.merge(page: pagination.next_page)),
+                    class: "button button--secondary" %>
+      <%% end %>
+    </div>
+  </nav>
+<%% end %>

data/lib/generators/b4um/pagination/templates/pagination.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module B4umPagination
+  Pagination = Data.define(
+    :current_page,
+    :per_page,
+    :total_count,
+    :total_pages,
+    :previous_page,
+    :next_page
+  )
+
+  private
+
+  def b4um_paginate(scope, per_page:)
+    current_page = [params.fetch(:page, 1).to_i, 1].max
+    total_count = scope.count
+    total_pages = [(total_count.to_f / per_page).ceil, 1].max
+    current_page = [current_page, total_pages].min
+
+    records = scope
+              .limit(per_page)
+              .offset((current_page - 1) * per_page)
+
+    pagination = Pagination.new(
+      current_page: current_page,
+      per_page: per_page,
+      total_count: total_count,
+      total_pages: total_pages,
+      previous_page: current_page > 1 ? current_page - 1 : nil,
+      next_page: current_page < total_pages ? current_page + 1 : nil
+    )
+
+    [records, pagination]
+  end
+end

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

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "action_dispatch"
+require "rails/generators/rails/scaffold/scaffold_generator"
+
+module B4um
+  module Generators
+    class ScaffoldGenerator < Rails::Generators::ScaffoldGenerator
+      source_root File.expand_path("templates", __dir__)
+
+      class << self
+        def desc(_description = nil)
+          "Generates a B4UM scaffold."
+        end
+      end
+
+      class_option :param,
+                   type: :string,
+                   desc: "Attribute used for a readable URL parameter"
+
+      class_option :layout,
+                   type: :string,
+                   default: "bento",
+                   enum: %w[bento table],
+                   desc: "Index layout: bento or table"
+
+      def create_b4um_form
+        form_path = File.join(
+          "app/views",
+          plural_table_name,
+          "_form.html.erb"
+        )
+
+        remove_file form_path
+
+        template(
+          "_form.html.erb.tt",
+          form_path
+        )
+      end
+
+      def create_b4um_resource
+        resource_path = File.join(
+          "app/views",
+          plural_table_name,
+          "_#{singular_table_name}.html.erb"
+        )
+
+        remove_file resource_path
+
+        template(
+          "_resource.html.erb.tt",
+          resource_path
+        )
+      end
+
+      def create_b4um_index
+        index_path = File.join(
+          "app/views",
+          plural_table_name,
+          "index.html.erb"
+        )
+
+        partial_path = File.join(
+          "app/views",
+          plural_table_name,
+          "_#{options[:layout]}.html.erb"
+        )
+
+        remove_file index_path
+
+        template(
+          "index.html.erb.tt",
+          index_path
+        )
+
+        template(
+          "_#{options[:layout]}.html.erb.tt",
+          partial_path
+        )
+      end
+
+      def create_b4um_show
+        show_path = File.join(
+          "app/views",
+          plural_table_name,
+          "show.html.erb"
+        )
+
+        remove_file show_path
+
+        template(
+          "show.html.erb.tt",
+          show_path
+        )
+      end
+
+      def create_b4um_new
+        new_path = File.join(
+          "app/views",
+          plural_table_name,
+          "new.html.erb"
+        )
+
+        remove_file new_path
+
+        template(
+          "new.html.erb.tt",
+          new_path
+        )
+      end
+
+      def create_b4um_edit
+        edit_path = File.join(
+          "app/views",
+          plural_table_name,
+          "edit.html.erb"
+        )
+
+        remove_file edit_path
+
+        template(
+          "edit.html.erb.tt",
+          edit_path
+        )
+      end
+
+      def add_secure_password
+        return unless attributes.any? { |attribute| attribute.name == "password_digest" }
+
+        inject_into_class(
+          File.join("app/models", "#{singular_table_name}.rb"),
+          class_name,
+          "  has_secure_password\n"
+        )
+      end
+
+      def add_bcrypt
+        return unless attributes.any? { |attribute| attribute.name == "password_digest" }
+
+        gemfile_path = "Gemfile"
+        gemfile = File.read(gemfile_path)
+
+        if gemfile.match?(/^#\s*gem ["']bcrypt["']/)
+          uncomment_lines gemfile_path, /gem ["']bcrypt["']/
+        elsif !gemfile.match?(/^gem ["']bcrypt["']/)
+          gem "bcrypt", "~> 3.1"
+        end
+      end
+
+      def update_password_params
+        return unless attributes.any? { |attribute| attribute.name == "password_digest" }
+
+        controller_path = File.join(
+          "app/controllers",
+          "#{plural_table_name}_controller.rb"
+        )
+
+        gsub_file(
+          controller_path,
+          ":password_digest",
+          ":password, :password_confirmation"
+        )
+      end
+
+      def update_multiple_attachments
+        attachment_attributes = attributes.select do |attribute|
+          attribute.type == :attachments
+        end
+
+        return if attachment_attributes.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(
+          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")
+        )
+
+        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")
+        )
+
+        attachment_names.each do |name|
+          gsub_file(
+            controller_path,
+            "#{name}: []",
+            "#{name}: [], remove_#{name}_ids: []"
+          )
+        end
+      end
+
+      def add_readable_param
+        param_name = options[:param]
+
+        return if param_name.blank?
+
+        unless attributes.any? { |attribute| attribute.name == param_name }
+          say_status(
+            :warning,
+            "--param=#{param_name} ignored: attribute does not exist",
+            :yellow
+          )
+
+          return
+        end
+
+        inject_into_class(
+          File.join("app/models", "#{singular_table_name}.rb"),
+          class_name,
+          <<~RUBY
+            def to_param
+              "\#{id} \#{#{param_name}}".parameterize
+            end
+          RUBY
+        )
+      end
+
+      def update_destroy_flash
+        controller_path = File.join(
+          "app/controllers",
+          "#{plural_table_name}_controller.rb"
+        )
+
+        controller = File.read(
+          File.join(destination_root, controller_path)
+        )
+
+        # Rails-Scaffold mit respond_to / format.html
+        if controller.match?(
+          /format\.html \{ redirect_to ([^,]+), notice: ("[^"]* was successfully destroyed\."), status: :see_other \}/
+        )
+          gsub_file(
+            controller_path,
+            /
+              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
+          )
+
+          return
+        end
+
+        # 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
+        )
+      end
+
+      def add_navigation_link
+        navigation_path = "app/views/shared/_navigation.html.erb"
+        full_navigation_path = File.join(destination_root, navigation_path)
+
+        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,
+                                 controller: :#{plural_table_name} %>
+
+            #{marker}
+        ERB
+
+        gsub_file(
+          navigation_path,
+          marker,
+          navigation_link.chomp
+        )
+      end
+    end
+  end
+end

data/lib/generators/b4um/scaffold/templates/_bento.html.erb.tt

@@ -0,0 +1,26 @@
+<div id="<%= plural_table_name %>" class="b4um-grid">
+  <%% <%= plural_table_name %>.each_with_index do |<%= singular_table_name %>, index| %>
+    <%% card_class =
+      case index % 5
+      when 0
+        "b4um-card b4um-card--wide"
+      when 1
+        "b4um-card b4um-card--soft"
+      when 3
+        "b4um-card b4um-card--large"
+      else
+        "b4um-card"
+      end
+    %>
+
+    <article class="<%%= card_class %>">
+      <%%= render <%= singular_table_name %>, compact: true %>
+
+      <div class="b4um-card__actions">
+        <%%= link_to "Show",
+                    <%= singular_table_name %>,
+                    class: "button button--secondary" %>
+      </div>
+    </article>
+  <%% end %>
+</div>