ruby_raider 3.8.0 → 3.10.0

data/lib/ruby_raider/ffmpeg.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'net/http'
+require 'rbconfig'
+require 'securerandom'
+require 'uri'
+
+module RubyRaider
+  # Pinned, checksum-verified ffmpeg provisioning. Stdlib only so generated
+  # projects can load it standalone via `require 'ruby_raider/ffmpeg'`.
+  module Ffmpeg
+    MAX_REDIRECTS = 5
+    # Seconds for the whole download, redirects included.
+    DOWNLOAD_TIMEOUT = 300
+
+    # Checksums are filled in when the RaiderHQ `ffmpeg-7.1` release is cut.
+    RELEASE_BASE = 'https://github.com/RaiderHQ/ruby_raider/releases/download/ffmpeg-7.1/ffmpeg-7.1-'
+    MANIFEST = {
+      version: '7.1',
+      assets: {
+        'darwin-arm64' => { url: "#{RELEASE_BASE}darwin-arm64".freeze, sha256: nil }.freeze,
+        'darwin-x64' => { url: "#{RELEASE_BASE}darwin-x64".freeze, sha256: nil }.freeze,
+        'linux-x64' => { url: "#{RELEASE_BASE}linux-x64".freeze, sha256: nil }.freeze,
+        'windows-x64' => { url: "#{RELEASE_BASE}windows-x64.exe".freeze, sha256: nil }.freeze
+      }.freeze
+    }.freeze
+
+    PLATFORMS = %w[darwin-arm64 darwin-x64 linux-x64 windows-x64].freeze
+    # $stderr.puts, not Kernel#warn: warn is silenced under -W0 / $VERBOSE = nil.
+    # rubocop:disable Style/StderrPuts
+    DEFAULT_WARN = ->(message) { $stderr.puts("[video] #{message}") }
+    # rubocop:enable Style/StderrPuts
+
+    @verified = {}
+
+    class << self
+      def platform(host_os: RbConfig::CONFIG['host_os'], host_cpu: RbConfig::CONFIG['host_cpu'])
+        os = host_os_name(host_os)
+        cpu = host_cpu_name(host_cpu)
+        return nil unless os && cpu
+
+        candidate = "#{os}-#{cpu}"
+        PLATFORMS.include?(candidate) ? candidate : nil
+      end
+
+      def cache_dir(env: ENV, platform: self.platform)
+        override = env['RAIDER_CACHE_DIR']
+        return override if override && !override.empty?
+
+        local = env['LOCALAPPDATA']
+        if platform == 'windows-x64' && local && !local.empty?
+          File.join(local, 'raider')
+        else
+          File.join(Dir.home, '.cache', 'raider')
+        end
+      end
+
+      def cached_path(env: ENV, manifest: MANIFEST, platform: self.platform)
+        name = platform.to_s.start_with?('windows') ? 'ffmpeg.exe' : 'ffmpeg'
+        File.join(cache_dir(env:, platform:), 'ffmpeg', manifest[:version], name)
+      end
+
+      # No network: the env override if executable, else the verified cached binary.
+      # Never raises: any StandardError becomes one warning and nil.
+      def resolve(env: ENV, manifest: MANIFEST, warn: nil, platform: nil)
+        warn ||= DEFAULT_WARN
+        guarded(warn) do
+          lookup(env, manifest, warn, platform || self.platform).first
+        end
+      end
+
+      # Never raises: any StandardError becomes one warning and nil.
+      def ensure!(env: ENV, manifest: MANIFEST, fetch: nil, warn: nil, platform: nil)
+        warn ||= DEFAULT_WARN
+        guarded(warn) do
+          platform ||= self.platform
+          path, final = lookup(env, manifest, warn, platform)
+          next path if path || final
+
+          provision(env, manifest, fetch || method(:http_get), warn, platform)
+        end
+      end
+
+      # Cheap check, no network and no hashing: can this run get an ffmpeg at all?
+      # True for an executable RAIDER_FFMPEG_PATH or a checksummed asset for the platform.
+      def obtainable?(env: ENV, manifest: MANIFEST, platform: nil)
+        override = env['RAIDER_FFMPEG_PATH']
+        return true if override && !override.empty? && executable_file?(override)
+
+        !manifest[:assets][(platform || self.platform).to_s]&.fetch(:sha256, nil).nil?
+      rescue StandardError
+        false
+      end
+
+      def http_get(url, destination, limit = MAX_REDIRECTS, timeout: DOWNLOAD_TIMEOUT, deadline: nil)
+        raise ArgumentError, "refusing non-https url: #{url}" unless https?(url)
+        raise IOError, 'too many redirects' if limit.negative?
+
+        deadline ||= monotonic_now + timeout
+        uri = URI(url)
+        location = nil
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true, **socket_timeouts(deadline, timeout)) do |http|
+          http.request(Net::HTTP::Get.new(uri)) do |response|
+            location = handle_response(response, destination, deadline, timeout)
+          end
+        end
+        http_get(URI.join(url, location).to_s, destination, limit - 1, timeout:, deadline:) if location
+      end
+
+      private
+
+      # Returns the redirect location, or nil once the body is written.
+      def handle_response(response, destination, deadline, timeout)
+        case response
+        when Net::HTTPSuccess
+          File.open(destination, 'wb') do |file|
+            response.read_body do |chunk|
+              check_deadline(deadline, timeout)
+              file.write(chunk)
+            end
+          end
+          nil
+        when Net::HTTPRedirection
+          response['location'] || raise(IOError, 'redirect without Location header')
+        else
+          raise IOError, "download failed: HTTP #{response.code}"
+        end
+      end
+
+      def socket_timeouts(deadline, timeout)
+        left = check_deadline(deadline, timeout)
+        { open_timeout: [10, left].min, read_timeout: [60, left].min }
+      end
+
+      def check_deadline(deadline, timeout)
+        left = deadline - monotonic_now
+        raise IOError, "download took longer than #{timeout} seconds" unless left.positive?
+
+        left
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def guarded(warn)
+        yield
+      rescue StandardError => e
+        warn_nil(warn, "ffmpeg unavailable: #{e.message}")
+      end
+
+      def reset_verified_cache!
+        @verified.clear
+      end
+
+      def host_os_name(host_os)
+        case host_os
+        when /darwin/ then 'darwin'
+        when /linux/ then 'linux'
+        when /mswin|mingw|cygwin|windows/ then 'windows'
+        end
+      end
+
+      def host_cpu_name(host_cpu)
+        case host_cpu
+        when /arm64|aarch64/ then 'arm64'
+        when /x86_64|x64|amd64/ then 'x64'
+        end
+      end
+
+      # Returns [path_or_nil, final]. final means "do not try to download".
+      def lookup(env, manifest, warn, platform)
+        override = env['RAIDER_FFMPEG_PATH']
+        if override && !override.empty?
+          return [override, true] if executable_file?(override)
+
+          warn.call('RAIDER_FFMPEG_PATH is not an executable file; ignoring')
+        end
+        cached_lookup(env, manifest, warn, platform)
+      end
+
+      def cached_lookup(env, manifest, warn, platform)
+        sha = manifest[:assets][platform.to_s]&.fetch(:sha256, nil)
+        path = cached_path(env:, manifest:, platform:)
+        return [nil, false] unless platform && sha && executable_file?(path)
+        return [path, true] if verified_cached?(path, sha)
+
+        FileUtils.rm_f(path)
+        warn.call('cached ffmpeg failed checksum; video disabled')
+        [nil, true]
+      end
+
+      def verified_cached?(path, sha256)
+        key = verification_key(path, sha256)
+        return true if @verified[key]
+
+        ok = verified?(path, sha256)
+        @verified[key] = true if ok
+        ok
+      end
+
+      def verification_key(path, sha256)
+        stat = File.stat(path)
+        [path, stat.ino, stat.mtime.to_f, stat.ctime.to_f, stat.size, sha256]
+      end
+
+      def provision(env, manifest, fetch, warn, platform)
+        asset = manifest[:assets][platform.to_s]
+        unless asset
+          label = platform || "#{RbConfig::CONFIG['host_os']}/#{RbConfig::CONFIG['host_cpu']}"
+          return warn_nil(warn, "no ffmpeg build for this platform (#{label})")
+        end
+        return warn_nil(warn, 'ffmpeg build not published yet') unless asset[:sha256]
+        return warn_nil(warn, "refusing non-https ffmpeg url: #{asset[:url]}") unless https?(asset[:url])
+
+        download(cached_path(env:, manifest:, platform:), asset, fetch, warn)
+      end
+
+      def download(destination, asset, fetch, warn)
+        part = "#{destination}.#{Process.pid}.#{SecureRandom.hex(4)}.part"
+        created = missing_dirs(File.dirname(destination))
+        begin
+          FileUtils.mkdir_p(File.dirname(destination))
+          fetch.call(asset[:url], part)
+          return warn_nil(warn, "ffmpeg checksum mismatch for #{asset[:url]}; download discarded") unless verified?(part, asset[:sha256])
+
+          File.chmod(0o755, part)
+          # Rename wins: if another process already installed a valid binary, keep it.
+          File.rename(part, destination) unless File.file?(destination) && verified?(destination, asset[:sha256])
+          @verified[verification_key(destination, asset[:sha256])] = true
+          destination
+        rescue StandardError => e
+          warn_nil(warn, "ffmpeg download failed: #{e.message}")
+        ensure
+          FileUtils.rm_f(part)
+          remove_empty(created)
+        end
+      end
+
+      # The dirs mkdir_p would create for dir, deepest first.
+      def missing_dirs(dir)
+        missing = []
+        until File.exist?(dir) || File.dirname(dir) == dir
+          missing << dir
+          dir = File.dirname(dir)
+        end
+        missing
+      end
+
+      # After a failed download, so CI never caches an empty ffmpeg/<version>/.
+      # Dir.rmdir only removes empty dirs, so a concurrent install is kept.
+      def remove_empty(dirs)
+        dirs.each { |dir| Dir.rmdir(dir) }
+      rescue SystemCallError
+        nil
+      end
+
+      def verified?(path, sha256)
+        Digest::SHA256.file(path).hexdigest.casecmp?(sha256)
+      end
+
+      def executable_file?(path)
+        File.file?(path) && File.executable?(path)
+      end
+
+      def https?(url)
+        URI(url).scheme == 'https'
+      rescue URI::InvalidURIError
+        false
+      end
+
+      def warn_nil(warn, message)
+        warn.call(message)
+        nil
+      end
+    end
+  end
+end

data/lib/ruby_raider.rb

@@ -8,6 +8,8 @@ autoload :UtilityCommands, File.expand_path('commands/utility_commands', __dir__
 
 module RubyRaider
   class Raider < Thor
+    def self.exit_on_failure? = true
+
     no_tasks do
       def current_version = File.read(File.expand_path('version', __dir__)).strip
     end
@@ -52,9 +54,6 @@ module RubyRaider
     no_tasks do
       def generate_from_parameters(params)
         InvokeGenerators.generate_framework(params)
-      rescue InvokeGenerators::InvalidParameters => e
-        puts "Invalid parameters: #{e.message}"
-        exit 1
       end
 
       def merge_flags(params)

data/lib/scaffolding/project_detector.rb

@@ -66,9 +66,7 @@ module ScaffoldProjectDetector
   def validate_project
     warnings = []
     warnings << 'Gemfile not found. Are you in a Ruby Raider project directory?' unless File.exist?('Gemfile')
-    unless File.exist?(CONFIG_PATH)
-      warnings << "#{CONFIG_PATH} not found. Scaffolded pages won't include URL navigation methods."
-    end
+    warnings << "#{CONFIG_PATH} not found. Scaffolded pages won't include URL navigation methods." unless File.exist?(CONFIG_PATH)
     warnings
   end
 

data/lib/scaffolding/scaffolding.rb

@@ -95,5 +95,4 @@ class Scaffolding < Thor::Group
   def default_path(standard_path, file_type)
     path ? "#{path}/#{normalized_name}#{file_type}" : standard_path
   end
-
 end

data/lib/utilities/utilities.rb

@@ -7,7 +7,12 @@ module Utilities
 
   class << self
     def browser=(browser)
-      set('browser', browser.to_s.delete_prefix(':'))
+      reload_config
+      name = browser.to_s.delete_prefix(':')
+      @config['browser'] = name
+      @config['browser_arguments'] ||= {}
+      @config['browser_arguments'][name] ||= []
+      overwrite_yaml
     end
 
     def page_path=(path)
@@ -54,7 +59,8 @@ module Utilities
     def delete_browser_options
       reload_config
       browser_name = @config['browser'] || 'chrome'
-      @config['browser_arguments']&.delete(browser_name)
+      @config['browser_arguments'] ||= {}
+      @config['browser_arguments'][browser_name] = []
       overwrite_yaml
     end
 
@@ -62,6 +68,13 @@ module Utilities
       set('headless', enabled)
     end
 
+    def video_enabled=(enabled)
+      reload_config
+      video = @config['video']
+      @config['video'] = (video.is_a?(Hash) ? video : {}).merge('enabled' => enabled)
+      overwrite_yaml
+    end
+
     # Set multiple config keys in a single YAML write.
     # Usage: Utilities.batch_update(browser: 'chrome', timeout: 30)
     def batch_update(**settings)

data/lib/version

@@ -1 +1 @@
-3.8.0
+3.10.0

data/ruby_raider.gemspec

@@ -13,12 +13,14 @@ Gem::Specification.new do |s|
   s.files  = `git ls-files -z`.split("\x0")
   s.bindir = 'bin'
   s.executables << 'raider'
+  s.add_development_dependency 'bundler-audit', '~> 0.9'
   s.add_development_dependency 'rake', '~> 13.0.6'
-  s.add_development_dependency 'reek', '~> 6.1.0'
+  s.add_development_dependency 'reek', '~> 6.5'
   s.add_development_dependency 'rspec', '~> 3.11.0'
   s.add_development_dependency 'rubocop', '~> 1.27'
   s.add_development_dependency 'rubocop-performance', '~> 1.15.0'
   s.add_development_dependency 'rubocop-rspec', '~> 2.9.0'
+  s.add_development_dependency 'ruby_audit', '~> 3.1'
   s.add_development_dependency 'steep', '~> 1.9'
 
   s.add_runtime_dependency 'thor', '~> 1.2.1'

data/sig/commands/utility_commands.rbs

@@ -5,10 +5,13 @@ class UtilityCommands < Thor
   def browser: (?String? default_browser) -> void
   def browser_options: (*String opts) -> void
   def raid: () -> void
-  def config: () -> void
   def timeout: (String seconds) -> void
   def viewport: (String dimensions) -> void
   def platform: (String platform) -> void
   def start_appium: () -> void
   def desktop: () -> void
+  def video: (String action) -> void
+  def video_install: () -> void
+  def video_status: () -> void
+  def video_toggle: (bool enabled) -> void
 end

data/sig/generators/invoke_generators.rbs

@@ -1,9 +1,8 @@
 # Type definitions for InvokeGenerators module
 module InvokeGenerators
-  class InvalidParameters < ArgumentError
-  end
-
   def self?.generate_framework: (?Hash[Symbol, untyped] structure) -> void
+  def self?.normalise_options: (Hash[Symbol, untyped] structure) -> Hash[Symbol, untyped]
+  def self?.validate_option: (Symbol key, untyped value, Array[String] allowed) -> void
   def self?.validate_ci: (untyped provider) -> void
   def self?.print_mobile_azure_notice: (Hash[Symbol, untyped] structure) -> void
   def self?.add_generator: (Array[String] generators, *String gens) -> void

data/sig/ruby_raider/ffmpeg.rbs

@@ -0,0 +1,23 @@
+module RubyRaider
+  module Ffmpeg
+    type asset = { url: String, sha256: String? }
+    type manifest = { version: String, assets: Hash[String, asset] }
+
+    MAX_REDIRECTS: Integer
+    DOWNLOAD_TIMEOUT: Integer
+    RELEASE_BASE: String
+    MANIFEST: manifest
+    PLATFORMS: Array[String]
+    DEFAULT_WARN: ^(String) -> void
+
+    self.@verified: Hash[Array[untyped], bool]
+
+    def self.platform: (?host_os: String, ?host_cpu: String) -> String?
+    def self.cache_dir: (?env: Hash[String, String], ?platform: String?) -> String
+    def self.cached_path: (?env: Hash[String, String], ?manifest: manifest, ?platform: String?) -> String
+    def self.resolve: (?env: Hash[String, String], ?manifest: manifest, ?warn: (^(String) -> void)?, ?platform: String?) -> String?
+    def self.ensure!: (?env: Hash[String, String], ?manifest: manifest, ?fetch: (^(String, String) -> untyped)?, ?warn: (^(String) -> void)?, ?platform: String?) -> String?
+    def self.obtainable?: (?env: Hash[String, String], ?manifest: manifest, ?platform: String?) -> bool
+    def self.http_get: (String url, String destination, ?Integer limit, ?timeout: Numeric, ?deadline: Float?) -> void
+  end
+end

data/sig/utilities/utilities.rbs

@@ -13,6 +13,7 @@ module Utilities
   def self?.platform=: (String platform) -> void
   def self?.browser_options=: (Array[String] opts) -> void
   def self?.delete_browser_options: () -> void
+  def self?.video_enabled=: (bool enabled) -> void
   def self?.batch_update: (**untyped settings) -> void
   def self?.run: (?String? opts) -> void
   def self?.parallel_run: (?String? opts, ?untyped? _settings) -> void

data/spec/commands/raider_commands_spec.rb

@@ -3,7 +3,8 @@
 require 'rspec'
 require_relative '../../lib/ruby_raider'
 
-RSpec.describe RubyRaider::Raider do
+# Command specs are grouped by CLI area under spec/commands, not by constant path
+RSpec.describe RubyRaider::Raider do # rubocop:disable RSpec/FilePath
   describe 'new command' do
     context 'with parameters' do
       it 'calls InvokeGenerators.generate_framework with parsed hash' do
@@ -65,4 +66,58 @@ RSpec.describe RubyRaider::Raider do
       expect(subcommands).to include('utility')
     end
   end
+
+  describe 'CLI exit status' do
+    require 'open3'
+    require 'tmpdir'
+
+    let(:raider_bin) { File.expand_path('../../bin/raider', __dir__) }
+
+    def run_raider(*args, chdir: Dir.pwd)
+      Open3.capture3(RbConfig.ruby, raider_bin, *args, chdir:)
+    end
+
+    it 'exits non-zero for an unknown command' do
+      _out, err, status = run_raider('u', 'debug', 'on')
+
+      expect(status.exitstatus).not_to eq(0)
+      expect(err).to include('Could not find command "debug"')
+    end
+
+    it 'exits zero for version' do
+      _out, _err, status = run_raider('version')
+
+      expect(status.exitstatus).to eq(0)
+    end
+
+    it 'rejects an unknown framework without creating the project' do
+      Dir.mktmpdir do |dir|
+        out, err, status = run_raider('new', 'x', '-p', 'framework:minitest', 'automation:selenium', chdir: dir)
+
+        expect(status.exitstatus).not_to eq(0)
+        expect(out + err).to include('framework', 'rspec', 'cucumber')
+        expect(File.exist?(File.join(dir, 'x'))).to be(false)
+      end
+    end
+
+    it 'rejects an unknown automation without creating the project' do
+      Dir.mktmpdir do |dir|
+        out, err, status = run_raider('new', 'x', '-p', 'framework:rspec', 'automation:playwright', chdir: dir)
+
+        expect(status.exitstatus).not_to eq(0)
+        expect(out + err).to include('automation', 'selenium', 'cross_platform')
+        expect(File.exist?(File.join(dir, 'x'))).to be(false)
+      end
+    end
+
+    it 'rejects automation:appium and points to the mobile platforms' do
+      Dir.mktmpdir do |dir|
+        out, err, status = run_raider('new', 'x', '-p', 'framework:rspec', 'automation:appium', chdir: dir)
+
+        expect(status.exitstatus).not_to eq(0)
+        expect(out + err).to include('automation', 'ios', 'android', 'cross_platform')
+        expect(File.exist?(File.join(dir, 'x'))).to be(false)
+      end
+    end
+  end
 end

data/spec/generators/fixtures/video_helper_stubs/selenium-webdriver.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Minimal stand-in for selenium-webdriver, which is not in ruby_raider's bundle.
+# spec/generators/video_helper_spec.rb puts this directory on $LOAD_PATH so the
+# rendered video_helper.rb can `require 'selenium-webdriver'`.
+module Selenium
+  module WebDriver
+    module Error
+      class WebDriverError < StandardError; end
+      class NoSuchAlertError < WebDriverError; end
+    end
+
+    module Support
+      class AbstractEventListener
+        def before_navigate_to(url, driver) end
+        def after_navigate_to(url, driver) end
+        def before_find(by, what, driver) end
+        def after_find(by, what, driver) end
+        def before_click(element, driver) end
+        def after_click(element, driver) end
+        def before_change_value_of(element, driver) end
+        def after_change_value_of(element, driver) end
+        def before_execute_script(script, driver) end
+        def after_execute_script(script, driver) end
+      end
+    end
+  end
+end