ruby_everywhere 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b255975aa8724cb4980606ddbde415eea3a238c193ffce8530028ef5fdc63c24
-  data.tar.gz: 386145d42d750984da4fa800ea9b63417371937dbf67d49642a229cd92cfbb71
+  metadata.gz: 7ffb921df597efe047c25240e7d8b92aaad49c00c90d546020e053eac618739a
+  data.tar.gz: 17315b4c5d91eced13b44d7147942d7d6357ee791b8622425ab655eb97b1ab27
 SHA512:
-  metadata.gz: 6af24db6e60c693ae855fa47832564074d887c18248a63be23c343c5e85c7d84cf4210017ba6bb26dae9950bb6b1394255f02cbea4d278f9407952a22f37dd6c
-  data.tar.gz: 368f12504a2a5748aa30eaf641eadf5b85bbd54b99e0f372015b9621510f01dc5779ca6e3e37cfab594083768815e40e48200e2c3649195c5b5e800cc7cf5557
+  metadata.gz: 71d9ba1ea63abe51a7262f02f069ef9f068d3192bb20800bdd0fba8bcd50f36f2daa83bb3f758e7273576b69b88be5541428b41f93021579cc1b5054532099ad
+  data.tar.gz: 59632bacae03ade28233832d0193d2500e4e3f85c07b7e61a39f1e086cc398b40f66d48091ffc9e336a11e2f91994b666ea60fc7ab2cbef2b76252d6fb0ada60

data/README.md

@@ -0,0 +1,255 @@
+# RubyEverywhere
+
+**Ship desktop and mobile apps from the Ruby web apps you already know how to build.**
+
+[rubyeverywhere.com](https://rubyeverywhere.com) · by [Andrea Fomera](https://afomera.dev)
+
+RubyEverywhere takes a Rails (or Sinatra, or Hanami) app and gives it a native
+life on the platforms your users are already on:
+
+- **Desktop** — a [Tauri](https://tauri.app)-based shell. In *local* mode your
+  whole app is pressed into a single-file binary with
+  [Tebako](https://github.com/tamatebako/tebako) and runs on-device, no Ruby
+  install required; in *remote* mode the shell is a thin native wrapper around
+  your deployed app.
+- **iOS** — a [Hotwire Native](https://native.hotwired.dev) shell with a real
+  tab bar, nav-bar buttons, menus, action sheets, notifications, haptics,
+  biometrics, deep links, and native sign-in.
+- **Android** — a feature-for-feature Hotwire Native Android port of the same
+  shell, stamped from the same `config/everywhere.yml`.
+
+One config file, one CLI, one JavaScript API. The web app stays the source of
+truth — most of what you'd normally rebuild natively (tabs, routes, menus,
+badges) deploys with your Rails app rather than through an app-store review.
+
+## Install
+
+```sh
+gem install ruby_everywhere
+```
+
+This gives you two equivalent executables — `every` and `rbe` — plus the
+packaging toolchain (the `rbe-tebako` fork) as a dependency.
+
+Or add it to your app's Gemfile, which also wires up the Rails engine (bridge
+asset serving, importmap pin, view helpers, the live mobile config endpoint):
+
+```ruby
+gem "ruby_everywhere"
+```
+
+Requires Ruby >= 3.2.
+
+**The gem is free, and it always will be.** Everything here — the CLI, the
+desktop shell, both mobile shells, the bridge — is MIT licensed and yours to
+use, forever, with no account and no key. Local builds run on a Mac today
+(pressing, code signing, Xcode and the Android SDK all want a macOS host).
+If you don't own one, or you'd rather not keep a build toolchain healthy, the
+[RubyEverywhere Platform](https://rubyeverywhere.com) is a paid service coming
+soon that runs the exact same builds for you — see
+[Hosted builds](#hosted-builds) below. It's a convenience, never a gate: nothing
+in this gem is held back for it.
+
+## Quick start
+
+```sh
+cd path/to/your/app
+
+every install          # remote mode: a native shell around your deployed app
+every install --local  # local mode: compile and ship the app itself
+
+every doctor           # check the toolchain before your first build
+
+every dev              # dev server + native shells on demand, live reload
+every dev --ios        # ...straight into the iOS Simulator
+every dev --android    # ...straight into the Android emulator
+
+every build            # package the macOS .app
+every build --ios      # build the iOS shell
+every build --android  # build the APK/AAB
+```
+
+`every install` is idempotent — it adds `config/everywhere.yml`, a boot stub,
+and the framework-specific config tweaks it needs, and skips anything already
+in place. For Rails it does the surgery for you; for Sinatra and Hanami it
+vendors the bridge and prints the remaining wiring rather than guessing at your
+boot files.
+
+`every dev` never packages anything: it runs your ordinary dev server and points
+the native shells at it, so the edit-refresh loop is untouched Rails.
+
+## Configuration
+
+Everything per-app lives in `config/everywhere.yml`. The native shell templates
+are frozen — the CLI stamps a copy per app and only ever writes the identity,
+config, icon, and color files, so a shell upgrade never collides with your app.
+
+```yaml
+app:
+  name: My Really Awesome App
+  bundle_id: com.example.myapp     # set it once; renaming moves users' data
+  version: 1.2.0
+  entry_path: /dashboard           # where the app opens
+  icon: icon.png
+
+appearance:
+  tint_color: "#CC342D"
+  background_color:                # one hex string, or split by system theme
+    light: "#FAF9F7"
+    dark: "#1C1B1A"
+
+remote:
+  url: https://app.example.com     # remote mode: the deployed app to wrap
+
+tabs:                              # the native mobile tab bar
+  - name: Builds
+    path: /builds
+    icons:
+      ios: hammer                  # SF Symbol
+      android: build               # Material icon
+
+permissions:                       # only declared permissions can ever prompt
+  notifications: true
+  camera: "Scan QR codes to pair devices."   # the sentence iOS shows
+
+rules:                             # Hotwire Native path configuration
+  - patterns: ["/preferences$"]
+    properties:
+      context: modal
+
+build:
+  ruby: "4.0.6"
+  targets: [macos-arm64, ios-arm64, android-arm64]
+
+updates:                           # self-hosted, signed auto-updates
+  url: https://updates.example.com
+  public_key: RWQ…
+  auto: check                      # off | check | download | install
+```
+
+Also supported: `auth:` (native OAuth sign-in with a callback scheme),
+`deep_linking:` (universal links / App Links — the gem serves the
+`apple-app-site-association` and `assetlinks.json` files for you), and
+`native:` for "supernative" extensions — Swift you keep in your app repo under
+`native/ios/` that `every build` compiles into the shell, including SwiftUI
+screens, bridge components, a custom splash, and pinned SPM packages.
+
+Tabs and path rules ship two ways from that one source: baked into the app
+bundle for offline/first launch, and served live from
+`/everywhere/{ios,android}_v1.json`, so changing them deploys with your web app.
+`Everywhere.filter_tabs` lets you vary the tab bar per request — it shares the
+app's session, so signed-out users can get a different bar without a release.
+
+## The JavaScript bridge
+
+The gem ships `@rubyeverywhere/bridge` — one API for the browser, the desktop
+shell, and the mobile shells. Rails apps get it served and importmap-pinned
+automatically; Sinatra and Hanami get it vendored to `public/bridge.js`.
+
+```js
+import Everywhere from "@rubyeverywhere/bridge"
+
+Everywhere.platform          // "desktop" | "mobile" | "browser"
+Everywhere.native            // true inside a RubyEverywhere app
+
+Everywhere.notify({ title, body })
+Everywhere.menu({ title, items })
+Everywhere.haptics.impact("medium")
+Everywhere.badge.setTab("/inbox", 3)
+Everywhere.permissions.request("camera")
+Everywhere.storage.set("theme", "dark")
+Everywhere.updates.check()
+```
+
+Everything degrades gracefully — the same page works in a plain browser tab and
+gains native powers inside the app. See
+[`bridge/README.md`](bridge/README.md) for the full surface.
+
+Most native chrome needs no JavaScript at all. Tag ordinary markup and the
+bridge lifts it into real native controls; tapping the native control just
+`.click()`s the element it mirrors, so behavior stays defined once in the DOM.
+Rails ships helpers that emit exactly that markup:
+
+```erb
+<%= everywhere_nav_button "New", new_note_path, icons: { ios: "plus", android: "add" } %>
+<%= everywhere_fab new_note_path %>
+<%= everywhere_nav_menu "More" do %>
+  <%= everywhere_menu_item "Delete", note_path(@note), method: :delete, style: "destructive" %>
+<% end %>
+```
+
+Plus `native_app?`, `native_platform`, `everywhere_badge`,
+`everywhere_biometric_lock`, and friends.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `every install` | Prepare an app (boot stub, `config/everywhere.yml`, config tweaks) |
+| `every doctor` | Check the toolchain — Tebako, Rust, brew deps, Xcode, Android SDK/JDK |
+| `every dev` | Dev server with native shells on demand (`--desktop --ios --android --browser`) |
+| `every logs` | Stream shell logs from the Simulator or Android device |
+| `every build` | Package natively — desktop, `--ios`, or `--android` |
+| `every icon` | Generate `.icns` / `.ico` / Linux icons from a source PNG |
+| `every release` | Sign, notarize, staple, and emit a `release.json` receipt |
+| `every updates keygen` | Generate a minisign-compatible update-signing keypair |
+| `every publish` | Publish a release to your update bucket |
+| `every clean` | Remove the shell build caches |
+| `every shell-dir` | Print the path of the bundled shell template |
+| `every platform …` | Hosted builds: `login`, `logout`, `auth status`, `build` |
+
+Run `every` with no arguments for the full list, or `every <command> --help` for
+a command's flags.
+
+## Auto-updates
+
+Desktop releases can update themselves from a bucket you own, with no service in
+the middle:
+
+```sh
+every updates keygen                  # once, per app
+every release                         # build, sign, notarize, staple
+every publish --notes-file NOTES.md   # sign the manifest, upload, flip latest.json
+```
+
+The public key ships in the app; the secret key never leaves your machine. Apps
+can check, install, and switch channels at runtime via `Everywhere.updates`.
+
+## Hosted builds
+
+Don't have a Mac, or want iOS and Android built without babysitting Xcode, the
+Android SDK, and a signing setup? The **RubyEverywhere Platform** — a paid
+service, coming soon — runs the same builds on managed machines and hands back
+the artifacts. The CLI already speaks to it:
+
+```sh
+every platform login
+every platform build --target ios-arm64,android-arm64
+```
+
+Same gem, same `config/everywhere.yml`, same output — you're paying for the
+build machines and the toolchain upkeep, not for features. The gem stays free
+and complete on its own.
+
+## Project layout
+
+```
+lib/everywhere/          the CLI, config, builders, and Rails engine
+exe/every, exe/rbe       the executables
+bridge/                  @rubyeverywhere/bridge — the JS half
+support/shell/           the Tauri desktop shell template
+support/mobile/ios/      the Hotwire Native iOS shell template
+support/mobile/android/  the Hotwire Native Android shell template
+```
+
+The shell templates have their own READMEs documenting the freeze rules — what
+the CLI stamps per app and what it must never touch:
+[iOS](support/mobile/ios/README.md) · [Android](support/mobile/android/README.md).
+
+## Contributing
+
+Bug reports and pull requests are welcome. Run the test suite with `rake test`.
+
+## License
+
+Released under the [MIT License](LICENSE.txt). Copyright © 2026 Andrea Fomera.

data/bridge/everywhere/bridge.js

@@ -16,6 +16,7 @@
 //   Everywhere.on("menu", handler)       // shell events; returns unsubscribe fn
 //   Everywhere.visit("/settings")        // Turbo.visit with location fallback
 //   Everywhere.reloadTabs()              // re-fetch native tab/nav config (mobile)
+//   Everywhere.auth.signIn("/auth/github") // provider sign-in in the system browser (mobile)
 //
 //   Everywhere.haptics.impact("medium")  // light | medium | heavy | soft | rigid
 //   Everywhere.haptics.notification("success") // success | warning | error
@@ -532,8 +533,9 @@ const mobile = {
   // Ask the shell to re-fetch its native navigation config (tabs + path
   // rules) now, instead of waiting for the next app foreground. Call it after
   // a change that affects which tabs should show — signing in or out — so the
-  // tab bar updates immediately. Uses a dedicated WKScriptMessageHandler, so
-  // it doesn't depend on a bridge component being mounted on the page.
+  // tab bar updates immediately. Uses the shell's control channel (a dedicated
+  // WKScriptMessageHandler on iOS, a WebMessageListener on Android), so it
+  // doesn't depend on a bridge component being mounted on the page.
   reloadTabs() {
     const control = nativeControlChannel()
     if (control) {
@@ -566,6 +568,16 @@ const mobile = {
     if (control) control.postMessage({ action: "clearInstance", ...(to ? { to } : {}) })
   },
 
+  // Open a provider sign-in in the system browser rather than this web view —
+  // where Google refuses to run at all and the rest lose the password manager
+  // and the user's existing session. The shell takes it from here: auth
+  // session, one-time handoff token, full reset onto the signed-in app.
+  authSignIn(path) {
+    const control = nativeControlChannel()
+    if (control) control.postMessage({ action: "authFlow", to: path })
+    else window.location.assign(path)
+  },
+
   // Real haptics via the shell's "everywhere--haptics" component; vibration
   // fallback while the handshake completes or on an older shell.
   haptic(kind, value) {
@@ -702,10 +714,43 @@ const mobile = {
   }
 }
 
+// The shell's out-of-band command line: app-level actions (reset, tabs,
+// badges, instance, auth) that must work on any page, whether or not a bridge
+// component happens to be mounted on it. Each shell injects it its own way,
+// and the two APIs disagree about what a message is:
+//
+//   iOS     — WKUserContentController.add(_:name:) hands us
+//             window.webkit.messageHandlers.everywhereControl, whose
+//             postMessage takes an *object* and serializes it across the
+//             boundary for us.
+//   Android — WebViewCompat.addWebMessageListener("everywhereControl") hands us
+//             window.everywhereControl, backed by a WebMessagePort, and a web
+//             message is *text*: postMessage(String). (Android has no user
+//             scripts either, so the shell injects this with
+//             addDocumentStartJavaScript — it's in place before page JS runs.)
+//
+// Normalizing here rather than at each call site is the point: the seven
+// callers below all speak the object shape, and only this function knows which
+// shell is listening. iOS gets its handler back untouched — it already is the
+// normalized shape, so that path stays byte-for-byte what it was.
 function nativeControlChannel() {
-  return window.webkit &&
+  if (typeof window === "undefined") return null
+
+  const webkit =
+    window.webkit &&
     window.webkit.messageHandlers &&
     window.webkit.messageHandlers.everywhereControl
+  if (webkit) return webkit
+
+  const android = window.everywhereControl
+  if (android && typeof android.postMessage === "function") {
+    // Built per call, not cached: a fresh document (a Turbo drive visit is
+    // not, but a real navigation is) gets a fresh injected object, and there's
+    // nothing here worth keeping alive across one.
+    return { postMessage: (message) => android.postMessage(JSON.stringify(message)) }
+  }
+
+  return null
 }
 
 // --- public surface ----------------------------------------------------------
@@ -790,6 +835,18 @@ export const Everywhere = {
     else this.visit(to || window.location.pathname)
   },
 
+  // Third-party sign-in (everywhere.yml `auth:`). You rarely need this: the
+  // shell already diverts the paths listed there, so a plain link to
+  // /auth/github does the right thing everywhere. Call it when the sign-in is
+  // driven by something the shell can't see as a visit — a fetch, a custom
+  // element, a button that has other work to do first.
+  auth: {
+    signIn(path) {
+      if (adapter.authSignIn) adapter.authSignIn(path)
+      else window.location.assign(path)
+    }
+  },
+
   clipboard: {
     write(text) {
       return adapter.clipboardWrite(text)

data/lib/everywhere/android_resources.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Everywhere
+  # Compiles an app's native/android/assets/ tree into Android drawable
+  # resources so native code can reach them by name — R.drawable.logo in Kotlin,
+  # @drawable/logo in a layout.
+  #
+  # Deliberately the same filename API as the iOS side (see AssetCatalog), so one
+  # assets/ tree can be authored once and dropped into both native/ios/ and
+  # native/android/: <name>[@2x|@3x][~dark].<ext>. What differs is where the
+  # markers land, because Android expresses both as directory qualifiers rather
+  # than as catalog metadata:
+  #
+  #   logo.png        → res/drawable/logo.png              (density-independent baseline)
+  #   logo@2x.png     → res/drawable-xhdpi/logo.png        (2x = 320dpi)
+  #   logo@3x.png     → res/drawable-xxhdpi/logo.png       (3x = 480dpi)
+  #   logo~dark.png   → res/drawable-night/logo.png
+  #   logo@2x~dark.png→ res/drawable-night-xhdpi/logo.png
+  #
+  # Sub-directories organise the source tree but do NOT namespace the result —
+  # res/ is flat, and asset names are global on iOS too, so assets/branding/
+  # logo.png is R.drawable.logo either way.
+  module AndroidResources
+    # Raster formats aapt2 accepts as-is. WebP is included (and PDF/SVG are not)
+    # because that is the split Android itself draws — the reverse of iOS.
+    RASTER = %w[.png .jpg .jpeg .webp].freeze
+
+    # A drawable written as XML: vectors, shapes, layer lists, selectors. Scale
+    # -free, so the density qualifiers above don't apply to them.
+    VECTOR = %w[.xml].freeze
+    EXTENSIONS = (RASTER + VECTOR).freeze
+
+    # iOS's @2x/@3x in Android's density buckets. 1x is plain `drawable`, not
+    # `drawable-mdpi`: both mean 160dpi, but the unqualified directory is also
+    # the fallback every density falls back TO, which is what a single-file
+    # asset needs to be.
+    DENSITIES = { nil => nil, "2x" => "xhdpi", "3x" => "xxhdpi" }.freeze
+
+    # Written by the Android builder itself (adaptive launcher icon layers) or
+    # shipped in the frozen template's own res/. Both would collide in the
+    # merged resource table, so they're refused by name here — a merge conflict
+    # from aapt2 arrives minutes into a Gradle run and names no fix.
+    RESERVED = %w[
+      ic_launcher ic_launcher_round ic_launcher_foreground ic_launcher_background
+      ic_tab_placeholder
+    ].freeze
+
+    # An Android resource entry is a field on the generated R class, so the name
+    # has to be a Java identifier — and aapt2 additionally rejects uppercase in
+    # a res/ filename. Hyphens and dots are legal on iOS and never here.
+    VALID_NAME = /\A[a-z][a-z0-9_]*\z/
+
+    # Reserved words can't name a field on R. `val`/`fun` are fine (Kotlin reads
+    # R from Java), so this is the Java list, not the Kotlin one.
+    JAVA_KEYWORDS = %w[
+      abstract assert boolean break byte case catch char class const continue default do double else
+      enum extends final finally float for goto if implements import instanceof int interface long
+      native new package private protected public return short static strictfp super switch
+      synchronized this throw throws transient try void volatile while
+    ].freeze
+
+    class << self
+      # Copy every image under `source` into `res` as a drawable resource.
+      # Returns [names, errors]; nothing is written when errors is non-empty, so
+      # a broken assets/ tree can't half-stamp the resource dirs.
+      def write!(source, res)
+        variants, errors = plan(source)
+        return [[], errors] unless errors.empty?
+
+        variants.each do |variant|
+          dir = File.join(res, variant[:dir])
+          FileUtils.mkdir_p(dir)
+          FileUtils.cp(variant[:path], File.join(dir, "#{variant[:name]}#{variant[:extension]}"))
+        end
+
+        [variants.map { |variant| variant[:name] }.uniq.sort, []]
+      end
+
+      private
+
+      # Errors are collected (not raised) so one `every build` reports every
+      # problem in the tree instead of the first.
+      def plan(source)
+        errors = []
+        files = Dir.glob(File.join(source, "**", "*"))
+                   .select { |path| File.file?(path) && !File.basename(path).start_with?(".") }
+                   .sort
+        images, other = files.partition { |path| EXTENSIONS.include?(File.extname(path).downcase) }
+
+        other.each { |path| errors << unsupported(path, source) }
+        variants = images.filter_map { |path| variant(path, source, errors) }
+        errors.concat(clash_errors(variants))
+
+        [variants, errors]
+      end
+
+      def unsupported(path, source)
+        relative = relative(path, source)
+        case File.extname(path).downcase
+        when ".svg", ".pdf"
+          "#{relative}: Android has no runtime SVG or PDF renderer — export a PNG, or convert it to " \
+            "a VectorDrawable (Android Studio: right-click res → New → Vector Asset) and ship the .xml"
+        else
+          "#{relative}: unsupported image type — use #{EXTENSIONS.join(", ")}"
+        end
+      end
+
+      def variant(path, source, errors)
+        relative = relative(path, source)
+        extension = File.extname(path).downcase
+        stem = File.basename(path, File.extname(path))
+
+        # A nine-patch is `logo.9.png`, whose stem carries a dot that no valid
+        # resource name may — so it would otherwise fail with a naming error
+        # that says nothing about what the author actually tried to do.
+        if stem.end_with?(".9")
+          errors << "#{relative}: nine-patch drawables aren't supported yet — ship a plain #{extension} " \
+                    "(or a VectorDrawable .xml, which stretches without one)"
+          return nil
+        end
+
+        name, scale, dark = parse(stem)
+
+        unless name.match?(VALID_NAME)
+          errors << "#{relative}: #{name.inspect} isn't a usable Android resource name — use lowercase " \
+                    "letters, digits and _, starting with a letter (#{suggestion(name).inspect} would " \
+                    "work). Unlike iOS, Android has no room for capitals, hyphens or dots here"
+          return nil
+        end
+        if JAVA_KEYWORDS.include?(name)
+          errors << "#{relative}: #{name.inspect} is a Java keyword, so it can't name a field on R — " \
+                    "rename it (#{"#{name}_image".inspect})"
+          return nil
+        end
+        if RESERVED.include?(name)
+          errors << "#{relative}: #{name} is reserved by the shell (launcher icon and tab placeholder) — " \
+                    "rename it"
+          return nil
+        end
+        if scale && VECTOR.include?(extension)
+          errors << "#{relative}: an XML drawable is scale-free — drop the @#{scale} suffix"
+          return nil
+        end
+
+        { name: name, extension: extension, dir: directory(scale, dark), source_dir: File.dirname(relative),
+          scale: scale, dark: dark, vector: VECTOR.include?(extension), path: path, relative: relative }
+      end
+
+      # Trailing @2x/@3x and ~dark markers, in either order, off the stem —
+      # character for character AssetCatalog#parse, because the two platforms
+      # read the same filenames.
+      def parse(stem)
+        name = stem.dup
+        scale = nil
+        dark = false
+        loop do
+          if name.sub!(/~dark\z/, "")
+            dark = true
+          elsif name.sub!(/@([23])x\z/, "")
+            scale = "#{Regexp.last_match(1)}x"
+          else
+            break
+          end
+        end
+        [name, scale, dark]
+      end
+
+      # Qualifier order is fixed by the platform and is not alphabetical: UI mode
+      # (night) comes before density. `drawable-xhdpi-night` is not a directory
+      # Android will ever match — it's silently ignored, which reads as "my dark
+      # asset doesn't work" with nothing in the log.
+      def directory(scale, dark)
+        ["drawable", dark ? "night" : nil, DENSITIES.fetch(scale)].compact.join("-")
+      end
+
+      # What the author probably meant, so the error can show it rather than
+      # describe it. Not applied automatically: R.drawable.<name> is written by
+      # hand in Kotlin, so a name we invented is a name nobody can guess.
+      def suggestion(name)
+        candidate = name.gsub(/([a-z0-9])([A-Z])/, '\1_\2').downcase.gsub(/[^a-z0-9]+/, "_")
+                        .gsub(/_+/, "_").delete_prefix("_").delete_suffix("_")
+        candidate.match?(/\A[a-z]/) ? candidate : "image_#{candidate}"
+      end
+
+      def clash_errors(variants)
+        errors = []
+        variants.group_by { |variant| variant[:name] }.each do |name, group|
+          dirs = group.map { |variant| variant[:source_dir] }.uniq
+          if dirs.length > 1
+            listed = dirs.map { |dir| dir == "." ? "assets/" : "assets/#{dir}/" }.join(" and ")
+            errors << "#{name}: same asset name in #{listed} — res/ is flat, so both would become " \
+                      "R.drawable.#{name}. Rename one"
+          end
+          if group.map { |variant| variant[:vector] }.uniq.length > 1
+            errors << "#{name}: mixes an XML drawable with bitmaps — pick one per asset"
+          end
+
+          # Same destination directory and same name: aapt2 sees two files
+          # claiming one resource, whatever their extensions.
+          group.group_by { |variant| variant[:dir] }.each_value do |clash|
+            next if clash.length < 2
+
+            errors << "#{name}: #{clash.map { |variant| variant[:relative] }.join(" and ")} both become " \
+                      "res/#{clash.first[:dir]}/#{name}"
+          end
+        end
+        errors
+      end
+
+      def relative(path, source)
+        path.delete_prefix("#{source}/")
+      end
+    end
+  end
+end