ruby_everywhere 0.1.15 → 0.2.0

data/bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubyeverywhere/bridge",
-  "version": "0.3.0",
+  "version": "0.2.0",
   "description": "One API for browser, desktop, and mobile — the JS half of RubyEverywhere",
   "type": "module",
   "main": "everywhere/bridge.js",

data/lib/everywhere/builders/ios.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "../paths"
+require_relative "../shellout"
+require_relative "../log_filter"
+require_relative "../icon"
+require_relative "../ui"
+
+module Everywhere
+  module Builders
+    # Assembles a Hotwire Native iOS app around an already-deployed (remote
+    # mode) app. No Tebako on iOS — the "build" is: copy the gem's frozen
+    # Xcode template, stamp it (xcconfig + everywhere.json + AppIcon; never
+    # the pbxproj), and hand it to xcodebuild.
+    #
+    # MVP scope is the Simulator (ad-hoc signed, no certs). Device signing,
+    # archive/.ipa export and store distribution hang off this same seam
+    # later — see platform/docs/build-engine.md §5.
+    class Ios
+      # Fixed by the template contract: the target/product is always "App"
+      # (App.app), so build paths never depend on per-app values.
+      SCHEME = "App"
+
+      def initialize(config:, root:, target:, template_dir: nil)
+        @config = config
+        @root = root
+        @target = target
+        @template_dir = template_dir
+      end
+
+      # Build the Simulator .app and copy it into dist_dir. `dev` builds Debug
+      # and relaxes the remote-mode requirement (the dev URL arrives at launch
+      # via SIMCTL_CHILD_EVERYWHERE_DEV_URL, not baked into the bundle).
+      # Returns the path of the built .app.
+      def build!(dist_dir:, dev: false)
+        preflight!(dev: dev)
+        template = @template_dir ? File.expand_path(@template_dir) : Paths.ios_dir!
+        work = stage(template)
+        stamp!(work)
+        configuration = dev ? "Debug" : "Release"
+        xcodebuild!(work, configuration, dist_dir)
+        collect(configuration, dist_dir)
+      end
+
+      private
+
+      def name = @config.name(target: @target)
+      def bundle_id = @config.bundle_id(target: @target)
+
+      def preflight!(dev:)
+        unless dev || @config.remote?
+          UI.die!("iOS apps are remote mode only for now — set remote.url in config/everywhere.yml " \
+                  "(the shell wraps your deployed app; nothing is packaged locally)")
+        end
+        UI.die!("iOS builds need macOS with Xcode installed") unless RUBY_PLATFORM.include?("darwin")
+        return if Shellout.run?("xcrun", "--sdk", "iphonesimulator", "--show-sdk-path", quiet: true)
+
+        UI.die!("no iOS Simulator SDK — install full Xcode (not just the Command Line Tools) " \
+                "and run: xcode-select --switch /Applications/Xcode.app")
+      end
+
+      # Copy the template into the app's persistent work dir. Persistent (not
+      # a tmpdir) so the project path is stable — Xcode's incremental state
+      # stays valid and users can open the stamped project directly.
+      def stage(template)
+        work = Paths.ios_work_dir(bundle_id)
+        FileUtils.mkdir_p(File.dirname(work))
+        FileUtils.rm_rf(work)
+        FileUtils.cp_r(template, work)
+        work
+      end
+
+      # The whole per-app surface: one xcconfig (identity), two JSON resources
+      # (runtime config + path configuration with baked tabs), one PNG (icon),
+      # and the Extensions/ buildable folder (app-authored Swift + generated
+      # registry). The pbxproj is never touched.
+      def stamp!(work)
+        UI.step("stamping shell #{UI.dim("(#{bundle_id} → #{UI.short_path(work)})")}")
+        write_xcconfig(work)
+        File.write(File.join(work, "App", "Resources", "everywhere.json"),
+                   @config.to_shell_json(target: @target))
+        # Same document MobileConfigEndpoint serves live — this baked copy is
+        # the offline/first-launch fallback the shell loads synchronously.
+        File.write(File.join(work, "App", "Resources", "path-configuration.json"),
+                   @config.path_configuration_json("ios"))
+        write_launch_background(work)
+        write_usage_strings(work)
+        write_app_icon(work)
+        write_extensions(work)
+        write_native_packages(work)
+      end
+
+      # Native extensions: the app repo's native/ios/*.swift copied into the
+      # template's Extensions/ folder, plus a generated registry naming what
+      # everywhere.yml declares (native.ios). Extensions/ is a filesystem-
+      # synchronized (buildable) group, so dropping files in IS the
+      # integration — the stamp-only contract holds.
+      def write_extensions(work)
+        errors = @config.native_ios_errors
+        UI.die!("native.ios in config/everywhere.yml:\n#{errors.join("\n")}") unless errors.empty?
+
+        dest = File.join(work, "App", "Extensions")
+        source = File.join(@root, "native", "ios")
+        sources = File.directory?(source) ? Dir.glob(File.join(source, "**", "*.swift")).sort : []
+
+        sources.each do |file|
+          relative = file.delete_prefix("#{source}/")
+          if File.basename(file) == "EverywhereExtensions.swift"
+            UI.die!("native/ios/#{relative}: EverywhereExtensions.swift is generated by " \
+                    "`every build` — declare your types under native.ios in config/everywhere.yml instead")
+          end
+          target_file = File.join(dest, relative)
+          FileUtils.mkdir_p(File.dirname(target_file))
+          FileUtils.cp(file, target_file)
+        end
+
+        if @config.native_ios?
+          UI.step("bundling native extensions #{UI.dim("(#{sources.length} Swift files from native/ios)")}")
+          FileUtils.mkdir_p(dest)
+          File.write(File.join(dest, "EverywhereExtensions.swift"), extensions_registry)
+        elsif sources.any?
+          UI.warn "native/ios has Swift files but everywhere.yml declares nothing under native.ios — " \
+                  "they compile in, but no components/screens/splash are hooked up"
+        end
+      end
+
+      # The generated half of the extension seam (the template ships an empty
+      # default). Declared names are validated as Swift identifiers above, so
+      # interpolation is safe; a declared-but-missing type fails the build
+      # with a Swift error naming it — the honest signal.
+      def extensions_registry
+        components = @config.native_ios_components.map { |type| "#{type}.self" }.join(", ")
+        screens = @config.native_ios_screens
+        splash = @config.native_ios_splash
+
+        screen_body =
+          if screens.empty?
+            "        nil"
+          else
+            ["        switch identifier {",
+             *screens.map { |id, type| "        case #{id.inspect}: return everywhereHost(#{type}(url: url))" },
+             "        default: return nil",
+             "        }"].join("\n")
+          end
+
+        <<~SWIFT
+          // Written by `every build` from config/everywhere.yml (native.ios) — do
+          // not edit; changes belong in native/ios/ and everywhere.yml.
+          import HotwireNative
+          import SwiftUI
+          import UIKit
+
+          enum EverywhereExtensions {
+              static let components: [BridgeComponent.Type] = [#{components}]
+
+              static func screen(for identifier: String, url: URL) -> UIViewController? {
+          #{screen_body}
+              }
+
+              static func splashViewController() -> UIViewController? {
+                  #{splash ? "everywhereHost(#{splash}())" : "nil"}
+              }
+          }
+        SWIFT
+      end
+
+      # Third-party Swift packages → the template's local NativeExtensions
+      # package. The App target already links (a fixed, frozen pbxproj entry)
+      # this local package; we only regenerate its manifest and the re-export
+      # shim, so app-authored native/ios code reaches every pinned product with
+      # `import NativeExtensions` — and the stamp-only contract holds (the
+      # pbxproj is never touched, packages flow through Package.swift instead).
+      def write_native_packages(work)
+        packages = @config.native_ios_packages
+        pkg_dir = File.join(work, "NativeExtensions")
+        sources = File.join(pkg_dir, "Sources", "NativeExtensions")
+        FileUtils.mkdir_p(sources)
+        # A stray Xcode/SPM index cache in the template must not leak into the
+        # app's build (it pins a different dependency graph).
+        FileUtils.rm_rf(File.join(pkg_dir, ".build"))
+
+        File.write(File.join(pkg_dir, "Package.swift"), native_package_manifest(packages))
+        File.write(File.join(sources, "Exports.swift"), native_package_exports(packages))
+
+        return if packages.empty?
+
+        UI.step("pinning native packages #{UI.dim("(#{packages.length} SPM " \
+                "dependenc#{packages.length == 1 ? "y" : "ies"} in NativeExtensions)")}")
+      end
+
+      # The generated NativeExtensions/Package.swift. Every string interpolated
+      # here is validated by Config#native_ios_package_errors (URLs, semver,
+      # module names), and .inspect renders Swift-compatible string literals.
+      def native_package_manifest(packages)
+        dependencies = packages.map do |pkg|
+          ".package(url: #{pkg["url"].inspect}, #{swift_requirement(pkg["requirement"])})"
+        end
+        products = packages.flat_map do |pkg|
+          identity = @config.package_identity(pkg["url"])
+          pkg["products"].map { |name| ".product(name: #{name.inspect}, package: #{identity.inspect})" }
+        end
+
+        <<~SWIFT
+          // swift-tools-version:5.9
+          // Written by `every build` from config/everywhere.yml (native.ios.packages)
+          // — do not edit; changes belong in config/everywhere.yml.
+          import PackageDescription
+
+          let package = Package(
+              name: "NativeExtensions",
+              platforms: [.iOS(.v15)],
+              products: [
+                  .library(name: "NativeExtensions", targets: ["NativeExtensions"])
+              ],
+              dependencies: #{swift_array(dependencies, indent: 8)},
+              targets: [
+                  .target(name: "NativeExtensions", dependencies: #{swift_array(products, indent: 12)})
+              ]
+          )
+        SWIFT
+      end
+
+      # The re-export shim: one `@_exported import` per pinned product, so the
+      # App target's native/ios code sees every module through NativeExtensions.
+      def native_package_exports(packages)
+        header = <<~SWIFT
+          // Written by `every build` from config/everywhere.yml (native.ios.packages)
+          // — re-exports each pinned product so native/ios code reaches it with a
+          // single `import NativeExtensions`. Do not edit.
+        SWIFT
+        modules = packages.flat_map { |pkg| pkg["products"] }.uniq.sort
+        return header if modules.empty?
+
+        "#{header}#{modules.map { |m| "@_exported import #{m}" }.join("\n")}\n"
+      end
+
+      def swift_requirement(requirement)
+        value = requirement["value"].inspect
+        "#{requirement["kind"]}: #{value}"
+      end
+
+      # A Swift array literal: "[]" when empty, else one element per line at
+      # `indent` spaces with the closing bracket de-dented by four.
+      def swift_array(elements, indent:)
+        return "[]" if elements.empty?
+
+        pad = " " * indent
+        "[\n#{elements.map { |element| "#{pad}#{element}" }.join(",\n")}\n#{" " * (indent - 4)}]"
+      end
+
+      # Permission usage strings → Info.plist. iOS crashes a permission
+      # request whose usage-description key is missing, so declarations are
+      # validated here (good strings are mandatory) and stamped with plutil.
+      def write_usage_strings(work)
+        errors = @config.permission_errors("ios")
+        UI.die!("permissions in config/everywhere.yml:\n#{errors.join("\n")}") unless errors.empty?
+
+        plist = File.join(work, "App", "Info.plist")
+        @config.permissions.each do |name, usage|
+          key = Everywhere::Config::IOS_USAGE_KEYS[name] or next
+          Shellout.run!({}, "plutil", "-replace", key, "-string", usage["ios"], plist)
+        end
+      end
+
+      # The launch-screen (and splash overlay) background — the storyboard's
+      # LaunchBackground named color, stamped from appearance.background_color
+      # so the launch frame matches the app instead of the template default.
+      def write_launch_background(work)
+        colors = @config.background_color
+        light = Icon.hex_rgb(colors&.fetch("light", nil)) or return
+        dark = Icon.hex_rgb(colors["dark"]) || light
+
+        entry = lambda do |rgb, appearances|
+          { "color" => {
+              "color-space" => "srgb",
+              "components" => {
+                "alpha" => "1.000",
+                "red" => format("0x%02X", rgb[0]),
+                "green" => format("0x%02X", rgb[1]),
+                "blue" => format("0x%02X", rgb[2])
+              }
+            },
+            "idiom" => "universal" }.merge(appearances)
+        end
+
+        require "json"
+        dest = File.join(work, "App", "Assets.xcassets", "LaunchBackground.colorset")
+        FileUtils.mkdir_p(dest)
+        File.write(
+          File.join(dest, "Contents.json"),
+          JSON.pretty_generate(
+            "colors" => [
+              entry.call(light, {}),
+              entry.call(dark, "appearances" => [{ "appearance" => "luminosity", "value" => "dark" }])
+            ],
+            "info" => { "author" => "xcode", "version" => 1 }
+          )
+        )
+      end
+
+      def write_xcconfig(work)
+        File.write(File.join(work, "App", "App.xcconfig"), <<~XCCONFIG)
+          // Written by `every build --target #{@target}` — do not edit; changes
+          // belong in config/everywhere.yml.
+          PRODUCT_BUNDLE_IDENTIFIER = #{bundle_id}
+          MARKETING_VERSION = #{@config.version(target: @target)}
+          CURRENT_PROJECT_VERSION = 1
+          INFOPLIST_KEY_CFBundleDisplayName = #{name}
+          DEVELOPMENT_TEAM =
+        XCCONFIG
+      end
+
+      def write_app_icon(work)
+        source = @config.icon
+        unless source && File.exist?(source)
+          UI.warn "no app icon (set app.icon or add icon.png) — shipping the placeholder"
+          return
+        end
+
+        background = Icon.hex_rgb(@config.background_color&.fetch("light", nil))
+        dest = File.join(work, "App", "Assets.xcassets", "AppIcon.appiconset")
+        return if Icon.write_ios_appiconset(source, dest, background: background)
+
+        UI.warn "couldn't read #{File.basename(source)} — shipping the placeholder icon"
+      end
+
+      def xcodebuild!(work, configuration, dist_dir)
+        UI.step("building iOS shell #{UI.dim("(xcodebuild, #{configuration}, first run compiles HotwireNative)")}")
+        FileUtils.mkdir_p(dist_dir)
+        log = File.join(dist_dir, "ios-build.log")
+        Shellout.run_logged!({},
+                             ["xcodebuild", "build",
+                              "-project", File.join(work, "App.xcodeproj"),
+                              "-scheme", SCHEME,
+                              "-configuration", configuration,
+                              "-destination", "generic/platform=iOS Simulator",
+                              "-derivedDataPath", Paths.ios_derived_data_dir,
+                              "-clonedSourcePackagesDirPath", Paths.ios_packages_dir,
+                              # Ad-hoc sign (no certs needed on the Simulator).
+                              # CODE_SIGNING_ALLOWED=NO ships an UNSIGNED app,
+                              # and securityd rejects its data-protection
+                              # keychain writes (SecAccessControl items, e.g.
+                              # the Face ID login credential) with -34018.
+                              "CODE_SIGN_IDENTITY=-"],
+                             log: log, filter: LogFilter.for(:xcodebuild))
+      end
+
+      # Copy the product out of DerivedData. The ".simulator.app" suffix keeps
+      # it visibly distinct from the desktop dist/<Name>.app (and out of
+      # release.rb's dist/*.app glob).
+      def collect(configuration, dist_dir)
+        built = File.join(Paths.ios_derived_data_dir, "Build", "Products",
+                          "#{configuration}-iphonesimulator", "App.app")
+        UI.die!("xcodebuild reported success but #{built} is missing") unless File.directory?(built)
+
+        dest = File.join(dist_dir, "#{name}.simulator.app")
+        FileUtils.rm_rf(dest)
+        FileUtils.cp_r(built, dest)
+        dest
+      end
+    end
+  end
+end

data/lib/everywhere/cli.rb

@@ -6,6 +6,7 @@ require_relative "framework"
 require_relative "commands/build"
 require_relative "commands/clean"
 require_relative "commands/dev"
+require_relative "commands/logs"
 require_relative "commands/icon"
 require_relative "commands/doctor"
 require_relative "commands/install"
@@ -37,6 +38,7 @@ module Everywhere
     register "doctor",  Commands::Doctor
     register "install", Commands::Install
     register "dev",     Commands::Dev
+    register "logs",    Commands::Logs
     register "build",   Commands::Build
     register "clean",   Commands::Clean
     register "icon",    Commands::Icon

data/lib/everywhere/commands/build.rb

@@ -9,6 +9,7 @@ require_relative "../log_filter"
 require_relative "../png"
 require_relative "../icon"
 require_relative "../paths"
+require_relative "../builders/ios"
 
 module Everywhere
   module Commands
@@ -23,7 +24,7 @@ module Everywhere
     class Build < Dry::CLI::Command
       SHIM = File.expand_path("~/.tebako-shims/clang++")
 
-      desc "Package the app into a double-clickable desktop app (tebako press + shell + .app bundle)"
+      desc "Package the app natively — desktop (tebako press + shell + .app) or iOS (--target ios-arm64)"
 
       option :root,       default: ".",              desc: "App root directory"
       option :output,     default: nil,              desc: "Output binary path (default: dist/<app>)"
@@ -38,6 +39,21 @@ module Everywhere
                app_name: nil, target: "macos-arm64", shell_dir: nil, skip_press: false, **)
         root_path = File.expand_path(root)
         config = Everywhere::Config.load(root_path)
+
+        # Builder dispatch on the target's os (build-engine.md §5): macOS is
+        # the tebako+tauri path below; iOS is a Hotwire Native shell built by
+        # its own builder. Anything else has no builder yet.
+        case Everywhere::Config.os_of(target)
+        when "ios"
+          app = Builders::Ios.new(config: config, root: root_path, target: target)
+                             .build!(dist_dir: File.expand_path("dist", root_path))
+          UI.success("built #{rel(app, root_path)}")
+          return
+        when "macos" # the rest of this method
+        else
+          UI.die!("no builder for target #{target} — macos-* and ios-* are supported")
+        end
+
         # 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)

data/lib/everywhere/commands/clean.rb

@@ -5,19 +5,28 @@ require "fileutils"
 
 module Everywhere
   module Commands
-    # Wipes the shared cargo build cache under ~/.rubyeverywhere (or
-    # $RUBYEVERYWHERE_HOME). Safe to run any time: only compiled shell output
-    # lives there, so the next `every dev`/`every build` just recompiles cold.
+    # Wipes the shared build caches under ~/.rubyeverywhere (or
+    # $RUBYEVERYWHERE_HOME): the cargo shell cache plus the iOS DerivedData /
+    # SPM / stamped-project dirs. Safe to run any time: only compiled shell
+    # output lives there, so the next `every dev`/`every build` recompiles cold.
     class Clean < Dry::CLI::Command
-      desc "Remove the cargo shell-build cache (~/.rubyeverywhere/shell-target)"
+      desc "Remove the shell build caches (~/.rubyeverywhere: shell-target, ios-*)"
 
       def call(**)
-        target = Everywhere::Paths.cargo_target_dir
-        return UI.step("nothing to clean #{UI.dim("(#{target} doesn't exist)")}") unless File.exist?(target)
-
-        size = human_size(dir_bytes(target))
-        FileUtils.rm_rf(target)
-        UI.success("removed #{target} (#{size} freed) — the next build recompiles the shell cold")
+        caches = [Everywhere::Paths.cargo_target_dir,
+                  Everywhere::Paths.ios_derived_data_dir,
+                  Everywhere::Paths.ios_packages_dir,
+                  File.join(Everywhere::Paths.cache_dir, "ios")].select { |d| File.exist?(d) }
+        return UI.step("nothing to clean #{UI.dim("(no build caches under #{Everywhere::Paths.cache_dir})")}") if caches.empty?
+
+        freed = 0
+        caches.each do |dir|
+          bytes = dir_bytes(dir)
+          freed += bytes
+          FileUtils.rm_rf(dir)
+          UI.ok("removed #{dir} #{UI.dim("(#{human_size(bytes)})")}")
+        end
+        UI.success("#{human_size(freed)} freed — the next build recompiles the shells cold")
       end
 
       private