shiplog 0.2.0 → 0.3.0

data/app/controllers/shiplog/admin/entries/translations_controller.rb

@@ -0,0 +1,35 @@
+module Shiplog
+  module Admin
+    module Entries
+      # An admin's edit of an entry's translation (title and body) into one of config.locales. It is published
+      # at once and kept until the English text changes: the translation is marked edited and made from the
+      # entry's current English text, so it shows even if it was stale.
+      class TranslationsController < ApplicationController
+        before_action :set_entry_and_locale
+
+        def update
+          translation = @entry.translations.find_or_initialize_by(locale: @locale)
+          translation.assign_attributes(translation_params)
+          translation.assign_attributes(edited_by_admin: true, source_digest: @entry.translation_source_digest)
+          if translation.save
+            redirect_to edit_entry_path(@entry, inbox_filter_params), notice: t("shiplog.admin.entries.translations.saved", default: "Translation saved.")
+          else
+            redirect_to edit_entry_path(@entry, inbox_filter_params), alert: translation.errors.full_messages.to_sentence
+          end
+        end
+
+        private
+
+        def set_entry_and_locale
+          @entry = Entry.find(params[:entry_id])
+          @locale = params[:translation_locale].to_s
+          head :not_found unless Entry.translated_locale?(@locale)
+        end
+
+        def translation_params
+          params.expect(translation: %i[title body])
+        end
+      end
+    end
+  end
+end

data/app/controllers/shiplog/admin/entries_controller.rb

@@ -12,7 +12,7 @@ module Shiplog
         @page = page_number
         scope = Entry.where(status: @status)
         scope = scope.where(kind: @kind) if @kind
-        records = scope.includes(:subject).order(updated_at: :desc, id: :desc)
+        records = scope.includes(:subject, :area).order(updated_at: :desc, id: :desc)
           .offset((@page - 1) * PER_PAGE).limit(PER_PAGE + 1).to_a
         @more = records.size > PER_PAGE
         @entries = records.first(PER_PAGE)
@@ -23,11 +23,17 @@ module Shiplog
       end
 
       def update
-        if @entry.update(entry_params)
+        @entry.assign_attributes(entry_params)
+        @entry.area_set_by_admin = true if @entry.area_id_changed? # the admin's choice, which detection never overwrites
+        if @entry.save
           redirect_to root_path(inbox_filter_params), notice: t("shiplog.admin.entries.saved")
         else
           render :edit, status: :unprocessable_content
         end
+      rescue ActiveRecord::InvalidForeignKey
+        # The selected area was deleted between the validation and the save.
+        @entry.errors.add(:area_id, t("shiplog.admin.entries.area_gone", default: "no longer exists"))
+        render :edit, status: :unprocessable_content
       rescue ActiveRecord::RecordNotUnique
         # Two concurrent kind switches can both pass the validation; the unique index has the last word.
         @entry.errors.add(:changelog_kind, :taken)
@@ -48,7 +54,7 @@ module Shiplog
       end
 
       def entry_params
-        params.expect(entry: %i[title body released_on changelog_kind])
+        params.expect(entry: %i[title body released_on changelog_kind area_id])
       end
 
       def page_number

data/app/controllers/shiplog/changelog_entries_controller.rb

@@ -0,0 +1,26 @@
+module Shiplog
+  # The permalink page of a published feature or change: /changelog/:slug.
+  class ChangelogEntriesController < PublicController
+    def show
+      @entry = Entry.published_changelog.with_images_loaded.find_by(slug: params[:slug])
+      return pass_to_host_routes unless @entry
+
+      notify_changelog_seen
+      @newer = @entry.newer_changelog_entry
+      @older = @entry.older_changelog_entry
+      preload_translations(@entry, @newer, @older)
+      fresh_when etag: [ *shiplog_etag_parts, *shiplog_area_etag_parts, [ @entry, @newer, @older ].map { |entry| [ entry&.id, entry&.updated_at, entry&.area_id ] },
+        shiplog_image_etag_parts([ @entry ]), shiplog_translation_etag_parts([ @entry, @newer, @older ]) ]
+    end
+
+    private
+
+    # The engine is usually mounted at "/", so /changelog/:slug can shadow a host route below the changelog
+    # path (/changelog/archive, declared after the mount). An unknown slug answers 404 with X-Cascade: pass,
+    # which makes the router try the routes after the engine's mount; if none matches, the host's own 404 shows.
+    def pass_to_host_routes
+      response.set_header("X-Cascade", "pass")
+      head :not_found
+    end
+  end
+end

data/app/controllers/shiplog/changelog_feeds_controller.rb

@@ -0,0 +1,19 @@
+module Shiplog
+  # The Atom feed of the latest published features and changes: /changelog.atom.
+  class ChangelogFeedsController < PublicController
+    LIMIT = 50
+
+    layout false
+    before_action :set_area
+
+    def show
+      scope = Entry.published_changelog.newest_first
+      scope = scope.where(area_id: @area.id) if @area
+      @entries = scope.includes(:area).with_images_loaded.limit(LIMIT).to_a
+      @entries.select!(&:permalink?) # no slug (or an invalid one) means no stable id: left out
+      preload_translations(@entries)
+      fresh_when etag: [ *shiplog_etag_parts, *shiplog_area_etag_parts, @entries.map { |entry| [ entry.id, entry.updated_at, entry.area_id ] },
+        shiplog_image_etag_parts(@entries), shiplog_translation_etag_parts(@entries) ]
+    end
+  end
+end

data/app/controllers/shiplog/changelogs_controller.rb

@@ -2,24 +2,40 @@ module Shiplog
   class ChangelogsController < PublicController
     PER_PAGE = 30
     MAX_PAGE = 100_000
+    MIN_FILTER_AREAS = 2
+
+    before_action :set_area, only: :show
 
     def show
       @page = page_number
-      scope = Entry.approved.where(kind: %w[feature change]).where.not(released_on: nil)
-        .order(released_on: :desc, approved_at: :desc, id: :desc)
+      scope = Entry.published_changelog.newest_first
       @query = search_query
-      scope = scope.search(@query) if @query
-      records = scope.offset((@page - 1) * PER_PAGE).limit(PER_PAGE + 1).to_a
+      scope = scope.search(@query, locale: I18n.locale) if @query
+      scope = scope.where(area_id: @area.id) if @area
+      @areas = filter_areas
+      records = scope.includes(:area).with_images_loaded.offset((@page - 1) * PER_PAGE).limit(PER_PAGE + 1).to_a
       return head(:not_found) if @page > 1 && records.empty?
 
+      notify_changelog_seen
       @older = records.size > PER_PAGE
       @months = records.first(PER_PAGE).group_by { |entry| entry.released_on.beginning_of_month }
       @result_count = scope.count if @query
-      fresh_when etag: [ *shiplog_etag_parts, @query, @page, @older, @months.values.flatten.map { |entry| [ entry.id, entry.updated_at ] } ]
+      shown = @months.values.flatten
+      preload_translations(shown)
+      fresh_when etag: [ *shiplog_etag_parts, *shiplog_area_etag_parts, @areas.map(&:id), @query, @page, @older,
+        shown.map { |entry| [ entry.id, entry.updated_at, entry.area_id ] },
+        shiplog_image_etag_parts(shown), shiplog_translation_etag_parts(shown) ]
     end
 
     private
 
+    # The areas to offer as filter links: those with published entries, in the admin's order, and only when there
+    # are at least two (a single area filters nothing).
+    def filter_areas
+      areas = Area.ordered.where(id: Entry.published_changelog.where.not(area_id: nil).select(:area_id)).to_a
+      areas.size >= MIN_FILTER_AREAS ? areas : []
+    end
+
     # The normalised search query (words joined by one space), or nil when search is off or the query is blank.
     def search_query
       return unless Shiplog.config.changelog_search && params[:q].is_a?(String)

data/app/controllers/shiplog/public_controller.rb

@@ -8,10 +8,65 @@ module Shiplog
     helper Shiplog::SwitcherHelper
     helper Shiplog::RoadmapHelper
     helper Shiplog::HostRoutesHelper
+    helper Shiplog::PermalinkHelper
     layout -> { Shiplog.config.public_layout }
 
     private
 
+    # Calls config.on_changelog_seen for a visit to the changelog index or a permalink page. It runs before
+    # the page renders (the actions call it once they know the page exists, ahead of fresh_when and the
+    # implicit render), so a host navbar badge in the same response shows the count the callback just stored,
+    # also when the answer ends up a 304 (a revisit is a visit). Not called for 404s or the feed.
+    # The response is not sent yet, so the callback can still set cookies or headers. A failing callback is
+    # logged and never breaks the page.
+    def notify_changelog_seen
+      callback = Shiplog.config.on_changelog_seen
+      return unless callback && request.format.html?
+
+      callback.call(self)
+    rescue StandardError => error
+      Rails.logger.error("[shiplog] on_changelog_seen failed: #{error.class}: #{error.message}\n#{error.backtrace&.first(5)&.join("\n")}")
+    end
+
+    # Sets @area from ?area=<slug>. A blank or non-string value is ignored; a slug no area has is a 404 (a
+    # renamed or deleted area has no page to show, rather than the unfiltered list under a filtered URL).
+    def set_area
+      slug = params[:area]
+      return unless slug.is_a?(String) && slug.present?
+
+      @area = Area.find_by(slug:)
+      head(:not_found) unless @area
+    end
+
+    # What the markup shows of the areas: names, translated names, slugs and order of every area (the tags and the filter), which
+    # entries' updated_at don't reflect when an area is renamed or entries are moved in bulk.
+    def shiplog_area_etag_parts
+      [ @area&.id, Area.ordered.pluck(:id, :name, :slug, :position, :name_translations) ]
+    end
+
+    # What the markup shows of the entries' screenshots: their blob ids, order and alt texts. Nothing while
+    # screenshots are off. Load the entries with `Entry.with_images_loaded` to avoid a query per entry.
+    def shiplog_image_etag_parts(entries)
+      Shiplog.images? ? entries.compact.map { |entry| [ entry.id, entry.image_etag_parts ] } : []
+    end
+
+    # Loads the translations the page shows (the request locale's) for these entries in one query; see
+    # Entry.preload_translations. Call it before the entries are rendered or their ETag is computed.
+    def preload_translations(*entries)
+      Entry.preload_translations(entries.flatten)
+    end
+
+    # What the markup shows of the entries' translations: which current translation each entry shows, and when
+    # it last changed. Nothing under a locale that is not translated.
+    def shiplog_translation_etag_parts(entries)
+      return [] unless Entry.translated_locale?(I18n.locale)
+
+      entries.compact.filter_map do |entry|
+        translation = entry.translation
+        [ entry.id, translation.id, translation.updated_at ] if translation
+      end
+    end
+
     # What the rendered markup depends on besides the data: the locale, the gem version and the styling
     # config. Host parent controllers rendering per-user layout content should declare `etag { current_user&.id }`.
     def shiplog_etag_parts

data/app/controllers/shiplog/roadmaps_controller.rb

@@ -4,7 +4,9 @@ module Shiplog
       @columns = Roadmap.new(published_only: true).columns
       preload_cards(@columns)
       @shipped = recently_shipped
-      fresh_when etag: [ *shiplog_etag_parts, etag_for(@columns), shipped_etag(@shipped) ]
+      shown = [ *@columns.values.flatten.map(&:entry), *@shipped ]
+      preload_translations(shown)
+      fresh_when etag: [ *shiplog_etag_parts, etag_for(@columns), shipped_etag(@shipped), shiplog_translation_etag_parts(shown) ]
     end
 
     private

data/app/frontend/shiplog/admin.css

@@ -103,6 +103,7 @@
   }
   .shiplog-admin .shiplog-badge--warning { border-color: #bf8700; color: #9a6700; }
   .shiplog-admin .shiplog-badge--error { border-color: #cf222e; color: #cf222e; }
+  .shiplog-admin .shiplog-badge--area { border-color: var(--sa-accent); color: var(--sa-accent); }
 
   .shiplog-admin .shiplog-button {
     background: var(--sa-surface);
@@ -115,6 +116,7 @@
     padding: 0.25rem 0.75rem;
     text-decoration: none;
   }
+  .shiplog-admin .shiplog-button:disabled { cursor: default; opacity: 0.5; }
   .shiplog-admin .shiplog-button--primary { background: var(--sa-accent); border-color: var(--sa-accent); color: #fff; }
 
   .shiplog-admin .shiplog-admin-split { display: grid; gap: 1.5rem; grid-template-columns: repeat(auto-fit, minmax(20rem, 1fr)); }
@@ -125,6 +127,13 @@
   .shiplog-admin .shiplog-admin-form textarea { box-sizing: border-box; font: inherit; width: 100%; }
   .shiplog-admin .shiplog-admin-actions { border-top: 1px solid var(--sa-border); display: grid; gap: 0.75rem; margin-top: 1rem; padding-top: 1rem; }
   .shiplog-admin .shiplog-admin-inline-form { display: flex; flex-wrap: wrap; gap: 0.5rem; }
+  .shiplog-admin .shiplog-admin-images { margin-top: 1rem; }
+  .shiplog-admin .shiplog-admin-images__list { display: grid; gap: 1rem; list-style: none; margin: 0 0 1rem; padding: 0; }
+  .shiplog-admin .shiplog-admin-images__item { align-items: flex-start; border-bottom: 1px solid var(--sa-border); display: flex; flex-wrap: wrap; gap: 1rem; padding-bottom: 1rem; }
+  .shiplog-admin .shiplog-admin-images__thumb { border: 1px solid var(--sa-border); border-radius: 0.25rem; height: auto; max-height: 8rem; max-width: 12rem; object-fit: contain; }
+  .shiplog-admin .shiplog-admin-images__controls { display: grid; flex: 1; gap: 0.5rem; min-width: 16rem; }
+  .shiplog-admin .shiplog-admin__visually-hidden { border: 0; clip-path: inset(50%); height: 1px; overflow: hidden; position: absolute; white-space: nowrap; width: 1px; }
+  .shiplog-admin .shiplog-area-row__count { text-align: right; }
   .shiplog-admin .shiplog-admin-source { background: var(--sa-bg); overflow-x: auto; padding: 0.75rem; white-space: pre-wrap; word-break: break-word; }
 
   .shiplog-admin .shiplog-board { display: grid; gap: 1rem; grid-template-columns: repeat(auto-fit, minmax(16rem, 1fr)); }

data/app/frontend/shiplog/shiplog.css

@@ -152,7 +152,8 @@
   .shiplog-entries { display: grid; gap: 0.75rem; list-style: none; margin: 0; padding: 0; }
 
   .shiplog-card,
-  .shiplog-entry {
+  .shiplog-entry,
+  .shiplog-permalink {
     background: var(--sl-card);
     border: 1px solid var(--sl-border);
     border-radius: var(--sl-radius);
@@ -241,10 +242,14 @@
     width: 0.75rem;
   }
 
-  .shiplog-entry { align-items: center; display: flex; flex-wrap: wrap; gap: 0.25rem 0.625rem; }
+  .shiplog-entry,
+  .shiplog-permalink { align-items: center; display: flex; flex-wrap: wrap; gap: 0.25rem 0.625rem; }
   .shiplog-entry__title,
   .shiplog-entry__body { flex-basis: 100%; }
   .shiplog-entry__title { font-size: 1rem; margin: 0.25rem 0 0; }
+  .shiplog-entry__title a { color: inherit; text-decoration: none; }
+  .shiplog-entry__title a:hover { color: var(--sl-accent); text-decoration: underline; }
+  .shiplog-entry__title a:focus-visible { outline: 2px solid var(--sl-accent); outline-offset: 2px; }
   .shiplog-entry__body { color: var(--sl-muted); }
   .shiplog-entry__date { color: var(--sl-muted); font-size: 0.8125rem; }
 
@@ -256,6 +261,9 @@
     font-weight: 600;
     padding: 0 0.5rem;
   }
+  .shiplog-permalink .shiplog-entry__title { font-size: 1.5rem; }
+  .shiplog-permalink--feature { border-left: 4px solid var(--sl-accent); }
+  .shiplog-permalink--feature .shiplog-entry__category { background: var(--sl-accent); border-color: var(--sl-accent); color: #fff; }
   .shiplog-entry--feature { border-left: 4px solid var(--sl-accent); padding: var(--sl-space) calc(var(--sl-space) * 1.25); }
   .shiplog-entry--feature .shiplog-entry__title { font-size: 1.25rem; }
   .shiplog-entry--feature .shiplog-entry__category { background: var(--sl-accent); border-color: var(--sl-accent); color: #fff; }
@@ -264,6 +272,43 @@
   .shiplog-pagination__link { color: var(--sl-accent); }
   .shiplog-pagination__link--older { margin-left: auto; }
 
+  .shiplog-permalink__back { color: var(--sl-accent); display: inline-block; margin-top: var(--sl-space); }
+  .shiplog-permalink__nav {
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--sl-space);
+    justify-content: space-between;
+    margin-top: calc(var(--sl-space) * 2);
+  }
+  .shiplog-permalink__nav-link { color: var(--sl-accent); }
+  .shiplog-permalink__nav-link--older { margin-left: auto; text-align: right; }
+  .shiplog-permalink__back:focus-visible,
+  .shiplog-permalink__nav-link:focus-visible { outline: 2px solid var(--sl-accent); outline-offset: 2px; }
+
+  .shiplog-entry__area {
+    color: var(--sl-muted);
+    font-size: 0.75rem;
+    font-weight: 600;
+    letter-spacing: 0.02em;
+    text-transform: uppercase;
+  }
+
+  .shiplog-entry__images { display: grid; flex-basis: 100%; gap: 0.75rem; margin-top: 0.5rem; }
+  .shiplog-entry__image { border: 1px solid var(--sl-border); border-radius: 0.5rem; display: block; height: auto; max-width: 100%; }
+
+  .shiplog-areas { display: flex; flex-wrap: wrap; gap: 0.5rem; margin: var(--sl-space) 0; }
+  .shiplog-areas__link {
+    border: 1px solid var(--sl-border);
+    border-radius: 1rem;
+    color: var(--sl-fg);
+    font-size: 0.875rem;
+    padding: 0.125rem 0.75rem;
+    text-decoration: none;
+  }
+  .shiplog-areas__link:hover { border-color: var(--sl-accent); }
+  .shiplog-areas__link:focus-visible { outline: 2px solid var(--sl-accent); outline-offset: 2px; }
+  .shiplog-areas__link--current { background: var(--sl-accent); border-color: var(--sl-accent); color: #fff; }
+
   .shiplog-search { display: flex; flex-wrap: wrap; gap: 0.5rem; margin: var(--sl-space) 0; }
   .shiplog-search__input {
     flex: 1 1 14rem;

data/app/helpers/shiplog/admin/entries_helper.rb

@@ -19,6 +19,21 @@ module Shiplog
         entry.title.presence || source_title(entry.subject)
       end
 
+      # The URL of an image's thumbnail: a 200x200 variant when the host can make them (image_processing and a
+      # processor, see Shiplog.image_variants?), else the original (the stylesheet sizes it).
+      def image_thumbnail_path(image)
+        source = Shiplog.image_variants? && image.variable? ? image.variant(resize_to_limit: [ 200, 200 ]) : image
+        polymorphic_path(source)
+      rescue ActionController::UrlGenerationError, NoMethodError, ArgumentError
+        nil
+      end
+
+      # "Spanish (es)" for a locale of config.locales; the code alone when Shiplog has no name for the language.
+      def translation_language_label(locale)
+        name = Shiplog::Translator.language_name(locale)
+        name == locale.to_s ? name : "#{name} (#{locale})"
+      end
+
       def entries_filter_path(status: nil, kind: nil, page: nil)
         root_path({ status:, kind:, page: }.compact_blank)
       end

data/app/helpers/shiplog/permalink_helper.rb

@@ -0,0 +1,113 @@
+module Shiplog
+  # Markup helpers of the permalink pages, the Atom feed and the entries' screenshots.
+  module PermalinkHelper
+    DESCRIPTION_LENGTH = 160
+
+    # The path of an entry's permalink page, or nil when the entry has no slug the route accepts (a link is
+    # an extra, never a reason to fail the page).
+    def shiplog_entry_path(entry)
+      changelog_entry_path(entry.slug) if entry.permalink?
+    rescue ActionController::UrlGenerationError
+      nil
+    end
+
+    # The absolute URL of a named engine route: config.canonical_url plus the route's path (which carries the
+    # engine's mount prefix) when it is set, the request's own origin otherwise.
+    #   shiplog_absolute_url(:changelog_feed)  # => "https://trackberry.com/changelog.atom"
+    def shiplog_absolute_url(route, *args)
+      canonical = Shiplog.config.canonical_url
+      canonical ? "#{canonical}#{public_send("#{route}_path", *args)}" : public_send("#{route}_url", *args)
+    end
+
+    # The absolute URL of an entry's permalink page, or nil when it has no valid slug.
+    def shiplog_entry_url(entry)
+      shiplog_absolute_url(:changelog_entry, entry.slug) if shiplog_entry_path(entry)
+    end
+
+    # The authority of the feed's tag URIs: the canonical host, else the request's.
+    def shiplog_tag_host
+      canonical = Shiplog.config.canonical_url
+      canonical ? URI.parse(canonical).host : request.host
+    end
+
+    # A link to an entry's permalink page, or the plain content in a span when it has none.
+    def shiplog_entry_link(entry, name = nil, html_options = {}, &block)
+      name, html_options = capture(&block), name || {} if block
+      path = shiplog_entry_path(entry)
+      path ? link_to(name, path, html_options) : content_tag(:span, name, html_options.slice(:class))
+    end
+
+    # The id of a month's section on the changelog list.
+    def shiplog_month_anchor(date) = "shiplog-month-#{date.strftime("%Y-%m")}"
+
+    # The body, on one line and cut for a meta description. Plain text: tag helpers escape it.
+    def shiplog_entry_description(entry)
+      truncate(entry.display_body.to_s.squish, length: DESCRIPTION_LENGTH, separator: " ")
+    end
+
+    # The Open Graph meta tags of a permalink page, for `content_for :shiplog_og`.
+    def shiplog_og_tags(entry, url:)
+      tags = {
+        "og:title" => entry.display_title, "og:description" => shiplog_entry_description(entry),
+        "og:type" => "article", "og:url" => url, "og:image" => shiplog_entry_og_image(entry)
+      }
+      safe_join(tags.compact_blank.map { |property, content| tag.meta(property:, content:) }, "\n")
+    end
+
+    # The absolute URL of the image to show when the page is shared (the first image), or nil.
+    def shiplog_entry_og_image(entry)
+      image = shiplog_images(entry).first
+      shiplog_image_url(image) if image
+    end
+
+    # The HTML of an entry in the Atom feed: its text, then its images with absolute URLs.
+    def shiplog_feed_content(entry)
+      images = shiplog_images(entry).filter_map do |image|
+        url = shiplog_image_url(image)
+        tag.p(tag.img(src: url, alt: entry.image_alt(image), **shiplog_image_size(image))) if url
+      end
+      safe_join([ simple_format(h(entry.display_body)), *images ], "\n")
+    end
+
+    # An entry's images in order, or none while screenshots are off.
+    def shiplog_images(entry)
+      Shiplog.images? ? entry.ordered_images : []
+    end
+
+    # The images of an entry under its body: `limit` of them (all by default). Nil when it has none to show.
+    def shiplog_entry_images(entry, limit: nil)
+      images = shiplog_images(entry)
+      images = images.first(limit) if limit
+      tags = images.filter_map do |image|
+        path = shiplog_image_path(image)
+        tag.img(src: path, alt: entry.image_alt(image), loading: "lazy", class: shiplog_class(:entry_image), **shiplog_image_size(image)) if path
+      end
+      tag.div(safe_join(tags), class: shiplog_class(:entry_images)) if tags.any?
+    end
+
+    # Active Storage's routes belong to the host: url_for reaches them through main_app (see HostRoutesHelper).
+    # Nil when the host can't build the route.
+    def shiplog_image_path(image)
+      polymorphic_path(image)
+    rescue ActionController::UrlGenerationError, NoMethodError, ArgumentError
+      nil
+    end
+
+    # The image's absolute URL: config.canonical_url plus its path when set, the request's origin otherwise.
+    def shiplog_image_url(image)
+      canonical = Shiplog.config.canonical_url
+      return polymorphic_url(image) unless canonical
+
+      path = shiplog_image_path(image)
+      "#{canonical}#{path}" if path
+    rescue ActionController::UrlGenerationError, NoMethodError, ArgumentError
+      nil
+    end
+
+    # width and height from the blob's analysis, when it has run and found them.
+    def shiplog_image_size(image)
+      metadata = image.blob.metadata
+      { width: metadata[:width], height: metadata[:height] }.select { |_, value| value.to_i.positive? }
+    end
+  end
+end

data/app/helpers/shiplog/roadmap_helper.rb

@@ -2,6 +2,15 @@ module Shiplog
   module RoadmapHelper
     include Shiplog::SwitcherHelper
 
+    # English texts of the roadmap columns, used when the host's locale has no shiplog.columns translations.
+    COLUMN_DEFAULTS = {
+      in_progress: { title: "In progress", description: "What we're building now" },
+      coming_soon: { title: "Coming soon", description: "Planned next" },
+      later: { title: "Later", description: "On our radar" }
+    }.freeze
+
+    def shiplog_column_defaults = COLUMN_DEFAULTS
+
     # The configured label of a repository (config.repository_labels, matched case-insensitively), or nil.
     def shiplog_repository_label(repository)
       labels = Shiplog.config.repository_labels

data/app/helpers/shiplog/unseen_helper.rb

@@ -0,0 +1,9 @@
+module Shiplog
+  # The "what's new" count for host views: `helper Shiplog::UnseenHelper`, then
+  # `shiplog_unseen_count(current_user.changelog_seen_at)`. Shiplog doesn't know about users, so the host
+  # supplies the "last seen" time (and stamps it from config.on_changelog_seen).
+  module UnseenHelper
+    # The number of approved features and changes approved after `since` (all of them while it is nil), at most 99.
+    def shiplog_unseen_count(since) = Shiplog.unseen_count(since:)
+  end
+end

data/app/jobs/shiplog/detect_areas_job.rb

@@ -0,0 +1,18 @@
+module Shiplog
+  # Backfills product areas for entries that have none (see AreaDetector). Enqueued by the admin's Areas page.
+  # A failure is logged and recorded for the Areas page (Setting "area_detection"), never raised: the job is not
+  # retried, the admin clicks again once the cause (usually the rewriter) is fixed.
+  class DetectAreasJob < ApplicationJob
+    SETTING = "area_detection".freeze
+    MAX_ERROR_CHARS = 500
+
+    # recheck: true first makes the entries the AI left unplaced eligible again.
+    def perform(recheck: false)
+      assigned = AreaDetector.new.call(recheck:)
+      Setting.write(SETTING, at: Time.current.iso8601, assigned:) if assigned # nil: another run was in progress
+    rescue StandardError => error
+      Rails.logger.error("[shiplog] Detect areas failed: #{error.class}: #{error.message}\n#{error.backtrace&.first(5)&.join("\n")}")
+      Setting.write(SETTING, at: Time.current.iso8601, error: "#{error.class}: #{error.message}".truncate(MAX_ERROR_CHARS))
+    end
+  end
+end

data/app/jobs/shiplog/rewrite_entry_job.rb

@@ -2,8 +2,11 @@ module Shiplog
   class RewriteEntryJob < ApplicationJob
     discard_on ActiveRecord::RecordNotFound
 
+    # After writing the draft, screenshots from the GitHub body are attached to a draft that has none (the
+    # fetcher checks, never raises, and leaves approved entries alone).
     def perform(entry_id, force: false)
-      Rewriter.new(Entry.find(entry_id)).call(force:)
+      entry = Rewriter.new(Entry.find(entry_id)).call(force:)
+      ImageFetcher.call(entry)
     end
   end
 end

data/app/jobs/shiplog/translate_area_job.rb

@@ -0,0 +1,25 @@
+module Shiplog
+  # Translates an area's name into every locale of config.locales with one LLM call (see AreaTranslator).
+  # Enqueued when an area is created or renamed, by "Translate names" (with `force: true`) and by
+  # `shiplog:translate_approved`. Without force a locale that has a name is left alone, an admin's edit included;
+  # a repeat when every locale has one makes no LLM call.
+  #
+  # A failure (the rewriter raised, or its reply was unusable) is logged and retried twice, with a growing wait,
+  # then logged again and dropped: never an endless retry. The English name stays shown meanwhile.
+  class TranslateAreaJob < ApplicationJob
+    ATTEMPTS = 3
+
+    retry_on StandardError, attempts: ATTEMPTS, wait: :polynomially_longer do |job, error|
+      Rails.logger.error("[shiplog] Giving up translating area #{job.arguments.first.try(:id)} after #{ATTEMPTS} attempts: #{error.class}: #{error.message}")
+    end
+    # Declared after retry_on, which makes it win: an area deleted since the job was enqueued is not an error.
+    discard_on ActiveJob::DeserializationError, ActiveRecord::RecordNotFound
+
+    def perform(area, force: false)
+      AreaTranslator.new(area).call(force:)
+    rescue StandardError => error
+      Rails.logger.error("[shiplog] Translating area #{area.id} failed (attempt #{executions} of #{ATTEMPTS}): #{error.class}: #{error.message}")
+      raise
+    end
+  end
+end

data/app/jobs/shiplog/translate_entry_job.rb

@@ -0,0 +1,25 @@
+module Shiplog
+  # Translates an approved entry into one locale of config.locales (see Translator). Enqueued when an entry is
+  # approved and when the English text of an approved entry changes: a repeat for the same English text makes no
+  # LLM call. `force: true` (the admin's Retranslate) ignores the stored digest and an admin's edit.
+  #
+  # A failure (the rewriter raised, or its reply was unusable) is logged and retried twice, with a growing wait,
+  # then logged again and dropped: never an endless retry. The English text stays shown meanwhile.
+  class TranslateEntryJob < ApplicationJob
+    ATTEMPTS = 3
+
+    retry_on StandardError, attempts: ATTEMPTS, wait: :polynomially_longer do |job, error|
+      entry, locale = job.arguments
+      Rails.logger.error("[shiplog] Giving up translating entry #{entry.try(:id)} into #{locale} after #{ATTEMPTS} attempts: #{error.class}: #{error.message}")
+    end
+    # Declared after retry_on, which makes it win: an entry deleted since the job was enqueued is not an error.
+    discard_on ActiveJob::DeserializationError, ActiveRecord::RecordNotFound
+
+    def perform(entry, locale, force: false)
+      Translator.new(entry, locale).call(force:)
+    rescue StandardError => error
+      Rails.logger.error("[shiplog] Translating entry #{entry.id} into #{locale} failed (attempt #{executions} of #{ATTEMPTS}): #{error.class}: #{error.message}")
+      raise
+    end
+  end
+end