b4um_generators 0.1.0

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/b4um_generators.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "lib/b4um_generators/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "b4um_generators"
+  spec.version = B4umGenerators::VERSION
+  spec.authors = ["Alexander Baum"]
+  spec.email = ["info@b4um.com"]
+
+  spec.summary = "Rails generators for b4um applications"
+  spec.description = "Reusable Rails generators, templates and application defaults for b4um projects."
+  spec.homepage = "https://www.b4um.com"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |file|
+      file.start_with?("test/", "spec/", "features/", ".git", "Gemfile")
+    end
+  end
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |file| File.basename(file) }
+  spec.require_paths = ["lib"]
+  spec.add_dependency "railties", ">= 8.0", "< 9.0"
+end

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "b4um_generators"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/b4um_generators/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module B4umGenerators
+  VERSION = "0.1.0"
+end

data/lib/b4um_generators.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "b4um_generators/version"
+
+module B4umGenerators
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/generators/b4um/bento/bento_generator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/named_base"
+
+module B4um
+  module Generators
+    class BentoGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :layout,
+                   type: :string,
+                   default: "grid",
+                   enum: %w[bento grid list alternating],
+                   desc: "Layout: bento, grid, list, or alternating"
+
+      class << self
+        def desc(_description = nil)
+          "Generates a B4UM Bento partial for an existing model."
+        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_resource_partial
+        return if File.exist?(resource_partial_path)
+
+        raise Thor::Error,
+              "Resource partial not found: app/views/#{plural_table_name}/_#{file_name}.html.erb"
+      end
+
+      def create_bento_partial
+        template(
+          template_name,
+          File.join(
+            "app/views",
+            plural_table_name,
+            "_bento.html.erb"
+          )
+        )
+      end
+
+      private
+
+      def model_path
+        File.join(
+          destination_root,
+          "app/models",
+          "#{file_name}.rb"
+        )
+      end
+
+      def resource_partial_path
+        File.join(
+          destination_root,
+          "app/views",
+          plural_table_name,
+          "_#{file_name}.html.erb"
+        )
+      end
+
+      def template_name
+        case options[:layout]
+        when "grid"
+          "_grid.html.erb.tt"
+        when "list"
+          "_list.html.erb.tt"
+        when "alternating"
+          "_alternating.html.erb.tt"
+        else
+          "_bento.html.erb.tt"
+        end
+      end
+    end
+  end
+end

data/lib/generators/b4um/bento/templates/_alternating.html.erb.tt

@@ -0,0 +1,15 @@
+<div id="<%= plural_table_name %>" class="b4um-alternating">
+  <%% <%= plural_table_name %>.each_with_index do |<%= file_name %>, index| %>
+    <article class="b4um-alternating__item <%%= "b4um-alternating__item--reverse" if index.odd? %>">
+      <div class="b4um-alternating__content">
+        <%%= render <%= file_name %>, compact: true %>
+      </div>
+
+      <div class="b4um-alternating__actions">
+        <%%= link_to "Show",
+                    <%= file_name %>,
+                    class: "button button--secondary" %>
+      </div>
+    </article>
+  <%% end %>
+</div>

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

@@ -0,0 +1,26 @@
+<div id="<%= plural_table_name %>" class="b4um-grid">
+  <%% <%= plural_table_name %>.each_with_index do |<%= file_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 <%= file_name %>, compact: true %>
+
+      <div class="b4um-card__actions">
+        <%%= link_to "Show",
+                    <%= file_name %>,
+                    class: "button button--secondary" %>
+      </div>
+    </article>
+  <%% end %>
+</div>

data/lib/generators/b4um/bento/templates/_grid.html.erb.tt

@@ -0,0 +1,13 @@
+<div id="<%= plural_table_name %>" class="b4um-card-grid">
+  <%% <%= plural_table_name %>.each do |<%= file_name %>| %>
+    <article class="b4um-card">
+      <%%= render <%= file_name %>, compact: true %>
+
+      <div class="b4um-card__actions">
+        <%%= link_to "Show",
+                    <%= file_name %>,
+                    class: "button button--secondary" %>
+      </div>
+    </article>
+  <%% end %>
+</div>

data/lib/generators/b4um/bento/templates/_list.html.erb.tt

@@ -0,0 +1,15 @@
+<div id="<%= plural_table_name %>" class="b4um-list">
+  <%% <%= plural_table_name %>.each do |<%= file_name %>| %>
+    <article class="b4um-list__item">
+      <div class="b4um-list__content">
+        <%%= render <%= file_name %>, compact: true %>
+      </div>
+
+      <div class="b4um-list__actions">
+        <%%= link_to "Show",
+                    <%= file_name %>,
+                    class: "button button--secondary" %>
+      </div>
+    </article>
+  <%% end %>
+</div>

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

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/migration"
+
+module B4um
+  module Generators
+    class CommentsGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Installs polymorphic comments for B4UM resources."
+
+      argument :commentable,
+               type: :string,
+               required: true,
+               banner: "MODEL"
+
+      def self.next_migration_number(_dirname)
+        if @previous_migration_number
+          @previous_migration_number += 1
+        else
+          @previous_migration_number =
+            Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+        end
+
+        @previous_migration_number.to_s
+      end
+
+      def validate_commentable_model
+        model_path = File.join(
+          destination_root,
+          "app/models",
+          "#{commentable.to_s.underscore}.rb"
+        )
+
+        return if File.exist?(model_path)
+
+        raise Thor::Error,
+              "Commentable model not found: app/models/#{commentable.to_s.underscore}.rb"
+      end
+
+      def create_comment_model
+        model_path = File.join(
+          destination_root,
+          "app/models/comment.rb"
+        )
+
+        return if File.exist?(model_path)
+
+        template(
+          "comment.rb.tt",
+          "app/models/comment.rb"
+        )
+      end
+
+      def add_comments_association
+        model_name = commentable.to_s.underscore
+        model_path = File.join(
+          "app/models",
+          "#{model_name}.rb"
+        )
+
+        full_model_path = File.join(
+          destination_root,
+          model_path
+        )
+
+        model = File.read(full_model_path)
+
+        return if model.include?(
+          "has_many :comments,"
+        )
+
+        association = [
+          "  has_many :comments,",
+          "           as: :commentable,",
+          "           dependent: :destroy",
+          ""
+        ].join("\n")
+
+        inject_into_class(
+          model_path,
+          commentable.to_s.classify,
+          association
+        )
+      end
+
+      def create_comments_migration
+        existing_migration = Dir.glob(
+          File.join(
+            destination_root,
+            "db/migrate/*_create_comments.rb"
+          )
+        )
+
+        return if existing_migration.any?
+
+        migration_template(
+          "create_comments.rb.tt",
+          "db/migrate/create_comments.rb"
+        )
+      end
+
+      def create_comments_controller
+        controller_path = "app/controllers/comments_controller.rb"
+        full_controller_path = File.join(destination_root, controller_path)
+
+        unless File.exist?(full_controller_path)
+          template(
+            "comments_controller.rb.tt",
+            controller_path
+          )
+
+          return
+        end
+
+        controller = File.read(full_controller_path)
+
+        unless controller.include?("COMMENTABLES = {")
+          upgraded = upgrade_legacy_comments_controller?(
+            controller_path,
+            controller
+          )
+
+          unless upgraded
+            raise Thor::Error,
+                  "Cannot modify existing CommentsController: " \
+                  "its structure is not recognized by the B4UM generator."
+          end
+        end
+
+        controller = File.read(full_controller_path)
+
+        param_name = "#{commentable.to_s.underscore}_id"
+        class_name = commentable.to_s.classify
+
+        return if controller.include?(
+          %("#{param_name}" => #{class_name})
+        )
+
+        inject_into_file(
+          controller_path,
+          after: "  COMMENTABLES = {\n"
+        ) do
+          %(    "#{param_name}" => #{class_name},\n)
+        end
+      end
+
+      def create_comments_partial
+        partial_path = File.join(
+          destination_root,
+          "app/views/comments/_comments.html.erb"
+        )
+
+        return if File.exist?(partial_path)
+
+        template(
+          "_comments.html.erb.tt",
+          "app/views/comments/_comments.html.erb"
+        )
+      end
+
+      def add_comments_routes
+        routes_path = "config/routes.rb"
+        full_routes_path = File.join(destination_root, routes_path)
+
+        routes = File.read(full_routes_path)
+        resource_name = commentable.to_s.underscore.pluralize
+
+        return if routes.include?(
+          "resources :#{resource_name} do\n    resources :comments"
+        )
+
+        gsub_file(
+          routes_path,
+          "  resources :#{resource_name}\n",
+          [
+            "  resources :#{resource_name} do",
+            "    resources :comments, only: %i[create destroy]",
+            "  end",
+            ""
+          ].join("\n")
+        )
+      end
+
+      def add_comments_to_show_view
+        model_name = commentable.to_s.underscore
+        show_path = File.join(
+          "app/views",
+          model_name.pluralize,
+          "show.html.erb"
+        )
+        full_show_path = File.join(destination_root, show_path)
+
+        return unless File.exist?(full_show_path)
+
+        show_view = File.read(full_show_path)
+        render_line =
+          %(<%= render "comments/comments", commentable: @#{model_name} %>)
+
+        return if show_view.include?(render_line)
+
+        append_to_file(
+          show_path,
+          "\n#{render_line}\n"
+        )
+      end
+
+      private
+
+      def upgrade_legacy_comments_controller?(controller_path, controller)
+        match = controller.match(
+          /@commentable = ([A-Z]\w*(?:::\w+)*)\.find\(\s*params\[:(\w+_id)\]\s*\)/
+        )
+
+        return false unless match
+
+        legacy_class = match[1]
+        legacy_param = match[2]
+
+        commentables = [
+          "",
+          "  COMMENTABLES = {",
+          %(    "#{legacy_param}" => #{legacy_class}),
+          "  }.freeze",
+          ""
+        ].join("\n")
+
+        inject_into_file(
+          controller_path,
+          commentables,
+          after: "class CommentsController < ApplicationController\n"
+        )
+
+        set_commentable = [
+          "  def set_commentable",
+          "    param_name, commentable_class = COMMENTABLES.find do |key, _klass|",
+          "      params[key].present?",
+          "    end",
+          "",
+          "    raise ActiveRecord::RecordNotFound unless param_name",
+          "",
+          "    @commentable = commentable_class.find(params[param_name])",
+          "  end"
+        ].join("\n")
+
+        gsub_file(
+          controller_path,
+          /  def set_commentable\n.*?^  end$/m,
+          set_commentable
+        )
+
+        true
+      end
+    end
+  end
+end

data/lib/generators/b4um/comments/templates/_comments.html.erb.tt

@@ -0,0 +1,63 @@
+<section class="b4um-comments">
+  <div class="page-header">
+    <h2>Comments</h2>
+  </div>
+
+  <div class="b4um-grid">
+    <div class="b4um-card b4um-card--full">
+      <%% if commentable.comments.any? %>
+        <div class="b4um-comments__list">
+          <%% commentable.comments.order(created_at: :desc).each do |comment| %>
+            <article class="b4um-comments__item">
+              <div class="b4um-comments__body">
+                <%%= simple_format(comment.body) %>
+              </div>
+
+              <div class="b4um-comments__meta">
+                <%%= l(comment.created_at, format: :short) %>
+              </div>
+
+              <div class="b4um-comments__actions">
+                <%%= button_to "Delete",
+                              [commentable, comment],
+                              method: :delete,
+                              class: "button button--danger",
+                              form: {
+                                data: {
+                                  turbo_confirm: "Are you sure?"
+                                }
+                              } %>
+              </div>
+            </article>
+          <%% end %>
+        </div>
+      <%% else %>
+        <p class="b4um-comments__empty">
+          No comments yet.
+        </p>
+      <%% end %>
+
+      <div class="b4um-comments__form">
+        <h3>Add comment</h3>
+
+        <%%= form_with model: [commentable, Comment.new],
+                      class: "form" do |form| %>
+          <div class="form-field form-field--textarea">
+            <%%= form.text_area :body,
+                               class: "form-textarea",
+                               placeholder: " ",
+                               required: true %>
+            <%%= form.label :body,
+                           "Comment",
+                           class: "form-label" %>
+          </div>
+
+          <div class="form-actions">
+            <%%= form.submit "Add comment",
+                            class: "form-submit" %>
+          </div>
+        <%% end %>
+      </div>
+    </div>
+  </div>
+</section>

data/lib/generators/b4um/comments/templates/comment.rb.tt

@@ -0,0 +1,5 @@
+class Comment < ApplicationRecord
+  belongs_to :commentable, polymorphic: true
+
+  validates :body, presence: true
+end

data/lib/generators/b4um/comments/templates/comments_controller.rb.tt

@@ -0,0 +1,45 @@
+class CommentsController < ApplicationController
+  COMMENTABLES = {
+    "<%= commentable.to_s.underscore %>_id" => <%= commentable.to_s.classify %>
+  }.freeze
+
+  before_action :set_commentable
+
+  def create
+    @comment = @commentable.comments.build(comment_params)
+
+    if @comment.save
+      redirect_to @commentable,
+                  notice: "Comment was successfully created.",
+                  status: :see_other
+    else
+      redirect_to @commentable,
+                  alert: @comment.errors.full_messages.to_sentence,
+                  status: :see_other
+    end
+  end
+
+  def destroy
+    comment = @commentable.comments.find(params[:id])
+    comment.destroy!
+
+    flash[:deleted] = "Comment was successfully destroyed."
+    redirect_to @commentable, status: :see_other
+  end
+
+  private
+
+  def set_commentable
+    param_name, commentable_class = COMMENTABLES.find do |key, _klass|
+      params[key].present?
+    end
+
+    raise ActiveRecord::RecordNotFound unless param_name
+
+    @commentable = commentable_class.find(params[param_name])
+  end
+
+  def comment_params
+    params.expect(comment: [:body])
+  end
+end

data/lib/generators/b4um/comments/templates/create_comments.rb.tt

@@ -0,0 +1,14 @@
+class CreateComments < ActiveRecord::Migration[8.0]
+  def change
+    create_table :comments do |t|
+      t.text :body, null: false
+
+      t.references :commentable,
+                   polymorphic: true,
+                   null: false,
+                   index: true
+
+      t.timestamps
+    end
+  end
+end