ruby_everywhere 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bb96376a66f4202388542212bc1d03b2dea1bb6519ccc4a8339cc1b3cda3e43
-  data.tar.gz: be5f8b69e0157a93dfc1837445faa8f4e6326678741b88ddd76c9bff0521ddf5
+  metadata.gz: 7ffb921df597efe047c25240e7d8b92aaad49c00c90d546020e053eac618739a
+  data.tar.gz: 17315b4c5d91eced13b44d7147942d7d6357ee791b8622425ab655eb97b1ab27
 SHA512:
-  metadata.gz: 29c23a79521c57f81a0881e663debc4e2c9a505a424dbe8b615c1a1c5eccba3d93c1dfd7ee0281ea04c8121d2c4ba6ec4c0de8276453ab5ca0d348d6d8afdf00
-  data.tar.gz: 7a626876bb0820701922e23990541e149360b35246b2456be3b2d5f7729743f2c5e3772d6e9e2d94d7ea898b85d6e528ff5e9ad85e919653357463073cfbdcea
+  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/README.md

@@ -33,6 +33,11 @@ Everywhere.confirm("Sure?")          // Promise<boolean>, native dialog when pos
 Everywhere.on("menu", handler)       // shell events; returns an unsubscribe fn
 Everywhere.visit("/settings")        // Turbo.visit with location fallback
 
+Everywhere.menu({ title, items })    // Promise<item | null> — native action
+                                     // sheet in the shell, a styled bottom
+                                     // sheet everywhere else. items:
+                                     // [{ title, id?, style?, disabled? }]
+
 Everywhere.clipboard.write(text)     // Promise<void>
 Everywhere.clipboard.read()          // Promise<string | null>
 
@@ -61,6 +66,49 @@ Everywhere.storage.clear()           // Promise<boolean> — clears app keys onl
 // desktop shell. Settings, not secrets — tokens go in biometrics.credential.
 ```
 
+### Native chrome (nav bar buttons, menus, action sheets)
+
+Tag ordinary markup, and inside the mobile shell the bridge lifts it into real
+native controls — a nav-bar button, a pull-down / overflow menu, or an action
+sheet. Tapping the native control just `.click()`s the element it mirrors, so a
+link navigates, a submit submits, and behavior stays defined once in the DOM. In
+a browser the same markup is the plain HTML it already is. No JavaScript, no
+Stimulus — CSP-safe.
+
+```html
+<!-- becomes a nav-bar button (right side); icons are per-platform like tabs -->
+<a href="/notes/new" data-everywhere-nav-button
+   data-everywhere-nav-title="New"
+   data-everywhere-nav-icon-ios="plus"
+   data-everywhere-nav-icon-android="add">New</a>
+
+<!-- a submit button in the nav bar -->
+<button type="submit" data-everywhere-nav-button
+        data-everywhere-nav-title="Save" data-everywhere-nav-style="done">Save</button>
+
+<!-- a nav-bar pull-down / overflow menu (defaults to the ⋯ icon) -->
+<div data-everywhere-nav-menu data-everywhere-nav-title="More">
+  <a href="/share" data-everywhere-menu-item data-everywhere-menu-title="Share">Share</a>
+  <button form="delete_1" data-everywhere-menu-item
+          data-everywhere-menu-title="Delete"
+          data-everywhere-menu-style="destructive">Delete</button>
+</div>
+
+<!-- an in-content action sheet: a trigger and the items it opens -->
+<div data-everywhere-menu>
+  <button data-everywhere-menu-trigger>Options</button>
+  <div data-everywhere-menu-items>
+    <a href="/x/edit" data-everywhere-menu-item>Edit</a>
+  </div>
+</div>
+```
+
+Rails ships helpers that emit exactly this — `everywhere_nav_button`,
+`everywhere_submit_button`, `everywhere_nav_menu` / `everywhere_menu_item`,
+`everywhere_menu`, and `everywhere_fab` (a floating action button). Include
+`everywhere/native.css` for the FAB, the action-sheet fallback, and the
+safe-area utilities.
+
 ### Multi-instance apps
 
 Apps whose users pick a server — one hosted platform, many instances — opt in