env_style 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f87c2b9a5857a93ec7c9d6613a4611a8008a9cdb3d2c9aee4ef4b3eaa4a18155
+  data.tar.gz: 6b016e7ba90eba8ee50af1cdbb2288aef0bbaca5a12333468e1ccde9397af496
+SHA512:
+  metadata.gz: adc331a51d5f5d17379d0b00c413189b7e884f2a32be3db7beb66bd2a861fca3057d2d42995ee58b44673ce8068811a45c0256b07b279d42a12a4de03ef28934
+  data.tar.gz: 6de84f78750a3436f57c6c451a927e872efd38f341a0cc44d0c81a29894cc339006eec937970df5ceced67d6d337edf01299c23260aeb211f59849bcdf00048f

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
+
+## [0.1.0] - 2026-07-07
+
+### Added
+
+- Initial release.
+- Mountable Rails engine that tints an application's favicon a distinct color per environment at runtime, leaving production untouched.
+- Environment resolution mirroring env.style: `config.environment` → `ENV["ENV_STYLE_ENV"]` → `Rails.env`, with per-environment colors and a `default_color` for unknown non-production environments.
+- Source resolution with zero-config auto-discovery (`public/icon.svg` → `public/icon.png` → `public/favicon.svg` → `public/favicon.ico`, SVG preferred), an explicit `config.source` override (contained within `Rails.root`), and per-environment source hashes. The served `Content-Type` reflects the source's true media type, sniffed from its magic bytes.
+- SVG tinting with no image library: a `fill`/`stroke`/`currentColor` swap for monochrome marks and a luminance-preserving `<feColorMatrix>` duotone for multicolor marks. Color spellings are canonicalized (3-digit hex, common CSS names) when counting distinctness, so a mark written `#000`/`black`/`#000000` is treated as monochrome.
+- Raster tinting with libvips (`ruby-vips`): a luminance-preserving recolor with alpha preserved and `exclude_colors`, plus `exclude_tolerance` to also preserve the anti-aliased halo of near-matching pixels around an excluded region.
+- Opt-in `rasterize_svg` to render an SVG source to a tinted PNG at a configurable `rasterize_size` (default `32` px), staying crisp on hi-dpi tabs.
+- `env_style_favicon_tags` view helper that emits the favicon `<link>` for the resolved source, working identically in Hotwire and Inertia apps.
+- On-demand, deterministic tinting keyed on `(source digest, environment, color, format, exclude_colors, exclude_tolerance, rasterize_size)`, served with a strong ETag and `Cache-Control: no-cache, must-revalidate`, so browsers cache the icon and revalidate with a `304 Not Modified` before any image work.
+- Graceful degradation: if tinting ever fails, the favicon route serves the untouched source (non-cacheably) instead of raising, matching the never-break-the-page contract.

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,304 @@
+<p align="center">
+  <img src="docs/logo.png" alt="EnvStyle logo" width="160">
+</p>
+
+<h1 align="center">EnvStyle</h1>
+
+<p align="center">
+  <a href="https://badge.fury.io/rb/env_style"><img src="https://badge.fury.io/rb/env_style.svg" alt="Gem Version"></a>
+  <a href="https://github.com/milkstrawai/env_style/actions/workflows/ci.yml"><img src="https://github.com/milkstrawai/env_style/actions/workflows/ci.yml/badge.svg" alt="Build Status"></a>
+  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
+  <img src="https://img.shields.io/badge/Ruby-%3E%3D%203.2-CC342D.svg" alt="Ruby >= 3.2">
+  <img src="https://img.shields.io/badge/Rails-%3E%3D%207.2-D30001.svg" alt="Rails >= 7.2">
+</p>
+
+<p align="center">
+  <strong>A distinct favicon color per environment, so you never deploy to the wrong tab.</strong>
+</p>
+
+EnvStyle is a mountable Rails engine that tints your app's favicon a different color in development, staging, and preview — while leaving **production untouched**. It's the Rails equivalent of [env.style][env-style], but it runs at **request time** instead of build time, and it sits below your front-end framework, so it works identically in Hotwire and Inertia apps and depends on neither.
+
+## Table of Contents
+
+- [The Problem](#the-problem)
+- [The Solution](#the-solution)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Usage](#usage)
+- [Configuration](#configuration)
+- [How It Works](#how-it-works)
+- [Operational Notes](#operational-notes)
+- [Troubleshooting](#troubleshooting)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
+
+## The Problem
+
+You have five tabs open: production, staging, a preview branch, and two local servers. They all render the same favicon. You run a destructive rake task, submit a form, or click "Delete" — in the wrong tab. Every tab looks the same, so the only defense is reading the URL every single time.
+
+[env.style][env-style] solves this beautifully for build-time front-ends, but it has two gaps for a Rails app:
+
+- It restyles at **build time**, so a build promoted from staging to production keeps its staging tint (see [rails/rails#44211][rails-44211] for the friction this causes).
+- It's coupled to a JS build pipeline, which doesn't map cleanly onto a server-rendered Rails app that may or may not use Hotwire, Inertia, or a bundler at all.
+
+## The Solution
+
+EnvStyle serves the favicon from a route it owns and tints it **when the request comes in**, based on the environment resolved at that moment. A build promoted to production re-resolves and serves the untouched icon — no rebuild, no stale tint. Because the whole mechanism is a server route plus one `<link>` tag in your layout `<head>`, it is completely framework agnostic: no JavaScript, no coupling to Turbo, Stimulus, Inertia, or Vue.
+
+- **Runtime, not build time.** The environment is resolved per request.
+- **Production untouched.** Production is never tinted and does zero image work.
+- **Framework agnostic.** A route and a `<link>` tag — that's the entire integration surface.
+- **Zero-config.** With no initializer, it auto-discovers your icon and uses a built-in color map. Adding the helper is the only required step.
+
+## Requirements
+
+- Ruby >= 3.2
+- Rails >= 7.2 (`railties`, `actionpack`, `activesupport`)
+- [libvips][libvips] — only for tinting **raster** icons (PNG/ICO). SVG icons need no system dependency. libvips already ships in the default Rails 8 Dockerfile (it is Active Storage's default variant processor), so most modern apps already have it.
+
+## Installation
+
+Add the gem to your `Gemfile`:
+
+```ruby
+gem "env_style"
+```
+
+Install it:
+
+```sh
+bundle install
+```
+
+If you serve a **raster** favicon (PNG/ICO), install libvips (skip this for SVG-only apps):
+
+```sh
+# macOS
+brew install vips
+
+# Debian / Ubuntu
+apt-get install -y libvips
+```
+
+Mount the engine in `config/routes.rb`:
+
+```ruby
+Rails.application.routes.draw do
+  mount EnvStyle::Engine => "/env_style"
+end
+```
+
+## Quick Start
+
+Three snippets and you're done. First, the Gemfile (above). Then mount the engine (above). Then add the helper to your layout `<head>` — the **same line** whether you use Hotwire or Inertia:
+
+```erb
+<%# app/views/layouts/application.html.erb %>
+<head>
+  <%= env_style_favicon_tags %>
+</head>
+```
+
+That's it. With no initializer, EnvStyle auto-discovers `public/icon.svg` (or `public/icon.png`, `public/favicon.svg`, `public/favicon.ico`), tints it blue in development and amber in staging/preview, and leaves production untouched.
+
+## Usage
+
+### Environment resolution
+
+The environment name is resolved in this order (mirroring env.style):
+
+1. `config.environment` (explicit override)
+2. `ENV["ENV_STYLE_ENV"]`
+3. `Rails.env`
+
+The resolved name is mapped to a color via `config.colors`, falling back to `default_color` for any non-production environment that isn't listed. **`production` is never tinted**, and a `nil` `default_color` leaves unknown environments untouched too.
+
+### Colors
+
+The built-in map covers the common environments:
+
+```ruby
+{
+  "development" => "#3b82f6", # blue
+  "staging"     => "#f59e0b", # amber
+  "preview"     => "#f59e0b"  # amber
+}
+```
+
+Override or extend it in the initializer (see [Configuration](#configuration)). Any CSS color string works for SVG sources; raster sources require a hex color.
+
+### Source resolution
+
+You never need the icon's public URL — only its bytes on disk — so its location and asset pipeline are irrelevant. Resolution has two tiers:
+
+**Auto-discovery (default).** The first existing path wins, preferring SVG:
+
+```
+public/icon.svg  →  public/icon.png  →  public/favicon.svg  →  public/favicon.ico
+```
+
+**Explicit `config.source` (override).** A `Rails.root`-relative path (string or `Pathname`) always wins, for any non-conventional name or location:
+
+```ruby
+c.source = Rails.root.join("app/frontend/images/logo.svg")
+```
+
+The path must resolve **within `Rails.root`** — absolute paths under the root are fine, but a path that escapes it (via `..` or an unrelated absolute path) is ignored, so deriving `source` from untrusted input can't be used to read arbitrary files.
+
+### Per-environment icons
+
+Pass a hash to use a different icon per environment (like env.style). Environments absent from the hash fall back to auto-discovery:
+
+```ruby
+c.source = {
+  "development" => "public/icon-dev.svg",
+  "staging"     => "public/icon-staging.png"
+}
+```
+
+### Raster tinting and `exclude_colors`
+
+Raster icons are recolored with a luminance-preserving tint (shading is kept; the hue shifts to the environment color), with **alpha preserved**. Colors listed in `exclude_colors` are left exactly as they are — handy for keeping a white background white:
+
+```ruby
+c.exclude_colors = ["#ffffff"]
+```
+
+An exact-match exclusion can leave a faint tinted halo around the mark, because the anti-aliased edge pixels next to (say) a white background aren't *exactly* white and so still get tinted. Widen the match with `exclude_tolerance` — the per-channel sRGB distance (0–255) a pixel may sit from an excluded color and still be preserved. It defaults to `0` (exact match only); a small value such as `8` also keeps the near-matching halo:
+
+```ruby
+c.exclude_colors    = ["#ffffff"]
+c.exclude_tolerance = 8
+```
+
+### SVG rasterization (opt-in)
+
+By default, SVG sources stay SVG (crisp, scalable, no system dependency). If you specifically want a tinted **PNG** rendered from an SVG source, opt in:
+
+```ruby
+c.rasterize_svg = true
+```
+
+The PNG is rendered at `rasterize_size` pixels per edge (default `32`) rather than the SVG's intrinsic size, so a small `viewBox` still yields a crisp favicon on hi-dpi tabs. Bump it for sharper output:
+
+```ruby
+c.rasterize_size = 64
+```
+
+This path uses libvips' SVG loader, which requires a libvips built with librsvg.
+
+### Disabling
+
+`enabled` is the master switch. When it's `false`, `env_style_favicon_tags` emits nothing, so no favicon `<link>` is added to your pages. (The mounted route still responds if requested directly, streaming the source untouched — but nothing links to it.)
+
+```ruby
+c.enabled = !Rails.env.production?
+```
+
+## Configuration
+
+An initializer is entirely optional. When you want one:
+
+```ruby
+# config/initializers/env_style.rb
+EnvStyle.configure do |c|
+  c.enabled        = true                                 # master switch
+  c.source         = Rails.root.join("public/icon.svg")   # optional; auto-discovered otherwise
+  c.colors         = { "development" => "#3b82f6",
+                       "staging"     => "#f59e0b",
+                       "preview"     => "#f59e0b" }
+  c.default_color  = "#6b7280"                             # unknown non-prod environments
+  c.exclude_colors = ["#ffffff"]                           # raster: preserve these pixels
+  c.exclude_tolerance = 0                                  # raster: per-channel sRGB match slack
+  c.environment    = ENV["ENV_STYLE_ENV"]                  # optional environment override
+  c.rasterize_svg  = false                                 # opt-in: render SVG → PNG via libvips
+  c.rasterize_size = 32                                    # edge length (px) of the rasterized PNG
+end
+```
+
+| Option | Default | Purpose |
+|---|---|---|
+| `enabled` | `true` | Master switch; `false` stops the helper from emitting a `<link>` (the route still responds if hit directly). |
+| `source` | `nil` (auto-discover) | Icon path, `Pathname`, or per-environment hash. |
+| `colors` | built-in map | Environment name → tint color. |
+| `default_color` | `"#6b7280"` | Tint for non-production environments not in `colors`; `nil` to skip them. |
+| `exclude_colors` | `[]` | Raster pixels to preserve verbatim. |
+| `exclude_tolerance` | `0` | Per-channel sRGB distance (0–255) a raster pixel may sit from an `exclude_colors` entry and still be preserved; `0` matches exactly, a small value keeps the anti-aliased halo. |
+| `environment` | `nil` | Explicit environment override (highest precedence). |
+| `rasterize_svg` | `false` | Render SVG sources to tinted PNG via libvips. |
+| `rasterize_size` | `32` | Edge length in pixels of the rasterized PNG (only when `rasterize_svg` is `true`); larger renders crisper on hi-dpi tabs. |
+| `logger` | `Rails.logger` | Where the "no source icon found" warning is written. |
+
+## How It Works
+
+### Rendering pipeline
+
+`env_style_favicon_tags` renders a `<link>` that points at the engine route (`/env_style/favicon.svg` or `/env_style/favicon.png`, chosen from the resolved source). When the browser requests it, `EnvStyle::FaviconsController` resolves the environment and either tints the source or — for production and any untouched environment — streams the source bytes verbatim.
+
+- **SVG** is tinted by rewriting markup: a monochrome mark has its `fill`/`currentColor` swapped; a multicolor mark is wrapped in a group carrying a luminance-preserving `<feColorMatrix>` duotone filter. No image library involved.
+- **Raster** is tinted with libvips: luminance scales the tint per pixel, alpha is carried through, and `exclude_colors` pixels are masked back to their originals.
+
+### Caching
+
+Tinting happens on demand and is deterministic in `(source digest, environment, color, format)` — plus `exclude_colors` for raster output. Rather than keep a server-side cache coherent across workers, EnvStyle leans on HTTP: every response carries a strong **ETag** over that tuple and `Cache-Control: no-cache, must-revalidate`. Browsers and proxies cache the icon and revalidate with a conditional request, which the controller answers with a `304 Not Modified` **before** doing any image work — so a favicon is tinted at most once per client cache-miss, and a promoted deploy always re-resolves the environment instead of serving a stale-env icon.
+
+### Framework compatibility
+
+The mechanism sits at the Rails/document layer, below your front-end framework:
+
+- **Hotwire.** A plain server route plus a layout `<head>` tag. Turbo never touches it.
+- **Inertia.** The `<link>` renders in the root ERB layout on the initial full-page load and persists across client-side visits (the document is never reloaded). The `/env_style/favicon.*` request carries no `X-Inertia` header, so Inertia's middleware passes it straight through, and SSR is unaffected because the root layout `<head>` is still Rails-rendered. *Caveat:* if your app sets its favicon via Inertia's `<Head>` component, manage it in one place — a client-side favicon set there would override this one.
+
+### Design notes / rejected alternatives
+
+- **No-dependency, SVG-only.** Rejected as the sole strategy: Safari has historically cached and mishandled SVG favicons, and many apps ship raster icons. EnvStyle handles SVG with zero dependencies but also supports raster.
+- **Pure-Ruby raster gems.** `chunky_png` is PNG-only; `pura-image` can't recolor. Neither covers the raster tinting requirement.
+- **Runtime-detect-with-squircle fallback.** Rejected as non-deterministic across machines.
+- **libvips.** Chosen as the one robust raster backend. It already ships with modern Rails (the default Rails 8 Dockerfile, Active Storage's default variant processor), and the dependency is stated upfront so it is never a surprise.
+
+## Operational Notes
+
+- **Production does zero image work.** Production is untouched — the controller streams the source bytes with no tinting.
+- **Performance.** Repeat requests from a client that already has the icon short-circuit to a `304 Not Modified` before any tinting, so image work happens only on a genuine cache-miss — a few milliseconds for a small icon. There is no server-side cache to grow or invalidate.
+- **libvips.** Required only for raster tinting. SVG-only apps never load it (`ruby-vips` is required lazily).
+- **Source changes.** Because the ETag includes the source digest, editing the source icon produces a new validator and a freshly tinted result on the next request.
+- **Scope.** v1 tints the favicon only — no apple-touch or PWA icon variants.
+
+## Troubleshooting
+
+- **`env_style: no source icon found — set EnvStyle.config.source`** — no icon was auto- discovered. Add `public/icon.svg` (or `.png`), or set `config.source`. The helper emits nothing and nothing crashes.
+- **The favicon isn't tinted in development.** Confirm the engine is mounted, the helper is in your layout `<head>`, and the resolved environment has a color (it isn't `production`, and `default_color` isn't `nil`).
+- **A pure-black raster (PNG/ICO) icon barely changes color.** Raster tinting is luminance-preserving, so a pixel with zero luminance stays dark for any tint. Prefer an SVG source (the default) or a non-pure-black raster for a visible tint.
+- **`Vips::Error` / "class \"svgload\" not found" with `rasterize_svg = true`.** Your libvips was built without librsvg. Install a librsvg-enabled libvips, or leave `rasterize_svg` `false` and serve tinted SVG.
+- **`LoadError: cannot load such file -- vips`** — install libvips (see [Installation](#installation)); it is only needed for raster icons.
+
+## Development
+
+```sh
+bin/setup            # install dependencies
+bundle exec rake     # run the tests and RuboCop
+```
+
+Tests run against a bare Rails app under `test/dummy` that mounts the engine and includes both a Hotwire-style and an Inertia-style layout. To exercise every supported Rails version:
+
+```sh
+bundle exec appraisal install
+bundle exec appraisal rake test
+```
+
+With [mise][mise] installed, `mise run test` and `mise run appraisal` wrap the above.
+
+## Contributing
+
+Bug reports and pull requests are welcome at <https://github.com/milkstrawai/env_style>. Please add tests for any change and keep `bundle exec rake` green.
+
+## License
+
+Released under the [MIT License](LICENSE.txt).
+
+[env-style]: https://github.com/QuadDepo/env.style
+[rails-44211]: https://github.com/rails/rails/issues/44211
+[libvips]: https://www.libvips.org/
+[mise]: https://mise.jdx.dev/

data/app/controllers/env_style/application_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module EnvStyle
+  # Base controller for the engine. It inherits straight from
+  # ActionController::Base rather than the host's ApplicationController so the
+  # public favicon route is never gated by the host's authentication filters.
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/env_style/favicons_controller.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module EnvStyle
+  # Serves the (possibly tinted) favicon. Bytes are deterministic, so the
+  # response carries a strong ETag and revalidation headers — a promoted deploy
+  # re-resolves the environment instead of serving a stale-env icon.
+  class FaviconsController < ApplicationController
+    def show
+      favicon = Favicon.new(root: Rails.root)
+      return head :not_found unless favicon.available?
+
+      fresh_when(strong_etag: favicon.etag)
+      response.cache_control.replace(no_cache: true, extras: ["must-revalidate"])
+      return if performed?
+
+      send_favicon(favicon)
+    end
+
+    private
+
+    # Tint failures (e.g. a non-hex color on a raster source) must never break
+    # the tab: fall back to the untouched source, labeled with the source's own
+    # content type so the bytes are never mislabeled.
+    def send_favicon(favicon)
+      send_data(favicon.bytes, type: favicon.content_type, disposition: "inline")
+    rescue StandardError => e
+      EnvStyle.logger.warn("env_style: favicon tinting failed (#{e.class}: #{e.message}); serving source untouched")
+      serve_untouched(favicon)
+    end
+
+    # The ETag stamped by fresh_when describes the intended tint output, not
+    # these fallback bytes, so drop it and mark the response no-store. (Rack's
+    # ETag middleware may re-add a weak body-digest validator downstream; that is
+    # harmless — it differs from the tinted validator, and no-store forbids
+    # caching anyway.) This stops a client from caching the fallback under the
+    # tinted validator and then getting a 304 once tinting recovers.
+    def serve_untouched(favicon)
+      response.headers.delete("ETag")
+      response.cache_control.replace(no_store: true)
+      send_data(favicon.source_bytes, type: favicon.source_content_type, disposition: "inline")
+    end
+  end
+end

data/app/helpers/env_style/favicon_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EnvStyle
+  # Mixed into the host application's views so a single line in the layout head
+  # emits the right <link> for the resolved source and environment.
+  module FaviconHelper
+    # Emits the favicon <link> tag, or nothing when EnvStyle is disabled or no
+    # source icon can be found. The tag always points at the engine route; the
+    # controller decides whether to tint or stream the source untouched.
+    def env_style_favicon_tags
+      return unless EnvStyle.config.enabled
+
+      favicon = EnvStyle::Favicon.new(root: Rails.root)
+      return unless favicon.available?
+
+      href = favicon.format == EnvStyle::Favicon::PNG ? env_style.png_favicon_path : env_style.svg_favicon_path
+      tag.link(rel: "icon", type: favicon.content_type, href: href)
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+EnvStyle::Engine.routes.draw do
+  get "favicon.svg", to: "favicons#show", as: :svg_favicon, defaults: { format: "svg" }
+  get "favicon.png", to: "favicons#show", as: :png_favicon, defaults: { format: "png" }
+end

data/lib/env_style/configuration.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module EnvStyle
+  # Built-in per-environment tint colors. Production is intentionally absent so
+  # it is never tinted; unknown non-production environments fall back to
+  # {Configuration#default_color}.
+  DEFAULT_COLORS = {
+    "development" => "#3b82f6",
+    "staging" => "#f59e0b",
+    "preview" => "#f59e0b"
+  }.freeze
+
+  # Neutral gray used for non-production environments with no explicit color.
+  DEFAULT_COLOR = "#6b7280"
+
+  # Holds every knob EnvStyle exposes. Defaults make the gem work with no
+  # initializer at all; a host app overrides what it needs.
+  class Configuration
+    # Master switch. When false, the helper emits no favicon link (the route
+    # still serves the source untouched if requested directly).
+    attr_accessor :enabled
+
+    # Source icon path (String/Pathname, Rails.root-relative) or a per-env Hash.
+    # nil means auto-discover (see EnvStyle::Source).
+    attr_accessor :source
+
+    # Environment name => tint color (any CSS color string).
+    attr_accessor :colors
+
+    # Tint color for non-production environments not listed in #colors.
+    attr_accessor :default_color
+
+    # Colors preserved as-is when tinting raster icons (e.g. white backgrounds).
+    attr_accessor :exclude_colors
+
+    # Per-channel sRGB tolerance (0..255) for #exclude_colors matching. 0 keeps
+    # only exact matches; a higher value also preserves the anti-aliased halo of
+    # near-matching pixels around an excluded region.
+    attr_accessor :exclude_tolerance
+
+    # Explicit environment override, highest precedence in resolution.
+    attr_accessor :environment
+
+    # When true, SVG sources are rasterized to PNG via libvips instead of
+    # served as tinted SVG.
+    attr_accessor :rasterize_svg
+
+    # Edge length in pixels of the rasterized PNG when #rasterize_svg is true.
+    # Larger values render crisper favicons on hi-dpi tabs.
+    attr_accessor :rasterize_size
+
+    # Logger for EnvStyle warnings; defaults to Rails.logger at runtime.
+    attr_accessor :logger
+
+    def initialize
+      @enabled = true
+      @source = nil
+      @colors = DEFAULT_COLORS.dup
+      @default_color = DEFAULT_COLOR
+      @exclude_colors = []
+      @exclude_tolerance = 0
+      @environment = nil
+      @rasterize_svg = false
+      @rasterize_size = 32
+      @logger = nil
+    end
+  end
+end

data/lib/env_style/engine.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module EnvStyle
+  # The mountable engine. Isolating the namespace keeps the favicon route and
+  # controller from colliding with the host app, and the initializer makes the
+  # +env_style_favicon_tags+ helper available in the host's layouts.
+  class Engine < ::Rails::Engine
+    isolate_namespace EnvStyle
+
+    initializer "env_style.view_helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include EnvStyle::FaviconHelper
+      end
+    end
+  end
+end

data/lib/env_style/environment.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module EnvStyle
+  # Resolves the current environment name and the tint color it maps to.
+  #
+  # Resolution order mirrors env.style:
+  #   config.environment -> ENV["ENV_STYLE_ENV"] -> Rails.env
+  #
+  # Production is never tinted, and a disabled configuration or an environment
+  # with no color leaves the favicon untouched.
+  class Environment
+    PRODUCTION = "production"
+
+    def initialize(config: EnvStyle.config, rails_env: self.class.rails_env,
+                   env_style_env: ENV.fetch("ENV_STYLE_ENV", nil))
+      @config = config
+      @rails_env = presence(rails_env)
+      @env_style_env = presence(env_style_env)
+    end
+
+    # The resolved environment name, or nil when it cannot be determined.
+    def name
+      presence(@config.environment) || @env_style_env || @rails_env
+    end
+
+    # Whether the favicon should be tinted for this environment.
+    def tint?
+      !color.nil?
+    end
+
+    # The tint color for this environment, or nil when it must stay untouched.
+    def color
+      return nil unless @config.enabled
+      return nil if name.nil? || name == PRODUCTION
+
+      presence(@config.colors[name]) || presence(@config.default_color)
+    end
+
+    # Rails.env as a string when Rails is loaded, otherwise nil.
+    def self.rails_env
+      Rails.env.to_s if defined?(Rails) && Rails.respond_to?(:env)
+    end
+
+    private
+
+    def presence(value)
+      string = value.to_s
+      string unless string.empty?
+    end
+  end
+end

data/lib/env_style/favicon.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module EnvStyle
+  # Ties the pieces together: resolves the source and environment, decides the
+  # output format, and returns the bytes to serve — tinted for non-production
+  # environments, verbatim otherwise.
+  #
+  # Tinting happens on demand. The result is deterministic, so the strong ETag
+  # lets browsers and proxies cache it and revalidate with a 304 — there is no
+  # server-side cache to keep coherent across workers.
+  class Favicon
+    SVG = :svg
+    PNG = :png
+    CONTENT_TYPES = {
+      SVG => SvgTinter::CONTENT_TYPE,
+      PNG => RasterTinter::CONTENT_TYPE
+    }.freeze
+
+    def initialize(config: EnvStyle.config, environment: Environment.new(config: config),
+                   root: Source.rails_root)
+      @config = config
+      @environment = environment
+      @source = Source.new(config: config, root: root, env_name: environment.name)
+    end
+
+    def available?
+      @source.found?
+    end
+
+    # The format of the bytes actually served. An untouched favicon streams the
+    # source verbatim, so its format (and content type) follow the source — never
+    # the tint-output format, which would mislabel the bytes.
+    def format
+      return @format if defined?(@format)
+
+      @format = tinted? ? tinted_format : source_format
+    end
+
+    # The content type of the bytes actually served: the tint-output type when
+    # tinted, otherwise the source's own media type. A non-PNG raster served
+    # untouched (say a real favicon.ico) is labeled with its true type rather
+    # than the .png route it happens to travel.
+    def content_type
+      tinted? ? CONTENT_TYPES.fetch(format) : source_content_type
+    end
+
+    # The media type of the untouched source, used on the degradation path so
+    # source bytes are never mislabeled with the tint-output type.
+    def source_content_type
+      @source.content_type
+    end
+
+    def tinted?
+      @environment.tint?
+    end
+
+    # A strong validator for the served bytes. exclude_colors and its matching
+    # tolerance are folded in for raster output: both change which pixels are preserved.
+    def etag
+      @etag ||= Digest::SHA256.hexdigest(etag_inputs.join("|"))
+    end
+
+    # Bytes to serve: tinted when the environment calls for it, otherwise the
+    # untouched source (zero image work).
+    def bytes
+      return @bytes if defined?(@bytes)
+
+      @bytes = tinted? ? render : source_bytes
+    end
+
+    # The untouched source bytes, used both for passthrough and as the graceful
+    # fallback when tinting fails.
+    def source_bytes
+      @source.read
+    end
+
+    private
+
+    def tinted_format
+      @source.raster? || @config.rasterize_svg ? PNG : SVG
+    end
+
+    def source_format
+      @source.raster? ? PNG : SVG
+    end
+
+    def etag_inputs
+      inputs = [@source.digest, @environment.name, @environment.color, format]
+      inputs.push(@config.exclude_colors.join(","), @config.exclude_tolerance, @config.rasterize_size) if format == PNG
+      inputs
+    end
+
+    def render
+      case format
+      when SVG
+        SvgTinter.new(color: @environment.color).call(@source.read)
+      when PNG
+        RasterTinter.new(color: @environment.color, exclude_colors: @config.exclude_colors,
+                         tolerance: @config.exclude_tolerance)
+                    .call(raster_source_bytes)
+      end
+    end
+
+    def raster_source_bytes
+      @source.raster? ? @source.read : rasterize_svg(@source.read)
+    end
+
+    # Rasterize at a target pixel size rather than the SVG intrinsic size: a
+    # small viewBox would otherwise yield a low-res favicon on hi-dpi tabs.
+    # thumbnail_buffer drives the SVG loader scale to hit +rasterize_size+.
+    def rasterize_svg(svg_bytes)
+      require "vips"
+
+      Vips::Image.thumbnail_buffer(svg_bytes, @config.rasterize_size).write_to_buffer(".png")
+    end
+  end
+end

data/lib/env_style/raster_tinter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module EnvStyle
+  # Tints a raster icon (PNG/ICO/...) with libvips through ruby-vips.
+  #
+  # The recolor is luminance-preserving: each pixel's perceptual brightness
+  # scales the tint color, so shading survives while the hue shifts. Alpha is
+  # carried through untouched, and any pixel within +tolerance+ of a color in
+  # +exclude_colors+ (for example a white background) is left exactly as it was.
+  # A +tolerance+ of 0 keeps only exact matches; a larger value also preserves
+  # the anti-aliased halo of near-matching pixels around an excluded region.
+  #
+  # +vips+ is required lazily so SVG-only applications never need libvips.
+  class RasterTinter
+    CONTENT_TYPE = "image/png"
+
+    def initialize(color:, exclude_colors: [], tolerance: 0)
+      @color = color.to_s
+      @exclude_colors = Array(exclude_colors)
+      @tolerance = tolerance
+    end
+
+    def content_type
+      CONTENT_TYPE
+    end
+
+    def call(bytes)
+      require "vips"
+
+      image = Vips::Image.new_from_buffer(bytes, "").colourspace("srgb")
+      alpha = image.bands >= 4 ? image.extract_band(3) : nil
+      rgb = image.extract_band(0, n: 3)
+
+      recolored = apply_exclusions(rgb, tint(rgb))
+      recolored = recolored.bandjoin(alpha) if alpha
+      recolored.cast(:uchar).copy(interpretation: :srgb).write_to_buffer(".png")
+    end
+
+    private
+
+    # Scale the tint by each pixel's luminance (0..1), preserving shading.
+    def tint(rgb)
+      red, green, blue = rgb_channels(@color)
+      scale = rgb.colourspace("b-w").cast(:float) / 255.0
+
+      (scale * red).bandjoin([scale * green, scale * blue]).cast(:uchar)
+    end
+
+    # Keep original pixels wherever they are within tolerance of an excluded color.
+    def apply_exclusions(rgb, tinted)
+      mask = exclusion_mask(rgb)
+      return tinted if mask.nil?
+
+      mask.ifthenelse(rgb, tinted)
+    end
+
+    def exclusion_mask(rgb)
+      masks = @exclude_colors.map { |color| color_match_mask(rgb, color) }
+      masks.reduce(:|)
+    end
+
+    # A pixel matches when it is within +tolerance+ of the target on every channel.
+    # Casting to float first avoids uchar underflow when a channel sits below the
+    # target; with tolerance 0 this reduces to an exact per-channel equality.
+    def color_match_mask(rgb, color)
+      distance = (rgb.cast(:float) - rgb_channels(color)).abs
+      distance.relational_const(:lesseq, @tolerance).bandand
+    end
+
+    def rgb_channels(color)
+      hex = color.to_s.delete_prefix("#")
+      hex = hex.chars.map { |char| char * 2 }.join if hex.length == 3
+      unless hex.match?(/\A[0-9a-fA-F]{6}\z/)
+        raise ConfigurationError, "env_style: raster tinting needs a hex color, got #{color.inspect}"
+      end
+
+      hex.scan(/../).map { |pair| pair.to_i(16) }
+    end
+  end
+end

data/lib/env_style/source.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "digest"
+
+module EnvStyle
+  # Resolves and reads the source icon: the file whose bytes we tint and serve.
+  #
+  # Resolution has two tiers:
+  #   1. Explicit +config.source+ (a Rails.root-relative path/Pathname, or a
+  #      per-environment Hash) always wins.
+  #   2. Otherwise auto-discovery walks a conventional list, preferring SVG.
+  #
+  # Nothing found never raises: it logs an actionable warning (outside
+  # production) and reports itself as not found.
+  class Source
+    # Auto-discovery candidates, in priority order. SVG is preferred over raster.
+    AUTO_DISCOVERY = %w[
+      public/icon.svg
+      public/icon.png
+      public/favicon.svg
+      public/favicon.ico
+    ].freeze
+
+    # Sniffs SVG by content so a mislabeled extension still resolves correctly.
+    SVG_SNIFF = /<svg[\s>]/i
+
+    SVG_MEDIA_TYPE = "image/svg+xml"
+
+    # Raster media types keyed by their leading magic bytes, checked in order.
+    # WEBP is matched separately because its "WEBP" marker sits at byte 8, past
+    # the leading "RIFF" chunk id.
+    RASTER_SIGNATURES = {
+      "\x89PNG".b => "image/png",
+      "\x00\x00\x01\x00".b => "image/vnd.microsoft.icon",
+      "GIF8".b => "image/gif",
+      "\xFF\xD8\xFF".b => "image/jpeg",
+      "BM".b => "image/bmp"
+    }.freeze
+
+    # Media type for an unrecognized raster. Conservative on purpose: the only
+    # raster engine route is +.png+, and browsers sniff the bytes themselves, so
+    # a wrong-but-harmless label never breaks the tab.
+    DEFAULT_RASTER_MEDIA_TYPE = "image/png"
+
+    MISSING_MESSAGE = "env_style: no source icon found — set EnvStyle.config.source"
+
+    def initialize(config: EnvStyle.config, root: self.class.rails_root, env_name: nil)
+      @config = config
+      @root = root && Pathname(root)
+      @env_name = env_name
+    end
+
+    # The resolved icon path, or nil when nothing was found.
+    def path
+      return @path if defined?(@path)
+
+      @path = resolve_path
+    end
+
+    def found?
+      !path.nil?
+    end
+
+    # Raw binary bytes of the source icon, or nil when not found.
+    def read
+      return @read if defined?(@read)
+
+      @read = path&.binread
+    end
+
+    # :svg or :raster, decided by content; nil when not found.
+    def format
+      return nil unless found?
+
+      svg_content? ? :svg : :raster
+    end
+
+    def svg?
+      format == :svg
+    end
+
+    def raster?
+      format == :raster
+    end
+
+    # The true media type of the resolved source, sniffed from its bytes; nil
+    # when not found. SVG keeps the content-based sniff (a mislabeled extension
+    # still resolves), every other type is matched on its magic bytes, and an
+    # unrecognized raster falls back to {DEFAULT_RASTER_MEDIA_TYPE}. Unlike
+    # +format+, this distinguishes non-PNG rasters so untouched passthrough bytes
+    # are labeled with what they actually are.
+    def content_type
+      return nil unless found?
+      return SVG_MEDIA_TYPE if svg?
+
+      raster_content_type
+    end
+
+    # Content digest used to key caches and ETags; nil when not found.
+    def digest
+      return nil unless found?
+
+      Digest::SHA256.hexdigest(read)
+    end
+
+    def self.rails_root
+      Rails.root if defined?(Rails) && Rails.respond_to?(:root)
+    end
+
+    private
+
+    def resolve_path
+      candidate_path || warn_missing
+    end
+
+    def candidate_path
+      case @config.source
+      when Hash then hash_source_path
+      when nil  then auto_discovered_path
+      else           file_at(@config.source)
+      end
+    end
+
+    def hash_source_path
+      raw = @config.source[@env_name]
+      raw.nil? ? auto_discovered_path : file_at(raw)
+    end
+
+    def auto_discovered_path
+      return nil if @root.nil?
+
+      AUTO_DISCOVERY.map { |relative| @root.join(relative) }.find(&:file?)
+    end
+
+    def file_at(raw)
+      return nil if @root.nil?
+
+      candidate = @root.join(raw.to_s)
+      return nil unless candidate.file?
+
+      within_root?(candidate) ? candidate : nil
+    end
+
+    # Keeps an explicit source (relative, absolute, traversal, or symlink) from
+    # escaping Rails.root. realpath resolves symlinks and "..", so only files
+    # physically under the root are accepted; absolute paths under it still work.
+    def within_root?(path)
+      real = path.realpath
+      root = @root.realpath
+      real == root || real.to_s.start_with?("#{root}/")
+    rescue SystemCallError
+      false
+    end
+
+    def svg_content?
+      head = read.to_s.byteslice(0, 1024).to_s.force_encoding(Encoding::BINARY)
+      head.match?(SVG_SNIFF)
+    end
+
+    def raster_content_type
+      head = read.to_s.byteslice(0, 16).to_s.force_encoding(Encoding::BINARY)
+      return "image/webp" if webp?(head)
+
+      RASTER_SIGNATURES.each { |magic, media_type| return media_type if head.start_with?(magic) }
+      DEFAULT_RASTER_MEDIA_TYPE
+    end
+
+    def webp?(head)
+      head.start_with?("RIFF".b) && head.byteslice(8, 4) == "WEBP".b
+    end
+
+    def warn_missing
+      logger.warn(MISSING_MESSAGE) unless @env_name == Environment::PRODUCTION
+      nil
+    end
+
+    def logger
+      @config.logger || EnvStyle.logger
+    end
+  end
+end

data/lib/env_style/svg_tinter.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module EnvStyle
+  # Tints an SVG icon by rewriting its markup — no image library required.
+  #
+  # A monochrome mark (one color, or currentColor, or an implicit default) has
+  # its fill/stroke swapped for the tint. A multicolor mark is wrapped in a
+  # group carrying a luminance-preserving <feColorMatrix> duotone filter, so the
+  # artwork keeps its shading while shifting to the tint hue.
+  class SvgTinter
+    CONTENT_TYPE = "image/svg+xml"
+    FILTER_ID = "env-style-tint"
+
+    # Values that are not real colors and must never be swapped.
+    NON_COLORS = ["none", "transparent", "inherit", "currentcolor", ""].freeze
+
+    # Common CSS named colors mapped to canonical 6-digit hex, so that a mark
+    # written as "black" and "#000" is recognised as one color when counting
+    # distinctness. Used only for the count — never for the output markup.
+    CSS_COLORS = {
+      "aqua" => "#00ffff",
+      "black" => "#000000",
+      "blue" => "#0000ff",
+      "cyan" => "#00ffff",
+      "fuchsia" => "#ff00ff",
+      "gray" => "#808080",
+      "green" => "#008000",
+      "grey" => "#808080",
+      "lime" => "#00ff00",
+      "magenta" => "#ff00ff",
+      "maroon" => "#800000",
+      "navy" => "#000080",
+      "olive" => "#808000",
+      "orange" => "#ffa500",
+      "purple" => "#800080",
+      "red" => "#ff0000",
+      "silver" => "#c0c0c0",
+      "teal" => "#008080",
+      "white" => "#ffffff",
+      "yellow" => "#ffff00"
+    }.freeze
+
+    # Luminance weights (Rec. 709) used to preserve shading in the duotone.
+    LUMINANCE = [0.2126, 0.7152, 0.0722].freeze
+
+    # A CSS color value inside a style declaration: a hex, a functional notation
+    # (which may contain spaces/commas), or a plain token. Anchored so it never
+    # runs past the declaration's ; or the attribute's closing quote.
+    STYLE_VALUE = /#[0-9a-fA-F]+|(?:rgb|hsl)a?\([^)]*\)|[^;"'\s)]+/
+
+    def initialize(color:)
+      @color = color.to_s
+    end
+
+    def content_type
+      CONTENT_TYPE
+    end
+
+    def call(svg)
+      svg = svg.to_s
+      colors = distinct_colors(svg)
+      if colors.size >= 2
+        duotone(svg, colored: colors.any?)
+      else
+        monochrome(svg, colored: colors.any?)
+      end
+    end
+
+    private
+
+    def monochrome(svg, colored:)
+      had_color = colored || svg.match?(/currentColor/i)
+
+      out = svg.gsub(/currentColor/i, @color)
+      out = swap_attributes(out)
+      out = swap_style(out)
+      out = inject_root_fill(out) unless had_color
+      out
+    end
+
+    def duotone(svg, colored:)
+      rgb = rgb_floats(@color)
+      return monochrome(svg, colored: colored) if rgb.nil?
+
+      filter = %(<feColorMatrix type="matrix" values="#{color_matrix(rgb)}"/>)
+      defs = %(<defs><filter id="#{FILTER_ID}" color-interpolation-filters="sRGB">#{filter}</filter></defs>)
+
+      svg.sub(%r{(<svg\b[^>]*>)(.*)(</svg>)}mi) do
+        group = %(<g filter="url(##{FILTER_ID})">#{Regexp.last_match(2)}</g>)
+        "#{Regexp.last_match(1)}#{defs}#{group}#{Regexp.last_match(3)}"
+      end
+    end
+
+    def swap_attributes(svg)
+      svg.gsub(/((?:fill|stroke|stop-color)\s*=\s*)(["'])(.*?)\2/i) do
+        prefix = Regexp.last_match(1)
+        quote = Regexp.last_match(2)
+        value = Regexp.last_match(3)
+        paint = keep?(value) ? value : @color
+        "#{prefix}#{quote}#{paint}#{quote}"
+      end
+    end
+
+    def swap_style(svg)
+      svg.gsub(/\b(fill|stroke|stop-color)\s*:\s*(#{STYLE_VALUE})/i) do
+        property = Regexp.last_match(1)
+        value = Regexp.last_match(2)
+        keep?(value) ? Regexp.last_match(0) : "#{property}:#{@color}"
+      end
+    end
+
+    def inject_root_fill(svg)
+      svg.sub(/<svg\b/i) { |match| %(#{match} fill="#{@color}") }
+    end
+
+    def distinct_colors(svg)
+      colors = svg.scan(/(?:fill|stroke|stop-color)\s*=\s*["']([^"']+)["']/i).flatten
+      colors += svg.scan(/(?:fill|stroke|stop-color)\s*:\s*(#{STYLE_VALUE})/i).flatten
+      colors.map { |color| color.strip.downcase }.reject { |color| keep?(color) }.map { |color| canonical(color) }.uniq
+    end
+
+    # Canonicalizes an already-stripped, downcased color token so that
+    # equivalent spellings collapse: named colors become hex and 3-digit hex
+    # expands to 6 digits. Anything else (functional notations, unknown names)
+    # is returned unchanged.
+    def canonical(color)
+      color = CSS_COLORS.fetch(color, color)
+      return color unless color.start_with?("#")
+
+      hex = color.delete_prefix("#")
+      hex = hex.chars.map { |char| char * 2 }.join if hex.length == 3
+      "##{hex}"
+    end
+
+    def keep?(value)
+      normalized = value.strip.downcase
+      NON_COLORS.include?(normalized) || normalized.start_with?("url(")
+    end
+
+    def color_matrix(rgb)
+      rows = rgb.map do |channel|
+        weights = LUMINANCE.map { |weight| format("%.4f", weight * channel) }.join(" ")
+        "#{weights} 0 0"
+      end
+      (rows + ["0 0 0 1 0"]).join(" ")
+    end
+
+    def rgb_floats(color)
+      hex = color.delete_prefix("#")
+      hex = hex.chars.map { |c| c * 2 }.join if hex.length == 3
+      return nil unless hex.match?(/\A[0-9a-fA-F]{6}\z/)
+
+      hex.scan(/../).map { |pair| pair.to_i(16) / 255.0 }
+    end
+  end
+end

data/lib/env_style/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EnvStyle
+  VERSION = "0.1.0"
+end

data/lib/env_style.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "active_support"
+
+require_relative "env_style/version"
+require_relative "env_style/configuration"
+require_relative "env_style/environment"
+require_relative "env_style/source"
+require_relative "env_style/svg_tinter"
+require_relative "env_style/raster_tinter"
+require_relative "env_style/favicon"
+
+# EnvStyle tints an application's favicon a distinct color per environment, so
+# side-by-side browser tabs are visually distinguishable. Production is left
+# untouched, and setting {Configuration#enabled} to false stops the helper from
+# adding the favicon link.
+module EnvStyle
+  # Base class for every error EnvStyle raises.
+  class Error < StandardError; end
+
+  # Raised when the gem is misconfigured (bad color, unreadable source, ...).
+  class ConfigurationError < Error; end
+
+  class << self
+    # The process-wide configuration. Memoized; reset with {reset_configuration!}.
+    def configuration
+      @configuration ||= Configuration.new
+    end
+    alias config configuration
+
+    # Yields the configuration for block-style setup.
+    #
+    #   EnvStyle.configure do |c|
+    #     c.colors = { "staging" => "#f59e0b" }
+    #   end
+    def configure
+      yield(configuration)
+    end
+
+    # Rebuilds the configuration from defaults. Primarily used by tests.
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    # The logger EnvStyle writes warnings to: the configured logger, else
+    # Rails' logger when Rails is loaded, else a plain STDOUT logger.
+    def logger
+      configuration.logger || (Rails.logger if defined?(Rails) && Rails.respond_to?(:logger)) ||
+        Logger.new($stdout)
+    end
+  end
+end
+
+require_relative "env_style/engine" if defined?(Rails::Engine)

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: env_style
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ali Hamdi Ali Fadel
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+- !ruby/object:Gem::Dependency
+  name: ruby-vips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: EnvStyle is a mountable Rails engine that tints your app's favicon a
+  distinct color per environment at runtime, so side-by-side browser tabs are visually
+  distinguishable. It adds a route and a <link> tag to your layout, works with any
+  front-end (Hotwire, Inertia, or plain Rails), and leaves production untouched.
+email:
+- aliosm1997@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- app/controllers/env_style/application_controller.rb
+- app/controllers/env_style/favicons_controller.rb
+- app/helpers/env_style/favicon_helper.rb
+- config/routes.rb
+- lib/env_style.rb
+- lib/env_style/configuration.rb
+- lib/env_style/engine.rb
+- lib/env_style/environment.rb
+- lib/env_style/favicon.rb
+- lib/env_style/raster_tinter.rb
+- lib/env_style/source.rb
+- lib/env_style/svg_tinter.rb
+- lib/env_style/version.rb
+homepage: https://github.com/milkstrawai/env_style
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/milkstrawai/env_style
+  source_code_uri: https://github.com/milkstrawai/env_style
+  changelog_uri: https://github.com/milkstrawai/env_style/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: |
+  env_style tints raster favicons (PNG/ICO) with libvips through ruby-vips.
+  Install libvips if it is not already present:
+
+    macOS:  brew install vips
+    Debian: apt-get install -y libvips
+
+  SVG favicons need no system dependency, and libvips already ships in the
+  default Rails 8 Dockerfile, so most modern apps have it already.
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Per-environment favicon tinting for Rails.
+test_files: []