ruby_everywhere 0.1.15 → 0.2.0

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

@@ -0,0 +1,268 @@
+import Foundation
+import HotwireNative
+import UIKit
+
+/// A color that adapts to light/dark mode. Decodes either a single hex string
+/// (used for both appearances) or a `{"light": "#RRGGBB", "dark": "#RRGGBB"}` object.
+struct ThemedColor: Decodable {
+    let light: String
+    let dark: String?
+
+    init(from decoder: Decoder) throws {
+        if let container = try? decoder.singleValueContainer(), let hex = try? container.decode(String.self) {
+            light = hex
+            dark = nil
+            return
+        }
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        light = try container.decode(String.self, forKey: .light)
+        dark = try container.decodeIfPresent(String.self, forKey: .dark)
+    }
+
+    private enum CodingKeys: String, CodingKey {
+        case light, dark
+    }
+
+    var uiColor: UIColor {
+        let lightColor = UIColor(hex: light) ?? .tintColor
+        guard let dark, let darkColor = UIColor(hex: dark) else { return lightColor }
+        return UIColor { traits in
+            traits.userInterfaceStyle == .dark ? darkColor : lightColor
+        }
+    }
+}
+
+/// The app's configuration, stamped into the bundle as `everywhere.json` by
+/// `every build`. The raw template ships a placeholder pointing at rubyeverywhere.com.
+struct EverywhereConfig: Decodable {
+    let name: String
+    let version: String?
+    let mode: String?
+    let remoteUrl: String?
+    let remoteInstances: Bool?
+    let entryPath: String?
+    let tintColor: ThemedColor?
+    let backgroundColor: ThemedColor?
+    let permissions: [String]?
+    let splashMinSeconds: Double?
+    let lazyLoadTabs: Bool?
+
+    private enum CodingKeys: String, CodingKey {
+        case name
+        case version
+        case mode
+        case remoteUrl = "remote_url"
+        case remoteInstances = "remote_instances"
+        case entryPath = "entry_path"
+        case tintColor = "tint_color"
+        case backgroundColor = "background_color"
+        case permissions
+        case splashMinSeconds = "splash_min_seconds"
+        case lazyLoadTabs = "lazy_load_tabs"
+    }
+
+    /// Whether the tab bar defers each non-selected tab's initial visit until
+    /// it is first selected (everywhere.yml `lazy_load_tabs`). Absent in the
+    /// stamped config means the app didn't set it, so we match Hotwire Native's
+    /// own default: load every tab eagerly.
+    var lazyLoadsTabs: Bool {
+        lazyLoadTabs ?? false
+    }
+
+    /// Minimum on-screen time for an app-provided splash
+    /// (everywhere.yml native.ios.splash_min_seconds).
+    var splashMinimumDisplay: TimeInterval {
+        splashMinSeconds ?? 1.0
+    }
+
+    /// Whether everywhere.yml declares this permission. Undeclared camera and
+    /// location must never reach the system APIs — their Info.plist usage
+    /// strings are only stamped for declared permissions, and requesting
+    /// without one crashes the app.
+    func declaresPermission(_ name: String) -> Bool {
+        permissions?.contains(name) ?? false
+    }
+
+    static let shared: EverywhereConfig = {
+        guard let url = Bundle.main.url(forResource: "everywhere", withExtension: "json"),
+              let data = try? Data(contentsOf: url)
+        else {
+            fatalError("everywhere.json is missing from the app bundle — stamp this shell with `every build` before running it.")
+        }
+        do {
+            return try JSONDecoder().decode(EverywhereConfig.self, from: data)
+        } catch {
+            fatalError("everywhere.json in the app bundle is invalid (\(error)) — re-stamp this shell with `every build`.")
+        }
+    }()
+
+    /// The dev-server override, resolved once. `EVERYWHERE_DEV_URL` arrives
+    /// via `simctl launch` — but ONLY then. Relaunching from the home screen
+    /// (or after iOS force-kills the app for a Settings permission change)
+    /// has no env, which would silently fall back to the production
+    /// remote.url. Debug builds persist the last dev URL to survive those
+    /// 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 DEBUG
+            UserDefaults.standard.set(dev, forKey: key)
+            #endif
+            return url
+        }
+        #if DEBUG
+        if let saved = UserDefaults.standard.string(forKey: key), let url = URL(string: saved) {
+            return url
+        }
+        #endif
+        return nil
+    }()
+
+    // MARK: Instance override (multi-instance apps)
+
+    /// UserDefaults key holding the user-chosen instance root. Multi-instance
+    /// apps (`remote.instances: true`) boot into remote.url — the hosted
+    /// instance picker — until the picker calls `Everywhere.instance.set`;
+    /// from then on every launch boots the chosen instance, until cleared.
+    private static let instanceKey = "EverywhereInstanceURL"
+
+    /// The persisted instance override. Read per-access, never cached:
+    /// setInstance changes it mid-run and everything derived from rootURL
+    /// (start URL, path-configuration URL) must follow immediately.
+    static var instanceURL: URL? {
+        guard shared.remoteInstances == true else { return nil }
+        return UserDefaults.standard.string(forKey: instanceKey).flatMap { URL(string: $0) }
+    }
+
+    /// Persist (nil clears) the instance override. Only absolute http(s)
+    /// roots are accepted — the page posts arbitrary strings at the control
+    /// channel, and re-rooting the whole app is the one place that must not
+    /// take them on faith. (http stays allowed for LAN-hosted instances.)
+    @discardableResult
+    static func setInstanceURL(_ url: URL?) -> Bool {
+        guard let url else {
+            UserDefaults.standard.removeObject(forKey: instanceKey)
+            return true
+        }
+        guard let scheme = url.scheme?.lowercased(), ["https", "http"].contains(scheme),
+              url.host != nil
+        else { return false }
+        UserDefaults.standard.set(url.absoluteString, forKey: instanceKey)
+        return true
+    }
+
+    /// The root URL of the deployed app. A picked instance outranks the dev
+    /// override on purpose: it's the more recent, in-app expression of intent,
+    /// and dev-testing the picker flow only works if picking takes effect.
+    /// `Everywhere.instance.clear()` falls back to the dev/stamped root.
+    var rootURL: URL {
+        if let instance = Self.instanceURL {
+            return instance
+        }
+        if let dev = Self.devOverrideURL {
+            return dev
+        }
+        guard let remoteUrl, let url = URL(string: remoteUrl) else {
+            fatalError("remote.url not set in everywhere.yml — iOS shell is remote-mode only")
+        }
+        return url
+    }
+
+    /// The first location the navigator visits: rootURL joined with entry_path.
+    var startURL: URL {
+        guard let entryPath, !entryPath.isEmpty, entryPath != "/" else { return rootURL }
+        return url(forPath: entryPath)
+    }
+
+    /// The server half of the path configuration (rules + settings.tabs),
+    /// generated from everywhere.yml by the gem's MobileConfigEndpoint — so
+    /// tab changes deploy with the web app, no app-store release.
+    var pathConfigurationURL: URL {
+        url(forPath: "/everywhere/ios_v1.json")
+    }
+
+    /// The path-configuration sources. At launch we want both: the bundled
+    /// copy loads synchronously (instant tabs, works offline) and the live
+    /// server copy refines it. After launch — foregrounds and resets — we use
+    /// the server copy ONLY: it's the auth-aware source of truth, and skipping
+    /// the bundled copy avoids a flash of the baked (all-tabs) config before
+    /// the server's answer lands.
+    static func pathConfigurationSources(serverOnly: Bool = false) -> [PathConfiguration.Source] {
+        let server = PathConfiguration.Source.server(shared.pathConfigurationURL)
+        guard !serverOnly else { return [server] }
+
+        return [
+            .file(Bundle.main.url(forResource: "path-configuration", withExtension: "json")!),
+            server
+        ]
+    }
+
+    /// rootURL joined with an absolute-style path (leading `/` optional).
+    func url(forPath path: String) -> URL {
+        let root = rootURL
+        guard var components = URLComponents(url: root, resolvingAgainstBaseURL: false) else { return root }
+        let basePath = components.path.hasSuffix("/") ? String(components.path.dropLast()) : components.path
+        let suffix = path.hasPrefix("/") ? path : "/" + path
+        components.path = basePath + suffix
+        return components.url ?? root
+    }
+
+    var userAgentPrefix: String {
+        if let version {
+            return "RubyEverywhere/\(version) (ios)"
+        }
+        return "RubyEverywhere (ios)"
+    }
+
+    /// User-Agent for native URLSession requests (everywhereURLSession): the
+    /// shell prefix plus the Hotwire Native marker, so the gem's
+    /// native_app?/native_platform/native_version helpers see native-screen
+    /// requests exactly like web-view requests.
+    var nativeUserAgent: String {
+        "\(userAgentPrefix) Hotwire Native iOS"
+    }
+
+    var tint: UIColor? { tintColor?.uiColor }
+    var background: UIColor? { backgroundColor?.uiColor }
+
+    /// A compact JSON object injected into every page as `window.__EVERYWHERE_CONFIG__`.
+    /// Built per web view (not once at launch): `instance` must reflect the
+    /// override as it stands when the post-reset web views are created.
+    var webConfigJSON: String {
+        var payload: [String: Any] = ["name": name, "os": "ios"]
+        if let version { payload["version"] = version }
+        if remoteInstances == true {
+            payload["instances"] = true
+            if let instance = Self.instanceURL { payload["instance"] = instance.absoluteString }
+        }
+        guard let data = try? JSONSerialization.data(withJSONObject: payload, options: [.sortedKeys]),
+              let json = String(data: data, encoding: .utf8)
+        else {
+            return #"{"os":"ios"}"#
+        }
+        return json
+    }
+}
+
+extension UIColor {
+    /// Accepts `#RRGGBB` and `#RRGGBBAA` (leading `#` optional).
+    convenience init?(hex: String) {
+        var value = hex.trimmingCharacters(in: .whitespacesAndNewlines)
+        if value.hasPrefix("#") { value.removeFirst() }
+        guard value.count == 6 || value.count == 8, let bits = UInt64(value, radix: 16) else { return nil }
+
+        let red, green, blue, alpha: CGFloat
+        if value.count == 8 {
+            red = CGFloat((bits >> 24) & 0xFF) / 255.0
+            green = CGFloat((bits >> 16) & 0xFF) / 255.0
+            blue = CGFloat((bits >> 8) & 0xFF) / 255.0
+            alpha = CGFloat(bits & 0xFF) / 255.0
+        } else {
+            red = CGFloat((bits >> 16) & 0xFF) / 255.0
+            green = CGFloat((bits >> 8) & 0xFF) / 255.0
+            blue = CGFloat(bits & 0xFF) / 255.0
+            alpha = 1.0
+        }
+        self.init(red: red, green: green, blue: blue, alpha: alpha)
+    }
+}

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

@@ -0,0 +1,34 @@
+import SwiftUI
+import UIKit
+
+/// Called by the generated EverywhereExtensions registry around screen and
+/// splash declarations: UIViewController subclasses pass through untouched,
+/// SwiftUI views get wrapped in a hosting controller — the overload resolves
+/// per declared type at compile time, so everywhere.yml can name either kind.
+func everywhereHost(_ controller: UIViewController) -> UIViewController {
+    controller
+}
+
+func everywhereHost(_ view: some View) -> UIViewController {
+    UIHostingController(rootView: view)
+}
+
+/// URLSession for native extension code talking to the app's own server.
+/// Cookies come from HTTPCookieStorage.shared — which the shell mirrors from
+/// the web views, so requests ride the signed-in session — and every request
+/// carries the app's native User-Agent, so server-side native_app? /
+/// native_platform checks hold. Prefer this over URLSession.shared.
+let everywhereURLSession: URLSession = {
+    let configuration = URLSessionConfiguration.default
+    configuration.httpAdditionalHeaders = ["User-Agent": EverywhereConfig.shared.nativeUserAgent]
+    return URLSession(configuration: configuration)
+}()
+
+/// Route the app to a path (or absolute URL) from native extension code — the
+/// native counterpart of `Everywhere.visit()`. Relative paths resolve against
+/// the effective root (dev override / picked instance included); web routes
+/// load in the web view, native-screen routes push their screen.
+func everywhereVisit(_ path: String) {
+    NotificationCenter.default.post(name: .everywhereNativeVisit, object: nil,
+                                    userInfo: ["path": path])
+}

data/support/mobile/ios/App/Extensions/EverywhereExtensions.swift

@@ -0,0 +1,32 @@
+import HotwireNative
+import UIKit
+
+// The app-extension registry. This checked-in copy is the empty default so
+// the raw template builds unchanged; `every build` overwrites it — and drops
+// the app repo's native/ios/*.swift beside it — when config/everywhere.yml
+// declares native code:
+//
+//   native:
+//     ios:
+//       components: [ChartComponent]   # BridgeComponent subclasses to register
+//       screens:                       # path rules with view_controller: <id>
+//         map: MapScreen               #   SwiftUI View or UIViewController, init(url:)
+//       splash: LaunchSplash           # SwiftUI View or UIViewController, init()
+//
+// Extensions/ is a filesystem-synchronized (buildable) folder: files landing
+// here compile without the pbxproj ever being touched.
+enum EverywhereExtensions {
+    /// Extra bridge components, registered alongside the built-ins.
+    static let components: [BridgeComponent.Type] = []
+
+    /// The native screen for a path-configuration rule's `view_controller`
+    /// identifier; nil falls through to the standard web visit.
+    static func screen(for identifier: String, url: URL) -> UIViewController? {
+        nil
+    }
+
+    /// Replaces the splash overlay's default spinner when non-nil.
+    static func splashViewController() -> UIViewController? {
+        nil
+    }
+}

data/support/mobile/ios/App/Info.plist

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<key>NSAllowsLocalNetworking</key>
+		<true/>
+	</dict>
+	<key>UIApplicationSceneManifest</key>
+	<dict>
+		<key>UIApplicationSupportsMultipleScenes</key>
+		<false/>
+		<key>UISceneConfigurations</key>
+		<dict>
+			<key>UIWindowSceneSessionRoleApplication</key>
+			<array>
+				<dict>
+					<key>UISceneConfigurationName</key>
+					<string>Default</string>
+					<key>UISceneDelegateClassName</key>
+					<string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
+				</dict>
+			</array>
+		</dict>
+	</dict>
+</dict>
+</plist>

data/support/mobile/ios/App/Resources/everywhere.json

@@ -0,0 +1,8 @@
+{
+  "name": "RubyEverywhere",
+  "bundle_id": "com.rubyeverywhere.app",
+  "version": "0.1.0",
+  "mode": "remote",
+  "remote_url": "https://rubyeverywhere.com",
+  "entry_path": "/"
+}

data/support/mobile/ios/App/Resources/path-configuration.json

@@ -0,0 +1,19 @@
+{
+  "settings": {},
+  "rules": [
+    {
+      "patterns": [".*"],
+      "properties": {
+        "context": "default",
+        "pull_to_refresh_enabled": true
+      }
+    },
+    {
+      "patterns": ["/new$", "/edit$"],
+      "properties": {
+        "context": "modal",
+        "pull_to_refresh_enabled": false
+      }
+    }
+  ]
+}