ruby_everywhere 0.1.15 → 0.3.0

data/support/mobile/ios/App/Bridge/MenuComponent.swift

@@ -0,0 +1,192 @@
+import Foundation
+import HotwireNative
+import UIKit
+import WebKit
+
+/// Bridge component backing `everywhere--menu`: the native chrome the page
+/// declares with `data-everywhere-nav-*` / `data-everywhere-menu` (the
+/// everywhere_nav_button / everywhere_nav_menu / everywhere_menu Rails helpers).
+///
+/// Two events, both replied to by echoing back the tapped item's id so the web
+/// half can `.click()` the element it mirrors — behavior stays defined once, in
+/// the page:
+///   * `navItems` — install left/right `UIBarButtonItem`s on THIS screen's
+///     navigation bar (plain buttons, and pull-down `UIMenu`s for overflow
+///     menus). Native re-replies to the same message on every tap.
+///   * `menu` — present a `UIAlertController` action sheet, replying once with
+///     the selection (or a cancel).
+///
+/// Installs onto `delegate?.destination` — the visitable view controller this
+/// component instance belongs to — so buttons land on the right screen and go
+/// away with it, exactly like the framework's own per-page bridge components.
+final class MenuComponent: BridgeComponent {
+    override nonisolated class var name: String { "everywhere--menu" }
+
+    override func onReceive(message: Message) {
+        switch message.event {
+        case "navItems":
+            handleNavItems(message: message)
+        case "menu":
+            handleMenu(message: message)
+        default:
+            break
+        }
+    }
+
+    // MARK: Private
+
+    private var viewController: UIViewController? {
+        delegate?.destination as? UIViewController
+    }
+
+    // MARK: Nav bar items
+
+    private func handleNavItems(message: Message) {
+        guard let viewController, let data: NavItemsData = message.data() else { return }
+
+        var left: [UIBarButtonItem] = []
+        var right: [UIBarButtonItem] = []
+        for item in data.items {
+            let barButton = barButtonItem(for: item)
+            if item.side == "left" { left.append(barButton) } else { right.append(barButton) }
+        }
+
+        // Right-side items read right-to-left in a nav bar; reverse so the page
+        // order ("Edit", "Share") lands left-to-right as authored.
+        viewController.navigationItem.leftBarButtonItems = left.isEmpty ? nil : left
+        viewController.navigationItem.rightBarButtonItems = right.isEmpty ? nil : right.reversed()
+    }
+
+    private func barButtonItem(for item: NavItem) -> UIBarButtonItem {
+        let image = item.image.flatMap { UIImage(systemName: $0) }
+
+        // A pull-down / overflow menu: children become a native UIMenu, each
+        // echoing its own id back on selection.
+        if let children = item.children, !children.isEmpty {
+            let actions = children.map { child in
+                UIAction(
+                    title: child.title,
+                    image: child.image.flatMap { UIImage(systemName: $0) },
+                    attributes: child.style == "destructive" ? .destructive : []
+                ) { [weak self] _ in
+                    self?.replyTap(id: child.id)
+                }
+            }
+            let menu = UIMenu(title: item.title.isEmpty ? "" : item.title, children: actions)
+            let barButton = UIBarButtonItem(
+                title: item.title.isEmpty ? nil : item.title,
+                image: image ?? UIImage(systemName: "ellipsis.circle"),
+                menu: menu
+            )
+            return barButton
+        }
+
+        // A plain button: echo its id back so the web half clicks the element.
+        let action = UIAction(title: item.title, image: image) { [weak self] _ in
+            self?.replyTap(id: item.id)
+        }
+        let barButton: UIBarButtonItem
+        if let image {
+            barButton = UIBarButtonItem(image: image, primaryAction: action)
+        } else {
+            barButton = UIBarButtonItem(title: item.title, primaryAction: action)
+        }
+        barButton.style = item.style == "done" ? .done : .plain
+        barButton.isEnabled = !(item.disabled ?? false)
+        return barButton
+    }
+
+    private func replyTap(id: String) {
+        reply(to: "navItems", with: NavReply(action: "tap", id: id))
+    }
+
+    // MARK: Action sheet
+
+    private func handleMenu(message: Message) {
+        guard let viewController, let data: MenuData = message.data() else { return }
+
+        let sheet = UIAlertController(title: data.title, message: data.message, preferredStyle: .actionSheet)
+        for item in data.items {
+            let style: UIAlertAction.Style = item.style == "destructive" ? .destructive : .default
+            let action = UIAlertAction(title: item.title, style: style) { [weak self] _ in
+                self?.reply(to: "menu", with: MenuReply(action: "select", id: item.id))
+            }
+            action.isEnabled = !(item.disabled ?? false)
+            sheet.addAction(action)
+        }
+        sheet.addAction(UIAlertAction(title: "Cancel", style: .cancel) { [weak self] _ in
+            self?.reply(to: "menu", with: MenuReply(action: "cancel", id: nil))
+        })
+
+        // iPad / iOS 26 present action sheets as popovers, which need an anchor.
+        // The web sends the trigger's rect in page coordinates; offset by the
+        // web view's top content inset (the nav bar) to reach view coordinates.
+        if let popover = sheet.popoverPresentationController {
+            popover.sourceView = viewController.view
+            if let source = data.source {
+                var y = source.y
+                if let visitable = viewController as? Visitable,
+                   let webView = visitable.visitableView.webView {
+                    y += Double(webView.scrollView.adjustedContentInset.top)
+                }
+                popover.sourceRect = CGRect(x: source.x, y: y, width: source.width, height: source.height)
+            } else {
+                popover.sourceRect = CGRect(x: viewController.view.bounds.midX,
+                                            y: viewController.view.bounds.midY, width: 0, height: 0)
+                popover.permittedArrowDirections = []
+            }
+        }
+
+        viewController.present(sheet, animated: true)
+    }
+}
+
+// MARK: - Message data
+
+private extension MenuComponent {
+    struct NavItemsData: Decodable {
+        let items: [NavItem]
+    }
+
+    struct NavItem: Decodable {
+        let id: String
+        let title: String
+        let image: String?
+        let side: String?
+        let style: String?
+        let disabled: Bool?
+        let children: [MenuItem]?
+    }
+
+    struct MenuData: Decodable {
+        let title: String?
+        let message: String?
+        let items: [MenuItem]
+        let source: Source?
+    }
+
+    struct MenuItem: Decodable {
+        let id: String
+        let title: String
+        let image: String?
+        let style: String?
+        let disabled: Bool?
+    }
+
+    struct Source: Decodable {
+        let x: Double
+        let y: Double
+        let width: Double
+        let height: Double
+    }
+
+    struct NavReply: Encodable {
+        let action: String
+        let id: String
+    }
+
+    struct MenuReply: Encodable {
+        let action: String
+        let id: String?
+    }
+}

data/support/mobile/ios/App/Bridge/NotificationComponent.swift

@@ -0,0 +1,56 @@
+import Foundation
+import HotwireNative
+import UserNotifications
+
+/// Bridge component backing the `everywhere--notification` web component.
+/// Handles `notify` events by requesting authorization (if needed) and
+/// delivering an immediate local notification, then replies `{delivered: Bool}`.
+final class NotificationComponent: BridgeComponent {
+    override nonisolated class var name: String { "everywhere--notification" }
+
+    override func onReceive(message: Message) {
+        guard message.event == "notify" else { return }
+        guard let data: NotifyMessage = message.data() else {
+            reply(to: "notify", with: NotifyReply(delivered: false))
+            return
+        }
+        deliver(data)
+    }
+
+    private func deliver(_ data: NotifyMessage) {
+        let center = UNUserNotificationCenter.current()
+        center.requestAuthorization(options: [.alert, .sound, .badge]) { [weak self] granted, _ in
+            guard granted else {
+                self?.replyOnMain(delivered: false)
+                return
+            }
+
+            let content = UNMutableNotificationContent()
+            content.title = data.title
+            if let body = data.body {
+                content.body = body
+            }
+            content.sound = .default
+
+            let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
+            center.add(request) { error in
+                self?.replyOnMain(delivered: error == nil)
+            }
+        }
+    }
+
+    private nonisolated func replyOnMain(delivered: Bool) {
+        Task { @MainActor in
+            self.reply(to: "notify", with: NotifyReply(delivered: delivered))
+        }
+    }
+
+    private struct NotifyMessage: Decodable {
+        let title: String
+        let body: String?
+    }
+
+    private struct NotifyReply: Encodable {
+        let delivered: Bool
+    }
+}

data/support/mobile/ios/App/Bridge/PermissionsComponent.swift

@@ -0,0 +1,142 @@
+import AVFoundation
+import CoreLocation
+import Foundation
+import HotwireNative
+import UIKit
+import UserNotifications
+
+/// Bridge component backing `everywhere--permissions`. Handles `query` and
+/// `request` for notifications / camera / location, replying
+/// `{name, status}` with granted | denied | prompt | undeclared | unsupported,
+/// and `openSettings` for the denied dead-end (iOS never re-prompts).
+///
+/// Camera and location must be declared in everywhere.yml — that's what stamps
+/// their Info.plist usage strings, and requesting without one crashes the app —
+/// so undeclared permissions short-circuit to `undeclared` before any system API.
+final class PermissionsComponent: BridgeComponent {
+    override nonisolated class var name: String { "everywhere--permissions" }
+
+    private lazy var location = LocationPermission()
+
+    override func onReceive(message: Message) {
+        switch message.event {
+        case "query", "request":
+            guard let data: Payload = message.data() else { return }
+            handle(message, permission: data.name)
+        case "openSettings":
+            if let url = URL(string: UIApplication.openSettingsURLString) {
+                UIApplication.shared.open(url)
+            }
+        default:
+            break
+        }
+    }
+
+    private func handle(_ message: Message, permission: String) {
+        // Notifications carry no usage string, so they can't crash undeclared.
+        guard permission == "notifications" || EverywhereConfig.shared.declaresPermission(permission) else {
+            return reply(message, permission, "undeclared")
+        }
+
+        let event = message.event
+        switch permission {
+        case "notifications":
+            notifications(event) { [weak self] status in self?.reply(message, permission, status) }
+        case "camera":
+            camera(event) { [weak self] status in self?.reply(message, permission, status) }
+        case "location":
+            location.resolve(event) { [weak self] status in self?.reply(message, permission, status) }
+        default:
+            reply(message, permission, "unsupported")
+        }
+    }
+
+    /// Replies on the exact message that asked. Concurrent messages for the
+    /// same event (every permission row queries on page load at once) make
+    /// `reply(to: event)` unusable — it targets only the last-received message.
+    private func reply(_ message: Message, _ name: String, _ status: String) {
+        Task { @MainActor in
+            self.reply(with: message.replacing(data: StatusReply(name: name, status: status)))
+        }
+    }
+
+    // MARK: Notifications
+
+    private func notifications(_ event: String, completion: @escaping (String) -> Void) {
+        let center = UNUserNotificationCenter.current()
+        center.getNotificationSettings { settings in
+            switch settings.authorizationStatus {
+            case .authorized, .ephemeral:
+                completion("granted")
+            case .denied:
+                completion("denied")
+            default:
+                // .provisional (acquired silently, e.g. for badges) still
+                // counts as promptable — the user has never been asked, and
+                // a full request from it shows the real dialog.
+                guard event == "request" else { return completion("prompt") }
+                center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, _ in
+                    completion(granted ? "granted" : "denied")
+                }
+            }
+        }
+    }
+
+    // MARK: Camera
+
+    private func camera(_ event: String, completion: @escaping (String) -> Void) {
+        switch AVCaptureDevice.authorizationStatus(for: .video) {
+        case .authorized:
+            completion("granted")
+        case .denied, .restricted:
+            completion("denied")
+        default:
+            guard event == "request" else { return completion("prompt") }
+            AVCaptureDevice.requestAccess(for: .video) { granted in
+                completion(granted ? "granted" : "denied")
+            }
+        }
+    }
+
+    private struct Payload: Decodable {
+        let name: String
+    }
+
+    private struct StatusReply: Encodable {
+        let name: String
+        let status: String
+    }
+}
+
+/// When-in-use location authorization. The prompt answers through the
+/// manager's delegate, so the pending completion is held until
+/// `locationManagerDidChangeAuthorization` reports a decision.
+private final class LocationPermission: NSObject, CLLocationManagerDelegate {
+    private lazy var manager = CLLocationManager()
+    private var pending: ((String) -> Void)?
+
+    func resolve(_ event: String, completion: @escaping (String) -> Void) {
+        guard manager.authorizationStatus == .notDetermined else {
+            return completion(describe(manager.authorizationStatus))
+        }
+        guard event == "request" else { return completion("prompt") }
+
+        pending = completion
+        manager.delegate = self
+        manager.requestWhenInUseAuthorization()
+    }
+
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        guard manager.authorizationStatus != .notDetermined, let pending else { return }
+        self.pending = nil
+        pending(describe(manager.authorizationStatus))
+    }
+
+    private func describe(_ status: CLAuthorizationStatus) -> String {
+        switch status {
+        case .authorizedWhenInUse, .authorizedAlways: "granted"
+        case .denied, .restricted: "denied"
+        default: "prompt"
+        }
+    }
+}

data/support/mobile/ios/App/Bridge/StorageComponent.swift

@@ -0,0 +1,63 @@
+import Foundation
+import HotwireNative
+
+/// Bridge component backing `everywhere--storage`: device-local key/value
+/// settings persisted in UserDefaults for `Everywhere.storage.*`. Values ride
+/// the wire as JSON-encoded strings (the JS side owns encoding/decoding), so
+/// any JSON value round-trips without a typed schema here.
+///
+/// Keys are namespaced under "everywhere.app." so page data can never collide
+/// with the shell's own defaults (dev URL, instance override). Settings, not
+/// secrets: server tokens belong in the keychain via biometrics.credential.
+final class StorageComponent: BridgeComponent {
+    override nonisolated class var name: String { "everywhere--storage" }
+
+    private static let prefix = "everywhere.app."
+
+    override func onReceive(message: Message) {
+        let data: Payload? = message.data()
+        let defaults = UserDefaults.standard
+
+        switch message.event {
+        case "get":
+            guard let key = namespaced(data) else { return reply(message, Reply(ok: false)) }
+            reply(message, Reply(ok: true, value: defaults.string(forKey: key)))
+        case "set":
+            guard let key = namespaced(data), let value = data?.value else {
+                return reply(message, Reply(ok: false))
+            }
+            defaults.set(value, forKey: key)
+            reply(message, Reply(ok: true))
+        case "remove":
+            guard let key = namespaced(data) else { return reply(message, Reply(ok: false)) }
+            defaults.removeObject(forKey: key)
+            reply(message, Reply(ok: true))
+        case "clear":
+            for key in defaults.dictionaryRepresentation().keys where key.hasPrefix(Self.prefix) {
+                defaults.removeObject(forKey: key)
+            }
+            reply(message, Reply(ok: true))
+        default:
+            break
+        }
+    }
+
+    private func namespaced(_ data: Payload?) -> String? {
+        guard let key = data?.key, !key.isEmpty else { return nil }
+        return Self.prefix + key
+    }
+
+    private func reply(_ message: Message, _ payload: Reply) {
+        reply(with: message.replacing(data: payload))
+    }
+
+    private struct Payload: Decodable {
+        let key: String?
+        let value: String?
+    }
+
+    private struct Reply: Encodable {
+        let ok: Bool
+        var value: String? = nil
+    }
+}

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

@@ -0,0 +1,64 @@
+import UIKit
+
+/// A full-screen error page with a retry button, presented when a visit fails
+/// (e.g. the server is unreachable).
+final class ErrorViewController: UIViewController {
+    private let error: Error
+    private let retryHandler: (() -> Void)?
+
+    init(error: Error, retryHandler: (() -> Void)?) {
+        self.error = error
+        self.retryHandler = retryHandler
+        super.init(nibName: nil, bundle: nil)
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .systemBackground
+
+        let imageView = UIImageView(image: UIImage(systemName: "wifi.exclamationmark"))
+        imageView.preferredSymbolConfiguration = UIImage.SymbolConfiguration(pointSize: 48, weight: .medium)
+        imageView.tintColor = .secondaryLabel
+        imageView.contentMode = .scaleAspectFit
+
+        let messageLabel = UILabel()
+        messageLabel.text = error.localizedDescription
+        messageLabel.font = .preferredFont(forTextStyle: .body)
+        messageLabel.textColor = .secondaryLabel
+        messageLabel.textAlignment = .center
+        messageLabel.numberOfLines = 0
+
+        var buttonConfiguration = UIButton.Configuration.filled()
+        buttonConfiguration.title = "Retry"
+        buttonConfiguration.buttonSize = .large
+        let retryButton = UIButton(configuration: buttonConfiguration, primaryAction: UIAction { [weak self] _ in
+            self?.retry()
+        })
+        retryButton.isHidden = retryHandler == nil
+
+        let stackView = UIStackView(arrangedSubviews: [imageView, messageLabel, retryButton])
+        stackView.axis = .vertical
+        stackView.alignment = .center
+        stackView.spacing = 16
+        stackView.setCustomSpacing(24, after: messageLabel)
+        stackView.translatesAutoresizingMaskIntoConstraints = false
+
+        view.addSubview(stackView)
+        NSLayoutConstraint.activate([
+            stackView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
+            stackView.centerYAnchor.constraint(equalTo: view.centerYAnchor),
+            stackView.leadingAnchor.constraint(greaterThanOrEqualTo: view.layoutMarginsGuide.leadingAnchor),
+            stackView.trailingAnchor.constraint(lessThanOrEqualTo: view.layoutMarginsGuide.trailingAnchor)
+        ])
+    }
+
+    private func retry() {
+        retryHandler?()
+        dismiss(animated: true)
+    }
+}