shiplog 0.1.1 → 0.3.0

data/app/controllers/shiplog/admin/areas/moves_controller.rb

@@ -0,0 +1,13 @@
+module Shiplog
+  module Admin
+    module Areas
+      # Moves an area one place up or down (params[:direction]); anything else changes nothing.
+      class MovesController < ApplicationController
+        def create
+          Area.find(params[:area_id]).move(params[:direction])
+          redirect_to areas_path
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Shiplog
+  module Admin
+    # The Areas page: product areas with their entry counts; rename, edit the translated names, delete. Reordering, merging and detection
+    # are their own small controllers.
+    class AreasController < ApplicationController
+      before_action :set_area, only: %i[update destroy]
+
+      def index
+        @areas = Area.ordered.to_a
+        @counts = Area.entry_counts
+        @detection = Setting.read(DetectAreasJob::SETTING)
+      end
+
+      def update
+        if @area.update(area_attributes)
+          redirect_to areas_path, notice: t("shiplog.admin.areas.renamed", default: "Area renamed.")
+        else
+          redirect_to areas_path, alert: @area.errors.full_messages.to_sentence
+        end
+      end
+
+      def destroy
+        @area.destroy!
+        redirect_to areas_path, notice: t("shiplog.admin.areas.deleted", default: "Area deleted. Its entries have no area now.")
+      end
+
+      private
+
+      # The name, and the translated names of the configured locales. A rename drops the translations (they were of
+      # the old name) and enqueues a new translation, so the translations sent with it are ignored; without a
+      # rename they are kept as the admin typed them (an empty field removes one), over any earlier translation.
+      def area_attributes
+        permitted = params.expect(area: [ :name, { name_translations: {} } ])
+        attributes = { name: permitted[:name] }
+        submitted = permitted[:name_translations]
+        if submitted && permitted[:name].to_s.squish == @area.name
+          locales = Shiplog.config.locales.map(&:to_s)
+          attributes[:name_translations] = @area.name_translations.merge(submitted.to_h.slice(*locales).select { |_locale, value| value.is_a?(String) })
+        end
+        attributes
+      end
+
+      def set_area
+        @area = Area.find(params[:id])
+      end
+    end
+  end
+end

data/app/controllers/shiplog/admin/entries/images/moves_controller.rb

@@ -0,0 +1,20 @@
+module Shiplog
+  module Admin
+    module Entries
+      module Images
+        # Moves an image up or down in its entry's order (params[:direction]).
+        class MovesController < ApplicationController
+          before_action { head :not_found unless Shiplog.images? }
+
+          def create
+            entry = Entry.find(params[:entry_id])
+            return head(:not_found) unless entry.find_image(params[:image_id])
+
+            entry.move_image(params[:image_id], params[:direction] == "up" ? :up : :down)
+            redirect_to edit_entry_path(entry, inbox_filter_params), notice: t("shiplog.admin.entries.images.moved", default: "Image moved.")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Shiplog
+  module Admin
+    module Entries
+      # An entry's screenshots on the edit page: upload, alt text, remove. :id is the image's blob id, the key of
+      # the entry's order and alt texts. Not found while screenshots are off.
+      class ImagesController < ApplicationController
+        before_action :require_images
+        before_action :set_entry
+
+        def create
+          files = uploads
+          return back(alert: t("shiplog.admin.entries.images.none_selected", default: "Choose at least one image.")) if files.empty?
+
+          checked = files.index_with { |file| inspect_upload(file) }
+          rejected = checked.select { |_file, info| info.nil? }.keys
+          if rejected.any?
+            names = rejected.map { |file| file.original_filename.to_s.scrub.first(100) }.to_sentence
+            return back(alert: t("shiplog.admin.entries.images.rejected", names:, default: "Not added, only PNG, JPEG, GIF and WebP images up to 5 MB and 10,000 pixels a side are accepted: %{names}"))
+          end
+
+          @entry.add_images(checked.map { |file, info| attachable(file, info) }) # uploads first, locks only to attach
+          back(notice: t("shiplog.admin.entries.images.added", count: files.size, default: { one: "Image added.", other: "%{count} images added." }))
+        end
+
+        def update
+          return head(:not_found) unless @entry.find_image(params[:id])
+
+          @entry.update_image_alt(params[:id], params[:alt])
+          back(notice: t("shiplog.admin.entries.images.alt_saved", default: "Alt text saved."))
+        end
+
+        def destroy
+          return head(:not_found) unless @entry.find_image(params[:id])
+
+          @entry.remove_image(params[:id])
+          back(notice: t("shiplog.admin.entries.images.removed", default: "Image removed."))
+        end
+
+        private
+
+        def require_images
+          head :not_found unless Shiplog.images?
+        end
+
+        def set_entry
+          @entry = Entry.find(params[:entry_id])
+        end
+
+        def back(**flash)
+          redirect_to edit_entry_path(@entry, inbox_filter_params), **flash
+        end
+
+        def uploads
+          Array(params[:images]).select { |file| file.is_a?(ActionDispatch::Http::UploadedFile) }
+        end
+
+        # Decided by the file's bytes and size, never by the declared name or content type: the type, and the
+        # pixel size read from the header, which must be within the limits (see ImageType). Nil when refused.
+        def inspect_upload(file)
+          return unless file.size.between?(1, ImageType::MAX_BYTES)
+
+          file.rewind
+          ImageType.analyze(file.read(ImageType::MAX_BYTES + 1))
+        rescue ImageType::Invalid
+          nil
+        ensure
+          file.rewind
+        end
+
+        def attachable(file, info)
+          { io: file.tempfile, filename: file.original_filename.to_s.scrub.presence || "image", content_type: info.content_type, metadata: { width: info.width, height: info.height } }
+        end
+      end
+    end
+  end
+end

data/app/controllers/shiplog/admin/entries/translations/retranslations_controller.rb

@@ -0,0 +1,23 @@
+module Shiplog
+  module Admin
+    module Entries
+      module Translations
+        # Translates the entry into the locale again, ignoring the stored digest and an admin's edit.
+        class RetranslationsController < ApplicationController
+          def create
+            entry = Entry.find(params[:entry_id])
+            locale = params[:translation_locale].to_s
+            return head(:not_found) unless Entry.translated_locale?(locale)
+
+            back = edit_entry_path(entry, inbox_filter_params)
+            return redirect_to(back, alert: t("shiplog.admin.entries.translations.only_approved", default: "Only approved entries are translated.")) unless entry.approved?
+            return redirect_to(back, alert: t("shiplog.admin.entries.translations.no_rewriter", default: "Translating needs config.rewriter, which is not set.")) unless Shiplog.config.rewriter
+
+            TranslateEntryJob.perform_later(entry, locale.to_sym, force: true)
+            redirect_to back, notice: t("shiplog.admin.entries.translations.queued", default: "Translation queued. Refresh in a moment.")
+          end
+        end
+      end
+    end
+  end
+end

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/admin/syncs_controller.rb

@@ -4,8 +4,9 @@ module Shiplog
       DELIVERIES_SHOWN = 20
 
       def show
-        repositories = Repository.where(full_name: Shiplog.config.repositories).index_by(&:full_name)
-        @repositories = Shiplog.config.repositories.map { |full_name| [ full_name, repositories[full_name] ] }
+        names = Shiplog.config.repository_names
+        repositories = Repository.where(full_name: names).index_by(&:full_name)
+        @repositories = names.map { |full_name| [ full_name, repositories[full_name] ] }
         @deliveries = WebhookDelivery.order(received_at: :desc, id: :desc).limit(DELIVERIES_SHOWN)
         @webhook_secret_missing = Shiplog.config.webhook_secret.blank?
         @github_token_missing = Shiplog.config.resolved_github_token.blank?

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,21 +2,47 @@ 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)
-      records = scope.offset((@page - 1) * PER_PAGE).limit(PER_PAGE + 1).to_a
+      scope = Entry.published_changelog.newest_first
+      @query = search_query
+      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 }
-      fresh_when etag: [ *shiplog_etag_parts, @page, @older, @months.values.flatten.map { |entry| [ entry.id, entry.updated_at ] } ]
+      @result_count = scope.count if @query
+      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)
+
+      Entry.search_terms(params[:q]).join(" ").presence
+    end
+
     def page_number
       Integer(params[:page].to_s, 10, exception: false).to_i.clamp(1, MAX_PAGE)
     end

data/app/controllers/shiplog/public_controller.rb

@@ -5,15 +5,72 @@ module Shiplog
   class PublicController < Shiplog.config.public_parent_controller.constantize
     helper Shiplog::FrontendHelper
     helper Shiplog::StylingHelper
+    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
-      [ I18n.locale, Shiplog::VERSION, Shiplog.config.classes.hash, Shiplog.config.stylesheet ]
+      [ I18n.locale, Shiplog::VERSION, Shiplog.config.render_digest ]
     end
   end
 end

data/app/controllers/shiplog/roadmaps_controller.rb

@@ -2,13 +2,38 @@ module Shiplog
   class RoadmapsController < PublicController
     def show
       @columns = Roadmap.new(published_only: true).columns
-      fresh_when etag: [ *shiplog_etag_parts, etag_for(@columns) ]
+      preload_cards(@columns)
+      @shipped = recently_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
 
+    # The cards read each entry's issue, its repository (label) and its sub-issues (parts).
+    def preload_cards(columns)
+      entries = columns.values.flatten.map(&:entry)
+      ActiveRecord::Associations::Preloader.new(records: entries, associations: { subject: [ :repository, :children ] }).call
+    end
+
+    def recently_shipped
+      count = Shiplog.config.roadmap_shipped_count
+      return Entry.none if count.zero?
+
+      Entry.approved.where(kind: Entry::CHANGELOG_KINDS).where.not(released_on: nil)
+        .order(released_on: :desc, approved_at: :desc, id: :desc).limit(count).load
+    end
+
     def etag_for(columns)
-      columns.transform_values { |items| items.map { |item| [ item.entry.id, item.entry.updated_at ] } }
+      columns.transform_values do |items|
+        items.map do |item|
+          issue = item.entry.subject
+          [ item.entry.id, item.entry.updated_at, issue.updated_at, issue.children.size, issue.repository.full_name ]
+        end
+      end
     end
+
+    def shipped_etag(entries) = entries.map { |entry| [ entry.id, entry.updated_at ] }
   end
 end

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)); }