katalyst-koi 4.0.0

data/config/initializers/pagy.rb

@@ -0,0 +1 @@
+Pagy::I18n.load({ locale: "en", filepath: Koi::Engine.root.join("config/locales/pagy.en.yml") })

data/config/initializers/time_formats.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Time::DATE_FORMATS[:pretty] = ->(time) { time.strftime("%a, %b %e at %l:%M") + time.strftime("%p").downcase }
+Date::DATE_FORMATS[:default] = "%d %b %Y"
+Time::DATE_FORMATS[:default] = "%a, %b %e at %l:%M %p"

data/config/locales/koi.en.yml

@@ -0,0 +1,18 @@
+en:
+  time:
+    formats:
+      default: "%Y-%m-%dT%H:%M:%S.%L%z"
+      display: "%e %B %Y, %l:%M%P"
+  date:
+    formats:
+      default: "%Y-%m-%d"
+      display: "%e %B %Y"
+  koi:
+    labels:
+      new: New
+      search: Search
+  helpers:
+    hint:
+      default:
+        document: Must be less than %{max_size}
+        image: Must be less than %{max_size}

data/config/locales/pagy.en.yml

@@ -0,0 +1,6 @@
+en:
+  pagy:
+    nav:
+      prev: "←  Previous"
+      next: "Next  →"
+      gap: "…"

data/config/routes.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+  namespace :admin do
+    resource :session, only: %i[new create destroy]
+
+    resources :url_rewrites
+    resources :admin_users do
+      resources :credentials, only: %i[new create destroy]
+    end
+
+    resource :cache, only: %i[destroy]
+    resource :dashboard, only: %i[show]
+
+    root to: redirect("admin/dashboard")
+  end
+
+  scope :admin do
+    constraints ->(req) { req.session[:admin_user_id].present? } do
+      mount Katalyst::Content::Engine, at: "content"
+      mount Katalyst::Navigation::Engine, at: "navigation"
+      mount Flipper::UI.app(Flipper) => "flipper" if Object.const_defined?("Flipper::UI")
+    end
+  end
+end

data/db/migrate/20120220130849_devise_create_admins.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class DeviseCreateAdmins < ActiveRecord::Migration[4.2]
+  # rubocop:disable Metrics/BlockLength
+  def change
+    create_table(:admins) do |t|
+      ## Database authenticatable
+      t.string :email,              null: false, default: ""
+      t.string :encrypted_password, null: false, default: ""
+
+      ## Recoverable
+      t.string   :reset_password_token
+      t.datetime :reset_password_sent_at
+
+      ## Rememberable
+      t.datetime :remember_created_at
+
+      ## Trackable
+      t.integer  :sign_in_count, default: 0
+      t.datetime :current_sign_in_at
+      t.datetime :last_sign_in_at
+      t.string   :current_sign_in_ip
+      t.string   :last_sign_in_ip
+
+      ## Encryptable
+      # t.string :password_salt
+
+      ## Confirmable
+      # t.string   :confirmation_token
+      # t.datetime :confirmed_at
+      # t.datetime :confirmation_sent_at
+      # t.string   :unconfirmed_email # Only if using reconfirmable
+
+      ## Lockable
+      # t.integer  :failed_attempts, :default => 0 # Only if lock strategy is :failed_attempts
+      # t.string   :unlock_token # Only if unlock strategy is :email or :both
+      t.datetime :locked_at
+
+      ## Token authenticatable
+      # t.string :authentication_token
+
+      t.string :first_name
+      t.string :last_name
+      t.string :role
+
+      t.timestamps
+    end
+
+    add_index :admins, :email,                unique: true
+    add_index :admins, :reset_password_token, unique: true
+    # add_index :koi_admins, :confirmation_token,   :unique => true
+    # add_index :koi_admins, :unlock_token,         :unique => true
+    # add_index :koi_admins, :authentication_token, :unique => true
+  end
+  # rubocop:enable Metrics/BlockLength
+end

data/db/migrate/20130509235316_add_url_rewriter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class AddUrlRewriter < ActiveRecord::Migration[4.2]
+  def change
+    create_table :url_rewrites do |t|
+      t.text    :from
+      t.text    :to
+      t.boolean :active, default: true
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20230213053854_convert_devise_admins_to_rails.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ConvertDeviseAdminsToRails < ActiveRecord::Migration[7.0]
+  def change
+    rename_column :admins, :encrypted_password, :password_digest
+  end
+end

data/db/migrate/20230412023411_create_admin_user_credentials.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class CreateAdminUserCredentials < ActiveRecord::Migration[7.0]
+  def change
+    create_table :admin_credentials do |t|
+      t.string "external_id", index: { unique: true }
+      t.references :admin, null: false, foreign_key: true
+
+      t.string "public_key"
+      t.string "nickname"
+      t.bigint "sign_count", default: 0, null: false
+
+      t.timestamps
+    end
+
+    change_table :admins do |t|
+      t.column :webauthn_id, :string
+    end
+  end
+end

data/db/migrate/20230531063707_update_admin_users.rb

@@ -0,0 +1,37 @@
+class UpdateAdminUsers < ActiveRecord::Migration[7.0]
+  class Admin < ActiveRecord::Base; end
+
+  def up
+    add_column :admins, :name, :string
+
+    Admin.all.each do |admin|
+      admin.name = "#{admin.first_name} #{admin.last_name}"
+      admin.save!
+    end
+
+    remove_column :admins, :first_name, :string
+    remove_column :admins, :last_name, :string
+    remove_column :admins, :reset_password_token, :string, index: { unique: true }
+    remove_column :admins, :reset_password_sent_at, :datetime
+    remove_column :admins, :remember_created_at, :datetime
+    remove_column :admins, :locked_at, :datetime
+    remove_column :admins, :role, :string
+  end
+
+  def down
+    add_column :admins, :first_name, :string
+    add_column :admins, :last_name, :string
+    add_column :admins, :reset_password_token, :string, index: { unique: true }
+    add_column :admins, :reset_password_sent_at, :datetime
+    add_column :admins, :remember_created_at, :datetime
+    add_column :admins, :locked_at, :datetime
+    add_column :admins, :role, :string
+
+    Admin.all.each do |admin|
+      admin.first_name, admin.last_name = admin.name.split(' ', 2)
+      admin.save!
+    end
+
+    remove_column :admins, :name, :string
+  end
+end

data/db/migrate/20230602033610_add_archived_to_admin_users.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddArchivedToAdminUsers < ActiveRecord::Migration[7.0]
+  def change
+    add_column :admins, :archived_at, :datetime
+  end
+end

data/db/seeds.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Create a default admin user (only in development)
+if Rails.env.development? && !ENV["CI"]
+  Admin::User.create_with(
+    name:     `id -F`.strip,
+    password: "password",
+  ).find_or_create_by(email: "#{ENV['USER']}@katalyst.com.au")
+end

data/lib/generators/koi/active_record/active_record_generator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record/model/model_generator"
+
+module Koi
+  class ActiveRecordGenerator < ActiveRecord::Generators::ModelGenerator
+    source_root ActiveRecord::Generators::ModelGenerator.source_root
+
+    def admin_search
+      "PgSearch::Model".safe_constantize ? pg_search : sql_search
+    end
+
+    private
+
+    def pg_search
+      insert_into_file "app/models/#{file_name}.rb", after: "class #{class_name} < ApplicationRecord\n" do
+        <<~RUBY
+          include PgSearch::Model
+        RUBY
+      end
+
+      insert_into_file "app/models/#{file_name}.rb", before: "end\n" do
+        <<~RUBY
+          pg_search :admin_search, against: %i[#{search_fields.join(' ')}], using: { tsearch: { prefix: true } }
+        RUBY
+      end
+    end
+
+    def sql_search
+      insert_into_file "app/models/#{file_name}.rb", before: "end\n" do
+        <<~RUBY
+          scope :admin_search, ->(query) do
+            where("#{search_fields.map { |f| "#{f} LIKE :query" }.join(' OR ')}", query: "%\#{query}%")
+          end
+        RUBY
+      end
+    end
+
+    def search_fields
+      attributes.select { |attr| attr.type == :string }.map(&:name)
+    end
+  end
+end

data/lib/generators/koi/admin/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates a model with Koi admin crud
+
+Example:
+    bin/rails generate koi:admin Test name:string description:text
+
+    This will create a new model using the rails model generator, then run
+    the Koi admin controller generator.

data/lib/generators/koi/admin/admin_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails/generators/rails/scaffold/scaffold_generator"
+
+module Koi
+  class AdminGenerator < Rails::Generators::ScaffoldGenerator
+    # Replace the default model generator with our own
+    remove_hook_for(:orm)
+    hook_for(:orm, in: :koi, as: :admin, default: true)
+
+    # Disable default controller generation as we do not want to generate public
+    # controllers by default
+    remove_hook_for(:scaffold_controller)
+    remove_hook_for(:resource_route)
+
+    hook_for :admin_controller, in: :koi, as: :admin, type: :boolean, default: true
+
+    Rails::Generators::ModelGenerator.hook_for :admin_search, type: :boolean, default: true
+  end
+end

data/lib/generators/koi/admin_controller/USAGE

@@ -0,0 +1,17 @@
+Description:
+    Generates a Koi admin crud for the given model
+
+Example:
+    bin/rails generate koi:admin_controller Test
+
+    This will create:
+        app/controllers/admin/tests_controller.rb
+        app/views/admin/tests/_form_fields.html.erb
+        app/views/admin/tests/edit.html.erb
+        app/views/admin/tests/index.html.erb
+        app/views/admin/tests/new.html.erb
+        app/views/admin/tests/show.html.erb
+
+    This will update:
+        config/routes/admin.rb to include `resources :tests` to the :admin namespace
+        config/initializers/koi.rb to include "Tests => /admin/tests" in the Modules section

data/lib/generators/koi/admin_controller/admin_controller_generator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+require "rails/generators/resource_helpers"
+
+module Koi
+  class AdminControllerGenerator < Rails::Generators::NamedBase
+    include Rails::Generators::ResourceHelpers
+
+    source_root File.expand_path("templates", __dir__)
+
+    check_class_collision prefix: "Admin::", suffix: "Controller"
+
+    argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+    def create_controller_files
+      template("controller.rb",
+               File.join("app/controllers/admin",
+                         controller_class_path,
+                         "#{controller_file_name}_controller.rb"))
+    end
+
+    def create_spec_files
+      template("controller_spec.rb",
+               File.join("spec/requests/admin",
+                         controller_class_path,
+                         "#{controller_file_name}_controller_spec.rb"))
+    end
+
+    hook_for(:admin_views, in: :koi, type: :boolean, default: true)
+    hook_for(:admin_route, in: :koi, type: :boolean, default: true)
+
+    private
+
+    def permitted_params
+      attachments, others = attributes_names.partition { |name| attachments?(name) }
+      params              = others.map { |name| ":#{name}" }
+      params += attachments.map { |name| "#{name}: []" }
+      params.join(", ")
+    end
+
+    def attachments?(name)
+      attribute = attributes.find { |attr| attr.name == name }
+      attribute&.attachments?
+    end
+
+    def search_attribute
+      attributes.find { |attr| attr.type == :string }&.name
+    end
+  end
+end

data/lib/generators/koi/admin_controller/templates/controller.rb.tt

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Admin
+  class <%= controller_class_name %>Controller < ApplicationController
+
+    before_action :set_<%= singular_name %>, only: %i[show edit update destroy]
+
+    def index
+      collection = Collection.new.with_params(params).apply(::<%= class_name %>.strict_loading.all)
+      table      = Koi::IndexTableComponent.new(collection:)
+
+      respond_to do |format|
+        format.turbo_stream { render table } if self_referred?
+        format.html { render :index, locals: { table:, collection: } }
+      end
+    end
+
+    def show
+      render locals: { <%= singular_name %>: @<%= singular_name %> }
+    end
+
+    def new
+      render locals: { <%= singular_name %>: ::<%= class_name %>.new }
+    end
+
+    def edit
+      render locals: { <%= singular_name %>: @<%= singular_name %> }
+    end
+
+    def create
+      @<%= singular_name %> = ::<%= class_name %>.new(<%= singular_name %>_params)
+
+      if @<%= singular_name %>.save
+        redirect_to [:admin, @<%= singular_name %>]
+      else
+        render :new, locals: { <%= singular_name %>: @<%= singular_name %> }, status: :unprocessable_entity
+      end
+    end
+
+    def update
+      if @<%= singular_name %>.update(<%= singular_name %>_params)
+        redirect_to action: :show
+      else
+        render :edit, locals: { <%= singular_name %>: @<%= singular_name %> }, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @<%= singular_name %>.destroy
+
+      redirect_to action: :index
+    end
+
+    private
+
+    # Only allow a list of trusted parameters through.
+    def <%= "#{singular_table_name}_params" %>
+      <%- if attributes_names.empty? -%>
+        params.fetch(:<%= singular_table_name %>, {})
+      <%- else -%>
+        params.require(:<%= singular_table_name %>).permit(<%= permitted_params %>)
+      <%- end -%>
+    end
+
+    # Use callbacks to share common setup or constraints between actions.
+    def set_<%= singular_table_name %>
+      @<%= singular_table_name %> = ::<%= class_name %>.find(params[:id])
+    end
+
+    class Collection < Katalyst::Tables::Collection::Base
+      attribute :search, :string
+
+      config.sorting  = :<%= search_attribute %>
+      config.paginate = true
+
+      def filter
+        self.items = items.admin_search(search) if search.present?
+      end
+    end
+  end
+end

data/lib/generators/koi/admin_controller/templates/controller_spec.rb.tt

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Admin::<%= controller_class_name %>Controller do
+  let(:admin) { create(:admin) }
+  let(:model) { create(:<%= singular_name %>) }
+
+  include_context "with admin session"
+
+  describe "GET /admin/<%= plural_name %>" do
+    let(:action) { get polymorphic_path([:admin, <%= class_name %>]) }
+
+    it_behaves_like "requires admin"
+
+    it "renders successfully" do
+      action
+      expect(response).to have_http_status(:success)
+    end
+
+    context "with a large collection" do
+      before { create_list(:<%= singular_name %>, 25) }
+
+      it "paginates the collection" do
+        action
+        expect(response.body).to have_selector("tbody tr", count: 20)
+      end
+    end
+
+    context "with sort parameter" do
+      let(:action) { get polymorphic_path([:admin, <%= class_name %>], sort: "<%= search_attribute %> desc") }
+
+      before do
+        create(:<%= singular_name %>, <%= search_attribute %>: "first")
+        create(:<%= singular_name %>, <%= search_attribute %>: "second")
+      end
+
+      it "finds first in second place" do
+        action
+        expect(response.body).to have_selector("tbody tr + tr td", text: "first")
+      end
+    end
+
+    context "with search parameter" do
+      let(:action) { get polymorphic_path([:admin, <%= class_name %>], search: "first") }
+
+      before do
+        create(:<%= singular_name %>, <%= search_attribute %>: "first")
+        create(:<%= singular_name %>, <%= search_attribute %>: "second")
+      end
+
+      it "finds the needle" do
+        action
+        expect(response.body).to have_selector("table td", text: "first")
+      end
+
+      it "removes the chaff" do
+        action
+        expect(response.body).not_to have_selector("table td", text: "second")
+      end
+    end
+  end
+
+  describe "GET /admin/<%= plural_name %>/new" do
+    let(:action) { get new_polymorphic_path([:admin, <%= class_name %>]) }
+
+    it_behaves_like "requires admin"
+
+    it "renders successfully" do
+      action
+      expect(response).to have_http_status(:success)
+    end
+  end
+
+  describe "POST /admin/<%= plural_name %>" do
+    let(:action) { post polymorphic_path([:admin, <%= class_name %>]), params: { <%= singular_name %>: params } }
+    let(:params) { attributes_for(:<%= singular_name %>) }
+
+    it_behaves_like "requires admin"
+
+    it "renders successfully" do
+      action
+      expect(response).to redirect_to([:admin, assigns(:<%= singular_name %>)])
+    end
+
+    it "creates a <%= singular_name %>" do
+      expect { action }.to change(<%= class_name %>, :count).by(1)
+    end
+  end
+
+  describe "GET /admin/<%= plural_name %>/:id" do
+    let(:action) { get polymorphic_path([:admin, model]) }
+
+    it_behaves_like "requires admin"
+
+    it "renders successfully" do
+      action
+      expect(response).to have_http_status(:success)
+    end
+  end
+
+  describe "GET /admin/<%= plural_name %>/:id/edit" do
+    let(:action) { get edit_polymorphic_path([:admin, model]) }
+
+    it_behaves_like "requires admin"
+
+    it "renders successfully" do
+      action
+      expect(response).to have_http_status(:success)
+    end
+  end
+
+  describe "PATCH /admin/<%= plural_name %>/:id" do
+    let(:action) { patch polymorphic_path([:admin, model]), params: { <%= singular_name %>: params } }
+    let(:params) { attributes_for(:<%= singular_name %>) }
+
+    it_behaves_like "requires admin"
+
+    it "renders successfully" do
+      action
+      expect(response).to redirect_to(polymorphic_path([:admin, model]))
+    end
+  end
+
+  describe "DELETE /admin/<%= plural_name %>/:id" do
+    let(:action) { delete polymorphic_path([:admin, model]) }
+
+    it_behaves_like "requires admin"
+
+    it "renders successfully" do
+      action
+      expect(response).to redirect_to(polymorphic_path([:admin, <%= class_name %>]))
+    end
+  end
+end

data/lib/generators/koi/admin_route/admin_route_generator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "rails/generators/named_base"
+require "rails/generators/resource_helpers"
+
+module Koi
+  class AdminRouteGenerator < Rails::Generators::NamedBase
+    include Rails::Generators::ResourceHelpers
+
+    def add_route
+      route "resources :#{file_name.pluralize}", namespace: regular_class_path
+    end
+
+    def add_navigation
+      insert_into_file("config/initializers/koi.rb",
+                       "  \"#{[*regular_class_path.map(&:humanize),
+                               human_name.pluralize].join(' ')}\" => \"/admin#{route_url}\",\n",
+                       after: "Koi::Menu.modules = {\n")
+    end
+
+    private
+
+    # See Rails::Generators::Actions
+    # Replaces hard-coded route with admin route file
+    def route(routing_code, namespace: nil)
+      namespace = Array(namespace)
+      namespace_pattern = route_namespace_pattern(namespace)
+      routing_code = namespace.reverse.reduce(routing_code) do |code, name|
+        "namespace :#{name} do\n#{rebase_indentation(code, 2)}end"
+      end
+
+      log :route, routing_code
+
+      in_root do
+        if (namespace_match = match_file(route_file, namespace_pattern))
+          base_indent, *, existing_block_indent = namespace_match.captures.compact.map(&:length)
+          existing_line_pattern = /^ {,#{existing_block_indent}}\S.+\n?/
+          routing_code = rebase_indentation(routing_code, base_indent + 2).gsub(existing_line_pattern, "")
+          namespace_pattern = /#{Regexp.escape namespace_match.to_s}/
+        end
+
+        inject_into_file route_file, routing_code, after: namespace_pattern, verbose: true, force: false
+      end
+    end
+
+    # See Rails::Generators::Actions
+    # Replaces Routes.draw with namespace :admin as the search term
+    def route_namespace_pattern(namespace)
+      namespace.each_with_index.reverse_each.reduce(nil) do |pattern, (name, i)|
+        cummulative_margin = "\\#{i + 1}[ ]{2}"
+        blank_or_indented_line = "^[ ]*\n|^#{cummulative_margin}.*\n"
+        "(?:(?:#{blank_or_indented_line})*?^(#{cummulative_margin})namespace :#{name} do\n#{pattern})?"
+      end.then do |pattern|
+        /^( *)namespace :admin do\n#{pattern}/
+      end
+    end
+
+    def route_file
+      "config/routes/admin.rb"
+    end
+  end
+end

data/lib/generators/koi/admin_views/USAGE

@@ -0,0 +1,12 @@
+Description:
+    Generates a Koi admin crud views for the given model
+
+Example:
+    bin/rails generate koi:admin_views Test
+
+    This will create:
+        app/views/admin/tests/_fields.html.erb
+        app/views/admin/tests/edit.html.erb
+        app/views/admin/tests/index.html.erb
+        app/views/admin/tests/new.html.erb
+        app/views/admin/tests/show.html.erb