ruby_everywhere 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6445e84081e08a1d5c545054c0a7dc6ef2e4b05338aff54ea68dc4c48d6b6c60
-  data.tar.gz: 2a057925b0ee3266c294046b0be24cb1c0d3fa4b8a82e179b88425cd6afa7e91
+  metadata.gz: 19d066bb2584933621929b270c69e6205804d07441a6e4a8bfcc052cc6483e55
+  data.tar.gz: c337dfa569b91412f4cb03027006d3199c9f224ebe63e5c5a066396986729194
 SHA512:
-  metadata.gz: 1e8528cf2ac3b62191795709e23ee708d1c706672b8fc5d5f2beec6c3455d1a092b71498a086d67506e9c8175efcad1ad2f5c22df0b5d7dbe0f130a3aba8600e
-  data.tar.gz: ff1a73eeaabf7d7b839b092b3482c4a06511a6793133b6133f9671ad17d883092877b608fa8db04c9709a419d38c73f905e44dca32d952c992121a18c9e05aa1
+  metadata.gz: b0865c4cc65cfdc86706332f2d00c704fcd361ffe72ed6bbc51100297640634d246a3537b2f4ed38318fbacacbbd490ff422e4b6449905d06918ce7663dbc2f5
+  data.tar.gz: 119672c4cf55ea3ea05e768c3eba161ee2aa6b81b6f5f68046c6327bc99f2dcd9897658d7320e0a0d7a58cbc64d8ac457a2522d6cd71434f1df8ef974367a783

data/lib/everywhere/commands/build.rb

@@ -29,20 +29,23 @@ module Everywhere
       option :ruby,       default: "4.0.6",          desc: "Ruby version to package"
       option :entry,      default: "native_boot.rb", desc: "Entry point script relative to root"
       option :app_name,   default: nil,              desc: "Bundle name (default: capitalized app dir)"
+      option :target,     default: "macos-arm64",    desc: "Build target (os-arch) — selects any platforms: overrides"
       option :shell_dir,  default: nil,              desc: "Path to the shell's src-tauri directory"
       option :skip_press, type: :boolean, default: false, desc: "Reuse the existing pressed binary, only rebuild the .app"
 
       def call(root: ".", output: nil, ruby: "4.0.6", entry: "native_boot.rb",
-               app_name: nil, shell_dir: nil, skip_press: false, **)
+               app_name: nil, target: "macos-arm64", shell_dir: nil, skip_press: false, **)
         root_path = File.expand_path(root)
         config = Everywhere::Config.load(root_path)
-        app_name ||= config.name
+        # The os of `target` selects any per-platform overrides (bundle id,
+        # version, name) — local builds always target the host, macOS today.
+        app_name ||= config.name(target: target)
 
         # Remote mode: thin shell around an already-deployed app. No Rails app
         # required locally, nothing to press — just shell + config in a bundle.
         if config.remote?
           UI.step("#{UI.bold("remote")} mode → #{UI.cyan(config.remote_url)} #{UI.dim("(no local server packaged)")}")
-          app_dir = bundle_app(nil, app_name, shell_dir, config, dist_dir: File.expand_path("dist", root_path))
+          app_dir = bundle_app(nil, app_name, shell_dir, config, target: target, dist_dir: File.expand_path("dist", root_path))
           return
         end
 
@@ -64,7 +67,7 @@ module Everywhere
           press!(framework, entry, ruby, output_path)
         end
 
-        bundle_app(output_path, app_name, shell_dir, config) if RUBY_PLATFORM.include?("darwin")
+        bundle_app(output_path, app_name, shell_dir, config, target: target) if RUBY_PLATFORM.include?("darwin")
 
         UI.success("built #{output} (#{(File.size(output_path) / 1024.0 / 1024.0).round}MB)")
       end
@@ -112,7 +115,7 @@ module Everywhere
       # Assemble dist/<App Name>.app: the release shell binary + the pressed
       # Rails binary (as "app-server") + Info.plist + icon. An .app bundle is
       # just a directory layout, so we build it by hand — no tauri-cli needed.
-      def bundle_app(server_binary, app_name, shell_dir, config, dist_dir: nil)
+      def bundle_app(server_binary, app_name, shell_dir, config, target: "macos-arm64", dist_dir: nil)
         shell_dir ||= Everywhere::Paths.shell_dir!
         dist_dir ||= File.dirname(server_binary)
 
@@ -188,7 +191,7 @@ module Everywhere
         FileUtils.cp(shell_bin, File.join(macos, exe_name))
         FileUtils.cp(server_binary, File.join(macos, "app-server")) if server_binary
 
-        File.write(File.join(resources, "everywhere.json"), config.to_shell_json)
+        File.write(File.join(resources, "everywhere.json"), config.to_shell_json(target: target))
         if (splash = config.splash)
           if File.exist?(splash)
             FileUtils.cp(splash, File.join(resources, "splash.html"))
@@ -199,7 +202,7 @@ module Everywhere
         end
         icns = make_icns(macos_icon || File.join(shell_dir, "icons", "icon.png"), resources)
         File.write(File.join(app_dir, "Contents", "Info.plist"),
-                   info_plist(app_name, exe_name, icns, config.bundle_id, config.version))
+                   info_plist(app_name, exe_name, icns, config.bundle_id(target: target), config.version(target: target)))
 
         UI.step("signing #{File.basename(app_dir)}")
         Shellout.run!({}, "codesign", "-s", "-", "-f", File.join(macos, "app-server")) if server_binary

data/lib/everywhere/commands/install.rb

@@ -102,17 +102,26 @@ module Everywhere
         return change("create config/everywhere.yml", false) if File.exist?(config)
 
         app_name = File.basename(@root).split(/[-_]/).map(&:capitalize).join(" ")
+        slug = app_name.downcase.gsub(/[^a-z0-9]+/, "-")
         File.write(config, <<~YAML)
-          # RubyEverywhere app configuration — https://rubyeverywhere.com
+          # RubyEverywhere app configuration.
+          # Full reference: https://rubyeverywhere.com/docs/shared/everywhere-yml
           app:
             name: #{app_name}
             # Reverse-DNS app identifier: names the app-data directory on every
             # platform (and the macOS bundle id). Set once, never change it.
-            bundle_id: com.example.#{app_name.downcase.gsub(/[^a-z0-9]+/, "-")}
+            bundle_id: com.example.#{slug}
+            version: "0.1.0"       # marketing version (CFBundleShortVersionString)
+            mode: local            # "local" (compile & ship the app) or "remote" (native shell around a deployed site)
             entry_path: /          # initial url on app launch
             # icon: icon.png       # PNG used to generate app icons (defaults to icon.png at the app root if present)
             # splash: splash.html  # custom boot splash (HTML); window.__EVERYWHERE_CONFIG__ carries name/colors
 
+          # Remote mode only — the deployed URL the native shell opens.
+          # Set mode: remote above, then uncomment:
+          # remote:
+          #   url: https://example.com
+
           appearance:
             # Colors take a hex string, or split by system theme:
             #   tint_color:
@@ -122,6 +131,42 @@ module Everywhere
             background_color:
               light: "#FFFFFF"
               dark: "#1C1B1A"
+
+          # Native menu-bar items — each one visits a route in your app (no native code).
+          # menu:
+          #   - label: Settings…
+          #     path: /settings
+          #     accelerator: CmdOrCtrl+,
+          #   - separator
+          #   - label: Documentation
+          #     path: /help
+
+          # System tray / menu-bar-extra items — same shape as menu, plus action: show | quit.
+          # tray:
+          #   - label: Open #{app_name}
+          #     action: show
+          #   - label: New…
+          #     path: /new
+          #   - separator
+          #   - label: Quit
+          #     action: quit
+
+          # Durable build knobs (CLI flags still override per-run).
+          # build:
+          #   ruby: "4.0.6"
+          #   targets:               # the platforms you ship — the CI matrix, expressed once
+          #     - macos-arm64
+          #     # - ios-arm64         # future — mobile is remote mode only
+          #     # - android-arm64     # future — mobile is remote mode only
+          #   permissions: [notifications, filesystem:read, clipboard]
+
+          # Per-platform overrides. Keys are platform names (macos / ios / android /
+          # windows / linux); anything here overrides the app: defaults above for that
+          # platform — handy when a store needs a distinct bundle id or version.
+          # platforms:
+          #   ios:
+          #     bundle_id: com.example.#{slug}.ios
+          #     version: "0.1.1"
         YAML
         change("create config/everywhere.yml", true)
       end

data/lib/everywhere/commands/release.rb

@@ -37,7 +37,7 @@ module Everywhere
                app_name: nil, shell_dir: nil, env_file: nil, skip_build: false, **)
         root_path = File.expand_path(root)
         config = Everywhere::Config.load(root_path)
-        app_name ||= config.name
+        app_name ||= config.name(target: target)
         ruby ||= config.build_ruby || "4.0.6"
 
         preflight!(target)
@@ -49,7 +49,7 @@ module Everywhere
         #    notarize step below re-signs it inside-out with the Developer ID.
         unless skip_build
           UI.step("building #{UI.bold(app_name)} for #{UI.cyan(target)}")
-          Build.new.call(root: root, ruby: ruby, entry: entry, app_name: app_name, shell_dir: shell_dir, **)
+          Build.new.call(root: root, ruby: ruby, entry: entry, app_name: app_name, target: target, shell_dir: shell_dir, **)
         end
 
         app_dir = Dir[File.join(dist_dir, "*.app")].max_by { |d| File.mtime(d) }

data/lib/everywhere/config.rb

@@ -31,15 +31,23 @@ module Everywhere
       @root = root
     end
 
-    def name
-      app["name"] || File.basename(File.expand_path(root)).split(/[-_]/).map(&:capitalize).join(" ")
+    # Every target (os-arch string) resolves to a single platform (its os), and
+    # a platform may override the app-level identity/version keys — see
+    # `platforms:` below. Pass `target:` to any of these accessors to apply the
+    # matching override; omit it for the shared app-level value.
+    def self.os_of(target) = target.to_s.split("-", 2).first
+
+    def name(target: nil)
+      resolved(target)["name"] || File.basename(File.expand_path(root)).split(/[-_]/).map(&:capitalize).join(" ")
     end
 
     # Reverse-DNS identifier: macOS bundle id, and the name of the per-user
     # app-data directory on every platform. Set it explicitly and never change
-    # it — renaming moves users' data.
-    def bundle_id
-      app["bundle_id"] || "com.rubyeverywhere.#{name.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-|-\z/, "")}"
+    # it — renaming moves users' data. A platform may override it (e.g. the App
+    # Store often wants `com.example.app.ios`).
+    def bundle_id(target: nil)
+      resolved(target)["bundle_id"] ||
+        "com.rubyeverywhere.#{name(target: target).downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-|-\z/, "")}"
     end
 
     # App icon source: a PNG (ideally square, 1024px+). Explicit `app.icon`
@@ -67,9 +75,11 @@ module Everywhere
     end
 
     # Marketing/display version of the app (CFBundleShortVersionString, and the
-    # `version` recorded in the build receipt). Defaults conservatively.
-    def version
-      app["version"] || "0.1.0"
+    # `version` recorded in the build receipt). One shared `app.version` is the
+    # default for every target; a platform may override it when a store forces a
+    # different number. Defaults conservatively.
+    def version(target: nil)
+      resolved(target)["version"] || "0.1.0"
     end
 
     # The `build:` section — durable build knobs that were once `every build`
@@ -149,11 +159,13 @@ module Everywhere
     end
 
     # The subset the shell needs, shipped as JSON (env var in dev,
-    # Resources/everywhere.json inside a bundled .app).
-    def to_shell_hash
+    # Resources/everywhere.json inside a bundled .app). Pass `target:` so the
+    # packaged config reflects the platform being built (its bundle id / name).
+    def to_shell_hash(target: nil)
       {
-        "name" => name,
-        "bundle_id" => bundle_id,
+        "name" => name(target: target),
+        "bundle_id" => bundle_id(target: target),
+        "version" => version(target: target),
         "mode" => mode,
         "remote_url" => remote_url,
         "entry_path" => entry_path,
@@ -164,9 +176,9 @@ module Everywhere
       }.compact
     end
 
-    def to_shell_json
+    def to_shell_json(target: nil)
       require "json"
-      JSON.generate(to_shell_hash)
+      JSON.generate(to_shell_hash(target: target))
     end
 
     private
@@ -174,6 +186,19 @@ module Everywhere
     def app = @data.fetch("app", nil) || {}
     def appearance = @data.fetch("appearance", nil) || {}
 
+    # Per-platform overrides, keyed by os (macos / ios / android / windows /
+    # linux). Each value overrides the matching `app:` keys for that platform.
+    def platforms = @data.fetch("platforms", nil) || {}
+
+    # The app-level keys with the target's platform override merged on top.
+    # Blank override values are dropped (`.compact`) so they don't erase a
+    # default. Without a target — or without an override for that os — this is
+    # just the plain `app:` hash.
+    def resolved(target)
+      override = target && platforms[self.class.os_of(target)]
+      override.is_a?(Hash) ? app.merge(override.compact) : app
+    end
+
     def normalize_color(value)
       case value
       when String

data/lib/everywhere/receipt.rb

@@ -27,6 +27,7 @@ module Everywhere
       @config = config
       @framework = framework
       @ruby = ruby
+      @target_str = target                     # raw "os-arch" — selects platforms: overrides
       @target = parse_target(target, channel)
       @shell_dir = shell_dir
     end
@@ -35,9 +36,9 @@ module Everywhere
     def manifest
       {
         "app" => {
-          "name" => @config.name,
-          "bundle_id" => @config.bundle_id,
-          "version" => @config.version
+          "name" => @config.name(target: @target_str),
+          "bundle_id" => @config.bundle_id(target: @target_str),
+          "version" => @config.version(target: @target_str)
         },
         "framework" => framework_info,
         "ruby" => @ruby,

data/lib/everywhere/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 
   # Version of the vendored @rubyeverywhere/bridge JS this gem ships. Tracks
   # bridge/package.json — bump it whenever lib/everywhere/javascript/bridge.js is

data/support/shell/src-tauri/Cargo.lock

@@ -993,6 +993,9 @@ dependencies = [
 name = "example-shell"
 version = "0.1.0"
 dependencies = [
+ "objc2",
+ "objc2-foundation",
+ "objc2-web-kit",
  "serde_json",
  "tauri",
  "tauri-build",
@@ -2366,6 +2369,16 @@ dependencies = [
  "objc2-core-foundation",
 ]
 
+[[package]]
+name = "objc2-javascript-core"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a1e6550c4caed348956ce3370c9ffeca70bb1dbed4fa96112e7c6170e074586"
+dependencies = [
+ "objc2",
+ "objc2-core-foundation",
+]
+
 [[package]]
 name = "objc2-quartz-core"
 version = "0.3.2"
@@ -2378,6 +2391,17 @@ dependencies = [
  "objc2-foundation",
 ]
 
+[[package]]
+name = "objc2-security"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "709fe137109bd1e8b5a99390f77a7d8b2961dafc1a1c5db8f2e60329ad6d895a"
+dependencies = [
+ "bitflags 2.13.0",
+ "objc2",
+ "objc2-core-foundation",
+]
+
 [[package]]
 name = "objc2-ui-kit"
 version = "0.3.2"
@@ -2421,6 +2445,8 @@ dependencies = [
  "objc2-app-kit",
  "objc2-core-foundation",
  "objc2-foundation",
+ "objc2-javascript-core",
+ "objc2-security",
 ]
 
 [[package]]

data/support/shell/src-tauri/Cargo.toml

@@ -14,6 +14,15 @@ tauri-plugin-notification = "2"
 tauri-plugin-dialog = "2"
 tauri-plugin-clipboard-manager = "2"
 
+# macOS: set the WebView's `applicationNameForUserAgent`, which WKWebView
+# natively APPENDS to its real default UA — so we get the true system UA plus
+# our marker without ever reading or hardcoding the base string. Versions are
+# pinned to match what wry 0.55 already resolves, so no duplicate objc2 trees.
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2 = "0.6"
+objc2-foundation = { version = "0.3", features = ["NSString", "NSUUID", "NSProcessInfo"] }
+objc2-web-kit = { version = "0.3", features = ["WKWebViewConfiguration", "WKWebsiteDataStore"] }
+
 [profile.release]
 strip = true
 lto = true

data/support/shell/src-tauri/src/main.rs

@@ -32,6 +32,7 @@ struct AppConfig {
     raw_json: String,
     name: String,
     bundle_id: Option<String>,
+    version: Option<String>,
     entry_path: String,
     remote_url: Option<String>,
     background_light: Option<(u8, u8, u8)>,
@@ -71,6 +72,7 @@ fn load_config() -> AppConfig {
         raw_json: if value.is_null() { "{}".to_string() } else { value.to_string() },
         name: value["name"].as_str().unwrap_or("RubyEverywhere App").to_string(),
         bundle_id: value["bundle_id"].as_str().map(str::to_string),
+        version: value["version"].as_str().map(str::to_string),
         entry_path: value["entry_path"].as_str().unwrap_or("/").to_string(),
         remote_url: (value["mode"].as_str() == Some("remote"))
             .then(|| value["remote_url"].as_str().map(str::to_string))
@@ -549,12 +551,72 @@ const INIT_SCRIPT: &str = r#"
 })();
 "#;
 
+// The marker we append to the WebView's own user agent. We never build or
+// hardcode the browser part of the UA — the WebView keeps producing its real
+// default and this is added on the end, so anything the Ruby side sniffs (the
+// `browser` gem, `request.variant`) still sees a genuine desktop browser. The
+// contract with the app: `request.user_agent =~ %r{RubyEverywhere/([\d.]+)}`
+// tells it the request came from the native shell and which app version (from
+// everywhere.yml → the submitted build) made it. Version is absent only in bare
+// `cargo run` dev where no config was passed.
+fn ua_marker(config: &AppConfig) -> String {
+    let os = std::env::consts::OS;
+    match &config.version {
+        Some(v) => format!("RubyEverywhere/{v} ({os})"),
+        None => format!("RubyEverywhere ({os})"),
+    }
+}
+
+// macOS: build the WKWebViewConfiguration ourselves so we can set
+// `applicationNameForUserAgent` — WebKit appends it to the real default UA (the
+// one clean, no-read way to *append* rather than replace). Because wry uses the
+// config's own `websiteDataStore` when we supply a configuration (and ignores
+// Tauri's `data_store_identifier`), we must reproduce the per-app persistent
+// store here too, or logins would leak into the shared default store. Mirrors
+// wry's own logic: identified store on macOS 14+, default otherwise / in dev.
+#[cfg(target_os = "macos")]
+fn macos_webview_configuration(
+    config: &AppConfig,
+    dev_mode: bool,
+) -> objc2::rc::Retained<objc2_web_kit::WKWebViewConfiguration> {
+    use objc2::MainThreadMarker;
+    use objc2_foundation::{NSProcessInfo, NSString, NSUUID, NSOperatingSystemVersion};
+    use objc2_web_kit::{WKWebViewConfiguration, WKWebsiteDataStore};
+
+    let mtm = MainThreadMarker::new().expect("webview configuration must be built on the main thread");
+    let cfg = unsafe { WKWebViewConfiguration::new(mtm) };
+
+    unsafe {
+        cfg.setApplicationNameForUserAgent(Some(&NSString::from_str(&ua_marker(config))));
+    }
+
+    // Cookie / session persistence, keyed by bundle_id so each app is isolated.
+    // Dev mode keeps the default store (matches the previous ephemeral-ish dev
+    // behaviour). dataStoreForIdentifier needs macOS 14+.
+    if !dev_mode {
+        let os14 = NSProcessInfo::processInfo().isOperatingSystemAtLeastVersion(
+            NSOperatingSystemVersion { majorVersion: 14, minorVersion: 0, patchVersion: 0 },
+        );
+        if os14 {
+            let id = config.bundle_id.as_deref().unwrap_or("com.rubyeverywhere.app");
+            let store = unsafe {
+                WKWebsiteDataStore::dataStoreForIdentifier(&NSUUID::from_bytes(data_store_id(id)), mtm)
+            };
+            unsafe { cfg.setWebsiteDataStore(&store) };
+        }
+    }
+
+    cfg
+}
+
 fn build_window(
     app: &tauri::App,
     config: &AppConfig,
     title: &str,
     url: WebviewUrl,
 ) -> tauri::Result<tauri::WebviewWindow> {
+    let dev_mode = std::env::var("NATIVE_DEV_URL").is_ok();
+
     let mut builder = WebviewWindowBuilder::new(app, "main", url)
         .title(title)
         .inner_size(1100.0, 750.0)
@@ -566,23 +628,19 @@ fn build_window(
     }
 
     // Cookie / session persistence: give the webview a stable data store so
-    // logins survive relaunches. macOS wants a 16-byte identifier (derived from
-    // bundle_id); Windows/Linux want an explicit directory. Dev mode stays
-    // ephemeral — a persistent cache would keep serving stale dev assets.
-    let dev_mode = std::env::var("NATIVE_DEV_URL").is_ok();
+    // logins survive relaunches. macOS carries it (and the UA marker) on a
+    // custom WKWebViewConfiguration; Windows/Linux want an explicit directory.
+    // Dev mode stays ephemeral — a persistent cache would keep serving stale
+    // dev assets.
+    #[cfg(target_os = "macos")]
+    {
+        builder = builder.with_webview_configuration(macos_webview_configuration(config, dev_mode));
+    }
+    #[cfg(any(windows, target_os = "linux"))]
     if !dev_mode {
-        #[cfg(target_os = "macos")]
-        {
-            builder = builder.data_store_identifier(data_store_id(
-                config.bundle_id.as_deref().unwrap_or("com.rubyeverywhere.app"),
-            ));
-        }
-        #[cfg(any(windows, target_os = "linux"))]
-        {
-            if let Ok(dir) = app.path().data_dir() {
-                let id = config.bundle_id.clone().unwrap_or("com.rubyeverywhere.app".into());
-                builder = builder.data_directory(dir.join(id).join("webview"));
-            }
+        if let Ok(dir) = app.path().data_dir() {
+            let id = config.bundle_id.clone().unwrap_or("com.rubyeverywhere.app".into());
+            builder = builder.data_directory(dir.join(id).join("webview"));
         }
     }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_everywhere
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Andrea Fomera