ruby_everywhere 0.6.0 → 0.7.0

data/lib/everywhere/commands/dev.rb

@@ -58,7 +58,7 @@ module Everywhere
       def call(port: "3000", shell_dir: nil, target: nil, desktop: false, ios: false, android: false,
                mobile: false, browser: false, dev_url: nil, **)
         @shell_dir = shell_dir
-        @port = port
+        port = @port = validate_port!(port)
         @dev_url_override = dev_url
         # Children are spawned from pool threads as well as the main one.
         @pids = {}
@@ -147,8 +147,8 @@ module Everywhere
         else
           UI.step("starting #{UI.bold(framework.name)} dev server #{UI.dim("(" + framework.dev_command + ")")}")
           @dock.set(:web, :booting)
-          supervise(:web, { "PORT" => port.to_s }, framework.dev_command, chdir: framework.root)
-          wait_for_port(port)
+          pid = supervise(:web, { "PORT" => port.to_s }, framework.dev_command, chdir: framework.root)
+          wait_for_port(port, pid: pid)
           @dock.set(:web, :running, detail: ":#{port}")
         end
       end
@@ -272,6 +272,12 @@ module Everywhere
       end
 
       def launch_desktop
+        # Checked before anything is staged: without cargo the build dies deep
+        # in a relayed `sh: cargo: command not found`, after a dock entry and a
+        # half-written dev bundle say a shell is on its way.
+        Shellout.ensure_tool!("cargo", "the desktop shell is built with Rust — install it from " \
+                                       "https://rustup.rs, then press d again")
+
         # A bad `window:` or a broken assets/ tree marks the desktop red and
         # leaves the dev server and the mobile shells alone — the same deal
         # every other target gets when its build fails. Dying here would take
@@ -365,6 +371,15 @@ module Everywhere
       # covers plain http for local networking. Pressing i again rebuilds and
       # relaunches, so it doubles as a native-shell reload.
       def launch_ios
+        # xcodebuild and simctl are macOS-only, so `i` elsewhere can only ever
+        # produce a long build that fails at the first tool. Android stays
+        # available everywhere — its toolchain genuinely is cross-platform.
+        unless RUBY_PLATFORM.include?("darwin")
+          UI.warn("iOS builds need macOS and Xcode — #{UI.dim("nothing to do on this platform")}")
+          @dock.set(:ios, :idle, detail: "needs macOS")
+          return
+        end
+
         @dock.set(:ios, :building)
         app = Builders::Ios.new(config: @config, root: @config.root, target: IOS_TARGET)
                            .build!(dist_dir: File.expand_path("dist", @config.root), dev: true)
@@ -406,7 +421,22 @@ module Everywhere
 
       def launch_browser
         UI.step("opening browser → #{UI.cyan(@dev_url)}")
+        # `start` is a cmd builtin, not an executable, so it can't be probed or
+        # spawned directly; the empty "" is the window title argument, without
+        # which cmd reads the URL as one.
+        if Gem.win_platform?
+          system("cmd", "/c", "start", "", @dev_url)
+          return
+        end
+
         opener = RUBY_PLATFORM.include?("darwin") ? "open" : "xdg-open"
+        # A headless Linux box (or WSL) has no xdg-open, and run? would just
+        # return nil — the key would look broken. Print the URL instead.
+        unless Shellout.tool?(opener)
+          UI.warn("couldn't find #{opener} — open #{UI.cyan(@dev_url)} yourself")
+          return
+        end
+
         Shellout.run?(opener, @dev_url, quiet: true)
       end
 
@@ -506,8 +536,11 @@ module Everywhere
       # while one is going — including `q`.
       def interact
         @dock.announce_keys
-        saved_tty = `stty -g`.chomp
-        system("stty", "-icanon", "-echo")
+        # stty is POSIX-only, and the non-pty spawn path otherwise works on
+        # Windows: without it the menu simply stays line-buffered (press d,
+        # then Enter) rather than the session dying on Errno::ENOENT.
+        saved_tty = saved_tty_state
+        system("stty", "-icanon", "-echo") if saved_tty
         trap_exit_signals
         loop do
           case $stdin.getc
@@ -522,7 +555,19 @@ module Everywhere
           end
         end
       ensure
-        system("stty", saved_tty) unless saved_tty.to_s.empty?
+        system("stty", saved_tty) if saved_tty
+      end
+
+      # The tty settings to put back on the way out, or nil when there's no
+      # usable stty to read them with — the one signal both the raw-mode setup
+      # and its restore key off.
+      def saved_tty_state
+        return nil unless Shellout.tool?("stty")
+
+        state = `stty -g`.chomp
+        state.empty? ? nil : state
+      rescue StandardError
+        nil
       end
 
       # The dock hides the cursor and the key loop puts the tty in -icanon
@@ -613,17 +658,46 @@ module Everywhere
 
       def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+      # Checked once, up front: Integer() would otherwise raise from inside
+      # port_open? — an ArgumentError backtrace after the dock has already
+      # taken over the terminal.
+      def validate_port!(port)
+        number = begin
+          Integer(port.to_s, 10)
+        rescue ArgumentError, TypeError
+          UI.die!("--port must be a number (got #{port.inspect})")
+        end
+        UI.die!("--port must be between 1 and 65535 (got #{number})") unless (1..65_535).cover?(number)
+        number.to_s
+      end
+
+      # Any connect error means "nothing listening yet" for our purposes —
+      # ECONNREFUSED is the common one, but a firewall or an exhausted fd table
+      # answers differently and must not abort the session.
       def port_open?(port)
         TCPSocket.new("127.0.0.1", Integer(port)).close
         true
-      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT
+      rescue SystemCallError
         false
       end
 
-      def wait_for_port(port, timeout: 60)
-        deadline = Time.now + timeout
-        sleep 0.5 until port_open?(port) || Time.now > deadline
-        UI.die!("dev server never came up on port #{port}") unless port_open?(port)
+      # Watches the child as well as the port: a dev server that dies on
+      # startup (no `bundle install`, a bin/dev whose foreman isn't installed)
+      # never opens the port, and waiting out the full timeout for it buries
+      # the error it already printed under a minute of silence.
+      def wait_for_port(port, pid: nil, timeout: 60)
+        deadline = monotonic + timeout
+        until port_open?(port)
+          if pid && !ChildProcesses.alive?(pid)
+            UI.die!("the dev server exited before it finished booting — scroll up for its output " \
+                    "(did `bundle install` run? does bin/dev's foreman exist?)")
+          end
+          if monotonic > deadline
+            UI.die!("dev server never came up on port #{port} after #{timeout}s — it may just be slow " \
+                    "to boot; check its output above")
+          end
+          sleep 0.25
+        end
       end
     end
   end

data/lib/everywhere/commands/doctor.rb

@@ -3,48 +3,166 @@
 require "dry/cli"
 require_relative "../shellout"
 require_relative "../paths"
+require_relative "../config"
 require_relative "../android_sdk"
 
 module Everywhere
   module Commands
-    # Check that this machine can build native apps. Desktop checks always
-    # run; the iOS and Android sections join in when the app's build.targets
-    # include such a target, or explicitly via --target ios-* / android-*.
+    # Check that this machine can build native apps. Every section always
+    # shows, so one run answers "what can this machine build?" — but only the
+    # sections the app's build.targets declare (or --target names) gate the
+    # exit status: failing doctor over a toolchain the app doesn't use would
+    # be a lie, the same reasoning as the cmdline-tools warning below.
     class Doctor < Dry::CLI::Command
       desc "Check the toolchain (rbe-tebako, rust, brew deps; Xcode for iOS, SDK/JDK for Android)"
 
-      option :root,   default: ".", desc: "App root (its build.targets pick the sections)"
-      option :target, default: nil, desc: "Also check a specific target's toolchain (e.g. ios-arm64)"
+      option :root,   default: ".", desc: "App root (its build.targets pick which sections are required)"
+      option :target, default: nil, desc: "Require a specific target's toolchain (e.g. ios-arm64)"
 
       def call(root: ".", target: nil, **)
-        ok = true
-        ok &= check("rbe-tebako installed") { Shellout.run?("rbe-tebako help > /dev/null 2>&1") }
-        ok &= check("cargo installed")    { Shellout.run?("cargo --version > /dev/null 2>&1") }
-        ok &= check("homebrew bison")     { !`brew --prefix bison 2>/dev/null`.strip.empty? }
+        ok = config_check(root)
 
-        ok &= ios_checks if ios_wanted?(root, target)
-        ok &= android_checks if android_wanted?(root, target)
+        @optional_gaps = []
+        sections = [
+          ["Desktop", desktop_wanted?(root, target), method(:desktop_checks)],
+          ["iOS",     ios_wanted?(root, target),     method(:ios_checks)],
+          ["Android", android_wanted?(root, target), method(:android_checks)]
+        ]
+        # The sections that gate the run are the ones the user came to fix, so
+        # they come first; the informational ones read as an appendix.
+        # partition, not sort_by — Ruby's sort isn't stable.
+        required_sections, info_sections = sections.partition { |_, required, _| required }
+        (required_sections + info_sections).each do |name, required, checks|
+          ok &= section(name, required: required) { |req| checks.call(req) }
+        end
 
         puts
-        ok ? UI.success("ready to build") : UI.bad("fix the items above (see https://rubyeverywhere.com/docs/diy/requirements)")
+        if ok
+          note = @optional_gaps.any? ? " #{UI.dim("(#{@optional_gaps.join(" and ")} would need setup — see above)")}" : ""
+          UI.success("ready to build#{note}")
+        else
+          UI.bad("fix the items above (see https://rubyeverywhere.com/docs/diy/requirements)")
+        end
         exit(1) unless ok
       end
 
       private
 
+      # A section always renders; only a required one can fail the run. An
+      # optional section's gaps are remembered for the summary line instead.
+      def section(name, required:)
+        passed = yield(required)
+        @optional_gaps << name if !passed && !required
+        required ? passed : true
+      end
+
+      def section_label(name, required)
+        required ? name : "#{name} #{UI.dim("(not in build.targets — informational)")}"
+      end
+
+      def macos? = RUBY_PLATFORM.include?("darwin")
+
+      # Desktop is the implicit default: an app with no build.targets presses
+      # for the host. Any non-mobile target (or --target) counts as desktop,
+      # mirroring how build/dev route targets.
+      def desktop_wanted?(root, target)
+        return true if target && !%w[ios android].include?(Everywhere::Config.os_of(target))
+
+        targets = config(root).targets
+        targets.empty? || targets.any? { |t| !%w[ios android].include?(Everywhere::Config.os_of(t)) }
+      rescue StandardError
+        true
+      end
+
+      def desktop_checks(required = true)
+        puts
+        UI.step(section_label("Desktop target", required))
+        # Mirrors the gate in `every build`: pressing is macOS-only today, so
+        # probing for its toolchain elsewhere would only mislead.
+        unless macos?
+          return fix_check("macOS", "desktop builds are macOS-only for now") { false } if required
+
+          UI.warn("desktop builds are macOS-only for now — skipped")
+          return false
+        end
+
+        ok = fix_check("rbe-tebako installed",
+                       "it ships as a dependency of ruby_everywhere: `gem install rbe-tebako` " \
+                       "(or reinstall the gem)") { Shellout.run?("rbe-tebako help > /dev/null 2>&1") }
+        ok &= fix_check("cargo installed", "install Rust: https://rustup.rs") do
+          Shellout.run?("cargo --version > /dev/null 2>&1")
+        end
+        ok &= fix_check(bison_label, bison_hint) { bison? }
+        ok
+      end
+
+      # macOS ships a bison far too old for tebako's build, so there the brew
+      # one is the only one that counts — and asking brew is the only way to see
+      # it, since it stays off PATH (keg-only). Everywhere else the package
+      # manager installs a current bison normally.
+      def bison?
+        return Shellout.tool?("bison") unless macos?
+
+        out, status = Shellout.capture("brew", "--prefix", "bison")
+        !status.nil? && status.success? && !out.strip.empty?
+      end
+
+      def bison_label = macos? ? "homebrew bison" : "bison"
+      def bison_hint  = macos? ? "brew install bison" : "install bison with your package manager"
+
+      # Config.load raises on an unparseable everywhere.yml; doctor reports it
+      # as its first check and carries on with an empty config, so the machine
+      # that most needs the rest of the report still gets it. The load happens
+      # once, here, and every later reader gets what it produced.
+      def config_check(root)
+        return true unless File.exist?(File.join(File.expand_path(root), Everywhere::Config::FILE))
+
+        config(root)
+        if @config_error
+          UI.bad(@config_error)
+          return false
+        end
+
+        UI.ok(Everywhere::Config::FILE)
+        true
+      end
+
+      def config(root)
+        return @config if defined?(@config)
+
+        @config_error = nil
+        @config = begin
+          Everywhere::Config.load(File.expand_path(root))
+        rescue StandardError, SystemExit => e
+          @config_error = e.message
+          Everywhere::Config.new({}, File.expand_path(root))
+        end
+      end
+
       def ios_wanted?(root, target)
         return true if target && Everywhere::Config.os_of(target) == "ios"
 
-        Everywhere::Config.load(File.expand_path(root)).targets
-                          .any? { |t| Everywhere::Config.os_of(t) == "ios" }
+        config(root).targets.any? { |t| Everywhere::Config.os_of(t) == "ios" }
       rescue StandardError
         false
       end
 
-      def ios_checks
+      def ios_checks(required = true)
         puts
-        UI.step("iOS target")
-        ok = check("full Xcode selected") { Shellout.run?("xcodebuild -version > /dev/null 2>&1") }
+        UI.step(section_label("iOS target", required))
+        # Off macOS every tool below is guaranteed absent — one honest line
+        # beats four unfixable ✗s.
+        unless macos?
+          return fix_check("macOS with Xcode", "iOS apps can only be built on a Mac") { false } if required
+
+          UI.warn("needs macOS and Xcode — skipped")
+          return false
+        end
+
+        ok = fix_check("full Xcode selected",
+                       "install Xcode and run `sudo xcode-select -s /Applications/Xcode.app`") do
+          Shellout.run?("xcodebuild -version > /dev/null 2>&1")
+        end
         ok &= check("iOS Simulator SDK") do
           Shellout.run?("xcrun", "--sdk", "iphonesimulator", "--show-sdk-path", quiet: true)
         end
@@ -69,8 +187,7 @@ module Everywhere
       def android_wanted?(root, target)
         return true if target && Everywhere::Config.os_of(target) == "android"
 
-        Everywhere::Config.load(File.expand_path(root)).targets
-                          .any? { |t| Everywhere::Config.os_of(t) == "android" }
+        config(root).targets.any? { |t| Everywhere::Config.os_of(t) == "android" }
       rescue StandardError
         false
       end
@@ -80,9 +197,9 @@ module Everywhere
       # without exporting any of them, so a `which adb` would report a broken
       # machine that in fact builds fine. Nothing auto-installs — SDK components
       # are gigabytes — so each failure carries the exact command to run.
-      def android_checks
+      def android_checks(required = true)
         puts
-        UI.step("Android target")
+        UI.step(section_label("Android target", required))
         sdk = Everywhere::AndroidSdk
         root = sdk.sdk_root
 

data/lib/everywhere/commands/install.rb

@@ -56,6 +56,7 @@ module Everywhere
       end
 
       def install_sinatra
+        add_puma_gem
         vendor_bridge_to_public
         guide_rack_manual_steps(
           db: "point your production SQLite path at ENV.fetch(\"NATIVE_STORAGE_DIR\", \"storage\")",
@@ -65,6 +66,7 @@ module Everywhere
       end
 
       def install_hanami
+        add_puma_gem
         vendor_bridge_to_public
         guide_rack_manual_steps(
           db: "override DATABASE_URL from ENV[\"NATIVE_STORAGE_DIR\"] in config.ru when NATIVE_PACKAGED",
@@ -100,14 +102,35 @@ module Everywhere
         made ? UI.ok(label) : UI.step("#{label} #{UI.dim("(already done, skipped)")}")
       end
 
+      # A step whose file this app doesn't have. Every one of these is a shape a
+      # real app legitimately ships in (API-only, DATABASE_URL, no
+      # config/puma.rb), so say what was skipped — never raise on it.
+      def skip(label, reason)
+        UI.step("#{label} #{UI.dim("(skipped — #{reason})")}")
+      end
+
       def add_gem
+        UI.die!("no Gemfile in #{@root} — run `every install` inside your app") unless File.exist?(app_file("Gemfile"))
+
+        add_gemfile_gem("ruby_everywhere",
+                        comment: "# Desktop apps from this #{@framework.name.capitalize} app — https://rubyeverywhere.com")
+      end
+
+      # Packaged Rack apps serve through Puma at runtime (Framework#serve_rack
+      # requires it), so a missing gem surfaces as a LoadError on the end user's
+      # machine at first launch rather than here.
+      def add_puma_gem
+        add_gemfile_gem("puma", comment: "# Packaged RubyEverywhere apps serve through puma.")
+      end
+
+      def add_gemfile_gem(name, comment:)
         gemfile = app_file("Gemfile")
         contents = File.read(gemfile)
-        return change("add ruby_everywhere to Gemfile", false) if contents.match?(/gem ["']ruby_everywhere["']/)
+        return change("add #{name} to Gemfile", false) if contents.match?(/gem ["']#{name}["']/)
 
-        File.write(gemfile, "#{contents.chomp}\n\n# Desktop apps from this #{@framework.name.capitalize} app — https://rubyeverywhere.com\ngem \"ruby_everywhere\"\n")
+        File.write(gemfile, "#{contents.chomp}\n\n#{comment}\ngem \"#{name}\"\n")
         Shellout.run!({}, "bundle", "install", "--quiet", chdir: @root)
-        change("add ruby_everywhere to Gemfile", true)
+        change("add #{name} to Gemfile", true)
       end
 
       def write_config
@@ -214,9 +237,10 @@ module Everywhere
           #   targets:               # the platforms you ship — the CI matrix, expressed once
           #     - macos-arm64
           #     # - ios-arm64         # Hotwire Native shell; remote mode only. Local builds
-          #     #                     # (`every build` / `every dev --ios`) work today;
-          #     #                     # hosted platform builds for iOS aren't live yet.
-          #     # - android-arm64     # future — mobile is remote mode only
+          #     #                     # (`every build` / `every dev --ios`) and hosted
+          #     #                     # platform builds are both live.
+          #     # - ios-arm64:testflight   # optional per-target distribution channel
+          #     # - android-arm64     # Hotwire Native shell; remote mode only, hosted builds live
           #   capabilities: [notifications, filesystem:read, clipboard]  # desktop OS integration
 
           # Per-platform overrides. Keys are platform names (macos / ios / android /
@@ -321,6 +345,8 @@ module Everywhere
 
       def guard_bootsnap
         boot = app_file("config", "boot.rb")
+        return skip("guard bootsnap for packaged runs", "no config/boot.rb") unless File.exist?(boot)
+
         contents = File.read(boot)
         return change("guard bootsnap for packaged runs", false) if contents.include?("NATIVE_PACKAGED")
 
@@ -328,12 +354,16 @@ module Everywhere
           "# Bootsnap writes its cache to tmp/, which is read-only inside the packaged filesystem.\n" \
           "require \"bootsnap/setup\" unless ENV[\"NATIVE_PACKAGED\"]"
         end
-        File.write(boot, contents) if made
-        change("guard bootsnap for packaged runs", !!made)
+        return skip("guard bootsnap for packaged runs", "this app doesn't load bootsnap") unless made
+
+        File.write(boot, contents)
+        change("guard bootsnap for packaged runs", true)
       end
 
       def disable_force_ssl
         production = app_file("config", "environments", "production.rb")
+        return skip("disable force_ssl for localhost", "no config/environments/production.rb") unless File.exist?(production)
+
         contents = File.read(production)
         made = false
         made |= !!contents.gsub!(/^(\s*config\.assume_ssl\s*=\s*)true/) { "#{Regexp.last_match(1)}false # desktop: webview talks plain HTTP to 127.0.0.1" }
@@ -416,6 +446,11 @@ module Everywhere
       # connection was lost" (-1005). Single local user: keep-alives off.
       def disable_puma_keep_alives
         puma = app_file("config", "puma.rb")
+        unless File.exist?(puma)
+          return skip("disable puma keep-alives when packaged",
+                      "no config/puma.rb — add `enable_keep_alives false if ENV[\"NATIVE_PACKAGED\"]` to yours if you add one")
+        end
+
         contents = File.read(puma)
         return change("disable puma keep-alives when packaged", false) if contents.include?("enable_keep_alives")
 
@@ -431,6 +466,11 @@ module Everywhere
 
       def point_database_at_app_data
         db = app_file("config", "database.yml")
+        unless File.exist?(db)
+          return skip("point production SQLite at app-data dir",
+                      "no config/database.yml — point the packaged database at ENV[\"NATIVE_STORAGE_DIR\"] yourself")
+        end
+
         contents = File.read(db)
         return change("point production SQLite at app-data dir", false) if contents.include?("NATIVE_STORAGE_DIR")