shiplog 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2826f599a903db09dc27e45e8b8b0e1b4b643bce51b36a995d913addec96abe
-  data.tar.gz: d27c0d107c0dc01e1e0509eb6754cbebd5a210b1a5f049f0f3379c5f7dc63faa
+  metadata.gz: a624887b92e388e7234f1c9051437c7c8732b624f448ae4ed6a50834668835b3
+  data.tar.gz: 1a0f18b1f55b919bf9fcf04da75379666428a49fd312c75ea55c6d064e613959
 SHA512:
-  metadata.gz: 27a0a478a59b2770fee353de8b5305d6674fc485d9fe3cb79ab5e84f46ef4bbe590d68e3a063275c1de6f83e7603e32822b9e696da83f7c20b9ed3a200c3b7f8
-  data.tar.gz: 6f5fca4e30d1511e38d3272cbe997a8232d6c5b14c80ea4263925a05c5b7378eb10dfb0f48d0e65ebf6069334f01f725cb24d4ffbd4baa50ee105018a19e4225
+  metadata.gz: 3dd499eff9f0656078de85134f584ee13eddea6e98d9ad431d363da5bb4c53ce8c06c784914fc4ad2fdf5f30a4a2bc9c53632eed87b3dae1bbbd907efb1cfc88
+  data.tar.gz: c2322fb8cde5158aa51656e04d885faede534ab939e0a83677245ea1ab6130d11806cc7145f456f9b211b6b8fe7d2b7e821c198261660b23fe974db1dfee8226

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## 0.3.2 (2026-10-26)
+
+0.3.1 hosts should upgrade.
+
+### Fixed
+
+- Boot failure in 0.3.1: when a host initializer or gem loaded `ActionView::Base` early (for example `ActionView::Base.field_error_proc = ...` in `config/initializers`), the engine's `action_view` hook ran before the autoloaders existed and raised `NameError: uninitialized constant Shiplog::HeadTagsHelper`. `Shiplog::HeadTagsHelper` now lives in `lib/shiplog/head_tags_helper.rb` and is required explicitly, so it is neither autoloaded nor reloaded (it is included into a class that never reloads).
+- `shiplog_head_tags` raised `NoMethodError` in a view that lacks Shiplog's helpers, such as a ViewComponent or Phlex component rendered on a Shiplog page. It returns an empty string there: call it in the layout.
+- `shiplog_head_tags` no longer autoloads `Shiplog::PublicController` (and the host's parent controller) when a host page or mailer renders a layout that calls it. Shiplog's public controllers answer a `shiplog_public_page?` marker instead.
+- `og:image` and `Article.image` agree: `og:image` is the first screenshot whose URL can be built (it skipped to the callable when the first one had none), `Article.image` all of them, otherwise the `config.og_image` image.
+- The `EXCEPT_KEYS` constant is no longer visible in the host's views (it moved to `Shiplog::HeadTags`).
+
+### Changed
+
+- The legacy `content_for :shiplog_og` block includes the `config.og_image` fallback image when it is set (it did so in 0.3.1; the 0.3.1 notes said it was exactly as in 0.3.0).
+
+### Upgrading
+
+- Bump `config.cache_version` when you change your layout's head or override a `shiplog/head/*` partial: ETags don't cover layouts.
+- `config.og_image` output is not part of the ETag (only its presence is): bump `cache_version` when it changes.
+- With `except: :canonical`, `og:url` still carries Shiplog's canonical (which honours `config.canonical_url`). A host writing its own canonical should make it agree, and should not emit one on search pages, where Shiplog sets `noindex` (`content_for(:shiplog_robots)` is `"noindex"` there).
+
+## 0.3.1 (2026-10-26)
+
+### Added
+
+- schema.org structured data (JSON-LD) on the public pages, rendered by `shiplog_head_tags` (the legacy route is `content_for :shiplog_structured_data`; one `<script type="application/ld+json">` per page). A permalink page is an `Article` (`headline`, `description`, `inLanguage`, `datePublished`, `dateModified`, `url`, `mainEntityOfPage`, and when available `image`, `articleSection` and `publisher`, plus `isPartOf` the changelog); the changelog list is a `CollectionPage` with an `ItemList` of the entries on the page (left out for search results and an empty list); the roadmap is a `CollectionPage` with an `ItemList` of its cards. Titles and descriptions follow the request locale and `config.canonical_url`. The JSON is built from a Hash with `<`, `>` and `&` escaped as `\u003c`, `\u003e` and `\u0026`, so a `</script>` in a title cannot break out of the tag.
+- `shiplog_head_tags(except: [])` (`Shiplog::HeadTagsHelper`, with the data side in `Shiplog::HeadHelper`): one call in a host layout's `<head>` renders the description, canonical link, robots, Open Graph, Twitter card, Atom link and JSON-LD of the public pages, through the overridable partials `shiplog/_head_tags` and `shiplog/head/_meta`, `_open_graph`, `_feed` and `_structured_data`. `except:` takes `:description`, `:canonical`, `:robots`, `:open_graph`, `:twitter`, `:feed` and `:structured_data`; other keys raise `ArgumentError`. It returns an empty string outside Shiplog pages. It is available in every view of the host (a Rails `action_view` load hook includes `Shiplog::HeadTagsHelper`, which holds only this method). **0.3.1 can fail to boot, see 0.3.2.** Shiplog's own layout uses it.
+- A canonical link (new): a list page's own URL (its `area` and `page`, no other query parameters), a permalink's URL, honouring `config.canonical_url`. Search pages are `noindex` and have no canonical, so the two signals do not disagree. Twitter card tags (`twitter:card`, and `twitter:image`) are new too.
+- `config.og_image` (`nil` or `->(entry, locale) { url }`, evaluated in the view): the share image of a permalink page without a screenshot, as `og:image` (with `og:image:alt`), `twitter:image`, `twitter:card` = `summary_large_image` and `Article.image`. Paths are made absolute; an error or a non-http(s) value is logged and ignored. Only its presence is part of `render_digest`, not its output: bump `config.cache_version` when the output changes.
+- `config.structured_data` (default `true`; `false` turns the JSON-LD off). Part of `render_digest`, so changing it refreshes cached pages.
+
+### Upgrading
+
+- Custom `config.public_layout`: replace the `content_for(:shiplog_description)`, `:shiplog_og`, `:shiplog_feed`, `:shiplog_robots` and `:shiplog_structured_data` renders in the `<head>` with `<%= shiplog_head_tags %>`, and pass `except:` for the tags your layout writes itself (for example `except: [:open_graph, :twitter]` if it has its own share card). The `content_for` blocks still work (`:shiplog_og` now also carries the `config.og_image` fallback image), but are superseded: use `shiplog_head_tags` or the blocks, not both, because `shiplog_head_tags` does not read the blocks and rendering both duplicates the tags. Hosts that keep the blocks need no change.
+- Hosts with a custom `config.public_layout` that stay on the blocks should render `<%= content_for(:shiplog_structured_data) %>` in the `<head>`, next to `content_for(:shiplog_og)`. Without it the pages work as before, with no structured data. Shiplog's own layout already does.
+
 ## 0.3.0 (2026-10-26)
 
 ### Added

data/README.md

@@ -113,9 +113,11 @@ All settings live in `config/initializers/shiplog.rb`:
 | `extra_pages` | `[]` | Pages added to the switcher after Roadmap and Changelog: `[{ label:, path: }]`, each a String or a callable evaluated in the view. See [Product updates navigation](#product-updates-navigation). Anything else raises `ArgumentError`. |
 | `repository_labels` | `{}` | Tag shown on a roadmap card for the repository of its issue: `{ "owner/name" => "iPhone & iPad" }`. Values are Strings or callables evaluated in the view; repositories without one show no tag. |
 | `roadmap_shipped_count` | `4` | How many recently shipped changelog entries (features and changes) the roadmap lists below its columns. `0` hides the section. |
-| `cache_version` | `nil` | A String added to the public pages' ETag. Callables (`extra_pages`, `repository_labels`, `feedback_path`) cannot be fingerprinted, so bump it when the output of a callable you configured changes. |
+| `cache_version` | `nil` | A String added to the public pages' ETag. Callables (`extra_pages`, `repository_labels`, `feedback_path`, `og_image`) cannot be fingerprinted, so bump it when the output of a callable you configured changes. Also bump it when you change your layout's head or override a `shiplog/head/*` partial: ETags don't cover layouts. |
 | `feedback_path` | `nil` | Target of the roadmap's "Suggest a feature" link, a String or a callable evaluated in the view. No link while `nil`. |
 | `changelog_search` | `true` | Search box on the public changelog and `?q=` filtering. `false` hides the form and ignores `q`. See [Changelog search](#changelog-search). |
+| `structured_data` | `true` | schema.org JSON-LD on the public pages (see [Head tags](#head-tags)). `false` emits none. See [Structured data](#structured-data). Part of the ETag. |
+| `og_image` | `nil` | The image shared with a permalink page that has no screenshot: `nil` or a callable `->(entry, locale) { url }` evaluated in the view (`instance_exec`, so `main_app` route helpers work). See [Head tags](#head-tags). Anything else raises `ArgumentError`. Only its presence is part of the ETag, not its output: bump `cache_version` when its output changes. |
 | `on_changelog_seen` | `nil` | `->(controller) { ... }` called before each changelog index or permalink view renders (also for a 304 revisit), to stamp a visitor's "last seen" time. See [What's new](#whats-new-the-unseen-count). Anything but `nil` or a callable raises `ArgumentError`. |
 | `images` | `true` | [Screenshots](#screenshots) in entries. Effective only when Active Storage is loaded in the host; `false` turns fetching, upload and rendering off. `true` or `false`, anything else raises `ArgumentError`. |
 | `max_images_per_entry` | `4` | How many images are fetched from the GitHub body of a draft. A non-negative Integer; `0` fetches none (admin uploads are not capped). |
@@ -333,11 +335,7 @@ The public changelog has a search form above its months: `GET /changelog?q=csv`
 - The ETag includes the normalised query.
 - The model scope is `Shiplog::Entry.search(query)`.
 
-**Keeping search pages out of search engines.** A page with a query sets `content_for :shiplog_robots, "noindex"`. Shiplog's own layout turns that into `<meta name="robots" content="noindex">`. A host layout (`config.public_layout`) controls its own `<head>`, so emit it there:
-
-```erb
-<%= tag.meta name: "robots", content: content_for(:shiplog_robots) if content_for?(:shiplog_robots) %>
-```
+**Keeping search pages out of search engines.** A page with a query is `noindex`: `shiplog_head_tags` renders `<meta name="robots" content="noindex">` (see [Head tags](#head-tags)). Hosts still on the older blocks read `content_for :shiplog_robots`.
 
 ## Product areas
 
@@ -392,23 +390,58 @@ Every approved feature and change has its own page at `GET /changelog/:slug` (un
 - **Entries approved before 0.3.0** get their slug from the 0.3.0 migration (oldest first, so the oldest keeps the plain slug on duplicate titles). `bin/rails shiplog:backfill_slugs` (idempotent, oldest first) does the same for entries that old code approved during a deploy window. The public pages never write, because a host may send GETs to a read replica: an approved entry without a slug is listed without a link, left out of the feed and has no page until it has a slug. An entry whose stored slug the route rejects is treated the same way.
 - **The page** shows the entry, a "← Back to the changelog" link to the entry's month anchor, and its newer and older neighbours (`rel="prev"` and `rel="next"`, as in the pagination). Drafts, discarded and roadmap entries and unknown slugs answer 404 with `X-Cascade: pass`: the engine is usually mounted at `/`, and its `/changelog/:slug` route would otherwise shadow a host route of yours below the changelog path (say `/changelog/archive`, declared after the mount). The router carries on with the routes after the mount, and your own 404 shows if none matches. Declare such host routes after `mount Shiplog::Engine`; before it they win anyway.
 - **Caching:** the ETag covers the entry and its neighbours' ids and `updated_at`.
-- **Head tags:** the page sets `content_for :title`, `content_for :shiplog_description` (the body, cut at 160 characters) and `content_for :shiplog_og` (Open Graph: `og:title`, `og:description`, `og:type` = `article`, `og:url`). Shiplog's own layout renders them. A host layout (`config.public_layout`) controls its own `<head>`, so render them there, as for `:shiplog_robots`:
+- **Head tags:** the page's description (the body, cut at 160 characters), canonical link and Open Graph tags (`og:title`, `og:description`, `og:type` = `article`, `og:url`, and the image) come from `shiplog_head_tags`; see [Head tags](#head-tags).
+- **Styling:** the `permalink` (the `article`), `permalink_back`, `permalink_nav` and `permalink_nav_link` keys of [`config.classes`](#3-configclasses-tailwind-and-other-utility-frameworks). Override `shiplog/changelogs/_entry_content.html.erb` (locals `entry:`, `heading:`, `linked:`) to change what an entry shows in both the list and the permalink page.
+- **Texts:** `shiplog.permalink.title`, `.back`, `.nav_label`, `.newer` and `.older` (with `title`); all have English defaults.
+
+## Structured data
+
+The public pages describe themselves to search engines with schema.org JSON-LD: one `<script type="application/ld+json">` per page, rendered by `shiplog_head_tags` (see [Head tags](#head-tags); leave it out with `except: :structured_data`). The older `content_for :shiplog_structured_data` block still holds the same tag.
+
+- **Permalink page:** an `Article` with `headline` (the title, at most 110 characters), `description` (the meta description), `inLanguage` (`I18n.locale`, e.g. `en`, `es`), `datePublished` (the release date), `dateModified`, `url` and `mainEntityOfPage` (the permalink, honouring `config.canonical_url`), `image` (absolute URLs of the screenshots, else the `config.og_image` image, left out without any), `articleSection` (the area's name, when it has one), `publisher` (an `Organization` named `config.product_name`, left out while it is `nil`) and `isPartOf` (the changelog's `CollectionPage`). Titles and bodies follow the request locale, translations included.
+- **Changelog list:** a `CollectionPage` whose `mainEntity` is an `ItemList` of the entries on the current page (`position` counted on the page, `url`, `name`). Entries without a valid slug are skipped. Search results (they are `noindex`) and an empty list have none.
+- **Roadmap:** a `CollectionPage` with an `ItemList` of the cards (`position` and `name`; roadmap cards have no permalink, so no `url`).
+- **Safety:** the JSON is built from a Ruby Hash and `<`, `>` and `&` are written as `\u003c`, `\u003e` and `\u0026`, so a title containing `</script>` cannot close the tag.
+- **Off:** `config.structured_data = false` emits none. It is part of the ETag.
+
+## Head tags
+
+Shiplog's pages describe themselves in the `<head>`: description, canonical link, robots, Open Graph, Twitter card, the Atom feed link and JSON-LD. Shiplog's own layout renders them. If you set `config.public_layout` to a layout of your own, add one line to its `<head>`:
 
 ```erb
-<title><%= content_for(:title) %></title>
-<%= tag.meta name: "description", content: content_for(:shiplog_description) if content_for?(:shiplog_description) %>
-<%= content_for(:shiplog_og) %>
-<%= content_for(:shiplog_feed) %>
+<head>
+  <title><%= content_for(:title) %></title>
+  <%= shiplog_head_tags %>
+</head>
 ```
 
-- **Styling:** the `permalink` (the `article`), `permalink_back`, `permalink_nav` and `permalink_nav_link` keys of [`config.classes`](#3-configclasses-tailwind-and-other-utility-frameworks). Override `shiplog/changelogs/_entry_content.html.erb` (locals `entry:`, `heading:`, `linked:`) to change what an entry shows in both the list and the permalink page.
-- **Texts:** `shiplog.permalink.title`, `.back`, `.nav_label`, `.newer` and `.older` (with `title`); all have English defaults.
+`shiplog_head_tags` is available in every view of your app (the only Shiplog helper that is), and on any page that is not a Shiplog page it returns an empty string, so it is safe in a layout shared with your own pages. Call it in the layout, not inside a component (ViewComponent, Phlex): in a view that doesn't have Shiplog's helpers it also returns an empty string. `<title>` stays yours: it is `content_for(:title)`.
+
+After changing your layout's `<head>` or overriding a `shiplog/head/*` partial, bump `config.cache_version`: ETags don't cover layouts, so visitors with a cached page would keep the old tags.
+
+- **What each page gets.** Permalink: `description`, `canonical` (the permalink), `og:title`, `og:description`, `og:type` = `article`, `og:url`, `og:image` and `og:image:alt` when there is an image, `twitter:card` (`summary_large_image` with an image, `summary` without) and `twitter:image`, the Atom link and the `Article` JSON-LD. Changelog list: `canonical` (the list's own URL, with its `area` and `page` but without any other query parameter), `og:title`, `og:type` = `website`, `og:url`, `twitter:card` = `summary`, the Atom link and the `CollectionPage`. Roadmap: the same without the Atom link. Each key is emitted once.
+- **Search pages** (`?q=`) are `noindex` and have **no canonical** (and no `og:url`, no JSON-LD). The alternative, a canonical pointing at the plain list, would tell search engines to index a page while `noindex` tells them not to; mixed signals are ignored or worse, so a search page just asks not to be indexed.
+- **`except:`** leaves groups out, for tags your layout already writes: `shiplog_head_tags(except: [:canonical, :twitter])`. Valid keys: `:description`, `:canonical`, `:robots`, `:open_graph` (the `og:*` tags), `:twitter` (the `twitter:*` tags), `:feed` and `:structured_data`. Any other key raises `ArgumentError`.
+- **`except: :canonical` and `og:url`.** `except: :canonical` drops only the `<link rel="canonical">`. `og:url` keeps Shiplog's canonical, which honours `config.canonical_url`; to change it, drop `:open_graph` too. A host that writes its own canonical should make it agree with that one, and should not emit a canonical on search pages, where Shiplog sets `noindex`: Shiplog fills `content_for(:shiplog_robots)` with `"noindex"` there (and leaves it empty elsewhere), which your layout can check.
+- **Overridable partials.** Copy one into your app at the same path to change it (like the other [partials](#4-override-the-partials)):
+
+  | Partial | Renders |
+  |---|---|
+  | `shiplog/_head_tags.html.erb` | renders the four below |
+  | `shiplog/head/_meta.html.erb` | `description`, canonical link and `robots` |
+  | `shiplog/head/_open_graph.html.erb` | `og:*` and `twitter:*` |
+  | `shiplog/head/_feed.html.erb` | the Atom `<link rel="alternate">` |
+  | `shiplog/head/_structured_data.html.erb` | the JSON-LD `<script>` |
+
+  Every partial gets the same locals: `head` (a Hash with `:kind` (`:permalink`, `:changelog` or `:roadmap`), `:title`, `:entry` (permalink only), `:image`, `:canonical` and `:description`), `description`, `canonical`, `robots`, `open_graph` and `twitter` (Hashes of tag name to content), `feed_url`, `feed_title` and `json_ld`. What `except:` removed arrives as `nil` or `{}`, so a partial that renders its locals respects it.
+- **The share image.** The permalink page's image is the first screenshot whose URL can be built (absolute URL), else what `config.og_image` returns, else none. `config.og_image` is `nil` or `->(entry, locale) { url }`, evaluated in the view (`instance_exec`, so `main_app.my_card_url(entry.slug)` works). A path (`"/cards/dark.png"`) is made absolute with `config.canonical_url` or the request's origin. A callable that raises, or returns anything but an http(s) URL or a path (`javascript:`, `//host`, `nil`), is logged once for the page (`[shiplog] config.og_image ...`) and the page renders without the image. `Article.image` of the JSON-LD lists all the screenshots with a URL, else that same callable image. List pages and the roadmap get no image from Shiplog: your default applies, through your own tags (`except: [:open_graph, :twitter]`) or an override of `_open_graph`.
+- **The older `content_for` blocks** (`:shiplog_description`, `:shiplog_og`, `:shiplog_feed`, `:shiplog_robots`, `:shiplog_structured_data`) are still filled as in 0.3.0 and still work, but are superseded. The one difference: `:shiplog_og` now includes the `config.og_image` fallback image when that is set and the entry has no screenshot. Use `shiplog_head_tags` **or** the blocks, not both: `shiplog_head_tags` never reads the blocks, so a layout that renders both emits the tags twice. The blocks have neither the canonical link nor the Twitter tags. Upgrading: replace the `content_for` renders in your `<head>` with `shiplog_head_tags`, and pass `except:` for the tags your layout writes itself.
 
 ## Atom feed
 
 `GET /changelog.atom` serves the latest 50 approved features and changes (newest first) as an Atom feed. An entry has a stable id (a tag URI built from the permalink path, so a title edit does not change it), its permalink, `published` (the release date), `updated`, and its body as HTML. All URLs are absolute. The feed is cached with an ETag like the pages and answers 304 on a match; it does not call `on_changelog_seen`.
 
-The changelog and permalink pages advertise it with a `<link rel="alternate" type="application/atom+xml">` (`content_for :shiplog_feed`, rendered by Shiplog's layout; render it in a host layout too, see above) and the changelog shows a visible "Subscribe (Atom)" link (the `footnote_link` key). The feed has an `<author>` (the product name, or "Changelog"), which RFC 4287 requires when entries carry none. The feed is titled "Changelog", or "<product_name> changelog" when `config.product_name` is set, and follows the request locale. Texts: `shiplog.feed.title_with_product`, `.link_title` and `.subscribe`.
+The changelog and permalink pages advertise it with a `<link rel="alternate" type="application/atom+xml">` (rendered by `shiplog_head_tags`, see [Head tags](#head-tags); the older `content_for :shiplog_feed` block holds the same link) and the changelog shows a visible "Subscribe (Atom)" link (the `footnote_link` key). The feed has an `<author>` (the product name, or "Changelog"), which RFC 4287 requires when entries carry none. The feed is titled "Changelog", or "<product_name> changelog" when `config.product_name` is set, and follows the request locale. Texts: `shiplog.feed.title_with_product`, `.link_title` and `.subscribe`.
 
 ### Canonical URL
 

data/app/controllers/shiplog/public_controller.rb

@@ -9,8 +9,14 @@ module Shiplog
     helper Shiplog::RoadmapHelper
     helper Shiplog::HostRoutesHelper
     helper Shiplog::PermalinkHelper
+    helper Shiplog::StructuredDataHelper
+    helper Shiplog::HeadHelper
     layout -> { Shiplog.config.public_layout }
 
+    # Marks the controllers of the public pages, for shiplog_head_tags: checking this instead of the class keeps
+    # host pages from autoloading Shiplog::PublicController (and the host's parent controller).
+    def shiplog_public_page? = true
+
     private
 
     # Calls config.on_changelog_seen for a visit to the changelog index or a permalink page. It runs before

data/app/helpers/shiplog/head_helper.rb

@@ -0,0 +1,95 @@
+module Shiplog
+  # The data side of `<%= shiplog_head_tags %>` (see HeadTagsHelper, the only helper every view gets). Included
+  # in the engine's public controllers only.
+  #
+  # The views declare their page with #shiplog_head_page (which also fills the older `content_for` blocks, kept
+  # for backward compatibility); the partials below are overridable by the host app:
+  #   shiplog/_head_tags             renders the four below
+  #   shiplog/head/_meta             description, canonical, robots
+  #   shiplog/head/_open_graph       og:* and twitter:*
+  #   shiplog/head/_feed             the Atom alternate link
+  #   shiplog/head/_structured_data  the JSON-LD script
+  # Each receives the locals `head` (a Hash: :kind, :title, :entry, :canonical, :image, :description), `description`,
+  # `canonical`, `robots`, `open_graph` and `twitter` (Hashes of tag name => content), `feed_url`, `feed_title`
+  # and `json_ld`. Whatever `except:` removed arrives as nil or an empty Hash.
+  module HeadHelper
+    # Renders the head tags of the current page, leaving out the `skip` groups (see HeadTagsHelper, which
+    # validates and guards). An empty string when the page declared none.
+    def shiplog_render_head_tags(skip)
+      return "".html_safe unless @shiplog_head
+
+      render(partial: "shiplog/head_tags", locals: shiplog_head_locals(skip))
+    end
+
+    # Declares the page for shiplog_head_tags and fills the older content_for blocks (which shiplog_head_tags
+    # never reads). `kind` is :permalink,
+    # :changelog or :roadmap; the rest is what the page computed: entry (permalink), title, url (the page's
+    # absolute URL, nil for a search), query (a search), json_ld, feed (whether it advertises the Atom feed).
+    def shiplog_head_page(kind, title:, url: nil, entry: nil, query: nil, json_ld: nil, feed: true)
+      @shiplog_head = { kind:, title:, url:, entry:, query:, json_ld:, feed: }
+      shiplog_fill_legacy_blocks
+    end
+
+    private
+
+    def shiplog_fill_legacy_blocks
+      head = @shiplog_head
+      entry = head[:entry]
+      blocks = {
+        shiplog_description: (shiplog_entry_description(entry) if entry),
+        shiplog_og: (shiplog_og_tags(entry, url: head[:url]) if entry),
+        shiplog_robots: ("noindex" if head[:query]),
+        shiplog_feed: shiplog_head_feed_link(head),
+        shiplog_structured_data: head[:json_ld]
+      }
+      blocks.each { |name, value| content_for(name, value) if value.present? }
+    end
+
+    def shiplog_head_feed_link(head)
+      return unless head[:feed]
+
+      auto_discovery_link_tag(:atom, shiplog_absolute_url(:changelog_feed), title: shiplog_feed_title)
+    end
+
+    def shiplog_feed_title = t("shiplog.feed.link_title", default: "Changelog (Atom)")
+
+    def shiplog_head_locals(skip)
+      head = @shiplog_head
+      entry = head[:entry]
+      # A search page has no canonical: it is noindex, and noindex with a canonical sends search engines two
+      # signals that disagree.
+      canonical = head[:url] unless head[:query]
+      image = shiplog_entry_og_image(entry) if entry
+      description = shiplog_entry_description(entry) if entry
+      page = head.slice(:kind, :title, :entry).merge(canonical:, image:, description:)
+
+      {
+        head: page,
+        description: (description unless skip.include?(:description)),
+        canonical: (canonical unless skip.include?(:canonical)),
+        robots: ("noindex" if head[:query] && !skip.include?(:robots)),
+        open_graph: (skip.include?(:open_graph) ? {} : shiplog_head_open_graph(head, canonical, image, description)),
+        twitter: (skip.include?(:twitter) ? {} : shiplog_head_twitter(image)),
+        feed_url: (shiplog_absolute_url(:changelog_feed) if head[:feed] && !skip.include?(:feed)),
+        feed_title: shiplog_feed_title,
+        json_ld: (head[:json_ld] unless skip.include?(:structured_data))
+      }
+    end
+
+    def shiplog_head_open_graph(head, canonical, image, description)
+      entry = head[:entry]
+      {
+        "og:title" => (entry ? entry.display_title : head[:title]),
+        "og:description" => description,
+        "og:type" => (entry ? "article" : "website"),
+        "og:url" => canonical,
+        "og:image" => image,
+        "og:image:alt" => (entry.display_title if image)
+      }.compact_blank
+    end
+
+    def shiplog_head_twitter(image)
+      { "twitter:card" => (image ? "summary_large_image" : "summary"), "twitter:image" => image }.compact_blank
+    end
+  end
+end

data/app/helpers/shiplog/permalink_helper.rb

@@ -40,12 +40,13 @@ module Shiplog
     # 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: " ")
+    # The body, on one line and cut for a meta description. Plain text: tag helpers escape it. `escape: false`
+    # keeps the cut text raw (not HTML-escaped) for JSON, which escapes it its own way.
+    def shiplog_entry_description(entry, escape: true)
+      truncate(entry.display_body.to_s.squish, length: DESCRIPTION_LENGTH, separator: " ", escape:)
     end
 
-    # The Open Graph meta tags of a permalink page, for `content_for :shiplog_og`.
+    # The Open Graph meta tags of a permalink page, for `content_for :shiplog_og` (superseded by shiplog_head_tags).
     def shiplog_og_tags(entry, url:)
       tags = {
         "og:title" => entry.display_title, "og:description" => shiplog_entry_description(entry),
@@ -54,10 +55,46 @@ module Shiplog
       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.
+    # The absolute URL of the image to show when the page is shared, or nil: the entry's first screenshot with a URL, else
+    # what config.og_image returns for it. Computed once per entry per render, so a failing callable is logged
+    # once for a page.
     def shiplog_entry_og_image(entry)
-      image = shiplog_images(entry).first
-      shiplog_image_url(image) if image
+      @shiplog_og_images ||= {}.compare_by_identity
+      return @shiplog_og_images[entry] if @shiplog_og_images.key?(entry)
+
+      # Same rule as the JSON-LD Article image: screenshots whose URL can't be built are skipped.
+      screenshot = shiplog_images(entry).lazy.filter_map { |image| shiplog_image_url(image) }.first
+      @shiplog_og_images[entry] = screenshot || shiplog_configured_og_image(entry)
+    end
+
+    # What config.og_image gives for an entry (called in the view with the entry and the locale), as an absolute
+    # http(s) URL. Nil, after a log line, when it raises or returns something else.
+    def shiplog_configured_og_image(entry)
+      callable = Shiplog.config.og_image
+      return unless callable
+
+      value = callable.is_a?(Proc) ? instance_exec(entry, I18n.locale, &callable) : callable.call(entry, I18n.locale)
+      url = shiplog_absolute_http_url(value)
+      Rails.logger.warn("[shiplog] config.og_image ignored for entry #{entry.id}: expected an http(s) URL or a path, got #{value.inspect}") unless url
+      url
+    rescue StandardError => error
+      Rails.logger.error("[shiplog] config.og_image failed for entry #{entry.id}: #{error.class}: #{error.message}")
+      nil
+    end
+
+    # An http(s) URL as is, a path ("/cards/a.png", not "//host") made absolute with config.canonical_url or the
+    # request's origin; nil for anything else (javascript:, data:, blank, spaces, non-strings).
+    def shiplog_absolute_http_url(value)
+      return unless value.is_a?(String)
+
+      value = value.strip
+      return if value.match?(/[[:space:][:cntrl:]]/)
+
+      value = "#{Shiplog.config.canonical_url || request.base_url}#{value}" if value.match?(%r{\A/(?![/\\])})
+      uri = URI.parse(value)
+      value if uri.is_a?(URI::HTTP) && uri.host.present?
+    rescue URI::InvalidURIError
+      nil
     end
 
     # The HTML of an entry in the Atom feed: its text, then its images with absolute URLs.

data/app/helpers/shiplog/structured_data_helper.rb

@@ -0,0 +1,74 @@
+module Shiplog
+  # schema.org structured data (JSON-LD) of the public pages, for `shiplog_head_tags` (and `content_for :shiplog_structured_data`).
+  # Every method returns nil while config.structured_data is off, or when there is nothing worth describing.
+  module StructuredDataHelper
+    HEADLINE_LENGTH = 110
+    CONTEXT = "https://schema.org".freeze
+    # "<", ">" and "&" (and the line separators JavaScript treats as newlines) become JSON \u escapes: still the
+    # same string once parsed, but a "</script>" in a title cannot close the tag.
+    SCRIPT_ESCAPES = { "<" => "\\u003c", ">" => "\\u003e", "&" => "\\u0026", "
" => "\\u2028", "
" => "\\u2029" }.freeze
+
+    # A <script type="application/ld+json"> tag for a Hash, or nil while structured data is off.
+    def shiplog_json_ld(data)
+      return unless Shiplog.config.structured_data && data
+
+      json = JSON.generate(data).gsub(/[<>&

]/, SCRIPT_ESCAPES)
+      # Safe: JSON.generate output with every character that could end the script element escaped above.
+      content_tag(:script, json.html_safe, type: "application/ld+json")
+    end
+
+    # The Article of a permalink page.
+    def shiplog_article_json_ld(entry)
+      return unless Shiplog.config.structured_data
+
+      url = shiplog_entry_url(entry)
+      images = shiplog_images(entry).filter_map { |image| shiplog_image_url(image) }
+      images = [ shiplog_entry_og_image(entry) ].compact if images.empty?
+      shiplog_json_ld({
+        "@context" => CONTEXT, "@type" => "Article",
+        "headline" => truncate(entry.display_title.to_s.squish, length: HEADLINE_LENGTH, escape: false),
+        "description" => shiplog_entry_description(entry, escape: false).presence,
+        "inLanguage" => I18n.locale.to_s,
+        "datePublished" => entry.released_on&.iso8601, "dateModified" => entry.updated_at&.iso8601,
+        "url" => url, "mainEntityOfPage" => url,
+        "image" => images.presence,
+        "articleSection" => entry.area&.display_name.presence,
+        "publisher" => shiplog_publisher_json_ld,
+        "isPartOf" => { "@type" => "CollectionPage", "url" => shiplog_absolute_url(:changelog) }
+      }.compact)
+    end
+
+    # The CollectionPage of the changelog list: an ItemList of the entries shown. Nil for search results and an
+    # empty list.
+    def shiplog_changelog_json_ld(entries, name:, url:)
+      return if @query
+
+      items = entries.filter_map { |entry| [ shiplog_entry_url(entry), entry.display_title ] if entry.permalink? }
+      return if items.empty?
+
+      shiplog_collection_json_ld(name:, url:, items: items.map { |item_url, title| { "url" => item_url, "name" => title } })
+    end
+
+    # The CollectionPage of the roadmap: an ItemList of the cards, which have no URL.
+    def shiplog_roadmap_json_ld(entries, name:, url:)
+      return if entries.empty?
+
+      shiplog_collection_json_ld(name:, url:, items: entries.map { |entry| { "name" => entry.display_title } })
+    end
+
+    private
+
+    def shiplog_collection_json_ld(name:, url:, items:)
+      elements = items.each_with_index.map { |item, index| { "@type" => "ListItem", "position" => index + 1, **item } }
+      shiplog_json_ld({
+        "@context" => CONTEXT, "@type" => "CollectionPage", "name" => name, "url" => url, "inLanguage" => I18n.locale.to_s,
+        "mainEntity" => { "@type" => "ItemList", "itemListElement" => elements }
+      })
+    end
+
+    def shiplog_publisher_json_ld
+      name = Shiplog.config.product_name.presence
+      { "@type" => "Organization", "name" => name } if name
+    end
+  end
+end

data/app/views/layouts/shiplog/application.html.erb

@@ -4,10 +4,7 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width,initial-scale=1">
     <title><%= content_for(:title) %></title>
-    <% if content_for?(:shiplog_robots) %><meta name="robots" content="<%= content_for(:shiplog_robots) %>"><% end %>
-    <% if content_for?(:shiplog_description) %><meta name="description" content="<%= content_for(:shiplog_description) %>"><% end %>
-    <%= content_for(:shiplog_og) %>
-    <%= content_for(:shiplog_feed) %>
+    <%= shiplog_head_tags %>
     <%= csrf_meta_tags %>
     <%= csp_meta_tag %>
   </head>

data/app/views/shiplog/_head_tags.html.erb

@@ -0,0 +1,5 @@
+<%# Renders the head tags of a Shiplog page; see Shiplog::HeadHelper. Override the partials below to change a group. %>
+<%= render partial: "shiplog/head/meta", locals: local_assigns %>
+<%= render partial: "shiplog/head/open_graph", locals: local_assigns %>
+<%= render partial: "shiplog/head/feed", locals: local_assigns %>
+<%= render partial: "shiplog/head/structured_data", locals: local_assigns %>

data/app/views/shiplog/changelog_entries/show.html.erb

@@ -1,7 +1,5 @@
 <% content_for :title, t("shiplog.permalink.title", title: @entry.display_title, changelog: t("shiplog.changelog.title", default: "Changelog"), default: "%{title} · %{changelog}") %>
-<% content_for :shiplog_description, shiplog_entry_description(@entry) %>
-<% content_for :shiplog_og, shiplog_og_tags(@entry, url: shiplog_entry_url(@entry)) %>
-<% content_for :shiplog_feed, auto_discovery_link_tag(:atom, shiplog_absolute_url(:changelog_feed), title: t("shiplog.feed.link_title", default: "Changelog (Atom)")) %>
+<% shiplog_head_page :permalink, title: @entry.display_title, entry: @entry, url: shiplog_entry_url(@entry), json_ld: shiplog_article_json_ld(@entry) %>
 <%= render layout: "shiplog/page", locals: { name: "permalink" } do %>
   <%= render "shiplog/page_header", title: t("shiplog.changelog.title", default: "Changelog"), lede: nil %>
   <article class="<%= shiplog_class(:permalink, @entry.kind) %>">

data/app/views/shiplog/changelogs/show.html.erb

@@ -1,10 +1,9 @@
-<% content_for :title, t("shiplog.changelog.title", default: "Changelog") %>
-<% content_for :shiplog_feed, auto_discovery_link_tag(:atom, shiplog_absolute_url(:changelog_feed), title: t("shiplog.feed.link_title", default: "Changelog (Atom)")) %>
+<% changelog_title = t("shiplog.changelog.title", default: "Changelog") %>
+<% list_url = shiplog_absolute_url(:changelog, area: @area&.slug, page: (@page if @page > 1)) %>
+<% content_for :title, changelog_title %>
+<% shiplog_head_page :changelog, title: changelog_title, url: list_url, query: @query, json_ld: shiplog_changelog_json_ld(@months.values.flatten, name: changelog_title, url: list_url) %>
 <%= render layout: "shiplog/page", locals: { name: "changelog" } do %>
   <%= render "shiplog/page_header", title: t("shiplog.changelog.title", default: "Changelog"), lede: t("shiplog.changelog.lede", default: "New features and improvements, as they ship.") %>
-  <% if @query %>
-    <% content_for :shiplog_robots, "noindex" %>
-  <% end %>
   <% if Shiplog.config.changelog_search %>
     <%= render "shiplog/changelogs/search", query: @query, count: @result_count %>
   <% end %>

data/app/views/shiplog/head/_feed.html.erb

@@ -0,0 +1 @@
+<%= auto_discovery_link_tag(:atom, feed_url, title: feed_title) if feed_url.present? %>

data/app/views/shiplog/head/_meta.html.erb

@@ -0,0 +1,3 @@
+<%= tag.meta(name: "description", content: description) if description.present? %>
+<%= tag.link(rel: "canonical", href: canonical) if canonical.present? %>
+<%= tag.meta(name: "robots", content: robots) if robots.present? %>

data/app/views/shiplog/head/_open_graph.html.erb

@@ -0,0 +1,6 @@
+<% open_graph.each do |property, content| %>
+<%= tag.meta(property:, content:) %>
+<% end %>
+<% twitter.each do |name, content| %>
+<%= tag.meta(name:, content:) %>
+<% end %>

data/app/views/shiplog/head/_structured_data.html.erb

@@ -0,0 +1 @@
+<%= json_ld if json_ld.present? %>

data/app/views/shiplog/roadmaps/show.html.erb

@@ -1,4 +1,7 @@
-<% content_for :title, t("shiplog.roadmap.title", default: "Roadmap") %>
+<% roadmap_title = t("shiplog.roadmap.title", default: "Roadmap") %>
+<% roadmap_url = shiplog_absolute_url(:roadmap) %>
+<% content_for :title, roadmap_title %>
+<% shiplog_head_page :roadmap, title: roadmap_title, url: roadmap_url, feed: false, json_ld: shiplog_roadmap_json_ld(@columns.values.flatten.map(&:entry), name: roadmap_title, url: roadmap_url) %>
 <%= render layout: "shiplog/page", locals: { name: "roadmap" } do %>
   <%= render "shiplog/page_header", title: t("shiplog.roadmap.title", default: "Roadmap"), lede: t("shiplog.roadmap.lede", default: "What we're working on and what comes next.") %>
   <div class="<%= shiplog_class(:columns) %>">

data/lib/generators/shiplog/install/templates/initializer.rb.tt

@@ -122,6 +122,10 @@ Shiplog.configure do |config|
   # The public changelog's search box and ?q= filtering. Set to false to turn search off.
   # config.changelog_search = true
 
+  # schema.org structured data (JSON-LD) on the public pages: an Article on each permalink, a CollectionPage on
+  # the changelog and the roadmap. Set to false to turn it off.
+  # config.structured_data = true
+
   # "What's new". Shiplog doesn't know your users, so you supply the "last seen" time. This is called with the
   # controller on every changelog index or permalink view, BEFORE the page renders (a 304 revisit included), so a
   # navbar badge in the same response is current. It may write and runs on every visit: keep it cheap, and write
@@ -135,9 +139,18 @@ Shiplog.configure do |config|
 
   # The 0.3.0 migration gives entries approved so far their permalink slug. The public pages never write (a GET
   # may hit a read replica), so an entry approved by older code during a deploy window has no permalink until
-  # `bin/rails shiplog:backfill_slugs` runs. Permalink pages set `content_for :shiplog_og` (Open Graph tags),
-  # `content_for :shiplog_description` and `content_for :shiplog_feed` (the Atom discovery link); Shiplog's own
-  # layout renders them, so emit them in your layout's <head> when you set `config.public_layout`.
+  # `bin/rails shiplog:backfill_slugs` runs.
+
+  # With your own config.public_layout, add `<%%= shiplog_head_tags %%>` to its <head>: it renders the description,
+  # canonical link, robots, Open Graph, Twitter, Atom discovery and JSON-LD tags of the Shiplog pages (and nothing
+  # on your other pages). `except: [:feed, ...]` leaves out what your layout writes itself. The older
+  # `content_for :shiplog_og`, `:shiplog_description`, `:shiplog_feed`, `:shiplog_robots` and
+  # `:shiplog_structured_data` blocks still work but are superseded: use one or the other, never both.
+
+  # The image shared with a permalink page that has no screenshot (og:image, twitter:image, JSON-LD image): a
+  # callable evaluated in the view, so route helpers work. Return an http(s) URL or a path (made absolute); an
+  # error or any other value is logged and the page gets no image. List pages and the roadmap get none from Shiplog.
+  # config.og_image = ->(entry, locale) { main_app.url_for(controller: "/og_images", action: :show, id: entry.slug) }
 
   # Product areas. The rewriter's reply may name an area (an existing one, or a new name of 1-3 words); Shiplog
   # creates it while fewer than max_areas exist, so the AI cannot sprawl. The changelog offers an area filter

data/lib/shiplog/configuration.rb

@@ -34,13 +34,21 @@ module Shiplog
     attr_accessor :feedback_path
     # Whether the public changelog has a search box and honours ?q= (default true).
     attr_accessor :changelog_search
+    # Whether the public pages carry schema.org JSON-LD (rendered by shiplog_head_tags; default true).
+    attr_accessor :structured_data
+    # The image shared with a permalink page when the entry has no screenshot: nil (default) or a callable
+    # `->(entry, locale) { "https://cdn.example.com/card.png" }` evaluated in the view (instance_exec, so
+    # `main_app` route helpers work). A path is made absolute with canonical_url or the request's origin; an
+    # error or a non-http(s) value is logged and the page renders without the image. See shiplog_head_tags.
+    attr_reader :og_image
     # Called with the controller on each changelog index or permalink view (200 or 304 answers), e.g. to stamp
     # the visitor's "last seen" time. It runs BEFORE the page renders (so a badge in the same response is
     # current), on every visit, and may write: keep it cheap, e.g. write only when the stored time is older than
     # the newest entry. Nil by default. Not part of the ETag: it doesn't change the markup.
     attr_reader :on_changelog_seen
-    # Bump it when the output of a callable you configured changes (extra_pages, repository_labels, feedback_path):
-    # callables cannot be part of the ETag, so this is how cached public pages learn about it.
+    # Bump it when the output of a callable you configured changes (extra_pages, repository_labels, feedback_path,
+    # og_image): callables cannot be part of the ETag, so this is how cached public pages learn about it. Also
+    # bump it after changing the layout's head or a shiplog/head/* partial: ETags don't cover layouts.
     attr_accessor :cache_version
     attr_reader :extra_pages, :repository_labels, :roadmap_shipped_count
     # How many product areas the AI may create (default 8). Past it, entries can only join existing areas.
@@ -70,7 +78,7 @@ module Shiplog
         stylesheet, roadmap_shipped_count, cache_version, product_name, canonical_url,
         extra_pages.map { |page| [ stable.(page[:label]), stable.(page[:path]) ] },
         repository_labels.sort_by { |name, _| name.to_s }.map { |name, label| [ name, stable.(label) ] },
-        stable.(feedback_path), changelog_search, images, max_images_per_entry, locales
+        stable.(feedback_path), changelog_search, images, max_images_per_entry, locales, structured_data, stable.(og_image)
       ]
       Digest::SHA256.hexdigest(JSON.generate(data))
     end
@@ -156,6 +164,11 @@ module Shiplog
       @canonical_url = normalize_canonical_url(value)
     end
 
+    def og_image=(value)
+      raise ArgumentError, "og_image must be nil or a callable like ->(entry, locale) { url }, got #{value.inspect}" unless value.nil? || value.respond_to?(:call)
+      @og_image = value
+    end
+
     def on_changelog_seen=(value)
       raise ArgumentError, "on_changelog_seen must be nil or a callable, got #{value.inspect}" unless value.nil? || value.respond_to?(:call)
       @on_changelog_seen = value
@@ -227,6 +240,7 @@ module Shiplog
       @repository_labels = {}.freeze
       @roadmap_shipped_count = 4
       @changelog_search = true
+      @structured_data = true
       @max_areas = 8
       @images = true
       @max_images_per_entry = 4

data/lib/shiplog/engine.rb

@@ -2,6 +2,11 @@ module Shiplog
   class Engine < ::Rails::Engine
     isolate_namespace Shiplog
 
+    # shiplog_head_tags in every view, so a layout shared with the host's own pages can call it.
+    initializer "shiplog.head_tags_helper" do
+      ActiveSupport.on_load(:action_view) { include Shiplog::HeadTagsHelper }
+    end
+
     # Once per boot, after the host's initializers have set config.images: say why screenshots are off.
     config.after_initialize { Shiplog.log_images_status }
   end

data/lib/shiplog/head_tags_helper.rb

@@ -0,0 +1,34 @@
+module Shiplog
+  # Constants of shiplog_head_tags. Not included anywhere, so views of the host cannot see them.
+  module HeadTags
+    EXCEPT_KEYS = %i[description canonical robots open_graph twitter feed structured_data].freeze
+  end
+
+  # The one helper added to every view of the host (like a pagination gem's `paginate`), so a layout shared
+  # with the host's own pages can call `shiplog_head_tags`. The rest lives in Shiplog::HeadHelper, which only
+  # the engine's controllers include.
+  #
+  # This file is required by lib/shiplog.rb rather than autoloaded: the engine includes the module into
+  # ActionView::Base from an on_load hook, which can run during boot before the autoloaders are set up, and
+  # ActionView::Base never reloads, so the module must not either.
+  module HeadTagsHelper
+    # The head tags of the current Shiplog page; an empty string on any other page. `except:` leaves groups
+    # out, for tags your layout already writes: :description, :canonical, :robots, :open_graph, :twitter,
+    # :feed, :structured_data. An unknown key raises ArgumentError.
+    #
+    # Call it in the layout, not inside a component (ViewComponent, Phlex): there it gives an empty string.
+    # Use it OR the older `content_for :shiplog_*` blocks in a layout, not both: both would emit the tags twice.
+    def shiplog_head_tags(except: [])
+      keys = Array(except).map { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      unknown = keys - HeadTags::EXCEPT_KEYS
+      if unknown.any?
+        raise ArgumentError, "Unknown shiplog_head_tags except: key(s) #{unknown.map(&:inspect).join(", ")}. Valid keys: #{HeadTags::EXCEPT_KEYS.map(&:inspect).join(", ")}"
+      end
+      # A marker, not is_a?(Shiplog::PublicController): that would autoload the controller (and the host's
+      # parent controller) on every host page. Views that don't have the engine's helper (components) skip too.
+      return "".html_safe unless controller.respond_to?(:shiplog_public_page?) && respond_to?(:shiplog_render_head_tags, true)
+
+      shiplog_render_head_tags(keys)
+    end
+  end
+end

data/lib/shiplog/version.rb

@@ -1,3 +1,3 @@
 module Shiplog
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

data/lib/shiplog.rb

@@ -4,6 +4,7 @@ require "shiplog/configuration"
 require "shiplog/github/errors"
 require "shiplog/github/queries"
 require "shiplog/github/client"
+require "shiplog/head_tags_helper"
 require "shiplog/engine"
 require "shiplog/admin/engine"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shiplog
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Trackberry
@@ -72,9 +72,11 @@ files:
 - app/helpers/shiplog/application_helper.rb
 - app/helpers/shiplog/callable_helper.rb
 - app/helpers/shiplog/frontend_helper.rb
+- app/helpers/shiplog/head_helper.rb
 - app/helpers/shiplog/host_routes_helper.rb
 - app/helpers/shiplog/permalink_helper.rb
 - app/helpers/shiplog/roadmap_helper.rb
+- app/helpers/shiplog/structured_data_helper.rb
 - app/helpers/shiplog/styling_helper.rb
 - app/helpers/shiplog/switcher_helper.rb
 - app/helpers/shiplog/unseen_helper.rb
@@ -125,6 +127,7 @@ files:
 - app/views/layouts/shiplog/admin.html.erb
 - app/views/layouts/shiplog/application.html.erb
 - app/views/shiplog/_empty.html.erb
+- app/views/shiplog/_head_tags.html.erb
 - app/views/shiplog/_page.html.erb
 - app/views/shiplog/_page_header.html.erb
 - app/views/shiplog/_pagination.html.erb
@@ -151,6 +154,10 @@ files:
 - app/views/shiplog/changelogs/_month.html.erb
 - app/views/shiplog/changelogs/_search.html.erb
 - app/views/shiplog/changelogs/show.html.erb
+- app/views/shiplog/head/_feed.html.erb
+- app/views/shiplog/head/_meta.html.erb
+- app/views/shiplog/head/_open_graph.html.erb
+- app/views/shiplog/head/_structured_data.html.erb
 - app/views/shiplog/roadmaps/_card.html.erb
 - app/views/shiplog/roadmaps/_column.html.erb
 - app/views/shiplog/roadmaps/_shipped.html.erb
@@ -173,6 +180,7 @@ files:
 - lib/shiplog/github/client.rb
 - lib/shiplog/github/errors.rb
 - lib/shiplog/github/queries.rb
+- lib/shiplog/head_tags_helper.rb
 - lib/shiplog/version.rb
 - lib/tasks/shiplog.rake
 homepage: https://github.com/Trackberry/shiplog