ruby_native 0.15.2 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34a06223f80d171207b1eb5e0e56d67f3f02ba2737037fa06b7c16f4f3fbecad
-  data.tar.gz: 26c59be4e4848abb167cf45d39249609b888167aad3835eb367c70f4fc41f1ed
+  metadata.gz: f7c62d39c66e463239ff2c5cc4c66b868271758aa1e19fccdbc0fb25e446854b
+  data.tar.gz: 3c52d0ce183cedb9cfeced27ec2a504abbbc0a1675f0109d7f7e557b1d32dff7
 SHA512:
-  metadata.gz: b6a051041b02d7d87d2881b4ff279beed81d0f5291746611e601c1f68f8c46eb85539250fb34bb567394c4395b3ed99d44078132d6e0f6d894beb52f91694e25
-  data.tar.gz: 0cad8e6fac5dce1596ec40009a9e01f9ce1549b6ca3a89b3dee70205d40ff98ef5a6e99d112202e197d25d27ffb37fda4d268681e6137e8e0aa016b07b494414
+  metadata.gz: fee84930a92e36cc9602a00daeaeb184990becdcb5e3dcffd0baa12d1454a5c5f5228844ca90a9fd1b5f3c27b47902ef5f0d587056d83bcbd1021f5074158cee
+  data.tar.gz: f9e4c4741bb48cb5bb7b287bc56d3253c6f91825a9e028f52b1c2b36e7b94ae7bf3a63184327f5a5d7c20b71ee5956ed9f96709e37faf31cfe100cce35cc1bc4

data/config/signals.yml

@@ -0,0 +1,134 @@
+# The signal vocabulary: every data-native-* attribute Ruby Native accepts.
+#
+# `ruby_native check` validates your views against this file, and the native
+# shells assert their own vocabulary matches it. `since` is the gem version
+# that introduced the signal; a signal older than the shell running it is
+# ignored silently on device, which is what `check` exists to catch.
+#
+# `owner: shell` marks a signal the app writes into the page rather than one
+# your views emit.
+---
+signals:
+  data-native-action:
+    since: "0.11.2"
+  data-native-anchor:
+    since: "0.14.0"
+    helper: native_menu_tag
+  data-native-app:
+    owner: shell
+  data-native-badge:
+    since: "0.3.2"
+    helper: native_badge_tag
+    singleton: true
+  data-native-badge-home:
+    since: "0.3.2"
+    helper: native_badge_tag
+  data-native-badge-tab:
+    since: "0.3.2"
+    helper: native_badge_tag
+  data-native-button:
+    since: "0.4.0"
+  data-native-click:
+    since: "0.4.0"
+    helper: native_fab_tag
+  data-native-color:
+    since: "0.14.0"
+    helper: native_fab_tag
+  data-native-destructive:
+    since: "0.14.0"
+  data-native-fab:
+    since: "0.8.0"
+    helper: native_fab_tag
+    singleton: true
+  data-native-form:
+    since: "0.1.2"
+    helper: native_form_tag
+    singleton: true
+  data-native-haptic:
+    since: "0.2.7"
+    helper: native_haptic_data
+  data-native-href:
+    since: "0.4.0"
+    helper: native_fab_tag
+  data-native-icon:
+    since: "0.4.0"
+    helper: native_fab_tag
+  data-native-identity:
+    since: "0.12.0"
+    helper: native_identity_tag
+    singleton: true
+  data-native-keyboard-toolbar:
+    since: "0.15.0"
+    helper: native_keyboard_tag
+    singleton: true
+  data-native-menu:
+    since: "0.14.0"
+    helper: native_menu_tag
+  data-native-menu-item:
+    since: "0.4.0"
+  data-native-navbar:
+    since: "0.4.0"
+    helper: native_navbar_tag
+    singleton: true
+  data-native-overscroll-bottom:
+    since: "0.5.0"
+    helper: native_overscroll_tag
+    singleton: true
+  data-native-overscroll-top:
+    since: "0.5.0"
+    helper: native_overscroll_tag
+    singleton: true
+  data-native-position:
+    since: "0.4.0"
+  data-native-presentation:
+    since: "0.11.2"
+    helper: native_presentation_tag
+    singleton: true
+  data-native-price:
+    since: "0.5.3"
+  data-native-pull-to-refresh:
+    since: "0.10.0"
+    helper: native_navbar_tag
+  data-native-purchase:
+    since: "0.5.3"
+  data-native-push:
+    since: "0.1.2"
+    helper: native_push_tag
+    singleton: true
+  data-native-restore:
+    since: "0.5.3"
+  data-native-review:
+    since: "0.9.3"
+    helper: native_review_tag
+  data-native-segment:
+    since: "0.10.12"
+  data-native-selected:
+    since: "0.4.0"
+  data-native-share:
+    since: "0.10.9"
+  data-native-share-url:
+    since: "0.10.9"
+  data-native-submit-button:
+    since: "0.4.0"
+    singleton: true
+  data-native-tabs:
+    since: "0.1.2"
+    helper: native_tabs_tag
+    singleton: true
+  data-native-title:
+    since: "0.4.0"
+  data-native-toast:
+    since: "0.12.1"
+    helper: native_toast_tag
+  data-native-toast-appearance:
+    since: "0.12.1"
+    helper: native_toast_tag
+  data-native-toast-duration:
+    since: "0.12.1"
+    helper: native_toast_tag
+  data-native-toast-icon:
+    since: "0.12.1"
+    helper: native_toast_tag
+  data-native-toast-message:
+    since: "0.12.1"
+    helper: native_toast_tag

data/lib/generators/ruby_native/templates/ruby_native.yml

@@ -102,6 +102,23 @@ tabs:
 
   # Per-tab options (add to any tab above):
   #
+  #   # Localize this tab's title. Put the copy in your app's own locale files
+  #   # under `ruby_native.tabs.<key>.title`, the same way the error screen uses
+  #   # `ruby_native.errors.*`, and the device's language picks the translation:
+  #   #
+  #   #   # config/locales/it.yml
+  #   #   it:
+  #   #     ruby_native:
+  #   #       tabs:
+  #   #         home:
+  #   #           title: Casa
+  #   #
+  #   # `title:` above stays the fallback for a language you have not
+  #   # translated. Once every tab has a key you can drop `title:` entirely and
+  #   # keep all of your copy in the locale files.
+  #   # https://rubynative.com/docs/tabs#localization
+  #   key: home
+  #
   #   # Load this tab on launch instead of lazily.
   #   # Default: false.
   #   eager: true

data/lib/ruby_native/cli/check/signal_collector.rb

@@ -0,0 +1,30 @@
+module RubyNative
+  class CLI
+    class Check
+      # Walks a parsed template and records every data-native-* attribute with
+      # the lines it appears on. Attribute names built out of ERB cannot be
+      # resolved statically and are skipped rather than guessed at.
+      #
+      # Subclasses Herb::Visitor, so this file is only loaded once `herb` is
+      # known to be present.
+      class SignalCollector < Herb::Visitor
+        attr_reader :signals
+
+        def initialize
+          @signals = {}
+          super
+        end
+
+        def visit_html_attribute_name_node(node)
+          name = node.children.filter_map { |child| child.content if child.respond_to?(:content) }.join
+
+          if name.start_with?("data-native-")
+            (@signals[name] ||= []) << node.location.start.line
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/check.rb

@@ -0,0 +1,254 @@
+require "json"
+require "net/http"
+require "uri"
+require "yaml"
+require "ruby_native/cli/credentials"
+require "ruby_native/signals"
+require "ruby_native/version"
+
+module RubyNative
+  class CLI
+    # Static validation of a Rails app's views against the signal vocabulary.
+    #
+    # Signals fail silently by design: a shell that does not understand one
+    # ignores it. That is right for progressive enhancement and miserable for
+    # debugging, so this moves the diagnostics the bridge already runs per page
+    # visit to a whole-app pass that can fail CI before a build goes out.
+    class Check
+      CONFIG_PATH = "config/ruby_native.yml"
+      HOST = ENV.fetch("RUBY_NATIVE_HOST", "https://rubynative.com")
+      DEFAULT_PATHS = ["app/views"].freeze
+      PLATFORMS = %w[ios android].freeze
+
+      Offense = Struct.new(:file, :line, :severity, :message, keyword_init: true)
+
+      # The same checks `run` reports, for `deploy` to run as a preflight.
+      # Returns nil when herb is missing rather than failing: a deploy must not
+      # start depending on a gem the app never asked for.
+      def self.signal_offenses(paths: DEFAULT_PATHS)
+        return nil unless herb_available?
+
+        check = new([], paths: paths)
+
+        check.send(:template_files).flat_map { |file| check.send(:check_file, file) }
+      end
+
+      def self.herb_available?
+        require "herb"
+        require "ruby_native/cli/check/signal_collector"
+        true
+      rescue LoadError
+        false
+      end
+
+      def initialize(argv, paths: nil)
+        @deployed = argv.include?("--deployed")
+        @paths = paths || parse_paths(argv)
+      end
+
+      def run
+        require_herb!
+
+        files = template_files
+        if files.empty?
+          puts "No .html.erb templates found in #{@paths.join(", ")}."
+          return
+        end
+
+        offenses = files.flat_map { |file| check_file(file) }
+        offenses += deployed_offenses(files) if @deployed
+
+        report(files, offenses)
+        exit 1 if offenses.any? { |offense| offense.severity == :error }
+      end
+
+      private
+
+      # --- Loading ---
+
+      def require_herb!
+        return if self.class.herb_available?
+
+        puts "`ruby_native check` needs the herb gem, which parses HTML and ERB together."
+        puts ""
+        puts "Add it to your Gemfile:"
+        puts "  gem \"herb\""
+        puts ""
+        puts "Rails 8.2 and later already ship it as a dependency of Action View."
+        exit 1
+      end
+
+      def template_files
+        @paths.flat_map { |path| Dir.glob(File.join(path, "**", "*.html.erb")) }.sort
+      end
+
+      # --- Per-file checks ---
+
+      # Herb's parser tolerates markup its compiler rejects, so every template
+      # gets scanned whether or not it would build under Rails 8.2. Whether
+      # their ERB is Herb-clean is their upgrade to make, and `herb lint` is
+      # the tool for it.
+      def check_file(file)
+        signal_offenses(file, File.read(file, encoding: "UTF-8"))
+      rescue ArgumentError => error
+        [Offense.new(file: file, line: 1, severity: :error, message: "Could not read the file: #{error.message}")]
+      end
+
+      def signal_offenses(file, source)
+        result = Herb.parse(source)
+        collector = SignalCollector.new
+        result.value.accept(collector)
+
+        offenses = []
+
+        collector.signals.each do |name, lines|
+          unless RubyNative::Signals.known?(name)
+            suggestion = RubyNative::Signals.nearest(name)
+            message = "Unknown signal `#{name}`."
+            message += " Did you mean `#{suggestion}`?" if suggestion
+            offenses << Offense.new(file: file, line: lines.first, severity: :error, message: message)
+            next
+          end
+
+          if lines.size > 1 && RubyNative::Signals.singleton?(name)
+            offenses << Offense.new(
+              file: file,
+              line: lines[1],
+              severity: :warning,
+              message: "#{lines.size} elements carry `#{name}`; only the first one is used."
+            )
+          end
+
+          offenses.concat(version_offenses(file, name, lines.first))
+        end
+
+        offenses
+      end
+
+      # A signal newer than the installed gem is one the app was never told
+      # about, so it is inert on device however correct it looks in the markup.
+      def version_offenses(file, name, line)
+        since = RubyNative::Signals.since(name)
+        return [] unless since
+        return [] if Gem::Version.new(RubyNative::VERSION) >= Gem::Version.new(since)
+
+        [Offense.new(
+          file: file,
+          line: line,
+          severity: :error,
+          message: "`#{name}` needs Ruby Native #{since}, but this app is on #{RubyNative::VERSION}."
+        )]
+      end
+
+      # --- Deployed build check ---
+
+      # The gem version in the Gemfile says what the views may emit. The build
+      # in the store says what the app can actually honor, and those drift
+      # apart the moment someone bumps the gem without deploying.
+      def deployed_offenses(files)
+        app_id = config.dig(:ruby_native, :app_id)
+        unless app_id
+          puts "Skipping --deployed: no app_id in #{CONFIG_PATH}. Run `ruby_native deploy` once to link this app."
+          return []
+        end
+
+        unless Credentials.token
+          puts "Skipping --deployed: not logged in. Run `ruby_native login` first."
+          return []
+        end
+
+        used = signals_in(files)
+        PLATFORMS.flat_map { |platform| deployed_offenses_for(platform, app_id, used) }
+      end
+
+      def deployed_offenses_for(platform, app_id, used)
+        built = latest_build_version(app_id, platform)
+        return [] unless built
+
+        used.filter_map do |name, (file, line)|
+          since = RubyNative::Signals.since(name)
+          next unless since
+          next if Gem::Version.new(built) >= Gem::Version.new(since)
+
+          Offense.new(
+            file: file,
+            line: line,
+            severity: :error,
+            message: "`#{name}` needs #{since}, but the #{platform} build users have was made on #{built}."
+          )
+        end
+      end
+
+      def signals_in(files)
+        files.each_with_object({}) do |file, used|
+          collector = SignalCollector.new
+          Herb.parse(File.read(file, encoding: "UTF-8")).value.accept(collector)
+          collector.signals.each { |name, lines| used[name] ||= [file, lines.first] }
+        rescue StandardError
+          next
+        end
+      end
+
+      def latest_build_version(app_id, platform)
+        uri = URI("#{HOST}/api/v1/apps/#{app_id}/builds/latest?platform=#{platform}")
+        request = Net::HTTP::Get.new(uri)
+        request["Authorization"] = "Token #{Credentials.token}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(request)
+        end
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+        return nil if response.body.to_s.empty?
+
+        JSON.parse(response.body)["gem_version"]
+      rescue StandardError
+        # A check that cannot reach the API should not fail the build; the
+        # local checks above still ran and still mean something.
+        puts "Skipping --deployed for #{platform}: could not reach #{HOST}."
+        nil
+      end
+
+      def config
+        @config ||= if File.exist?(CONFIG_PATH)
+          YAML.load_file(CONFIG_PATH, symbolize_names: true, aliases: true) || {}
+        else
+          {}
+        end
+      rescue Psych::SyntaxError
+        {}
+      end
+
+      # --- Reporting ---
+
+      def report(files, offenses)
+        errors, warnings = offenses.partition { |offense| offense.severity == :error }
+
+        offenses.group_by(&:file).sort.each do |file, file_offenses|
+          puts file
+          file_offenses.sort_by(&:line).each do |offense|
+            location = "#{offense.line}:".ljust(5)
+            marker = offense.severity.to_s.ljust(8)
+            puts "  #{location}#{marker}#{offense.message}"
+          end
+          puts ""
+        end
+
+        summary = "Checked #{files.size} #{files.size == 1 ? "template" : "templates"}"
+        if offenses.empty?
+          puts "#{summary}. No problems found."
+        else
+          puts "#{summary}: #{errors.size} #{errors.size == 1 ? "error" : "errors"}, " \
+               "#{warnings.size} #{warnings.size == 1 ? "warning" : "warnings"}."
+        end
+      end
+
+      def parse_paths(argv)
+        flag = argv.find { |argument| argument.start_with?("--paths=") }
+        return DEFAULT_PATHS unless flag
+
+        flag.split("=", 2).last.split(",").map(&:strip).reject(&:empty?)
+      end
+    end
+  end
+end

data/lib/ruby_native/cli/deploy.rb

@@ -2,6 +2,7 @@ require "json"
 require "net/http"
 require "uri"
 require "openssl"
+require "ruby_native/cli/check"
 require "ruby_native/cli/credentials"
 require "ruby_native/version"
 
@@ -12,7 +13,7 @@ module RubyNative
       HOST = ENV.fetch("RUBY_NATIVE_HOST", "https://rubynative.com")
       POLL_INTERVAL = 5
       POLL_TIMEOUT = 600
-      PLATFORMS = %w[ios android].freeze
+      PLATFORMS = %w[ios android all].freeze
       # Consecutive failures tolerated mid-poll; one blip must not kill a
       # deploy whose build is succeeding server-side.
       MAX_POLL_FAILURES = 3
@@ -31,6 +32,7 @@ module RubyNative
 
       def initialize(argv)
         @if_needed = argv.include?("--if-needed")
+        @skip_check = argv.include?("--skip-check")
         @platform = parse_platform(argv)
       end
 
@@ -44,10 +46,14 @@ module RubyNative
           return
         end
 
+        check_signals! unless @skip_check
+
         build = trigger_build(app_id)
         return if @if_needed
 
-        poll_build_status(app_id, build)
+        # `builds` is present when one deploy started more than one; an older
+        # server omits it and the primary build is the whole story.
+        poll_build_status(app_id, build, Array(build["builds"]).drop(1))
       rescue TokenExpiredError
         abort_token_expired!
       rescue ConnectionError => error
@@ -58,6 +64,25 @@ module RubyNative
 
       private
 
+      # A broken signal is invisible until someone opens the build, so it is
+      # worth a second here rather than a TestFlight round trip. Skipped
+      # silently when herb is missing: this is a courtesy, not a dependency the
+      # gem gets to impose on a deploy.
+      def check_signals!
+        offenses = Check.signal_offenses
+        return if offenses.nil?
+
+        errors = offenses.select { |offense| offense.severity == :error }
+        return if errors.empty?
+
+        puts "Found #{errors.size} signal #{errors.size == 1 ? "problem" : "problems"} in your views:"
+        errors.first(10).each { |error| puts "  #{error.file}:#{error.line}  #{error.message}" }
+        puts "  ...and #{errors.size - 10} more." if errors.size > 10
+        puts
+        puts "These will not work in the build. Fix them, or deploy anyway with --skip-check."
+        exit 1
+      end
+
       def ensure_authenticated!
         return if Credentials.token
 
@@ -135,14 +160,30 @@ module RubyNative
         latest = fetch_latest_build(app_id)
         return false unless latest
 
-        latest_gem_version = latest["gem_version"]
-        return false unless latest_gem_version
+        return skip_all?(latest) if @platform == "all"
 
-        Gem::Version.new(latest_gem_version) >= Gem::Version.new(RubyNative::VERSION)
+        current?(latest["gem_version"])
       rescue ArgumentError
         false
       end
 
+      # Skip only when every platform that could build is already on this gem
+      # version. A track that is set up but has never built is exactly the case
+      # that must not skip, which is why the server reports `deployable`
+      # separately from whether a build exists.
+      def skip_all?(latest)
+        deployable = latest.select { |_platform, state| state.is_a?(Hash) && state["deployable"] }
+        return false if deployable.empty?
+
+        deployable.all? { |_platform, state| current?(state["gem_version"]) }
+      end
+
+      def current?(gem_version)
+        return false unless gem_version
+
+        Gem::Version.new(gem_version) >= Gem::Version.new(RubyNative::VERSION)
+      end
+
       def fetch_latest_build(app_id)
         # Platform-scoped, or --android --if-needed compares against the
         # latest iOS build and skips a build Android never got.
@@ -218,17 +259,21 @@ module RubyNative
 
       # --- Polling ---
 
-      def poll_build_status(app_id, build)
-        build_id = build["id"]
-        last_status = build["status"]
+      # Polls every build this deploy started, not just the first. With both
+      # platforms dispatched at once, watching only one meant a failed Android
+      # build exited 0 and left CI green over a broken release.
+      def poll_build_status(app_id, build, others = [])
+        states = ([build] + Array(others)).compact.uniq { |candidate| candidate["id"] }.map do |candidate|
+          { id: candidate["id"], platform: candidate["platform"], status: candidate["status"], not_found: 0, error: nil, result: nil }
+        end
+        many = states.size > 1
+
         puts ""
-        puts "Waiting for build to complete. Ctrl+C to exit (your build will continue)."
-        print_status(last_status)
+        puts "Waiting for #{many ? "builds" : "build"} to complete. Ctrl+C to exit (your #{many ? "builds" : "build"} will continue)."
+        states.each { |state| print_status(state[:status], label_for(state, many)) }
 
         started_at = Time.now
         connection_failures = 0
-        not_found_count = 0
-        reported_error = nil
 
         loop do
           sleep POLL_INTERVAL
@@ -239,70 +284,106 @@ module RubyNative
             exit 1
           end
 
-          begin
-            state, payload = fetch_build_status(app_id, build_id)
-            connection_failures = 0
-          rescue ConnectionError => error
+          connection_error = nil
+          reached = 0
+
+          states.reject { |state| state[:result] }.each do |state|
+            begin
+              api_state, payload = fetch_build_status(app_id, state[:id])
+              reached += 1
+            rescue ConnectionError => error
+              connection_error = error
+              next
+            end
+
+            advance_build(state, api_state, payload, many)
+          end
+
+          # Only a tick where nothing was reachable counts against the budget,
+          # so one platform answering keeps the deploy alive.
+          if reached.zero?
             connection_failures += 1
             next if connection_failures < MAX_POLL_FAILURES
 
             puts ""
-            puts error.message
+            puts connection_error.message
             puts "Your build is most likely still running server-side. Check the"
             puts "Ruby Native dashboard for the result: #{HOST}/dashboard"
             exit 1
           end
 
-          case state
-          when :not_found
-            not_found_count += 1
-            next if not_found_count < MAX_POLL_FAILURES
+          connection_failures = 0
+          break if states.all? { |state| state[:result] }
+        end
 
-            puts ""
-            puts "The server can no longer find this build (404). The app or build"
-            puts "may have been deleted or archived. Check the Ruby Native"
-            puts "dashboard: #{HOST}/dashboard"
-            exit 1
-          when :error
-            # The build keeps running server-side through a 500, so keep polling.
-            if payload != reported_error
-              reported_error = payload
-              puts ""
-              puts "#{URI(HOST).host} returned #{payload} while checking the build. Still trying..."
-            end
-            next
-          end
+        exit 1 if states.any? { |state| state[:result] == :failed }
+      rescue Interrupt
+        puts ""
+        puts ""
+        puts "Stopped polling. Your build is still running."
+        puts "Check the Ruby Native dashboard for status."
+      end
 
-          not_found_count = 0
-          data = payload
-          print_notice(data)
+      def advance_build(state, api_state, payload, many)
+        label = label_for(state, many)
 
-          if data["status"] != last_status
-            last_status = data["status"]
-            print_status(last_status)
-          end
+        case api_state
+        when :not_found
+          state[:not_found] += 1
+          return if state[:not_found] < MAX_POLL_FAILURES
 
-          case last_status
-          when "success", "ready"
-            puts ""
-            puts "Build succeeded!"
-            puts "  Version: v#{data["version"]} (#{data["number"]})"
-            puts "  Ruby Native: #{data["native_version"]}" if data["native_version"]
-            puts ""
-            puts success_destination_message(data)
-            break
-          when "failure", "failed", "cancelled"
+          puts ""
+          puts "#{label}The server can no longer find this build (404). The app or build"
+          puts "may have been deleted or archived. Check the Ruby Native"
+          puts "dashboard: #{HOST}/dashboard"
+          state[:result] = :failed
+          return
+        when :error
+          # The build keeps running server-side through a 500, so keep polling.
+          if payload != state[:error]
+            state[:error] = payload
             puts ""
-            puts "Build failed."
-            puts "  Error: #{data["error_message"]}" if data["error_message"]
-            exit 1
+            puts "#{label}#{URI(HOST).host} returned #{payload} while checking the build. Still trying..."
           end
+          return
+        end
+
+        state[:not_found] = 0
+        data = payload
+        print_notice(data)
+
+        if data["status"] != state[:status]
+          state[:status] = data["status"]
+          print_status(state[:status], label)
+        end
+
+        case state[:status]
+        when "success", "ready"
+          puts ""
+          puts "#{label}Build succeeded!"
+          puts "  Version: v#{data["version"]} (#{data["number"]})"
+          puts "  Ruby Native: #{data["native_version"]}" if data["native_version"]
+          puts ""
+          puts success_destination_message(data)
+          state[:result] = :succeeded
+        when "failure", "failed", "cancelled"
+          puts ""
+          puts "#{label}Build failed."
+          puts "  Error: #{data["error_message"]}" if data["error_message"]
+          state[:result] = :failed
+        end
+      end
+
+      # Platform names only appear when there is more than one build to tell
+      # apart, so single-platform output is unchanged.
+      def label_for(state, many)
+        return "" unless many
+
+        case state[:platform]
+        when "ios" then "iOS: "
+        when "android" then "Android: "
+        else ""
         end
-      rescue Interrupt
-        puts ""
-        puts ""
-        puts "Stopped polling. Your build is still running."
-        puts "Check the Ruby Native dashboard for status."
       end
 
       # Returns [:ok, data], [:not_found, nil], or [:error, description].
@@ -331,9 +412,9 @@ module RubyNative
         end
       end
 
-      def print_status(status)
+      def print_status(status, prefix = "")
         label = status_labels[status]
-        puts "  #{label}..." if label
+        puts "  #{prefix}#{label}..." if label
       end
 
       # Server-provided warnings (a lapsed payment, say) reach customers with
@@ -373,15 +454,19 @@ module RubyNative
         end
       end
 
+      # Every configured platform by default: "deploy my app" means the app, not
+      # whichever half was written first. The server decides what is actually
+      # ready, so an iOS-only app still just builds iOS.
       def parse_platform(argv)
         return "android" if argv.include?("--android")
+        return "ios" if argv.include?("--ios")
 
         flag = argv.find { |a| a.start_with?("--platform=") }
-        return "ios" unless flag
+        return "all" unless flag
 
         value = flag.split("=", 2).last
         unless PLATFORMS.include?(value)
-          puts "Unknown platform #{value.inspect}. Use --platform=ios or --platform=android."
+          puts "Unknown platform #{value.inspect}. Use --platform=ios, --platform=android, or --platform=all."
           exit 1
         end
         value

data/lib/ruby_native/cli.rb

@@ -1,3 +1,4 @@
+require "ruby_native/cli/check"
 require "ruby_native/cli/credentials"
 require "ruby_native/cli/deploy"
 require "ruby_native/cli/login"
@@ -8,6 +9,8 @@ module RubyNative
     def self.start(argv)
       command = argv.shift
       case command
+      when "check"
+        RubyNative::CLI::Check.new(argv).run
       when "deploy"
         RubyNative::CLI::Deploy.new(argv).run
       when "preview"
@@ -40,10 +43,15 @@ module RubyNative
       puts "Usage: ruby_native <command> [options]"
       puts ""
       puts "Commands:"
-      puts "  deploy        Trigger a build and wait for it to finish"
-      puts "    --android          Build for Android instead of iOS"
-      puts "    --platform=NAME    Build for ios or android"
+      puts "  check         Validate your views against the signal vocabulary"
+      puts "    --deployed         Also compare against the build your users have"
+      puts "    --paths=A,B        Directories to scan (default: app/views)"
+      puts "  deploy        Build every configured platform and wait for it to finish"
+      puts "    --ios              Build iOS only"
+      puts "    --android          Build Android only"
+      puts "    --platform=NAME    Build for ios, android, or all"
       puts "    --if-needed        Skip when this gem version is already built"
+      puts "    --skip-check       Deploy without checking your views for broken signals"
       puts "  login         Authenticate with Ruby Native"
       puts "  logout        Remove stored credentials"
       puts "  preview       Start a tunnel and display a QR code"

data/lib/ruby_native/helper.rb

@@ -347,6 +347,13 @@ module RubyNative
         @items = []
       end
 
+      # Adds a button to the nav bar. `position:` is :leading, :trailing (the
+      # default; repeat it and the buttons sit side by side), or :title, which
+      # turns the bar's title into a dropdown menu instead of adding a bar item.
+      # A :title button takes a menu block and no icon or label of its own: keep
+      # a title on `native_navbar_tag` and it labels the dropdown, or omit it and
+      # the `selected:` item's text does.
+      # https://rubynative.com/docs/navbar#title-menu
       def button(title = nil, icon: nil, icons: nil, href: nil, click: nil, position: :trailing, selected: false, &block)
         resolved = RubyNative::Helper.resolve_icon(icon: icon, icons: icons, platform: @context.try(:native_platform))
         data = { native_button: "" }

data/lib/ruby_native/signals.rb

@@ -0,0 +1,78 @@
+require "yaml"
+
+module RubyNative
+  # The signal vocabulary, loaded from config/signals.yml. This is the single
+  # source of truth for what a valid data-native-* attribute is: `ruby_native
+  # check` validates views against it, and the native shells assert their own
+  # copy matches.
+  module Signals
+    PATH = File.expand_path("../../config/signals.yml", __dir__)
+
+    class << self
+      def all
+        @all ||= YAML.load_file(PATH).fetch("signals").freeze
+      end
+
+      def names
+        @names ||= all.keys.freeze
+      end
+
+      def known?(name)
+        all.key?(name)
+      end
+
+      # Signals read via querySelector, where only the first match wins, so a
+      # second one on the same page is silently ignored.
+      def singletons
+        @singletons ||= all.select { |_name, meta| meta["singleton"] }.keys.freeze
+      end
+
+      def singleton?(name)
+        singletons.include?(name)
+      end
+
+      # The gem version that introduced the signal. nil for signals the app
+      # writes into the page rather than ones your views emit.
+      def since(name)
+        all.dig(name, "since")
+      end
+
+      def helper(name)
+        all.dig(name, "helper")
+      end
+
+      # Closest known signal within one or two edits, for "did you mean". A
+      # genuinely unrelated attribute gets no suggestion rather than a
+      # confusing one.
+      def nearest(name, threshold: 2)
+        # Ties on edit distance break toward the longer shared prefix, so a
+        # typo'd `data-native-tab` suggests `data-native-tabs` rather than
+        # `data-native-fab`, which is just as close by raw distance.
+        candidate = names.min_by { |known| [distance(name, known), -common_prefix_length(name, known)] }
+        candidate if candidate && distance(name, candidate) <= threshold
+      end
+
+      private
+
+      def common_prefix_length(a, b)
+        length = 0
+        length += 1 while length < a.length && length < b.length && a[length] == b[length]
+        length
+      end
+
+      def distance(a, b)
+        rows = Array.new(a.length + 1) { |i| [i] + Array.new(b.length, 0) }
+        (0..b.length).each { |j| rows[0][j] = j }
+
+        (1..a.length).each do |i|
+          (1..b.length).each do |j|
+            cost = a[i - 1] == b[j - 1] ? 0 : 1
+            rows[i][j] = [rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + cost].min
+          end
+        end
+
+        rows[a.length][b.length]
+      end
+    end
+  end
+end

data/lib/ruby_native/version.rb

@@ -1,3 +1,3 @@
 module RubyNative
-  VERSION = "0.15.2"
+  VERSION = "0.16.0"
 end

data/lib/ruby_native.rb

@@ -62,6 +62,7 @@ module RubyNative
     normalize_linked_paths
     backfill_tab_icons
     backfill_error_icons
+    warn_on_duplicate_tab_keys
   end
 
   # config/ruby_native.yml is rendered as ERB before it is parsed, so a
@@ -95,6 +96,21 @@ module RubyNative
     end
   end
 
+  # A tab's `key` names its copy in the host app's locale files, so two tabs
+  # sharing one read the same translations and one of them is always
+  # mislabeled. Warn rather than raise: both tabs still render, and a typo in
+  # the config should never take down boot.
+  def self.warn_on_duplicate_tab_keys
+    keys = Array(self.config[:tabs]).filter_map { |tab| tab[:key] if tab.is_a?(Hash) }
+    duplicates = keys.tally.select { |_, count| count > 1 }.keys
+    return if duplicates.empty?
+
+    Rails.logger.warn(
+      "[RubyNative] Duplicate tab key(s) in config/ruby_native.yml " \
+      "(#{duplicates.join(", ")}). Each tab needs its own key, or they share a title."
+    )
+  end
+
   # Mirrors `backfill_tab_icons` for the error screen: fills a state's flat
   # `icon` from its per-platform `icons` (ios first, then android), so the iOS
   # app, which reads only the flat `icon`, still renders one. An explicit
@@ -134,6 +150,7 @@ module RubyNative
     # Shipped app binaries have required the `appearance` key at decode; keep
     # emitting it so they still boot when the YAML omits the block.
     payload[:appearance] ||= {}
+    localize_tab_titles(payload[:tabs])
     errors = error_screen_config(payload[:errors])
     if errors.empty?
       payload.delete(:errors)
@@ -143,6 +160,51 @@ module RubyNative
     payload
   end
 
+  # Fills each tab's `titles` from `ruby_native.tabs.<key>.title` in the host
+  # app's locale files, mirroring the `ruby_native.errors.*` namespace. The map
+  # is emitted beside the flat `title` rather than replacing it, the same
+  # additive shape as `icon`/`icons`: both platforms decode `title` as a plain
+  # String, so an app that does not read `titles` yet keeps rendering the YAML
+  # copy. Tabs without a `key` are left exactly as authored.
+  #
+  # `title:` is optional in the YAML so a localized app can keep all of its copy
+  # in locale files, but it is never optional on the wire: both platforms decode
+  # it as a required, non-optional String, so a tab missing one fails the whole
+  # config decode and drops the user on the error screen. Fill it from the
+  # default locale, then from any locale that was translated.
+  def self.localize_tab_titles(tabs)
+    Array(tabs).each do |tab|
+      next unless tab.is_a?(Hash)
+
+      key = tab[:key].to_s
+      titles = key.empty? ? {} : translations_for("tabs.#{key}.title")
+      tab[:titles] = titles unless titles.empty?
+      next unless tab[:title].to_s.empty?
+
+      tab[:title] = titles[I18n.default_locale] || titles.values.first || fallback_tab_title(key)
+    end
+  end
+
+  # Reached only when a tab has no `title:` and no translation in any locale,
+  # which would otherwise serve a payload that cannot decode. Names the tab
+  # after its key ("order_history" -> "Order history") so the bar still renders
+  # something recognizable, and says so, since the copy is missing everywhere.
+  def self.fallback_tab_title(key)
+    if key.empty?
+      Rails.logger.warn(
+        "[RubyNative] A tab in config/ruby_native.yml has no `title:`. Give it one, or a `key:` " \
+        "with copy under `ruby_native.tabs.<key>.title` in your locale files."
+      )
+      return "Untitled"
+    end
+
+    Rails.logger.warn(
+      "[RubyNative] Tab #{key.inspect} in config/ruby_native.yml has no `title:` and no " \
+      "`ruby_native.tabs.#{key}.title` translation in any locale. Falling back to a title from the key."
+    )
+    key.humanize
+  end
+
   # Merges per-state error-screen icons (from YAML) with localized copy (from
   # I18n) into the shape the native apps decode. Omits any state with neither an
   # icon nor copy, so an untouched app sends no `errors` block at all.
@@ -155,7 +217,7 @@ module RubyNative
         entry[:icons] = state_config[:icons] if state_config[:icons]
       end
       ERROR_SCREEN_COPY_KEYS.each do |key|
-        translations = error_screen_translations("#{state}.#{key}")
+        translations = translations_for("errors.#{state}.#{key}")
         entry[key] = translations unless translations.empty?
       end
       result[state] = entry unless entry.empty?
@@ -163,17 +225,17 @@ module RubyNative
 
     # The Retry button label is shared by both states, so it sits at the top of
     # the block rather than under a state.
-    retry_label = error_screen_translations("retry")
+    retry_label = translations_for("errors.retry")
     config[:retry] = retry_label unless retry_label.empty?
     config
   end
 
-  # Reads `ruby_native.errors.<subkey>` for every available locale, keeping only
-  # the locales the developer actually translated. Copy lives in the host app's
-  # own locale files; the gem ships none.
-  def self.error_screen_translations(subkey)
+  # Reads `ruby_native.<subkey>` for every available locale, keeping only the
+  # locales the developer actually translated. Copy lives in the host app's own
+  # locale files; the gem ships none.
+  def self.translations_for(subkey)
     I18n.available_locales.each_with_object({}) do |locale, result|
-      value = I18n.t("ruby_native.errors.#{subkey}", locale: locale, default: nil)
+      value = I18n.t("ruby_native.#{subkey}", locale: locale, default: nil)
       result[locale] = value unless value.nil?
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_native
 version: !ruby/object:Gem::Version
-  version: 0.15.2
+  version: 0.16.0
 platform: ruby
 authors:
 - Joe Masilotti
@@ -84,6 +84,7 @@ files:
 - app/views/ruby_native/auth/start/show.html.erb
 - config/importmap.rb
 - config/routes.rb
+- config/signals.yml
 - exe/ruby_native
 - lib/generators/ruby_native/iap_generator.rb
 - lib/generators/ruby_native/install_generator.rb
@@ -93,6 +94,8 @@ files:
 - lib/ruby_native.rb
 - lib/ruby_native/certs/AppleRootCA-G3.cer
 - lib/ruby_native/cli.rb
+- lib/ruby_native/cli/check.rb
+- lib/ruby_native/cli/check/signal_collector.rb
 - lib/ruby_native/cli/credentials.rb
 - lib/ruby_native/cli/deploy.rb
 - lib/ruby_native/cli/login.rb
@@ -110,6 +113,7 @@ files:
 - lib/ruby_native/oauth_middleware.rb
 - lib/ruby_native/screenshots/sign_in_helper.rb
 - lib/ruby_native/set_cookie_header.rb
+- lib/ruby_native/signals.rb
 - lib/ruby_native/tunnel_cookie_middleware.rb
 - lib/ruby_native/version.rb
 homepage: https://rubynative.com