ruby_everywhere 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0f0efd687867d44e9b4223bd1bcdda51dd543236d8510069d9232b81e5e31dd
-  data.tar.gz: 4070286991240decb7b38abc1766a360e996153d8640f8a1f1c6339f247de6d9
+  metadata.gz: 6e02deeb4f95a031a3a44bae0e87dbaece25f95a919ff817927e9eb5b611ffbb
+  data.tar.gz: db779e7819a864517b0a44a388c56b835eb724a2d697af653857936cab505ac1
 SHA512:
-  metadata.gz: a5ba33fca0834b228b5567695414896cc218adc5d082a2ea46c33f728148f8b9f2fbfc09ab0455a5473f8f6a327352f9e38b489364092fe7f842e9e6a395a244
-  data.tar.gz: e6067ab08a817595a5076be7bdbd8dbb7a3a06964bbc5682409e4ad2a2cd7c1d7e87b07a4e6bd93e0ac48964553b70f0f3dbfd6fb693da53ccde51a7e3b5e3ae
+  metadata.gz: a1567ed4df49616f1c05fe481812a62bc9f3eb64e816e4702756a0614e282027016a4e76ad62a3097fced1bde908a22fdba8ae6b6b6a46aa24cdc227bb8bf32e
+  data.tar.gz: ed2ecc0ff275c958291986eb8ea23b0e9fde277b62dcffc614c61dd84f2d6c4c626e8c93d07a8563b4755cb036f56f4a0107e00cc6c46280c6e61c551e259c1e

data/bridge/README.md

@@ -0,0 +1,77 @@
+# @rubyeverywhere/bridge
+
+One API for the browser, the RubyEverywhere desktop shell, and (soon) Hotwire
+Native mobile apps — the JavaScript half of [RubyEverywhere](https://rubyeverywhere.com).
+
+App code writes to this surface only; platform differences live in adapters
+inside the package. Everything degrades gracefully: the same page works in a
+plain browser tab and gains native powers inside a RubyEverywhere app.
+
+## Install
+
+```sh
+npm install @rubyeverywhere/bridge
+```
+
+Using RubyEverywhere? You don't need npm at all: the `ruby_everywhere` gem
+ships this exact package. Rails apps get it served and importmap-pinned by the
+gem's engine (updates arrive with `bundle update ruby_everywhere`); Sinatra and
+Hanami apps get it vendored to `public/bridge.js` by `every install`.
+
+## Usage
+
+```js
+import Everywhere from "@rubyeverywhere/bridge"
+
+Everywhere.platform                  // "desktop" | "mobile" | "browser"
+Everywhere.os                        // "macos" | "windows" | "linux" | "ios" | "android" | "chromeos" | "unknown"
+Everywhere.native                    // true inside a RubyEverywhere app
+Everywhere.version                   // app version; null in a plain browser tab
+
+Everywhere.notify({ title, body })   // native notification / web Notification / console
+Everywhere.confirm("Sure?")          // Promise<boolean>, native dialog when possible
+Everywhere.on("menu", handler)       // shell events; returns an unsubscribe fn
+Everywhere.visit("/settings")        // Turbo.visit with location fallback
+
+Everywhere.clipboard.write(text)     // Promise<void>
+Everywhere.clipboard.read()          // Promise<string | null>
+```
+
+### Auto-updates
+
+Inside the desktop shell, apps with an update feed configured can check,
+install, and switch channels at runtime:
+
+```js
+Everywhere.updates.supported          // true when the shell has an update feed
+Everywhere.updates.channel            // effective channel ("stable", "beta", …)
+
+const result = await Everywhere.updates.check()
+// { available: true, version, notes, notesHtml } or { available: false }
+
+Everywhere.updates.install()          // download / verify / swap / relaunch
+Everywhere.updates.setChannel("beta") // Promise<{ channel }>, persisted by the shell
+
+Everywhere.updates.on("available", handler)
+// events: "available" | "none" | "progress" | "ready" | "error" | "channel"
+```
+
+`notes` is the release-notes markdown source; `notesHtml` is the same notes
+pre-rendered to HTML from your signed update feed, ready for a changelog
+modal: `el.innerHTML = notesHtml`.
+
+In a plain browser tab the updates API is inert: `check()` resolves
+`{ available: false, unsupported: true }` and nothing throws.
+
+## Platforms
+
+- **desktop** — the Tauri-based RubyEverywhere shell. Notifications, dialogs,
+  clipboard, shell events, and auto-updates are native.
+- **browser** — honest web fallbacks: the Notification API, `window.confirm`,
+  `navigator.clipboard`, DOM CustomEvents.
+- **mobile** — Hotwire Native detection is live; behavior currently falls back
+  to the browser adapter until the bridge-component adapter lands.
+
+## License
+
+MIT

data/bridge/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@rubyeverywhere/bridge",
+  "version": "0.3.0",
+  "description": "One API for browser, desktop, and mobile — the JS half of RubyEverywhere",
+  "type": "module",
+  "main": "everywhere/bridge.js",
+  "exports": { ".": "./everywhere/bridge.js" },
+  "files": ["everywhere/bridge.js", "README.md"],
+  "sideEffects": false,
+  "keywords": ["rubyeverywhere", "tauri", "hotwire", "turbo", "rails", "desktop", "native", "bridge"],
+  "homepage": "https://rubyeverywhere.com",
+  "license": "MIT",
+  "publishConfig": { "access": "public" }
+}

data/config/importmap.rb

@@ -0,0 +1,3 @@
+# Pin drawn into apps by Everywhere::Engine (before the app's own importmap,
+# which can therefore override it).
+pin "@rubyeverywhere/bridge", to: "everywhere/bridge.js"

data/lib/everywhere/commands/install.rb

@@ -66,7 +66,7 @@ module Everywhere
       # Rack frameworks vary too much to auto-edit their boot files safely, so we
       # vendor the bridge and print the remaining wiring rather than guess.
       def vendor_bridge_to_public
-        source = File.expand_path("../javascript/bridge.js", __dir__)
+        source = File.expand_path("../../../bridge/everywhere/bridge.js", __dir__)
         target_dir = app_file("public")
         FileUtils.mkdir_p(target_dir)
         target = File.join(target_dir, "bridge.js")
@@ -219,32 +219,36 @@ module Everywhere
         change("disable force_ssl for localhost", made)
       end
 
-      # Vendor @rubyeverywhere/bridge (one JS API across browser/desktop/mobile)
-      # and pin it for importmap. Re-running `every install` after a gem update
-      # refreshes the vendored copy.
+      # @rubyeverywhere/bridge (one JS API across browser/desktop/mobile) is
+      # served and pinned by Everywhere::Engine straight from the gem, so the
+      # bridge updates with `bundle update ruby_everywhere`. Nothing to vendor —
+      # just migrate apps installed before the engine existed (their vendored
+      # copy and pin would shadow the engine's, freezing them on an old bridge)
+      # and wire the import.
       def install_bridge
-        source = File.expand_path("../javascript/bridge.js", __dir__)
-        target_dir = app_file("vendor", "javascript")
-        target = File.join(target_dir, "@rubyeverywhere--bridge.js")
-        FileUtils.mkdir_p(target_dir)
-        # Stamp a machine-readable version marker on the vendored copy so the
-        # build receipt (Receipt#bridge_version) can record which bridge shipped.
-        # Comparing against the fully-stamped content keeps re-runs idempotent.
-        desired = "// @rubyeverywhere/bridge version: #{Everywhere::BRIDGE_VERSION} (vendored by `every install`)\n#{File.read(source)}"
-        fresh = !File.exist?(target) || File.read(target) != desired
-        File.write(target, desired) if fresh
+        fresh = remove_vendored_bridge
 
         importmap = app_file("config", "importmap.rb")
         if File.exist?(importmap)
           contents = File.read(importmap)
-          unless contents.include?("@rubyeverywhere/bridge")
-            File.write(importmap, contents.chomp + "\npin \"@rubyeverywhere/bridge\", to: \"@rubyeverywhere--bridge.js\" # vendored by `every install`\n")
+          stale_pin = /^pin ["']@rubyeverywhere\/bridge["'],\s*to:\s*["']@rubyeverywhere--bridge\.js["'].*\n/
+          if contents.match?(stale_pin)
+            File.write(importmap, contents.gsub(stale_pin, ""))
             fresh = true
           end
         end
         wire_application_js(fresh)
       end
 
+      def remove_vendored_bridge
+        target = app_file("vendor", "javascript", "@rubyeverywhere--bridge.js")
+        return false unless File.exist?(target)
+
+        FileUtils.rm(target)
+        change("remove vendored bridge (now served by the ruby_everywhere engine)", true)
+        true
+      end
+
       def wire_application_js(fresh)
         app_js = app_file("app", "javascript", "application.js")
         if File.exist?(app_js)

data/lib/everywhere/engine.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Everywhere
+  # Rails integration: serves @rubyeverywhere/bridge straight from the gem's
+  # bridge/ directory (the same files published to npm — single source) and
+  # contributes the importmap pin, so apps get bridge updates with
+  # `bundle update ruby_everywhere` — no vendored copy to refresh. Loaded only
+  # when Rails is present; Sinatra/Hanami apps keep the vendored
+  # public/bridge.js from `every install`.
+  class Engine < ::Rails::Engine
+    # bridge/ becomes an asset root, so bridge/everywhere/bridge.js gets the
+    # namespaced logical path "everywhere/bridge.js" (Propshaft and Sprockets
+    # both read config.assets.paths); Sprockets additionally needs the file
+    # declared precompilable.
+    initializer "everywhere.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.paths << Engine.root.join("bridge").to_s
+        app.config.assets.precompile += %w[everywhere/bridge.js] if app.config.assets.respond_to?(:precompile)
+      end
+    end
+
+    # Runs before importmap-rails adds the app's config/importmap.rb, so an
+    # app-level pin (e.g. a legacy vendored copy) still overrides ours.
+    initializer "everywhere.importmap", before: "importmap" do |app|
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << Engine.root.join("config/importmap.rb")
+      end
+    end
+  end
+end

data/lib/everywhere/receipt.rb

@@ -116,10 +116,18 @@ module Everywhere
         File.join(@root, "vendor", "javascript", "@rubyeverywhere", "bridge", "package.json")
       ].each { |p| (v = json_version(p)) and return v }
 
-      # Single-file vendored install: read a `// version: x.y.z` header marker
-      # if `every install` stamped one (best-effort until it does).
+      # Legacy single-file vendored install: read the `// version: x.y.z`
+      # marker `every install` stamped on the copy.
       flat = File.join(@root, "vendor", "javascript", "@rubyeverywhere--bridge.js")
-      File.exist?(flat) ? File.foreach(flat).first(6).join[/version:\s*([\d.]+)/i, 1] : nil
+      return File.foreach(flat).first(6).join[/version:\s*([\d.]+)/i, 1] if File.exist?(flat)
+
+      # Engine-served (Rails apps bundling ruby_everywhere): the bridge ships
+      # inside the gem, so it carries the gem's BRIDGE_VERSION. Best-effort —
+      # assumes the app bundles the same gem release that's running this build.
+      lock = File.join(@root, "Gemfile.lock")
+      return Everywhere::BRIDGE_VERSION if File.exist?(lock) && File.read(lock).match?(/^\s+ruby_everywhere\s/)
+
+      nil
     end
 
     def shell_version

data/lib/everywhere/version.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.1.9"
+  VERSION = "0.1.10"
 
-  # Version of the vendored @rubyeverywhere/bridge JS this gem ships. Tracks
-  # bridge/package.json — bump it whenever lib/everywhere/javascript/bridge.js is
-  # refreshed. `every install` stamps it into the vendored file so the build
-  # receipt can record which bridge shipped; it versions independently of the CLI.
-  BRIDGE_VERSION = "0.3.0"
+  # Version of the @rubyeverywhere/bridge JS this gem ships. bridge/ in the
+  # gem IS the npm package (served to Rails apps by Everywhere::Engine,
+  # vendored to public/ for Sinatra/Hanami), so its package.json is the single
+  # source of truth. The build receipt records it; it versions independently
+  # of the CLI.
+  BRIDGE_VERSION = File.read(
+    File.expand_path("../../bridge/package.json", __dir__)
+  )[/"version":\s*"([^"]+)"/, 1]
 end

data/lib/everywhere.rb

@@ -7,6 +7,9 @@ require_relative "everywhere/config"
 require_relative "everywhere/framework"
 require_relative "everywhere/database"
 require_relative "everywhere/boot"
+# Rails apps get the bridge served + pinned by the engine (Sinatra/Hanami
+# vendor it to public/ instead — see `every install`).
+require_relative "everywhere/engine" if defined?(::Rails::Engine)
 
 module Everywhere
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_everywhere
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Andrea Fomera
@@ -75,6 +75,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- bridge/README.md
+- bridge/everywhere/bridge.js
+- bridge/package.json
+- config/importmap.rb
 - exe/every
 - exe/rbe
 - lib/everywhere.rb
@@ -98,10 +102,10 @@ files:
 - lib/everywhere/commands/updates_keygen.rb
 - lib/everywhere/config.rb
 - lib/everywhere/database.rb
+- lib/everywhere/engine.rb
 - lib/everywhere/framework.rb
 - lib/everywhere/icon.rb
 - lib/everywhere/ignore.rb
-- lib/everywhere/javascript/bridge.js
 - lib/everywhere/log_filter.rb
 - lib/everywhere/minisign.rb
 - lib/everywhere/paths.rb