ruby_everywhere 0.6.0 → 0.7.0

data/lib/everywhere/platform/snapshot.rb

@@ -4,6 +4,7 @@ require "rubygems/package"
 require "zlib"
 require "digest"
 require_relative "../ignore"
+require_relative "../ui"
 
 module Everywhere
   module Platform
@@ -38,10 +39,19 @@ module Everywhere
 
       def add(tar, root, rel)
         abs = File.join(root, rel)
+        # lstat first: File.stat follows the link, so a dangling symlink (a
+        # deleted bundle path, a checked-in link to an absent sibling repo)
+        # would raise Errno::ENOENT and abort the whole snapshot.
+        return Everywhere::UI.warn("skipping dangling symlink #{rel}") if File.lstat(abs).symlink? && !File.exist?(abs)
+
         stat = File.stat(abs)
         tar.add_file_simple(rel, stat.mode & 0o777, stat.size) do |io|
           File.open(abs, "rb") { |f| IO.copy_stream(f, io) }
         end
+      rescue Errno::ENOENT, Errno::EACCES => e
+        # The listing is a snapshot in time; a dev server or watcher can delete a
+        # tmp/ file between the glob and here. Losing it beats losing the build.
+        Everywhere::UI.warn("skipping #{rel} (#{e.class.name.split("::").last})")
       end
     end
   end

data/lib/everywhere/receipt.rb

@@ -5,6 +5,7 @@ require "digest"
 require_relative "version"
 require_relative "shellout"
 require_relative "ignore"
+require_relative "paths"
 
 module Everywhere
   # Builds the machine-readable build receipt (release.json) — the same shape
@@ -22,14 +23,20 @@ module Everywhere
   class Receipt
     SCHEMA = 1
 
-    def initialize(root:, config:, framework:, ruby:, target:, channel:, shell_dir: nil)
+    # source_checksum/lockfile_checksum are optional so a caller building one
+    # receipt per target hashes the tree ONCE and threads the digest through the
+    # rest — they describe the source, which is identical for every target.
+    def initialize(root:, config:, framework:, ruby:, target:, channel:, shell_dir: nil,
+                   source_checksum: nil, lockfile_checksum: nil)
       @root = File.expand_path(root)
       @config = config
       @framework = framework
       @ruby = ruby
-      @target_str = target                     # raw "os-arch" — selects platforms: overrides
+      @target_str = target                     # bare "os-arch" — selects platforms: overrides
       @target = parse_target(target, channel)
       @shell_dir = shell_dir
+      @source_checksum = source_checksum
+      @lockfile_checksum = lockfile_checksum
     end
 
     # The deterministic build request.
@@ -48,7 +55,9 @@ module Everywhere
           "lockfile_checksum" => lockfile_checksum
         },
         "target" => @target,
-        "permissions" => @config.permissions
+        "permissions" => @config.permissions,
+        "mode" => @config.mode,
+        "remote" => { "url" => @config.remote_url }.compact
       }
     end
 
@@ -105,10 +114,15 @@ module Everywhere
         "cli" => Everywhere::VERSION,
         "bridge" => bridge_version,
         "shell" => shell_version,
-        "tebako" => tebako_version
+        # Only macOS targets are tebako-pressed; spawning rbe-tebako for a
+        # mobile receipt would cost a process to learn nothing.
+        "tebako" => macos? ? tebako_version : nil,
+        "hotwire_native" => hotwire_native_version
       }
     end
 
+    def macos? = @target["os"] == "macos"
+
     def bridge_version
       # Package installs: read the version straight from package.json.
       [
@@ -145,11 +159,40 @@ module Everywhere
       out[/version\s+([\d.]+)/i, 1]
     end
 
+    # Which Hotwire Native the bundled mobile template pins. Read straight off
+    # the frozen templates in the gem (no spawn): iOS from the SPM lockfile,
+    # Android from the Gradle dependency line. Best-effort — a receipt is worth
+    # writing even when the template is missing or reshaped.
+    def hotwire_native_version
+      case @target["os"]
+      when "ios"     then hotwire_native_ios_revision
+      when "android" then hotwire_native_android_version
+      end
+    end
+
+    def hotwire_native_ios_revision
+      dir = Paths.ios_dir or return nil
+      resolved = File.join(dir, "App.xcodeproj", "project.xcworkspace", "xcshareddata", "swiftpm", "Package.resolved")
+      pin = JSON.parse(File.read(resolved))["pins"].find { |p| p["identity"].to_s.include?("hotwire-native-ios") }
+      pin&.dig("state", "revision")&.slice(0, 12)
+    rescue StandardError
+      nil
+    end
+
+    def hotwire_native_android_version
+      dir = Paths.android_dir or return nil
+      File.read(File.join(dir, "app", "build.gradle.kts"))[/dev\.hotwire:core:([\d.]+)/, 1]
+    rescue StandardError
+      nil
+    end
+
     # ---- checksums -----------------------------------------------------------
 
     def lockfile_checksum
-      lock = File.join(@root, "Gemfile.lock")
-      File.exist?(lock) ? "sha256:#{Digest::SHA256.file(lock).hexdigest}" : nil
+      @lockfile_checksum ||= begin
+        lock = File.join(@root, "Gemfile.lock")
+        File.exist?(lock) ? "sha256:#{Digest::SHA256.file(lock).hexdigest}" : nil
+      end
     end
 
     def lockfile_gem_version(gem_name)
@@ -164,11 +207,13 @@ module Everywhere
     # Uses the SAME ignore rules as the (future) snapshot, so the checksum
     # describes exactly what ships.
     def source_checksum
-      digest = Digest::SHA256.new
-      Ignore.for(@root).files(@root).each do |rel|
-        digest << rel << "\0" << Digest::SHA256.file(File.join(@root, rel)).hexdigest << "\n"
+      @source_checksum ||= begin
+        digest = Digest::SHA256.new
+        Ignore.for(@root).files(@root).each do |rel|
+          digest << rel << "\0" << Digest::SHA256.file(File.join(@root, rel)).hexdigest << "\n"
+        end
+        "sha256:#{digest.hexdigest}"
       end
-      "sha256:#{digest.hexdigest}"
     end
 
     # ---- helpers -------------------------------------------------------------

data/lib/everywhere/shellout.rb

@@ -40,9 +40,27 @@ module Everywhere
 
     def run!(env, *cmd, chdir: Dir.pwd)
       success = system(child_env(env), *cmd, chdir: chdir)
+      # nil means the command never ran (missing binary), false that it failed.
+      UI.die!("#{cmd.first} not found — is it installed and on your PATH?") if success.nil?
       UI.die!("command failed: #{cmd.join(" ")}") unless success
     end
 
+    # Whether `name` resolves as an executable on the PATH children get (the
+    # unbundled one — a Bundler binstub visible to the CLI doesn't count).
+    def tool?(name)
+      return File.executable?(name) && !File.directory?(name) if name.include?("/")
+
+      path = (unbundled_base["PATH"] || ENV["PATH"]).to_s
+      exts = Gem.win_platform? ? [".exe", ".bat", ".cmd", ""] : [""]
+      path.split(File::PATH_SEPARATOR).any? do |dir|
+        exts.any? { |ext| File.executable?(File.join(dir, name + ext)) && !File.directory?(File.join(dir, name + ext)) }
+      end
+    end
+
+    def ensure_tool!(name, hint)
+      tool?(name) or UI.die!("#{name} not found — #{hint}")
+    end
+
     # quiet also detaches stdin. A quiet command is by definition one that has
     # nothing to say to the terminal, and `every dev` reads single keystrokes
     # from that same terminal — a child left holding stdin silently eats the
@@ -78,6 +96,7 @@ module Everywhere
     # ChildProcesses instead.
     def run_logged!(env, cmd, log:, filter: nil)
       require "open3"
+      ensure_tool!(cmd.first, "is it installed and on your PATH?")
       success = false
       File.open(log, "w") do |logf|
         # Inside an `every dev` worker the build leads its own process group,

data/lib/everywhere/simulator.rb

@@ -56,11 +56,22 @@ module Everywhere
       out, status = Shellout.capture("xcrun", "simctl", "list", "devices", "available", "-j")
       return [] unless status&.success?
 
-      JSON.parse(out).fetch("devices", {}).sort.flat_map { |_runtime, list| list }
+      JSON.parse(out).fetch("devices", {})
+          .sort_by { |runtime, _list| runtime_order(runtime) }
+          .flat_map { |_runtime, list| list }
     rescue JSON::ParserError
       []
     end
 
+    # Runtimes are keyed by identifier ("com.apple.CoreSimulator.SimRuntime.iOS-17-0"),
+    # so a plain string sort puts iOS-9-3 AFTER iOS-17-0 and "newest last" hands
+    # back the oldest runtime installed. Compare the version numerically, with
+    # the family (iOS/watchOS/…) as the primary key so the grouping is stable.
+    def runtime_order(runtime)
+      family, *version = runtime.to_s.split(".").last.to_s.split("-")
+      [family.to_s.downcase, version.map(&:to_i)]
+    end
+
     def wait_until_booted(udid, timeout: 60)
       deadline = Time.now + timeout
       until Time.now > deadline

data/lib/everywhere/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.6.0"
+  VERSION = "0.7.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,

data/support/mobile/android/app/build.gradle.kts

@@ -18,6 +18,15 @@ val everywhere = Properties().apply {
 fun stamped(key: String, default: String): String =
     everywhere.getProperty("everywhere.$key")?.takeIf { it.isNotBlank() } ?: default
 
+// Release signing and the versionCode override arrive as environment, never as
+// stamped properties: everywhere.properties lives in the work dir for the life
+// of the app, and a keystore password written there outlives the build that
+// needed it. `every build` resolves and passes these; a direct Gradle
+// invocation can export them itself.
+fun env(name: String): String? = System.getenv("EVERY_ANDROID_$name")?.takeIf { it.isNotBlank() }
+
+val releaseKeystore = env("KEYSTORE")?.let { file(it) }
+
 android {
     // The namespace is the R class / BuildConfig package and is frozen. It is
     // deliberately NOT the applicationId: apps rename their bundle id freely,
@@ -28,7 +37,7 @@ android {
     defaultConfig {
         applicationId = stamped("applicationId", "com.rubyeverywhere.app")
         versionName = stamped("versionName", "0.1.0")
-        versionCode = stamped("versionCode", "1").toInt()
+        versionCode = (env("VERSION_CODE") ?: stamped("versionCode", "1")).toInt()
 
         // minSdk 28 is Hotwire Native Android's floor and is not negotiable.
         // It also clears API 26 for Typeface.Builder.setFontVariationSettings,
@@ -63,11 +72,30 @@ android {
         getByName("main") { res.srcDir("src/stamped/res") }
     }
 
+    signingConfigs {
+        // Created only when a keystore is in the environment: the default build
+        // is an unsigned release, and a signingConfig with a null storeFile is
+        // a configuration-time failure rather than an unsigned APK.
+        releaseKeystore?.let { keystore ->
+            create("release") {
+                storeFile = keystore
+                storePassword = env("KEYSTORE_PASSWORD")
+                keyAlias = env("KEY_ALIAS")
+                // keytool -genkeypair without -keypass gives the key the store's
+                // password; the CLI resolves the same fallback before it gets here.
+                keyPassword = env("KEY_PASSWORD") ?: env("KEYSTORE_PASSWORD")
+            }
+        }
+    }
+
     buildTypes {
         getByName("debug") {
             isDebuggable = true
         }
         release {
+            if (releaseKeystore != null) {
+                signingConfig = signingConfigs.getByName("release")
+            }
             isMinifyEnabled = false
             proguardFiles(
                 getDefaultProguardFile("proguard-android-optimize.txt"),

data/support/mobile/ios/App/EverywhereConfig.swift

@@ -145,20 +145,31 @@ struct EverywhereConfig: Decodable {
     /// relaunches; release builds never read it.
     private static let devOverrideURL: URL? = {
         let key = "EverywhereDevURL"
-        if let dev = ProcessInfo.processInfo.environment["EVERYWHERE_DEV_URL"], let url = URL(string: dev) {
+        if let dev = ProcessInfo.processInfo.environment["EVERYWHERE_DEV_URL"], let url = rootWorthy(dev) {
             #if DEBUG
-            UserDefaults.standard.set(dev, forKey: key)
+            UserDefaults.standard.set(url.absoluteString, forKey: key)
             #endif
             return url
         }
         #if DEBUG
-        if let saved = UserDefaults.standard.string(forKey: key), let url = URL(string: saved) {
+        if let saved = UserDefaults.standard.string(forKey: key), let url = rootWorthy(saved) {
             return url
         }
         #endif
         return nil
     }()
 
+    /// A string as an app ROOT: everything derived from a root (path config,
+    /// tab URLs) is built by appending paths, so a root carrying a query or
+    /// fragment would smear them onto every derived URL. Paths are kept —
+    /// dev URLs legitimately carry entry_path.
+    private static func rootWorthy(_ string: String) -> URL? {
+        guard var components = URLComponents(string: string) else { return nil }
+        components.query = nil
+        components.fragment = nil
+        return components.url
+    }
+
     // MARK: Instance override (multi-instance apps)
 
     /// UserDefaults key holding the user-chosen instance root. Multi-instance
@@ -186,9 +197,10 @@ struct EverywhereConfig: Decodable {
             return true
         }
         guard let scheme = url.scheme?.lowercased(), ["https", "http"].contains(scheme),
-              url.host != nil
+              url.host != nil,
+              let root = rootWorthy(url.absoluteString)
         else { return false }
-        UserDefaults.standard.set(url.absoluteString, forKey: instanceKey)
+        UserDefaults.standard.set(root.absoluteString, forKey: instanceKey)
         return true
     }
 

data/support/mobile/ios/App/SceneDelegate.swift

@@ -1,5 +1,6 @@
 import AuthenticationServices
 import HotwireNative
+import SwiftUI
 import UIKit
 import WebKit
 
@@ -369,7 +370,15 @@ final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
                 nav.start()
             }
         } else {
-            let controller = HotwireTabBarController(navigatorDelegate: self, lazyLoadTabs: config.lazyLoadsTabs)
+            let controller = EverywhereTabBarController(navigatorDelegate: self, lazyLoadTabs: config.lazyLoadsTabs)
+            if config.remoteInstances == true {
+                controller.leaveTabIndex = entries.firstIndex { $0.path == EverywhereTabBarController.jumpLeavePath }
+                controller.onLeaveSelected = { [weak self] in
+                    guard let self else { return }
+                    EverywhereConfig.setInstanceURL(nil)
+                    self.resetApp(to: self.config.startURL)
+                }
+            }
             tabBarController = controller
             navigator = nil
             window?.rootViewController = controller
@@ -543,13 +552,23 @@ extension SceneDelegate: NavigatorDelegate {
         // App-provided native screens: a path rule's `view_controller`
         // identifier resolves through the extension registry (everywhere.yml
         // native.ios.screens). Unknown identifiers fall through to the web.
-        if let identifier = proposal.properties["view_controller"] as? String,
-           let screen = EverywhereExtensions.screen(for: identifier, url: proposal.url) {
-            // A native screen IS first content: without this, an app whose
-            // entry path is native never finishes a request and the splash
-            // sits until its safety timeout.
-            dismissSplash()
-            return .acceptCustom(screen)
+        if let identifier = proposal.properties["view_controller"] as? String {
+            if let screen = EverywhereExtensions.screen(for: identifier, url: proposal.url) {
+                // A native screen IS first content: without this, an app whose
+                // entry path is native never finishes a request and the splash
+                // sits until its safety timeout.
+                dismissSplash()
+                return .acceptCustom(screen)
+            }
+            // Previewing someone else's app (a picked instance): its rules
+            // name native screens compiled into ITS build, not this shell.
+            // Say so, instead of falling through to a web 404. Outside a
+            // preview an unknown id keeps falling through — there it's a
+            // typo, and the web response is the honest answer.
+            if config.remoteInstances == true, EverywhereConfig.instanceURL != nil {
+                dismissSplash()
+                return .acceptCustom(everywhereHost(MissingExtensionScreen(identifier: identifier)))
+            }
         }
         return .accept
     }
@@ -585,3 +604,51 @@ extension SceneDelegate: NavigatorDelegate {
         activeNavigator.activeNavigationController.present(errorViewController, animated: true)
     }
 }
+
+/// Tab bar that treats the Jump "leave preview" tab as a native action.
+/// The page behind that tab is a gem-served browser fallback with no Turbo,
+/// so letting it become a web visit can only end at Hotwire's "Turbo is not
+/// ready" screen — selecting it must clear the picked instance directly,
+/// and the tap never reaches the web layer.
+final class EverywhereTabBarController: HotwireTabBarController {
+    static let jumpLeavePath = "/everywhere/jump/leave"
+
+    var leaveTabIndex: Int?
+    var onLeaveSelected: (() -> Void)?
+
+    func tabBarController(_ tabBarController: UITabBarController,
+                          shouldSelect viewController: UIViewController) -> Bool {
+        guard let leaveTabIndex,
+              tabBarController.viewControllers?.firstIndex(of: viewController) == leaveTabIndex
+        else { return true }
+
+        onLeaveSelected?()
+        return false
+    }
+}
+
+/// Shown while PREVIEWING an app whose path rules route here natively: the
+/// screen exists as Swift in that app's native/ios, compiled into its real
+/// build — this shell only carries its own extensions. Honest placeholder
+/// beats a mystery web 404.
+struct MissingExtensionScreen: View {
+    let identifier: String
+
+    var body: some View {
+        VStack(spacing: 14) {
+            Image(systemName: "puzzlepiece.extension")
+                .font(.system(size: 44))
+                .foregroundStyle(.secondary)
+            Text("This screen is native")
+                .font(.title3.bold())
+            Text("In the full build, “\(identifier)” is a native screen compiled " +
+                 "into the app. Jump can't run another app's native code — " +
+                 "everything else in this preview works.")
+                .font(.callout)
+                .foregroundStyle(.secondary)
+                .multilineTextAlignment(.center)
+        }
+        .padding(32)
+        .navigationTitle("Preview")
+    }
+}

data/support/mobile/ios/App.xcodeproj/project.pbxproj

@@ -440,8 +440,8 @@
 			isa = XCRemoteSwiftPackageReference;
 			repositoryURL = "https://github.com/afomera/hotwire-native-ios";
 			requirement = {
-				branch = "fix/more-menu-navigator";
-				kind = branch;
+				kind = revision;
+				revision = 915194a338d0a4c686ee43ace7450b3aa0e885c3;
 			};
 		};
 /* End XCRemoteSwiftPackageReference section */

data/support/mobile/ios/App.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -5,7 +5,6 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/afomera/hotwire-native-ios",
       "state" : {
-        "branch" : "fix/more-menu-navigator",
         "revision" : "915194a338d0a4c686ee43ace7450b3aa0e885c3"
       }
     }

data/support/mobile/ios/README.md

@@ -42,12 +42,19 @@ recommitting — never in a stamped copy.
 
 ## SPM pin policy
 
-The project depends on one package:
-`https://github.com/hotwired/hotwire-native-ios`, `upToNextMajorVersion` from
-`1.3.0`. The committed
-`App.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved` pins
-the exact 1.3.x version used for builds; regenerating it (a deliberate act) is
-how the pin moves.
+The project depends on one remote package: the fork
+`https://github.com/afomera/hotwire-native-ios`, pinned to an **exact revision**
+(`kind = revision` in the pbxproj `XCRemoteSwiftPackageReference` requirement).
+A revision pin resolves offline from an existing SPM clone; a branch pin makes
+every build re-check the remote, which is why the template does not use one.
+
+Moving the pin is a deliberate two-file edit, and both files must carry the
+same SHA:
+
+1. `App.xcodeproj/project.pbxproj` — the `requirement` dict (`kind = revision;`
+   / `revision = <40-char sha>;`)
+2. `App.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved` —
+   the pin's `state.revision` (no `branch` key)
 
 ## Building standalone
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_everywhere
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Andrea Fomera
@@ -65,6 +65,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: rqrcode
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: RubyEverywhere gives a Rails (or Sinatra, or Hanami) app a native life
   on desktop, iOS, and Android. Desktop is a Tauri shell — in local mode the whole
   app is pressed into a single-file binary with Tebako and runs on-device with no
@@ -116,6 +130,7 @@ files:
 - lib/everywhere/commands/platform/login.rb
 - lib/everywhere/commands/platform/logout.rb
 - lib/everywhere/commands/platform/runner.rb
+- lib/everywhere/commands/preview.rb
 - lib/everywhere/commands/publish.rb
 - lib/everywhere/commands/release.rb
 - lib/everywhere/commands/shell_dir.rb
@@ -134,6 +149,7 @@ files:
 - lib/everywhere/framework.rb
 - lib/everywhere/icon.rb
 - lib/everywhere/ignore.rb
+- lib/everywhere/jump.rb
 - lib/everywhere/line_pump.rb
 - lib/everywhere/log_filter.rb
 - lib/everywhere/minisign.rb