meta-tags 2.23.0 → 2.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b4bb486b4a8b270f4e782ad51e97e5df1e48c494226f28c4242aaf17b4a20a3
-  data.tar.gz: 43ff472ad6406ee187d1234eb363d6a9a9d9360c460b651bfcf00ab503a62d01
+  metadata.gz: 566365edffbf0315633065a07584898e708104ed5657ae1b673302dcd10ed3b0
+  data.tar.gz: ffde1c27ef6745ad5ce3635118a63e4af9b3845dc4ee6ef4eb1c2747bd93f7e5
 SHA512:
-  metadata.gz: 98406f57fb0efc987f850478b5178c95634785853fdda24898aecde45b40893920c3533b86627d12e8a5b2cdd7526fb3a7c15b44617087c2029cb2329dac2908
-  data.tar.gz: dde7d53752a74f005e5ddafafea009c17aad3e67f119e825f5478285421c041060b7b766d7bcdb04bd4fb1bdea0d892a59b8a84e9c348ef55786b90b12c9a189
+  metadata.gz: ec303b92dcd6e228fb13d23ce7222f9086e53f715efdccc587c298ed1ad0de838917d29e818a2549f3c91600264b523075772272ce5aa0ea8dd8e1c1ebd6d3c9
+  data.tar.gz: 9caa336eb5b685e16fe8474ff3aa70e79ceb931c8bba1ddab58db5947a67a4a45d92ccb1ce1d2a6c34a033a54ff8a704ae76ecc386057607bb6f8fd5388bd6d6

data/CHANGELOG.md

@@ -2,6 +2,75 @@
 
 ## Unreleased
 
+## 2.24.0 (September 1, 2026) [☰](https://github.com/kpumuk/meta-tags/compare/v2.23.0...v2.24.0)
+
+Features:
+
+- Added the `truncate_array_items_at_boundaries` option for `title` and `keywords` arrays. When enabled, multi-item arrays stop before an overflowing item instead of cutting that item in the middle. The first or only item can still be truncated, so a non-empty value does not become empty ([354](https://github.com/kpumuk/meta-tags/pull/354)).
+
+  ```ruby
+  MetaTags.configure do |config|
+    config.title_limit = 12
+    config.truncate_array_items_at_boundaries = true
+  end
+
+  display_meta_tags(title: ["Shoes", "Running", "Men"])
+  # => <title>Shoes</title>
+  # With the option disabled: <title>Shoes | Runn</title>
+  ```
+
+- Added hash-based custom directives for `robots`, `googlebot`, and `bingbot`. `nil` and `true` produce valueless directives, `false` omits a directive, and other values use `name:value`; existing robots helpers and legacy scalar and array values remain supported ([224](https://github.com/kpumuk/meta-tags/pull/224), rebased in [361](https://github.com/kpumuk/meta-tags/pull/361), corrected in [406](https://github.com/kpumuk/meta-tags/pull/406)).
+
+  ```ruby
+  display_meta_tags(
+    robots: {
+      "max-snippet" => -1,
+      "max-video-preview" => -1
+    }
+  )
+  # => <meta name="robots" content="max-snippet:-1, max-video-preview:-1">
+  ```
+
+Bugfixes:
+
+- Made `skip_canonical_links_on_noindex` follow the directives that are actually rendered. Empty crawler lists and blank crawler names no longer suppress canonical links, while effective `noindex` directives in custom `robots`, `googlebot`, and `bingbot` values do ([405](https://github.com/kpumuk/meta-tags/pull/405), [413](https://github.com/kpumuk/meta-tags/pull/413), [416](https://github.com/kpumuk/meta-tags/pull/416)).
+- Preserved legacy scalar and array custom robots values instead of treating every value as a directive hash. This also fixes valueless directives being serialized with a trailing colon and disabled directives being rendered as `name:false` ([406](https://github.com/kpumuk/meta-tags/pull/406)).
+- Preserved an inherited `itemprop` on anonymous values inside recursively structured metadata, including arrays of Open Graph images. Named subproperties still do not inherit the attribute, and an explicit nested value still wins ([410](https://github.com/kpumuk/meta-tags/pull/410)).
+- Suppressed icon and array-form alternate links when their URL is `nil` or blank, instead of rendering unusable `href=""` elements ([411](https://github.com/kpumuk/meta-tags/pull/411)).
+- Fixed `MetaTagsCollection#page_title` when `site` is supplied through method defaults. It now excludes the site while `full_title` continues to include it ([412](https://github.com/kpumuk/meta-tags/pull/412)).
+
+  ```ruby
+  collection.page_title(site: "Site", title: "Page") # => "Page"
+  collection.full_title(site: "Site", title: "Page") # => "Site | Page"
+  ```
+
+- Deep-merged the `og` and `open_graph` aliases when both appear in one input hash, instead of silently discarding the canonical `og` value. `og` wins conflicting leaves in the same input; separate updates retain their existing last-update precedence ([414](https://github.com/kpumuk/meta-tags/pull/414)).
+- Aligned the packaged RBS contracts with existing runtime behavior: `description_limit` accepts `nil`, `title_tag_attributes` accepts Rails-style nested arrays and numeric or boolean values, and recursive metadata accepts finite `Float` values ([415](https://github.com/kpumuk/meta-tags/pull/415), [418](https://github.com/kpumuk/meta-tags/pull/418), [419](https://github.com/kpumuk/meta-tags/pull/419)).
+- Fixed the `lowercase` title option so it is consumed even when the page title is absent, rather than leaking into `<meta name="lowercase">`. String-like title values implementing `#to_str` are now coerced before lowercasing instead of raising `NoMethodError` ([420](https://github.com/kpumuk/meta-tags/pull/420)).
+
+Changes:
+
+- **MetaTags 3.0 migration:** direct Symbols in nested custom-tag arrays now emit a deprecation warning. MetaTags 2.x still renders them literally by default; set `resolve_symbolic_references_in_arrays = true` to opt in to 3.0 reference semantics now, and use Strings for values that should remain literal. Direct hash references, explicit `{_: ...}` references, top-level arrays, and specialized arrays keep their existing behavior ([409](https://github.com/kpumuk/meta-tags/pull/409)).
+
+  ```ruby
+  MetaTags.configure do |config|
+    config.resolve_symbolic_references_in_arrays = true
+  end
+
+  display_meta_tags(
+    image_src: "https://example.com/image.png",
+    og: {image: [:image_src]}
+  )
+  # => <link rel="image_src" href="https://example.com/image.png">
+  #    <meta property="og:image" content="https://example.com/image.png">
+  ```
+
+- Made README rendering examples executable regression tests and repaired confirmed dead reference links, reducing the chance that documented output drifts from the renderer ([404](https://github.com/kpumuk/meta-tags/pull/404), [417](https://github.com/kpumuk/meta-tags/pull/417)).
+- Made the `steep` Rake task propagate type-checking failures and reconciled the RBS signatures with the current Ruby implementation, so CI can no longer report success after Steep errors ([407](https://github.com/kpumuk/meta-tags/pull/407)).
+- Refreshed the supported development lockfiles, split Ruby 3.1 compatibility locks where patched dependencies require newer Ruby, and added an advisory audit covering every committed supported lockfile ([408](https://github.com/kpumuk/meta-tags/pull/408)).
+- Hardened GitHub Actions by removing untrusted checkouts from the privileged Dependabot workflow, declaring token permissions, adding stable required checks and a security policy, and enforcing OpenSSF Scorecards and pedantic zizmor checks ([357](https://github.com/kpumuk/meta-tags/pull/357), [358](https://github.com/kpumuk/meta-tags/pull/358), [359](https://github.com/kpumuk/meta-tags/pull/359), [360](https://github.com/kpumuk/meta-tags/pull/360), [362](https://github.com/kpumuk/meta-tags/pull/362), [374](https://github.com/kpumuk/meta-tags/pull/374)).
+- Updated the GitHub Actions toolchain throughout the release cycle, including `actions/checkout`, artifact upload, GitHub App authentication, `ruby/setup-ruby`, RubyGems release automation, Scorecards, and zizmor ([367](https://github.com/kpumuk/meta-tags/pull/367), [376](https://github.com/kpumuk/meta-tags/pull/376), [397](https://github.com/kpumuk/meta-tags/pull/397), [399](https://github.com/kpumuk/meta-tags/pull/399), [401](https://github.com/kpumuk/meta-tags/pull/401), [402](https://github.com/kpumuk/meta-tags/pull/402), [403](https://github.com/kpumuk/meta-tags/pull/403)).
+
 ## 2.23.0 (March 16, 2026) [☰](https://github.com/kpumuk/meta-tags/compare/v2.22.3...v2.23.0)
 
 Bugfixes:

data/README.md

@@ -2,6 +2,7 @@
 
 [![Tests](https://github.com/kpumuk/meta-tags/actions/workflows/tests.yml/badge.svg)](https://github.com/kpumuk/meta-tags/actions/workflows/tests.yml)
 [![Gem Version](https://badge.fury.io/rb/meta-tags.svg)](https://badge.fury.io/rb/meta-tags)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/kpumuk/meta-tags/badge)](https://scorecard.dev/viewer/?uri=github.com/kpumuk/meta-tags)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
 [![Gem Downloads](https://img.shields.io/gem/dt/meta-tags.svg)](https://badge.fury.io/rb/meta-tags)
 [![Changelog](https://img.shields.io/badge/Changelog-latest-blue.svg)](https://github.com/kpumuk/meta-tags/blob/main/CHANGELOG.md)
@@ -40,6 +41,25 @@ To override the defaults, create an initializer `config/initializers/meta_tags.r
 rails generate meta_tags:install
 ```
 
+When a truncation limit is reached, arrays passed to `title` or `keywords` can
+either partially truncate the last item or stop at item boundaries. Set
+`config.truncate_array_items_at_boundaries = true` to preserve whole items for
+multi-item arrays. Single-item arrays are still truncated normally.
+
+Symbols in nested custom tag arrays are literal values in MetaTags 2.x.
+MetaTags 3.0 will use them to look up normalized top-level tags. You can turn
+on this behavior now. Until then, each nested array that contains a direct
+Symbol value emits a deprecation warning:
+
+```ruby
+MetaTags.configure do |config|
+  config.resolve_symbolic_references_in_arrays = true
+end
+```
+
+When this option is on, use Strings for literal array values. MetaTags does not
+render a tag when a Symbol has no match.
+
 By default, meta tags are rendered with the key `name`. However, some meta tags are required to use `property` instead (like Facebook Open Graph object). The MetaTags gem allows you to configure which tags to render with the `property` attribute. The pre-configured list includes all possible Facebook Open Graph object types by default, but you can add your own in case you need it.
 
 ## MetaTags Usage
@@ -148,7 +168,7 @@ If you want to set the title and display another text, use this:
 
 ### Allowed options for `display_meta_tags` and `set_meta_tags` methods
 
-Use these options to customize the title format:
+Use these options to customize the generated tags:
 
 | Option         | Description                                                                                                         |
 | -------------- | ------------------------------------------------------------------------------------------------------------------- |
@@ -167,6 +187,9 @@ Use these options to customize the title format:
 | `:nofollow`    | Add nofollow meta tag; when true, "robots" will be used; accepts a string with a robot name or an array of strings  |
 | `:follow`      | Add follow meta tag; when true, "robots" will be used; accepts a string with a robot name or an array of strings    |
 | `:noarchive`   | Add noarchive meta tag; when true, "robots" will be used; accepts a string with a robot name or an array of strings |
+| `:robots`      | Add custom directives to the `robots` meta tag (Hash)                                                               |
+| `:googlebot`   | Add custom directives to the `googlebot` meta tag (Hash)                                                            |
+| `:bingbot`     | Add custom directives to the `bingbot` meta tag (Hash)                                                              |
 | `:canonical`   | Add canonical link tag                                                                                              |
 | `:prev`        | Add legacy prev pagination link tag                                                                                 |
 | `:next`        | Add legacy next pagination link tag                                                                                 |
@@ -297,6 +320,8 @@ These tags still matter for search snippets, canonicalization, robots directives
 
 Page titles help browsers, social previews, and search engines understand the page. Use unique, descriptive titles that match the visible page content.
 
+<!-- executable-example: titles -->
+
 ```ruby
 set_meta_tags title: "Member Login"
 # <title>Member Login</title>
@@ -319,6 +344,8 @@ Description meta tags help search engines generate snippets, but search engines
 
 Below is an example of how to set a description tag using Ruby:
 
+<!-- executable-example: description -->
+
 ```ruby
 set_meta_tags description: "This is a sample description"
 # <meta name="description" content="This is a sample description">
@@ -336,6 +363,8 @@ Further reading:
 
 The `keywords` tag is a legacy feature. MetaTags still supports it for backwards compatibility and for systems that still read it, but it is not a modern web SEO signal.
 
+<!-- executable-example: keywords -->
+
 ```ruby
 set_meta_tags keywords: %w[keyword1 keyword2 keyword3]
 # <meta name="keywords" content="keyword1, keyword2, keyword3">
@@ -352,6 +381,8 @@ Further reading:
 
 By using the noindex meta tag, you can signal to search engines not to include specific pages in their indexes.
 
+<!-- executable-example: noindex -->
+
 ```ruby
 set_meta_tags noindex: true
 # <meta name="robots" content="noindex">
@@ -371,6 +402,8 @@ Further reading:
 
 In most cases, you do not need to emit `index` explicitly because it is already the default for crawlable pages.
 
+<!-- executable-example: index -->
+
 ```ruby
 set_meta_tags index: true
 # <meta name="robots" content="index">
@@ -380,6 +413,8 @@ set_meta_tags index: true
 
 Nofollow meta tags tell a search engine not to follow the links on a specific page. It is entirely possible that a robot might find the same links on another page without a nofollow attribute, perhaps on another site, and still arrive at your undesired page.
 
+<!-- executable-example: nofollow -->
+
 ```ruby
 set_meta_tags nofollow: true
 # <meta name="robots" content="nofollow">
@@ -389,7 +424,7 @@ set_meta_tags nofollow: "googlebot"
 
 Further reading:
 
-- [About rel="nofollow"](http://www.google.com/support/webmasters/bin/answer.py?answer=96569)
+- [About rel="nofollow"](https://developers.google.com/search/docs/crawling-indexing/qualify-outbound-links)
 - [Meta tags](http://www.google.com/support/webmasters/bin/answer.py?hl=en&answer=79812)
 - [Google Search Central: robots meta tag and X-Robots-Tag](https://developers.google.com/search/docs/crawling-indexing/robots-meta-tag)
 
@@ -397,6 +432,8 @@ Further reading:
 
 You can use `follow` with `noindex` if you need that combination, but most pages do not need an explicit `follow` tag because it is also the default behavior.
 
+<!-- executable-example: follow -->
+
 ```ruby
 set_meta_tags noindex: true, follow: true
 # <meta name="robots" content="noindex, follow">
@@ -404,6 +441,39 @@ set_meta_tags noindex: true, follow: true
 
 This tag will prevent search engines from indexing this specific page, but it will still allow them to crawl and index the remaining pages on your website.
 
+### Robots
+
+Use the `robots`, `googlebot`, and `bingbot` hashes when you need directives beyond `index`, `noindex`, `follow`, `nofollow`, and `noarchive`.
+
+This is useful for directives such as `max-snippet`, `max-video-preview`, and `unavailable_after`.
+
+<!-- executable-example: robots -->
+
+```ruby
+set_meta_tags robots: {
+  "max-snippet" => -1,
+  "max-video-preview" => -1
+}
+# <meta name="robots" content="max-snippet:-1, max-video-preview:-1">
+
+set_meta_tags googlebot: {
+  unavailable_after: "2026-12-31"
+}
+# <meta name="googlebot" content="unavailable_after:2026-12-31">
+
+set_meta_tags bingbot: {
+  "max-image-preview" => "large"
+}
+# <meta name="bingbot" content="max-image-preview:large">
+```
+
+These hashes are merged with the existing robots helpers, so `noindex`, `nofollow`, and similar directives still render first for the same meta tag.
+
+Further reading:
+
+- [Google Search Central: robots meta tag and X-Robots-Tag](https://developers.google.com/search/docs/crawling-indexing/robots-meta-tag)
+- [Bing Webmaster Guidelines: robots meta tag support](https://www.bing.com/webmasters/help/which-robots-metatags-does-bing-support-5198d240)
+
 ### Canonical URL
 
 Canonical link elements help search engines consolidate duplicate or near-duplicate URLs under one preferred URL. They are a signal, not a guarantee.
@@ -411,6 +481,8 @@ Canonical link elements help search engines consolidate duplicate or near-duplic
 > [!NOTE]
 > If your goal is duplicate consolidation, prefer a canonical URL over `noindex`. If you do not want to mix canonical with `noindex`, set `MetaTags.config.skip_canonical_links_on_noindex = true`.
 
+<!-- executable-example: canonical -->
+
 ```ruby
 set_meta_tags canonical: "http://yoursite.com/canonical/url"
 # <link rel="canonical" href="http://yoursite.com/canonical/url">
@@ -426,17 +498,19 @@ Further reading:
 
 A favicon (short for Favorite icon), also known as a shortcut icon, website icon, tab icon, or bookmark icon, is a file containing one or more small icons, most commonly 16x16 pixels, associated with a particular website or web page.
 
+<!-- executable-example: icons -->
+
 ```ruby
 set_meta_tags icon: "/favicon.ico"
-# <link rel="icon" href="/favicon.ico" type="image/x-icon">
-set_meta_tags icon: "/favicon.png", type: "image/png"
-# <link rel="icon" href="/favicon.png" type="image/png">
+# <link rel="icon" type="image/x-icon" href="/favicon.ico">
+set_meta_tags icon: {href: "/favicon.png", type: "image/png"}
+# <link rel="icon" type="image/png" href="/favicon.png">
 set_meta_tags icon: [
   {href: "/images/icons/icon_96.png", sizes: "32x32 96x96", type: "image/png"},
   {href: "/images/icons/icon_itouch_precomp_32.png", rel: "apple-touch-icon-precomposed", sizes: "32x32", type: "image/png"}
 ]
-# <link rel="icon" href="/images/icons/icon_96.png" type="image/png" sizes="32x32 96x96">
-# <link rel="apple-touch-icon-precomposed" href="/images/icons/icon_itouch_precomp_32.png" type="image/png" sizes="32x32">
+# <link rel="icon" type="image/png" href="/images/icons/icon_96.png" sizes="32x32 96x96">
+# <link rel="apple-touch-icon-precomposed" type="image/png" href="/images/icons/icon_itouch_precomp_32.png" sizes="32x32">
 ```
 
 Further reading:
@@ -448,6 +522,8 @@ Further reading:
 
 Alternate link elements tell a search engine when there is content that's translated or targeted to users in a certain region.
 
+<!-- executable-example: alternate -->
+
 ```ruby
 set_meta_tags alternate: {"fr" => "http://yoursite.fr/alternate/url"}
 # <link rel="alternate" href="http://yoursite.fr/alternate/url" hreflang="fr">
@@ -478,6 +554,8 @@ Further reading:
 
 Previous and next links can describe a paginated sequence for browsers, feed readers, or custom consumers that still read them. Google no longer uses `rel="prev"` and `rel="next"` as an indexing signal, so treat them as optional interoperability metadata, not core SEO guidance.
 
+<!-- executable-example: pagination -->
+
 ```ruby
 set_meta_tags prev: "http://yoursite.com/url?page=1"
 # <link rel="prev" href="http://yoursite.com/url?page=1">
@@ -487,14 +565,15 @@ set_meta_tags next: "http://yoursite.com/url?page=3"
 
 Further reading:
 
-- [Pagination](http://support.google.com/webmasters/bin/answer.py?hl=en&answer=1663744)
-- [Pagination with rel="next" and rel="prev"](http://googlewebmastercentral.blogspot.ca/2011/09/pagination-with-relnext-and-relprev.html)
+- [Pagination with rel="next" and rel="prev"](https://developers.google.com/search/blog/2011/09/pagination-with-relnext-and-relprev)
 - [Google Search Central: pagination, incremental page loading, and infinite scroll](https://developers.google.com/search/docs/specialty/ecommerce/pagination-and-incremental-page-loading)
 
 ### image_src links
 
 `image_src` is a legacy share hint. Modern social sharing generally relies on Open Graph images and platform-specific card tags instead.
 
+<!-- executable-example: image-src -->
+
 ```ruby
 set_meta_tags image_src: "http://yoursite.com/icons/icon_32.png"
 # <link rel="image_src" href="http://yoursite.com/icons/icon_32.png">
@@ -504,8 +583,13 @@ set_meta_tags image_src: "http://yoursite.com/icons/icon_32.png"
 
 If your application still serves AMP pages, you can link the AMP version from the canonical page with `amphtml`. This is an optional legacy integration, not a general SEO requirement.
 
+In a routed Rails view, you can generate the absolute URL with
+`url_for(format: :amp, only_path: false)`.
+
+<!-- executable-example: amphtml -->
+
 ```ruby
-set_meta_tags amphtml: url_for(format: :amp, only_path: false)
+set_meta_tags amphtml: "https://www.example.com/document.amp"
 # <link rel="amphtml" href="https://www.example.com/document.amp">
 ```
 
@@ -517,6 +601,8 @@ To link back to the normal version, use the `canonical` tag.
 
 By including the `rel="manifest"` attribute in the `<link>` element of an HTML page, you can specify the location of the manifest file that describes the web application. This allows the browser to understand that the web page is an application and to provide features like offline access and the ability to add the application to the home screen of a mobile device.
 
+<!-- executable-example: manifest -->
+
 ```ruby
 set_meta_tags manifest: "manifest.json"
 # <link rel="manifest" href="manifest.json">
@@ -528,11 +614,13 @@ set_meta_tags manifest: "manifest.json"
 
 Meta refresh is a method of instructing a web browser to automatically refresh the current web page or frame after a given time interval. It is also possible to instruct the browser to fetch a different URL when the page is refreshed, by including the alternative URL in the content parameter. By setting the refresh time interval to zero (or a very low value), this allows meta refresh to be used as a method of URL redirection.
 
+<!-- executable-example: refresh -->
+
 ```ruby
 set_meta_tags refresh: 5
-# <meta content="5" http-equiv="refresh">
+# <meta http-equiv="refresh" content="5">
 set_meta_tags refresh: "5;url=http://example.com"
-# <meta content="5;url=http://example.com" http-equiv="refresh">
+# <meta http-equiv="refresh" content="5;url=http://example.com">
 ```
 
 Further reading:
@@ -544,23 +632,27 @@ Further reading:
 
 Open Search is a link element used to describe a search engine in a standard and accessible format.
 
+<!-- executable-example: open-search -->
+
 ```ruby
 set_meta_tags open_search: {
   title: "Open Search",
   href: "/opensearch.xml"
 }
-# <link href="/opensearch.xml" rel="search" title="Open Search" type="application/opensearchdescription+xml">
+# <link rel="search" type="application/opensearchdescription+xml" href="/opensearch.xml" title="Open Search">
 ```
 
 Further reading:
 
-- [OpenSearch specs](http://www.opensearch.org/Specifications/OpenSearch/1.1)
+- [OpenSearch specs](https://github.com/dewitt/opensearch/blob/master/opensearch-1-1-draft-6.md)
 - [OpenSearch wiki](http://en.wikipedia.org/wiki/OpenSearch)
 
 ### Hashes
 
 Any namespace can be created by simply passing a symbol name and a Hash. For example:
 
+<!-- executable-example: hashes -->
+
 ```ruby
 set_meta_tags foo: {
   bar: "lorem",
@@ -568,14 +660,20 @@ set_meta_tags foo: {
     qux: "ipsum"
   }
 }
-# <meta property="foo:bar" content="lorem">
-# <meta property="foo:baz:qux" content="ipsum">
+# <meta name="foo:bar" content="lorem">
+# <meta name="foo:baz:qux" content="ipsum">
 ```
 
+Arbitrary namespaces use the `name` attribute by default. To render `foo` and
+its colon-delimited children with `property`, add `foo` to
+`MetaTags.config.property_tags` in your initializer.
+
 ### Arrays
 
 Repeated meta tags can be easily created by using an Array within a Hash. For example:
 
+<!-- executable-example: arrays -->
+
 ```ruby
 set_meta_tags og: {
   image: ["http://example.com/rock.jpg", "http://example.com/rock2.jpg"]
@@ -588,6 +686,8 @@ set_meta_tags og: {
 
 To turn your web pages into graph objects, you'll need to add Open Graph protocol `<meta>` tags to your webpages. The tags allow you to specify structured information about your web pages. The more information you provide, the more opportunities your web pages can be surfaced within Facebook today and in the future. Here's an example for a movie page:
 
+<!-- executable-example: open-graph -->
+
 ```ruby
 set_meta_tags og: {
   title: "The Rock",
@@ -610,11 +710,13 @@ set_meta_tags og: {
 
 Multiple images declared as an **array** (look at the `_` character):
 
+<!-- executable-example: open-graph-images -->
+
 ```ruby
 set_meta_tags og: {
   title: "Two structured image properties",
   type: "website",
-  url: "view-source:http://examples.opengraphprotocol.us/image-array.html",
+  url: "http://examples.opengraphprotocol.us/image-array.html",
   image: [
     {
       _: "http://examples.opengraphprotocol.us/media/images/75.png",
@@ -641,6 +743,8 @@ set_meta_tags og: {
 
 Article meta tags are supported too:
 
+<!-- executable-example: article -->
+
 ```ruby
 set_meta_tags article: {
   published_time: "2013-09-17T05:59:00+01:00",
@@ -665,6 +769,8 @@ Further reading:
 
 X cards let links shared on X show richer previews. The metadata namespace is still `twitter:*`. Here is a simple summary card example:
 
+<!-- executable-example: twitter -->
+
 ```ruby
 set_meta_tags twitter: {
   card: "summary",
@@ -678,6 +784,8 @@ If you already publish Open Graph tags, you can often keep the X-specific tags m
 
 When you need to generate nested `twitter:image:*` tags, the `twitter:image` property is a string while sub-properties can be expressed as a `Hash` in MetaTags:
 
+<!-- executable-example: twitter-image -->
+
 ```ruby
 set_meta_tags twitter: {
   card: "summary_large_image",
@@ -697,6 +805,8 @@ set_meta_tags twitter: {
 
 A special parameter `itemprop` can be used on an "anonymous" tag "\_" to generate the "itemprop" HTML attribute:
 
+<!-- executable-example: twitter-itemprop -->
+
 ```ruby
 set_meta_tags twitter: {
   card: "summary_large_image",
@@ -723,6 +833,8 @@ Further reading:
 
 App Links is an open cross-platform solution for deep linking to content in your mobile app. Here's an example of iOS app integration:
 
+<!-- executable-example: app-links -->
+
 ```ruby
 set_meta_tags al: {
   ios: {
@@ -746,6 +858,8 @@ Starting from version 1.3.1, you can specify arbitrary meta tags, and they will
 
 Example:
 
+<!-- executable-example: custom-author -->
+
 ```ruby
 set_meta_tags author: "Dmytro Shteflyuk"
 # <meta name="author" content="Dmytro Shteflyuk">
@@ -753,6 +867,8 @@ set_meta_tags author: "Dmytro Shteflyuk"
 
 You can also specify the value as an Array, and the values will be displayed as a list of `meta` tags:
 
+<!-- executable-example: custom-author-array -->
+
 ```ruby
 set_meta_tags author: ["Dmytro Shteflyuk", "John Doe"]
 # <meta name="author" content="Dmytro Shteflyuk">

data/SECURITY.md

@@ -0,0 +1,40 @@
+# Security Policy
+
+## Supported Versions
+
+Security fixes are provided for the latest released version of `meta-tags`.
+
+Older releases may not receive security updates. If you are reporting a vulnerability, please confirm whether it affects the latest release.
+
+## Reporting a Vulnerability
+
+Please do not report security issues through public GitHub issues, discussions, or pull requests.
+
+Use GitHub's private vulnerability reporting feature in the repository's `Security` tab to report a vulnerability.
+
+If private reporting through GitHub is unavailable for any reason, send a report by email to `kpumuk@kpumuk.info` with `SECURITY` in the subject line.
+
+When possible, include:
+
+- a short description of the issue
+- the affected version, commit, or tag
+- any required environment or configuration details
+- step-by-step reproduction instructions
+- proof-of-concept code, logs, or screenshots
+- an explanation of the likely impact
+
+## Disclosure Policy
+
+Please allow a reasonable amount of time to investigate and prepare a fix before making the issue public.
+
+If the report is confirmed, the fix will be released as soon as practical. Public disclosure will generally happen through a GitHub security advisory and/or release notes after a fix is available.
+
+## Scope Notes
+
+`meta-tags` is a Ruby gem for Rails applications that renders HTML metadata such as titles, descriptions, canonical links, robots directives, and social tags.
+
+Some behavior may depend on the host Rails application, layouts, templates, framework version, gem version, or deployment/runtime configuration. If a report depends on a specific setup, include those details.
+
+## Response Expectations
+
+This is a single-maintainer project, so response times may vary. Good-faith reports are appreciated, and I will try to acknowledge valid reports as quickly as practical.

data/lib/generators/meta_tags/templates/config/initializers/meta_tags.rb

@@ -18,6 +18,11 @@ MetaTags.configure do |config|
   # a Unicode space (/\p{Space}/).
   # config.truncate_on_natural_separator = " "
 
+  # When true, arrays passed to `title` and `keywords` stop at item
+  # boundaries instead of partially truncating the overflowing item.
+  # Single-item arrays are still truncated normally. Default is false.
+  # config.truncate_array_items_at_boundaries = false
+
   # Maximum length of the page description. Default is 300.
   # Set to nil or 0 to remove limits.
   # config.description_limit = 300
@@ -38,6 +43,11 @@ MetaTags.configure do |config|
   # Default is false.
   # config.minify_output = false
 
+  # When true, Symbols inside nested meta tag arrays resolve as references to
+  # normalized top-level tags. Default is false until MetaTags 3.0, when this
+  # behavior will become the default.
+  # config.resolve_symbolic_references_in_arrays = false
+
   # When false, generated meta tags will be self-closing (<meta ... />) instead
   # of open (`<meta ...>`). Default is true.
   # config.open_meta_tags = true

data/lib/meta_tags/configuration.rb

@@ -15,6 +15,10 @@ module MetaTags
     # A string or regexp separator to truncate text at a natural break.
     attr_accessor :truncate_on_natural_separator
 
+    # When true, multi-item arrays stop at item boundaries instead of
+    # truncating the overflowing item.
+    attr_accessor :truncate_array_items_at_boundaries
+
     # How many characters to truncate description to.
     attr_accessor :description_limit
 
@@ -35,6 +39,10 @@ module MetaTags
     # Default is false.
     attr_accessor :minify_output
 
+    # When true, Symbols inside nested meta tag arrays resolve as references to
+    # normalized top-level tags. Default is false until MetaTags 3.0.
+    attr_accessor :resolve_symbolic_references_in_arrays
+
     # Custom meta tags that should use the `property` attribute instead of `name`.
     # An array of strings or symbols representing their names or name prefixes.
     attr_reader :property_tags
@@ -94,6 +102,7 @@ module MetaTags
       @title_limit = 70
       @truncate_site_title_first = false
       @truncate_on_natural_separator = " "
+      @truncate_array_items_at_boundaries = false
       @title_tag_attributes = {}
       @description_limit = 300
       @keywords_limit = 255
@@ -102,6 +111,7 @@ module MetaTags
       @property_tags = default_property_tags.dup
       @open_meta_tags = true
       @minify_output = false
+      @resolve_symbolic_references_in_arrays = false
       @skip_canonical_links_on_noindex = false
     end
   end

data/lib/meta_tags/meta_tags_collection.rb

@@ -70,13 +70,10 @@ module MetaTags
     # @param defaults [Hash] list of default meta tag attributes.
     # @return [String] page title.
     def page_title(defaults = {})
-      had_site = @meta_tags.key?(:site)
-      old_site = @meta_tags[:site]
-      @meta_tags[:site] = nil if had_site
-      full_title = with_defaults(defaults) { extract_full_title }
-      full_title.presence || old_site || ""
-    ensure
-      @meta_tags[:site] = old_site if had_site
+      with_defaults(defaults) do
+        site = extract(:site)
+        extract_full_title.presence || site || ""
+      end
     end
 
     # Deletes and returns a meta tag value by name.
@@ -110,12 +107,19 @@ module MetaTags
     #
     # @return [Array<String>] segments of page title.
     def extract_title
+      lowercase = extract(:lowercase) == true
       title = extract(:title).presence
       return [] unless title
 
-      # @type var title: Array[String]
       title = Array(title)
-      return title.map(&:downcase) if extract(:lowercase) == true
+      if lowercase
+        return title.map do |segment|
+          string = String.try_convert(segment)
+          raise ArgumentError, "Expected a string or an object that implements #to_str" unless string
+
+          string.downcase
+        end
+      end
 
       title
     end
@@ -137,10 +141,43 @@ module MetaTags
       TextNormalizer.safe_join([prefix, separator, suffix], "")
     end
 
-    # Extracts noindex settings as a Hash mapping noindex tag name to value.
+    # Extracts robots settings as a Hash mapping tag names to rendered values.
     #
-    # @return [Hash{String => String}] noindex attributes.
+    # @return [Hash{String => String}] robots attributes.
     def extract_robots
+      result = robots
+      delete(:noindex, :index, :follow, :nofollow, :noarchive)
+      [:robots, :googlebot, :bingbot].each do |bot|
+        extract(bot) if meta_tags[bot].is_a?(Hash)
+      end
+
+      result
+    end
+
+    # Returns whether robots settings produce a noindex directive.
+    #
+    # @return [Boolean] true when a noindex directive will be rendered.
+    def noindex?
+      contents = robots.values
+      property_tags = MetaTags.config.property_tags.map(&:to_s)
+      [:robots, :googlebot, :bingbot].each do |bot|
+        values = meta_tags[bot]
+        next if values.is_a?(Hash) || property_tags.include?(bot.to_s)
+
+        contents.concat(Array(values))
+      end
+
+      contents.any? do |content|
+        content.to_s.split(",").any? { |directive| directive.strip.casecmp?("noindex") }
+      end
+    end
+
+    protected
+
+    # Returns robots settings without modifying the collection.
+    #
+    # @return [Hash{String => String}] robots attributes.
+    def robots
       # @type var result: Hash[String, Array[String]]
       result = Hash.new { |h, k| h[k] = [] }
 
@@ -154,18 +191,36 @@ module MetaTags
         calculate_robots_attributes(result, attributes)
       end
 
+      [:robots, :googlebot, :bingbot].each do |bot|
+        values = meta_tags[bot]
+        if values.is_a?(Hash)
+          values.each do |key, value|
+            next if value == false
+
+            directive = (value.nil? || value == true) ? key.to_s : "#{key}:#{value}"
+            result[bot.to_s] << directive
+          end
+        end
+      end
+
       result.transform_values { |v| v.join(", ") }
     end
 
-    protected
-
     # Converts input hash to HashWithIndifferentAccess and renames :open_graph to :og.
+    # When both aliases contain hashes, they are deep-merged with :og taking precedence.
     #
     # @param meta_tags [Hash] list of meta tags.
     # @return [ActiveSupport::HashWithIndifferentAccess] normalized meta tags list.
     def normalize_open_graph(meta_tags)
       meta_tags = meta_tags.with_indifferent_access
-      meta_tags[:og] = meta_tags.delete(:open_graph) if meta_tags.key?(:open_graph)
+      if meta_tags.key?(:open_graph)
+        open_graph = meta_tags.delete(:open_graph)
+        if meta_tags.key?(:og)
+          meta_tags[:og] = open_graph.dup.deep_merge!(meta_tags[:og]) if open_graph.is_a?(Hash) && meta_tags[:og].is_a?(Hash)
+        else
+          meta_tags[:og] = open_graph
+        end
+      end
       meta_tags
     end
 
@@ -182,15 +237,32 @@ module MetaTags
     # Extracts a robots attribute name/value pair (noindex, nofollow, etc.).
     #
     # @param name [String, Symbol] noindex attribute name.
-    # @return [Array<String>] noindex attribute name and value pair.
+    # @return [Array<Object>] normalized robots tag name(s) and directive value.
     def extract_robots_attribute(name)
-      noindex = extract(name)
-      noindex_name = (noindex.is_a?(String) || noindex.is_a?(Array)) ? noindex : "robots"
-      noindex_value = noindex ? name.to_s : nil
+      noindex = meta_tags[name]
+      # @type var noindex_name: String | Array[String]
+      noindex_name = if noindex.is_a?(Array)
+        noindex.reject { |target| target.is_a?(String) && target.blank? }.map(&:to_s)
+      elsif noindex.is_a?(String)
+        noindex.presence || []
+      else
+        "robots"
+      end
+      noindex_value = if robots_attribute_present?(noindex) && noindex_name.present?
+        name.to_s
+      end
 
       [noindex_name, noindex_value]
     end
 
+    # Returns whether a robots attribute resolves to at least one target.
+    #
+    # @param value [Object] robots attribute value.
+    # @return [Boolean] true when the attribute produces a directive.
+    def robots_attribute_present?(value)
+      !!value && (!value.is_a?(Array) || !value.empty?)
+    end
+
     # Appends resolved robots directives while preserving first-write priority.
     #
     # @param result [Hash{String => Array<String>}] robots directives grouped by tag name.
@@ -203,8 +275,8 @@ module MetaTags
         names, value = extract_robots_attribute(attribute)
         next unless value
 
-        Array(names).each do |name|
-          # @type var name: String | Symbol
+        robot_names = names.is_a?(String) ? [names] : names
+        robot_names.each do |name|
           apply_robots_value(result, name, value, processed)
         end
       end
@@ -213,7 +285,7 @@ module MetaTags
     # Records a robots directive unless it has already been set for the same key.
     #
     # @param result [Hash{String => Array<String>}] robots directives grouped by tag name.
-    # @param name [String, Symbol] robots tag name.
+    # @param name [String] robots tag name.
     # @param value [String] robots directive value.
     # @param processed [Set<String>] names already recorded in this pass.
     # @return [void]

data/lib/meta_tags/railtie.rb

@@ -3,6 +3,10 @@
 module MetaTags
   # Hooks MetaTags helpers into Rails controllers and views.
   class Railtie < Rails::Railtie
+    initializer "meta_tags.register_deprecator", before: :load_environment_config do |app|
+      app.deprecators[:meta_tags] = MetaTags.deprecator if app.respond_to?(:deprecators)
+    end
+
     initializer "meta_tags.setup_action_controller" do
       ActiveSupport.on_load :action_controller do
         include MetaTags::ControllerHelper

data/lib/meta_tags/renderer.rb

@@ -77,7 +77,7 @@ module MetaTags
 
       icon.each do |icon_params|
         icon_params = {rel: "icon", type: "image/x-icon"}.with_indifferent_access.merge(icon_params)
-        tags << Tag.new(:link, icon_params)
+        tags << Tag.new(:link, icon_params) if icon_params[:href].present?
       end
     end
 
@@ -123,7 +123,8 @@ module MetaTags
         end
       elsif alternate.is_a?(Array)
         alternate.each do |link_params|
-          tags << Tag.new(:link, {rel: "alternate"}.with_indifferent_access.merge(link_params))
+          link_params = {rel: "alternate"}.with_indifferent_access.merge(link_params)
+          tags << Tag.new(:link, link_params) if link_params[:href].present?
         end
       end
     end
@@ -160,7 +161,7 @@ module MetaTags
     # @param tags [Array<Tag>] a buffer object to store tags in.
     def render_canonical_link(tags)
       href = meta_tags.extract(:canonical) # extract, so it's not used anywhere else
-      return if MetaTags.config.skip_canonical_links_on_noindex && meta_tags[:noindex]
+      return if MetaTags.config.skip_canonical_links_on_noindex && meta_tags.noindex?
       return if href.blank?
 
       @normalized_meta_tags[:canonical] = href
@@ -214,7 +215,11 @@ module MetaTags
       when Array
         process_array(tags, property, content, itemprop: itemprop)
       else
-        render_tag(tags, property, content, itemprop: itemprop)
+        if content.is_a?(Symbol) && MetaTags.config.resolve_symbolic_references_in_arrays
+          process_reference(tags, property, content, itemprop: itemprop)
+        else
+          render_tag(tags, property, content, itemprop: itemprop)
+        end
       end
     end
 
@@ -225,8 +230,12 @@ module MetaTags
     # @param content [Hash] nested meta tag attributes.
     # @param itemprop [String, Symbol, nil] inherited itemprop value.
     def process_hash(tags, property, content, itemprop: nil)
-      current_itemprop = content.delete(:itemprop)
+      itemprop_key = content.key?(:itemprop) ? :itemprop : "itemprop"
+      current_itemprop = content.key?(itemprop_key) ? content[itemprop_key] : itemprop
+
       content.each do |key, value|
+        next if key.to_s == "itemprop"
+
         if key.to_s == "_"
           key = property
           next_itemprop = current_itemprop
@@ -235,12 +244,11 @@ module MetaTags
           next_itemprop = nil
         end
 
-        normalized_value = if value.is_a?(Symbol)
-          normalized_meta_tags[value]
+        if value.is_a?(Symbol)
+          process_reference(tags, key, value, itemprop: next_itemprop)
         else
-          value
+          process_tree(tags, key, value, itemprop: next_itemprop)
         end
-        process_tree(tags, key, normalized_value, itemprop: next_itemprop)
       end
     end
 
@@ -251,9 +259,39 @@ module MetaTags
     # @param content [Array] array of nested meta tag attributes or values.
     # @param itemprop [String, Symbol, nil] value of the itemprop attribute.
     def process_array(tags, property, content, itemprop: nil)
+      unless MetaTags.config.resolve_symbolic_references_in_arrays
+        symbol_reference = content.find { |value| value.is_a?(Symbol) }
+        if symbol_reference
+          MetaTags.deprecator.warn(
+            "Passing #{symbol_reference.inspect} directly inside a nested meta tag Array is deprecated. " \
+              "It is rendered literally in MetaTags 2.x but will be interpreted as a mirrored reference in MetaTags 3.0. " \
+              "Set MetaTags.config.resolve_symbolic_references_in_arrays = true to opt in now; this behavior will " \
+              "become the default in MetaTags 3.0. Use a String to keep a literal value."
+          )
+        end
+      end
+
       content.each { |value| process_tree(tags, property, value, itemprop: itemprop) }
     end
 
+    # Resolves a Symbol reference and processes its normalized value once.
+    #
+    # @param tags [Array<Tag>] a buffer object to store tags in.
+    # @param property [String, Symbol] the meta tag property name.
+    # @param reference [Symbol] normalized top-level meta tag reference.
+    # @param itemprop [String, Symbol, nil] value of the itemprop attribute.
+    def process_reference(tags, property, reference, itemprop: nil)
+      content = normalized_meta_tags[reference]
+      case content
+      when Hash
+        process_hash(tags, property, content, itemprop: itemprop)
+      when Array
+        process_array(tags, property, content, itemprop: itemprop)
+      else
+        render_tag(tags, property, content, itemprop: itemprop)
+      end
+    end
+
     # Renders a single meta tag.
     #
     # @param tags [Array<Tag>] a buffer object to store tags in.

data/lib/meta_tags/text_normalizer.rb

@@ -152,13 +152,14 @@ module MetaTags
       return string_array if limit.nil? || limit <= 0
 
       length = 0
+      preserve_items = string_array.size > 1 && MetaTags.config.truncate_array_items_at_boundaries
       result = [] # : Array[String]
 
       string_array.each do |string|
         limit_left = calculate_limit_left(limit, length, result, separator)
 
         if string.length > limit_left
-          result << truncate(string, limit_left)
+          result << truncate(string, limit_left) if !preserve_items || result.empty?
           break string_array
         end
 

data/lib/meta_tags/version.rb

@@ -2,6 +2,6 @@
 
 module MetaTags
   # Gem version.
-  VERSION = "2.23.0"
+  VERSION = "2.24.0"
   public_constant :VERSION
 end

data/lib/meta_tags/view_helper.rb

@@ -151,6 +151,9 @@ module MetaTags
     # @option default [String, Integer] :refresh (nil) meta refresh tag;
     # @option default [Hash] :open_graph ({}) add Open Graph meta tags.
     # @option default [Hash] :open_search ({}) add Open Search link tag.
+    # @option default [Hash] :robots ({}) add robots meta tags.
+    # @option default [Hash] :googlebot ({}) add googlebot meta tags.
+    # @option default [Hash] :bingbot ({}) add bingbot meta tags.
     # @return [String] HTML meta tags to render in HEAD section of the
     #   HTML document.
     # @example Render meta tags in a layout

data/lib/meta_tags.rb

@@ -2,6 +2,7 @@
 
 require "set"
 require "active_support/core_ext/hash/indifferent_access"
+require "active_support/deprecation"
 
 # MetaTags gem namespace.
 module MetaTags
@@ -10,6 +11,11 @@ module MetaTags
     @config ||= Configuration.new
   end
 
+  # Returns the deprecator used for MetaTags API warnings.
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("3.0", "MetaTags")
+  end
+
   # Configures MetaTags gem.
   #
   # @yield [Configuration] configuration object.

data/sig/_private/rails_support.rbs

@@ -33,6 +33,11 @@ module ActionController
 end
 
 module ActiveSupport
+  class Deprecation
+    def initialize: (String deprecation_horizon, String gem_name) -> void
+    def warn: (String message) -> void
+  end
+
   class HashWithIndifferentAccess[unchecked out K, unchecked out V] < Hash[K, V]
     def with_indifferent_access: () -> self
     def deep_merge!: (instance | Hash[K, V] other) -> self

data/sig/lib/meta_tags/configuration.rbs

@@ -1,20 +1,22 @@
 module MetaTags
   class Configuration
     type html_tag_key = String | Symbol
-    type html_tag_value = Hash[html_tag_key, html_tag_value] | html_tag_content
-    type html_tag_content = String? | Symbol | (_Stringish & Object)
+    type html_tag_value = Hash[html_tag_key, html_tag_value] | Array[html_tag_value] | html_tag_content
+    type html_tag_content = String? | Symbol | Numeric | bool | (_Stringish & Object)
 
 
     attr_accessor title_limit: Integer?
     attr_accessor truncate_site_title_first: bool
     attr_accessor truncate_on_natural_separator: String?|Regexp
+    attr_accessor truncate_array_items_at_boundaries: bool
     attr_accessor title_tag_attributes: Hash[html_tag_key, html_tag_value]?
-    attr_accessor description_limit: Integer
+    attr_accessor description_limit: Integer?
     attr_accessor keywords_limit: Integer
     attr_accessor keywords_separator: String
     attr_accessor keywords_lowercase: bool
     attr_accessor open_meta_tags: bool
     attr_accessor minify_output: bool
+    attr_accessor resolve_symbolic_references_in_arrays: bool
     attr_reader property_tags: Array[String | Symbol]
     attr_accessor skip_canonical_links_on_noindex: bool
 

data/sig/lib/meta_tags/meta_tags_collection.rbs

@@ -28,14 +28,20 @@ module MetaTags
 
     def extract_robots: () -> Hash[String, String]
 
+    def noindex?: () -> bool
+
+    def robots: () -> Hash[String, String]
+
     def normalize_open_graph: (Hash[String | Symbol, untyped] meta_tags) -> ActiveSupport::HashWithIndifferentAccess[String | Symbol, untyped]
 
     def extract_separator_section: (String | Symbol name, String default) -> String
 
-    def extract_robots_attribute: (String | Symbol name) -> [String | Array[String | Symbol], String?]
+    def extract_robots_attribute: (String | Symbol name) -> [String | Array[String], String?]
+
+    def robots_attribute_present?: (untyped value) -> bool
 
     def calculate_robots_attributes: (Hash[String, Array[String]] result, String | Symbol | Array[String | Symbol] attributes) -> void
 
-    def apply_robots_value: (Hash[String, Array[String]] result, String | Symbol name, String value, Set[String] processed) -> void
+    def apply_robots_value: (Hash[String, Array[String]] result, String name, String value, Set[String] processed) -> void
   end
 end

data/sig/lib/meta_tags/renderer.rbs

@@ -2,7 +2,7 @@ module MetaTags
   class Renderer
     type meta_key = String | Symbol
     type meta_value = Hash[meta_key, meta_value] | Array[meta_value] | meta_content
-    type meta_content = String? | Symbol | Integer | bool | (_Timish & Object) | (_Stringish & Object)
+    type meta_content = String? | Symbol | Integer | Float | bool | (_Timish & Object) | (_Stringish & Object)
 
     attr_reader meta_tags: MetaTagsCollection
     attr_reader normalized_meta_tags: Hash[Symbol, meta_value]
@@ -31,20 +31,24 @@ module MetaTags
 
     def render_canonical_link: (Array[Tag] tags) -> void
 
-    def render_hashes: (Array[Tag] tags, **untyped opts) -> void
+    def render_hashes: (Array[Tag] tags) -> void
 
-    def render_hash: (Array[Tag] tags, untyped key, **untyped opts) -> void
+    def render_hash: (Array[Tag] tags, meta_key key) -> void
 
     def render_custom: (Array[Tag] tags) -> void
 
-    def process_tree: (Array[Tag] tags, meta_key property, meta_value content, ?itemprop: meta_key? itemprop, **untyped opts) -> void
+    def process_tree: (Array[Tag] tags, meta_key property, meta_value content, ?itemprop: meta_value itemprop) -> void
 
-    def process_hash: (Array[Tag] tags, meta_key property, Hash[meta_key, meta_value] content, **untyped opts) -> void
+    def process_hash: (Array[Tag] tags, meta_key property, Hash[meta_key, meta_value] content, ?itemprop: meta_value itemprop) -> void
 
-    def process_array: (Array[Tag] tags, meta_key property, Array[meta_value] content, **untyped opts) -> void
+    def process_array: (Array[Tag] tags, meta_key property, Array[meta_value] content, ?itemprop: meta_value itemprop) -> void
 
-    def render_tag: (Array[Tag] tags, meta_key name, meta_content value, ?itemprop: meta_key? itemprop) -> void
+    def process_reference: (Array[Tag] tags, meta_key property, Symbol reference, ?itemprop: meta_value itemprop) -> void
+
+    def render_tag: (Array[Tag] tags, meta_key name, meta_content value, ?itemprop: meta_value itemprop) -> void
 
     def configured_name_key: (meta_key name) -> Symbol
+
+    def property_tag?: (String name, String tag_name) -> bool
   end
 end

data/sig/lib/meta_tags/tag.rbs

@@ -7,6 +7,6 @@ module MetaTags
 
     def render: (_ActionViewBase view) -> String
 
-    def prepare_attributes: (Hash[String | Symbol, untyped] attributes) -> Hash[String | Symbol, untyped]
+    def serialize_iso8601_attributes: (Hash[String | Symbol, untyped] attributes) -> Hash[String | Symbol, untyped]
   end
 end

data/sig/lib/meta_tags/view_helper.rbs

@@ -4,6 +4,7 @@ module MetaTags
 
     type stringish = String | (_Stringish & Object)
     type robots_value = bool | String | Array[String]
+    type meta_tags = Hash[Renderer::meta_key, Renderer::meta_value]
 
     def meta_tags: () -> MetaTagsCollection
 

data/sig/lib/meta_tags.rbs

@@ -2,8 +2,10 @@ module MetaTags
   type meta_tags = Hash[Renderer::meta_key, Renderer::meta_value]
 
   self.@config: Configuration
+  self.@deprecator: ActiveSupport::Deprecation?
 
   def self.config: () -> Configuration
+  def self.deprecator: () -> ActiveSupport::Deprecation
   def self.configure: () { (Configuration) -> void } -> void
 
   interface _Stringish

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: meta-tags
 version: !ruby/object:Gem::Version
-  version: 2.23.0
+  version: 2.24.0
 platform: ruby
 authors:
 - Dmytro Shteflyuk
@@ -30,7 +30,7 @@ cert_chain:
   pPzkBOwQl2p1ykAEUe7cwoqJcO+1rPeTHjudNqhOfc3VnMA8A7uXOkTtYNVhvApn
   oW4hE/8SnZkQm8jzdi0iX9nWxo8=
   -----END CERTIFICATE-----
-date: 2026-03-16 00:00:00.000000000 Z
+date: 2026-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -227,6 +227,7 @@ files:
 - CONTRIBUTING.md
 - MIT-LICENSE
 - README.md
+- SECURITY.md
 - certs/kpumuk.pem
 - lib/generators/meta_tags/install_generator.rb
 - lib/generators/meta_tags/templates/config/initializers/meta_tags.rb