ideasbugs 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 03a9f3a848ba6fbdeba823dd0df27efe24a1fadb9c4856a91e76f46f0a16a409
+  data.tar.gz: 28f63f07db4e1fd53b37946a7ec372fd01221101a4ac51ee380c9b7399917c1c
+SHA512:
+  metadata.gz: f4661d353dc2cad65748718937aeaf2d5f78be428aed86e636b1a51ec27f6199ee030f89c618cb00543aa5572568cf048b3f8ef455e66ee332b777586227f161
+  data.tar.gz: 96a3ecaca262a905312402e6494623d866b642c83ecad73da4fbf80bfde4beb85696abacb549789030570568b751449c2f64eac6cb895c38582e7c13c5132fec

data/CHANGELOG.md

@@ -0,0 +1,114 @@
+# Changelog
+
+## 0.5.0 (2026-07-25)
+
+**The gem is now `ideasbugs`** (formerly `feedback_engine`). Full rebrand:
+
+- Gem name `ideasbugs`, module `Ideasbugs`, repository
+  github.com/yshmarov/ideasbugs.
+- Table `ideasbugs_feedbacks` (was `feedback_engine_feedbacks`), helper
+  `ideasbugs_tag` (was `feedback_engine_tag`), I18n scope `ideasbugs.*`,
+  initializer `config/initializers/ideasbugs.rb`, generator
+  `ideasbugs:install`, widget data attributes `data-ideasbugs-*`.
+- **Upgrading from feedback_engine:** swap the gem in your Gemfile, rename
+  the initializer and its `FeedbackEngine` constants to `Ideasbugs`, update
+  the layout tag/trigger attributes, remount the engine, and migrate:
+
+  ```ruby
+  rename_table :feedback_engine_feedbacks, :ideasbugs_feedbacks
+  # Existing screenshot attachments keep working after:
+  # UPDATE active_storage_attachments SET record_type = 'Ideasbugs::Feedback'
+  #   WHERE record_type = 'FeedbackEngine::Feedback'
+  ```
+
+  Versions ≤ 0.4.2 remain published under the old name; entries below this
+  point describe releases made as `feedback_engine`.
+
+## 0.4.2 (2026-07-25)
+
+- The default title CTA (`feedback_engine.title`, used as the modal heading
+  and by host-rendered triggers) now reads "Send bug/feature request" instead
+  of "Send feedback", localized in all 26 bundled languages.
+- The test suite migrated from RSpec to Minitest (development-only change;
+  nothing in the shipped gem is affected). `bundle exec rake test` and
+  `rake test:system` replace the rspec commands.
+
+## 0.4.1 (2026-07-23)
+
+- The widget JavaScript moved from `app/assets/` to `lib/` (it was always
+  inlined server-side, never served as an asset). Rails auto-registers every
+  engine's `app/assets/*` directory with the host's asset pipeline, so
+  Propshaft hosts were ingesting the file into their asset namespace under
+  the bare logical name `widget.js` — colliding with any other gem or host
+  file of the same name — and needlessly digesting a public copy at
+  precompile. The gem is now invisible to Sprockets/Propshaft entirely.
+  No behavior change.
+
+## 0.4.0 (2026-07-22)
+
+- Removed the clipboard-paste / drag-and-drop / file-chips screenshot intake
+  added in 0.3.0 — pasted files all arrive as `image.png` and the extra UI
+  wasn't worth its complexity. Screenshots are back to a plain file input.
+
+## 0.3.0 (2026-07-22)
+
+- Screenshots can be pasted (Cmd/Ctrl+V) or dragged & dropped anywhere on
+  the feedback form, not just picked via the file dialog. Selected files show
+  as removable chips; non-images are ignored and the configured maximum is
+  enforced at intake. (Removed again in 0.4.0.)
+- The dialog traps Tab focus while open and is labelled for screen readers
+  (`aria-labelledby`).
+- Dashboard search across message, author, and section (case-insensitive,
+  LIKE-wildcard-safe, works on SQLite/PostgreSQL/MySQL).
+- A raising `on_submit` hook no longer turns a saved submission into a 500 —
+  the error is logged and the widget still gets its 201.
+- Releases are automated via RubyGems trusted publishing: pushing a `v*` tag
+  builds and publishes the gem from CI (one-time setup on rubygems.org
+  required; see `.github/workflows/release.yml`).
+
+## 0.2.0 (2026-07-22)
+
+Security:
+
+- Dashboard screenshots are now streamed through an engine route gated by
+  `config.authorize_admin`, instead of linking public Active Storage blob
+  URLs. Screenshots can contain anything a user's screen showed; they are no
+  longer reachable without passing the dashboard's own authorization,
+  regardless of how the host configures blob access. (Also fixes broken
+  images in apps that lock their blob endpoints down.)
+
+Added:
+
+- Per-IP rate limiting on the submission endpoint via Rails' built-in
+  limiter (Rails 7.2+; no-op on 7.1). Default 10 submissions/minute; tune or
+  disable with `config.rate_limit`. Localized 429 message in all 26 languages.
+- Browser-level test suite for the widget (Capybara + headless Chrome):
+  open/submit/validation/screenshot-attach/Escape/custom-trigger flows.
+- CI now tests the full Rails support matrix: 7.1, 7.2, 8.0, and 8.1 across
+  Ruby 3.2–3.4.
+
+## 0.1.0 (2026-07-21)
+
+Initial release.
+
+- Drop-in feedback widget (`<%= feedback_engine_tag %>`): floating button +
+  self-styled modal with type, optional section, message, and optional
+  screenshots. Plain JavaScript, no build step, CSP-nonce aware, Turbo-safe,
+  follows system light/dark appearance and the app's `I18n.locale` (RTL
+  supported).
+- `feedback_engine_feedbacks` table with kind, section, message, status
+  (open / in_review / resolved), page URL, user agent, and loose author
+  attribution.
+- Screenshot uploads via Active Storage with server-side count / size /
+  content-type validation (configurable limits).
+- Built-in triage dashboard at the mount path: status tabs with counts, type
+  filter, detail view with screenshots, status transitions, delete. Gated by
+  `config.authorize_admin` (development-only by default).
+- Configuration hooks: `enabled`, `authorize_admin`, `current_user`,
+  `author_label`, `kinds`, `sections`, `screenshots` limits, `show_button`,
+  `button_label`, `mount_path`, `on_submit`.
+- `feedback_engine:install` generator (initializer, migration, mount).
+- Widget translations for English plus 25 more languages (ar, bg, bn, de, el,
+  es, fr, hi, hr, id, it, ja, ko, lb, nl, pl, pt, ro, ru, th, tr, uk, ur, vi,
+  zh-CN), with a parity spec keeping every locale's key set and interpolation
+  placeholders in sync.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2026 Yaroslav Shmarov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,339 @@
+# ideasbugs
+
+[![Gem Version](https://img.shields.io/gem/v/ideasbugs)](https://rubygems.org/gems/ideasbugs)
+[![Downloads](https://img.shields.io/gem/dt/ideasbugs)](https://rubygems.org/gems/ideasbugs)
+[![CI](https://github.com/yshmarov/ideasbugs/actions/workflows/ci.yml/badge.svg)](https://github.com/yshmarov/ideasbugs/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](MIT-LICENSE)
+
+In-app product feedback collection for Rails. (Formerly published as
+`feedback_engine` — see the [CHANGELOG](CHANGELOG.md) for the rename notes.)
+
+`ideasbugs` adds a **"Send feedback"** widget to your app — bug reports,
+feature requests, general comments, with optional screenshots — and stores
+every submission in your own database. A minimal built-in dashboard lets you
+browse and triage what users send. No third-party service, no data leaves your
+app.
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="demo-widget-dark.png">
+  <img alt="The feedback widget: type, section, message, and screenshots" src="demo-widget-light.png" width="420">
+</picture>
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="demo-dashboard-dark.png">
+  <img alt="The built-in triage dashboard: status tabs, filters, search" src="demo-dashboard-light.png" width="820">
+</picture>
+
+Both the widget and the dashboard follow the viewer's system appearance —
+these screenshots are the same pages in light and dark mode.
+
+## Why not Canny (or another feedback SaaS)?
+
+Hosted feedback tools are great until you notice the trade: your users'
+feedback lives in someone else's database, behind someone else's login, at a
+per-seat price. `ideasbugs` keeps the core loop — collect, triage,
+resolve — inside your app: **your database, your users, your auth, one gem.**
+Attribution plugs into whatever authentication you already have, gating is a
+lambda, and submissions are ordinary ActiveRecord rows you can query, export,
+or wire into Slack. (A public voting board à la Canny is on the
+[roadmap](https://github.com/yshmarov/ideasbugs/issues/1).)
+
+- **Zero UI dependencies.** The widget is plain JavaScript and styles itself.
+  No Tailwind, no Stimulus, no importmap, no build step. The dashboard renders
+  its own styles too.
+- **One line in your layout.** `<%= ideasbugs_tag %>` and you're
+  collecting feedback.
+- **Trigger it your way.** Use the built-in floating button, or hide it and
+  open the form from any element with a `data-ideasbugs-open` attribute.
+- **Screenshots included.** Users can attach up to 3 images (via Active
+  Storage) — limits are configurable and enforced server-side.
+- **Pluggable gating and attribution.** You decide who can send feedback, who
+  can read it, and how a submission is attributed to a user.
+- **Localized.** The widget follows your app's `I18n.locale`; translations ship
+  for English plus 25 more languages — Arabic, Bengali, Bulgarian, Chinese
+  (Simplified), Croatian, Dutch, French, German, Greek, Hindi, Indonesian,
+  Italian, Japanese, Korean, Luxembourgish, Polish, Portuguese, Romanian,
+  Russian, Spanish, Thai, Turkish, Ukrainian, Urdu and Vietnamese — with
+  English fallbacks for everything else. RTL locales render mirrored.
+
+## How it works
+
+1. `ideasbugs_tag` renders a floating **Feedback** button (bottom-right).
+2. Clicking it opens a small self-styled modal: type (bug / feature / other),
+   an optional section select, a message, and optional screenshots.
+3. The form `POST`s to the mounted engine with the page URL, the user agent,
+   and (if you configure it) the current user — stored in the
+   `ideasbugs_feedbacks` table.
+4. You browse and triage submissions at the mount path (`/feedback`): status
+   tabs (open → in review → resolved), type filter, search, screenshots
+   inline.
+
+## Requirements
+
+- Ruby >= 3.2
+- Rails >= 7.1
+- Active Storage (only if you want screenshot uploads)
+
+## Installation
+
+```ruby
+# Gemfile
+gem "ideasbugs"
+```
+
+```bash
+bundle install
+bin/rails generate ideasbugs:install
+bin/rails db:migrate
+```
+
+The generator:
+
+- writes `config/initializers/ideasbugs.rb`,
+- creates the `ideasbugs_feedbacks` migration,
+- mounts the engine in `config/routes.rb`:
+
+  ```ruby
+  mount Ideasbugs::Engine => "/feedback"
+  ```
+
+Then add the widget to your layout, right before `</body>`:
+
+```erb
+<%= ideasbugs_tag %>
+```
+
+> The widget reads the CSRF token from `<meta name="csrf-token">`, which
+> `csrf_meta_tags` in your layout already provides in a standard Rails app.
+
+Boot the app and look for the **Feedback** button in the bottom-right corner.
+Submissions appear at [`/feedback`](http://localhost:3000/feedback) (dashboard
+access defaults to development only — see below).
+
+## Configuration
+
+Everything is optional; the defaults work out of the box.
+
+```ruby
+# config/initializers/ideasbugs.rb
+Ideasbugs.configure do |config|
+  # Who can send feedback. Return false to hide the widget and reject
+  # submissions for this request. Defaults to everyone.
+  config.enabled = ->(request) { true }
+
+  # Who can browse and triage feedback at the mount path.
+  # DEFAULTS TO DEVELOPMENT ONLY — override before deploying.
+  config.authorize_admin = ->(request) { request.env["warden"]&.user&.admin? }
+
+  # Attribute feedback to a user (optional). Return an object responding to
+  # #id, or nil. Receives the request.
+  config.current_user = ->(request) { request.env["warden"]&.user }
+
+  # Label stored for the author and shown in the dashboard.
+  config.author_label = ->(user) { user.try(:email) }
+
+  # Feedback types users can pick from. Labels come from I18n
+  # (ideasbugs.kinds.<kind>).
+  config.kinds = %w[bug feature other]
+
+  # App areas shown as a select in the widget. Empty list hides the select.
+  config.sections = ["Dashboard", "Billing", "Settings"]
+
+  # Screenshot uploads (requires Active Storage).
+  config.screenshots = true
+  config.max_screenshots = 3
+  config.max_screenshot_size = 5.megabytes
+
+  # Per-IP throttle for the submission endpoint (Rails 7.2+; ignored on 7.1).
+  # Keyword arguments for Rails' rate limiter; nil disables throttling.
+  config.rate_limit = { to: 10, within: 1.minute }
+
+  # Show the floating feedback button. Set false and trigger the form from
+  # your own UI instead (see below).
+  config.show_button = true
+
+  # Fixed button text; leave nil to use the localized default.
+  config.button_label = nil
+
+  # Keep in sync with the `mount` in config/routes.rb.
+  config.mount_path = "/feedback"
+
+  # Called with each saved feedback — notify Slack, send an email, etc.
+  config.on_submit = ->(feedback) { FeedbackMailer.with(feedback:).new_feedback.deliver_later }
+end
+```
+
+### Opening the form from your own UI
+
+Prefer a nav item over the floating button? Add `data-ideasbugs-open` to
+any element and (optionally) hide the button:
+
+```ruby
+config.show_button = false # optional
+```
+
+Gate the trigger with the same check the widget uses — `ideasbugs_tag`
+renders nothing when `config.enabled` rejects the request, so an unguarded
+trigger would be a dead button for those users. The gem ships a
+`ideasbugs.title` label ("Send bug/feature request") in every bundled language, so
+a localized trigger needs no keys of your own:
+
+```erb
+<% if Ideasbugs.enabled?(request) %>
+  <button data-ideasbugs-open><%= t("ideasbugs.title") %></button>
+<% end %>
+```
+
+### Loading the widget only where it's used
+
+`ideasbugs_tag` in the layout puts the widget on every page. If your
+only trigger lives on one page, render the tag on that page instead — for
+example into the layout's `<head>` via `content_for`:
+
+```erb
+<%# app/views/layouts/application.html.erb %>
+<head>
+  ...
+  <%= yield :head %>
+</head>
+
+<%# app/views/users/show.html.erb — the page with the trigger %>
+<% content_for :head, ideasbugs_tag %>
+```
+
+This is Turbo-safe: the script installs its document-level listeners once per
+session and re-renders on `turbo:load` (see [Turbo](#turbo)), whether it
+arrives on the first page load or a later visit. The trade-off: a
+`data-ideasbugs-open` element on a page that never rendered the tag
+silently does nothing — if triggers may appear on several pages, keep the tag
+in the layout.
+
+### Protecting the dashboard
+
+The dashboard (index/show/triage) is gated by `config.authorize_admin`, which
+defaults to **development only** so a fresh install can never leak feedback in
+production. Grant access however your app resolves admins:
+
+```ruby
+# Devise:
+config.authorize_admin = ->(request) { request.env["warden"]&.user&.admin? }
+
+# Basic auth, feature flag, IP allowlist — anything based on the request:
+config.authorize_admin = ->(request) { Flipper.enabled?(:feedback_admin) }
+```
+
+You can also wrap the mount in your own routing constraint (the lambda still
+applies on top):
+
+```ruby
+authenticate :user, ->(user) { user.admin? } do
+  mount Ideasbugs::Engine => "/feedback"
+end
+```
+
+### Screenshots
+
+Uploads use Active Storage: `bin/rails active_storage:install` if you haven't
+already. Limits (`max_screenshots`, `max_screenshot_size`) are enforced
+server-side and shown as a hint in the widget. If Active Storage isn't loaded,
+the upload control simply doesn't render and uploads are rejected.
+
+### Notifications
+
+`config.on_submit` runs inline after each save — keep it fast or hand off to a
+job:
+
+```ruby
+config.on_submit = ->(feedback) do
+  SlackNotifier.post("New #{feedback.kind}: #{feedback.message.truncate(100)}")
+end
+```
+
+### Localizing the widget
+
+Every string resolves through Rails I18n under the `ideasbugs.*` scope
+and follows the current `I18n.locale`. Missing keys fall back to English. To
+add a language or reword the bundled copy, define the keys in your own locale
+files (yours win over the gem's):
+
+```yaml
+# config/locales/nl.yml
+nl:
+  ideasbugs:
+    button: "Feedback"
+    title: "Feedback versturen"
+    kinds:
+      bug: "Fout melden"
+      feature: "Functie aanvragen"
+      other: "Overig"
+    # …see config/locales/ideasbugs.en.yml for the full key list
+```
+
+Custom kinds get their labels the same way (`ideasbugs.kinds.<kind>`),
+falling back to `kind.humanize`.
+
+### Light / dark / system appearance
+
+Both the widget and the dashboard follow the operating-system appearance via
+`prefers-color-scheme` — no configuration needed.
+
+## Working with feedback in code
+
+Submissions are ordinary records:
+
+```ruby
+Ideasbugs::Feedback.where(status: "open").newest_first.each do |feedback|
+  puts "[#{feedback.kind}] #{feedback.message} — #{feedback.author_label}"
+end
+```
+
+Each row stores `kind`, `section`, `message`, `status` (`open`, `in_review`,
+`resolved`), `page_url`, `user_agent`, and optional `author_id` /
+`author_label`. Screenshots are Active Storage attachments
+(`feedback.screenshots`).
+
+## Security
+
+- Submission and dashboard access are both gated **on the server** for every
+  request; the dashboard denies everything outside development until you
+  configure `authorize_admin`.
+- Screenshots are **streamed through the dashboard's own gate**, never linked
+  as public Active Storage blob URLs — a screenshot can contain anything a
+  user's screen showed, so it is only reachable by someone who passes
+  `authorize_admin`, regardless of how your app configures blob access.
+- The submission endpoint is **rate-limited per IP** (10/minute by default,
+  via Rails' built-in limiter on Rails 7.2+), so one user or bot can't flood
+  your database with megabytes of uploads.
+- Screenshot count, size, and content type (images only) are validated
+  server-side, regardless of what the client claims.
+- The widget code carries the request's Content-Security-Policy nonce (the
+  same one `ActionDispatch` emits), so it runs under a nonce-based
+  `script-src` policy with no configuration. The runtime config ships as a
+  `<script type="application/json">` block (data, not code), so it needs no
+  nonce and stays correct across Turbo visits.
+- Author attribution is stored as loose fields (no foreign key into your user
+  table), so the gem never couples to your user model.
+
+## Turbo
+
+Works with Turbo Drive out of the box. Turbo replaces `<body>` on every visit,
+which would take the floating button with it, so the widget registers its
+document-level listeners once and re-renders on `turbo:load`.
+
+## Development
+
+```bash
+bin/setup        # or: bundle install
+bundle exec rake test        # unit + integration
+bundle exec rake test:system # browser tests (headless Chrome)
+bundle exec rubocop
+```
+
+Tests run against a dummy Rails app under `test/dummy`; the widget itself is
+covered by Capybara system tests in a real browser. CI runs the suite across
+Rails 7.1 / 7.2 / 8.0 / 8.1 and Ruby 3.2–3.4 (per-version Gemfiles live in
+`gemfiles/`).
+
+## License
+
+Released under the [MIT License](MIT-LICENSE).

data/Rakefile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb'].exclude('test/system/**/*')
+end
+
+namespace :test do
+  desc 'Run browser (system) tests'
+  Rake::TestTask.new(:system) do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/system/**/*_test.rb']
+  end
+end
+
+task default: :test

data/app/controllers/ideasbugs/application_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ideasbugs
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    private
+
+    def current_author
+      return @current_author if defined?(@current_author)
+
+      @current_author = Ideasbugs.config.current_user.call(request)
+    end
+  end
+end

data/app/controllers/ideasbugs/feedbacks_controller.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Ideasbugs
+  class FeedbacksController < ApplicationController
+    PER_PAGE = 50
+
+    layout 'ideasbugs/application', except: :create
+
+    # The widget posts here; everything else is the triage dashboard.
+    before_action :require_enabled, only: :create
+    before_action :require_admin, except: :create
+    before_action :set_feedback, only: %i[show update destroy]
+
+    # Throttle the public endpoint per IP so one user or bot can't flood the
+    # table (each submission may carry megabytes of screenshots). Uses the
+    # rate limiter built into Rails 7.2+ (backed by Rails.cache); on Rails 7.1
+    # this is a no-op. Tune or disable via config.rate_limit — read once at
+    # boot, after the host's initializer.
+    if respond_to?(:rate_limit) && Ideasbugs.config.rate_limit
+      rate_limit(**Ideasbugs.config.rate_limit,
+                 only: :create,
+                 with: -> { render json: { errors: [t_error(:error_rate_limited)] }, status: :too_many_requests })
+    end
+
+    def index
+      @status = Feedback::STATUSES.include?(params[:status]) ? params[:status] : 'open'
+      @kind = Ideasbugs.config.kinds.map(&:to_s).include?(params[:kind]) ? params[:kind] : nil
+      @query = params[:q].to_s.strip.presence
+      @counts = Feedback.group(:status).count
+
+      scope = Feedback.where(status: @status)
+      scope = scope.where(kind: @kind) if @kind
+      scope = search(scope) if @query
+      @page = [params[:page].to_i, 1].max
+      @feedbacks = scope.newest_first.offset((@page - 1) * PER_PAGE).limit(PER_PAGE + 1).to_a
+      @more = @feedbacks.size > PER_PAGE
+      @feedbacks = @feedbacks.first(PER_PAGE)
+    end
+
+    def show; end
+
+    def create
+      feedback = Feedback.new(feedback_params)
+      feedback.user_agent = request.user_agent
+      attribute_author(feedback)
+
+      error = attach_screenshots(feedback)
+      return render json: { errors: [error] }, status: :unprocessable_entity if error
+
+      if feedback.save
+        notify_host(feedback)
+        head :created
+      else
+        render json: { errors: feedback.errors.full_messages }, status: :unprocessable_entity
+      end
+    end
+
+    def update
+      @feedback.update!(params.require(:feedback).permit(:status))
+      redirect_back fallback_location: feedback_path(@feedback), status: :see_other
+    end
+
+    def destroy
+      @feedback.destroy!
+      redirect_to root_path, status: :see_other
+    end
+
+    private
+
+    def require_enabled
+      head :forbidden unless Ideasbugs.enabled?(request)
+    end
+
+    # Server-side gate for the dashboard. Default: development only.
+    def require_admin
+      return if Ideasbugs.admin?(request)
+
+      render plain: 'Forbidden. Set Ideasbugs.config.authorize_admin to grant access.',
+             status: :forbidden
+    end
+
+    def set_feedback
+      @feedback = Feedback.find(params[:id])
+    end
+
+    # Case-insensitive match on the free-text columns. LOWER() keeps it
+    # portable across SQLite/PostgreSQL/MySQL, and the explicit ESCAPE makes
+    # the sanitized backslash escapes work on SQLite, which has no default
+    # LIKE escape character.
+    def search(scope)
+      pattern = "%#{Feedback.sanitize_sql_like(@query.downcase)}%"
+      scope.where(
+        "LOWER(message) LIKE :q ESCAPE '\\' OR LOWER(COALESCE(author_label, '')) LIKE :q ESCAPE '\\' " \
+        "OR LOWER(COALESCE(section, '')) LIKE :q ESCAPE '\\'",
+        q: pattern
+      )
+    end
+
+    # The host's hook must never turn a saved submission into a 500 — the
+    # feedback is in the database; notification failures are the host's logs'
+    # problem.
+    def notify_host(feedback)
+      Ideasbugs.config.on_submit.call(feedback)
+    rescue StandardError => e
+      Rails.logger.error("ideasbugs: on_submit hook raised #{e.class}: #{e.message}")
+    end
+
+    def feedback_params
+      params.require(:feedback).permit(:kind, :section, :message, :page_url)
+    end
+
+    def attribute_author(feedback)
+      author = current_author
+      return unless author
+
+      feedback.author_id = author.id.to_s if author.respond_to?(:id)
+      feedback.author_label = Ideasbugs.config.author_label.call(author)
+    end
+
+    # Validates and attaches uploads. Returns an error message, or nil when
+    # everything (including "no screenshots at all") is fine.
+    def attach_screenshots(feedback)
+      files = Array(params.dig(:feedback, :screenshots)).reject(&:blank?)
+      return nil if files.empty?
+      return t_error(:error_save) unless Ideasbugs.config.screenshots_enabled?
+      return t_error(:error_too_many, count: Ideasbugs.config.max_screenshots) if too_many?(files)
+      return t_error(:error_too_large, size: max_size_mb) if files.any? { |f| f.size > max_size }
+      return t_error(:error_save) unless files.all? { |f| f.content_type.to_s.start_with?('image/') }
+
+      feedback.screenshots.attach(files)
+      nil
+    end
+
+    def too_many?(files)
+      files.size > Ideasbugs.config.max_screenshots
+    end
+
+    def max_size
+      Ideasbugs.config.max_screenshot_size
+    end
+
+    def max_size_mb
+      max_size / (1024 * 1024)
+    end
+
+    def t_error(key, **args)
+      defaults = {
+        error_save: 'Could not send feedback. Please try again.',
+        error_too_many: 'Too many screenshots (max %{count}).',
+        error_too_large: 'A screenshot is too large (max %{size} MB).',
+        error_rate_limited: 'Too many submissions. Please wait a moment and try again.'
+      }
+      I18n.t(key, scope: :ideasbugs, default: defaults[key], **args)
+    end
+  end
+end