ruby_raider 4.1.0 → 4.2.0

data/lib/utilities/schedules/schedule.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+require_relative 'rule'
+require_relative 'selection'
+require_relative 'project'
+
+module RubyRaider
+  module Schedules
+    # One scheduled test run: the shared rule (Rule) plus which tests run and how (show_browser). The OS
+    # entry runs `raider schedule run NAME` only; the selection, retries, notify and show_browser are
+    # read from schedules.yml at run time. Immutable.
+    # :reek:TooManyInstanceVariables { max_instance_variables: 14 } -- the fields of a schedules.yml entry
+    class Schedule < Rule
+      KIND = Kind::TESTS
+      KEYS = %w[name every at on retries notify show_browser selection os_id ruby bundle gem_env created_at].freeze
+      LINUX = /linux/
+      NO_BROWSER_ON_LINUX = "Show the browser isn't available for scheduled runs on Linux"
+
+      attr_reader :show_browser, :selection
+
+      def self.kind = KIND
+
+      # Linux schedules run from systemd or cron, with no display: show_browser is refused there
+      def self.build(project:, name:, every:, at: nil, on: nil, retries: 0, notify: false, show_browser: false, selection: Selection.all,
+                     now: Time.now, host_os: RbConfig::CONFIG['host_os'])
+        raise Error, NO_BROWSER_ON_LINUX if show_browser == true && host_os.match?(LINUX)
+
+        root = project.root
+        new(name: name, every: every, at: at, on: on, retries: retries, notify: notify, show_browser: show_browser, selection: selection,
+            os_id: os_id_for(root, name), ruby: RbConfig.ruby, bundle: bundle_path, gem_env: captured_gem_env,
+            project_root: root, created_at: now.getutc.iso8601)
+      end
+
+      # A schedules.yml entry; raises Error when it is not one this class wrote. A spec file that is gone
+      # still loads (selection.missing_file names it).
+      def self.from_h(hash, project_root, host_os: RbConfig::CONFIG['host_os'])
+        raise Error, 'A schedule entry must be a mapping' unless hash.is_a?(Hash)
+
+        fields = KEYS.to_h { |key| [key.to_sym, hash[key]] }
+        fields[:selection] = Selection.from_h(hash['selection'], root: project_root, host_os: host_os)
+        schedule = new(**fields, project_root: project_root)
+        # Strict: an entry copied from another project, or a moved project, is not this project's entry
+        raise Error, "Invalid os_id #{schedule.os_id.inspect} for #{schedule.name} in #{project_root}" unless schedule.os_id == os_id_for(project_root, schedule.name)
+
+        schedule
+      end
+
+      def initialize(name:, every:, at:, on:, retries:, selection:, os_id:, ruby:, bundle:, gem_env:, project_root:, created_at:, notify: false,
+                     show_browser: false)
+        super()
+        @name = checked_name(name)
+        @every = checked_every(every)
+        @at = checked_at(at)
+        @on = checked_on(on)
+        @retries = checked_retries(retries)
+        @notify = checked_flag('notify', notify)
+        @show_browser = checked_flag('show_browser', show_browser)
+        @selection = checked_selection(selection)
+        @os_id = checked_os_id(os_id)
+        @ruby = checked_path('ruby', ruby)
+        @bundle = checked_path('bundle', bundle)
+        @gem_env = checked_gem_env(gem_env)
+        @project_root = checked_path('project_root', project_root)
+        @created_at = checked_text('created_at', created_at)
+        freeze
+      end
+
+      def to_h
+        { 'name' => name, 'every' => every, 'at' => at, 'on' => on, 'retries' => retries, 'notify' => notify, 'show_browser' => show_browser,
+          'selection' => selection.to_h, 'os_id' => os_id, 'ruby' => ruby, 'bundle' => bundle, 'gem_env' => gem_env.dup, 'created_at' => created_at }
+      end
+
+      private
+
+      def checked_name(name)
+        return name.dup.freeze if name.is_a?(String) && KIND.valid_name?(name)
+
+        raise Error, "Invalid schedule name #{Schedules.printable(name.inspect)}: use 1 to 60 of a-z, 0-9 and _"
+      end
+
+      def checked_selection(selection)
+        return selection if selection.is_a?(Selection)
+
+        raise Error, 'Invalid selection: use a Selection'
+      end
+    end
+  end
+end

data/lib/utilities/schedules/schedule_store.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'store'
+require_relative 'schedule'
+
+module RubyRaider
+  module Schedules
+    # .raider/schedules/schedules.yml: the project's test schedules (Store with Schedule)
+    class ScheduleStore < Store
+      DIR = Schedule::KIND.dir
+      GITIGNORE_LINE = "#{DIR}/".freeze
+
+      def initialize(project)
+        super(project, Schedule)
+      end
+
+      # Appends .raider/schedules/ to the project's .gitignore (made when missing) unless that exact line is
+      # there; every byte already in the file is kept. The yml holds machine paths. true when it added it.
+      # Read and written through one handle that is not a link, so a linked .gitignore is never written through.
+      def ignore_in_git
+        File.open(gitignore, File::RDWR | File::APPEND | File::CREAT | NOFOLLOW | NONBLOCK, 0o644, binmode: true) do |file|
+          content = gitignore_text(file)
+          return false if ignored?(content)
+
+          prefix = content.empty? || content.end_with?("\n") ? '' : "\n"
+          file.write("#{prefix}#{GITIGNORE_LINE}\n")
+        end
+        true
+      rescue Errno::EACCES, Errno::EROFS
+        # A .gitignore we may not write is fine when it already has the line
+        return false if ignored?(File.open(gitignore, File::RDONLY | NOFOLLOW | NONBLOCK, binmode: true) { |file| gitignore_text(file) })
+
+        raise
+      rescue Errno::ELOOP, Errno::EMLINK
+        raise Error, ".gitignore is a link: add #{GITIGNORE_LINE} to it yourself"
+      rescue Errno::EISDIR
+        raise Error, '.gitignore must be a file'
+      end
+
+      private
+
+      def gitignore = project.path('.gitignore')
+
+      def gitignore_text(file)
+        raise Error, '.gitignore must be a file' unless file.stat.file?
+
+        file.read.to_s.b
+      end
+
+      def ignored?(content) = content.each_line.any? { |line| line.chomp == GITIGNORE_LINE }
+    end
+  end
+end

data/lib/utilities/schedules/scheduler.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rbconfig'
+require_relative 'adapter'
+require_relative 'next_run'
+require_relative 'os_enumerator'
+require_relative 'project'
+require_relative 'run_log'
+require_relative 'schedule'
+require_relative 'schedule_store'
+require_relative 'scheduler_steps'
+require_relative 'selection'
+
+module RubyRaider
+  module Schedules
+    # `raider schedule add | remove | list`: keeps the OS scheduler entries and .raider/schedules/schedules.yml
+    # in step (4.1's order). The OS entry is installed first and the yml written after, so the yml never names
+    # an entry the OS scheduler refused; remove takes the OS entry first, so a refusal keeps the yml entry to
+    # retry with. The OS entry is always built fresh (this ruby, bundle and gem env), never from the yml.
+    # :reek:TooManyInstanceVariables { max_instance_variables: 7 } -- the project, its store, the adapter, the streams, clock and OS
+    # :reek:TooManyConstants { max_constants: 7 } -- the kind, two time formats, the row keys and the list wording
+    class Scheduler
+      include SchedulerSteps
+
+      KIND = Schedule::KIND
+      TIME = '%a %H:%M'
+      LIST_TIME = '%a %-d %b %H:%M'
+      LAST = %w[status finished_at trigger counts].freeze
+      EMPTY = 'No schedules yet: raider schedule add <name> --every day --at 08:00'
+      UNLISTED = 'missing from schedules.yml'
+      RULE_KEYS = %w[every at on retries notify show_browser selection next_run_at].freeze
+
+      # The OS scheduler for this machine, for test schedules
+      def self.adapter(runner: Os::CommandRunner.new, host_os: RbConfig::CONFIG['host_os'])
+        Schedules.adapter(kind: KIND, runner: runner, host_os: host_os)
+      end
+
+      # adapter: nil picks the OS scheduler once add has checked everything else, so a refused command never touches it
+      def initialize(project, adapter: nil, store: ScheduleStore.new(project), out: $stdout, err: $stderr, now: -> { Time.now },
+                     host_os: RbConfig::CONFIG['host_os'])
+        @project = project
+        @adapter = adapter
+        @store = store
+        @out = out
+        @err = err
+        @now = now
+        @host_os = host_os
+      end
+
+      # Adds the schedule, or replaces the one with its name. Every check runs before a folder, the yml or
+      # the OS scheduler is touched.
+      def add(name, every:, files: [], tag: nil, at: nil, on: nil, retries: 0, notify: false, show_browser: false)
+        checked_name(name)
+        now = @now.call
+        selection = Selection.parse(files: files, tag: tag, root: @project.root, host_os: @host_os)
+        schedule = Schedule.build(project: @project, name: name, every: every, at: at, on: on, retries: retries, notify: notify,
+                                  show_browser: show_browser, selection: selection, now: now, host_os: @host_os)
+        @project.check_show_browser! if schedule.show_browser
+        @project.check_raider_version!
+        current = adapter
+        schedule_dirs(name)
+        @store.writable!
+        old = @store.find(name)
+        current.install(schedule)
+        save(schedule)
+        ignore_in_git
+        @out.puts("#{old ? 'Replaced' : 'Scheduled'} #{name}: #{schedule.rule_text}, next run #{NextRun.after(schedule, now).strftime(TIME)}")
+      end
+
+      def remove(name)
+        checked_name(name)
+        label = adapter.label
+        was_there = adapter.remove(Schedule.os_id_for(@project.root, name))
+        removed = delete(name, label)
+        raise Error, "No schedule #{name}" unless removed || was_there
+
+        @out.puts(was_there ? "Removed #{name}" : "Removed #{name} (it was already gone from #{label})")
+        @err.puts(unreadable_warning(name, label)) if removed.is_a?(Store::Removed)
+      end
+
+      # notice: the 4.1 cleanup's line (Legacy) for the JSON; as text it is already on stderr
+      def list(json: false, notice: nil)
+        now = @now.call
+        listed = @store.all
+        rows = listed.map { |schedule| row(schedule, now) } + unlisted_rows(listed.map(&:name))
+        return @out.puts(JSON.generate({ 'notice' => notice, 'schedules' => rows.map { |entry| entry[:json] } })) if json
+
+        return @out.puts(EMPTY) if rows.empty?
+
+        rows.each { |entry| @out.puts(Schedules.printable(entry[:text])) }
+        note = missed_runs_note
+        @out.puts(note) if note
+      end
+
+      private
+
+      attr_reader :store
+
+      def adapter = @adapter ||= Scheduler.adapter(host_os: @host_os)
+
+      def checked_name(name)
+        return if name.is_a?(String) && KIND.valid_name?(name)
+
+        raise Error, "Invalid schedule name #{Schedules.printable(name.inspect)}: use 1 to 60 of a-z, 0-9 and _"
+      end
+
+      # .raider/schedules/ and .raider/schedules/<name>/ (scheduler.log): 0700, no part of either a link
+      def schedule_dirs(name)
+        RunLog.private_dir(@project, KIND.dir)
+        RunLog.private_dir(@project, KIND.dir, name)
+      rescue SystemCallError => e
+        raise Error, "Could not make #{KIND.dir}/#{name}: #{e.message}"
+      end
+
+      # The schedule is installed and saved by now, so a .gitignore that can't take the line only warns
+      def ignore_in_git
+        @store.ignore_in_git
+      rescue Error, SystemCallError => e
+        @err.puts("Could not add #{ScheduleStore::GITIGNORE_LINE} to .gitignore: #{Schedules.printable(e.message)}")
+      end
+
+      def row(schedule, now)
+        name = schedule.name
+        next_run = NextRun.after(schedule, now)
+        state = os_state(schedule)
+        last = last_run(name)
+        json = { 'name' => name, 'every' => schedule.every, 'at' => schedule.at, 'on' => schedule.on, 'retries' => schedule.retries,
+                 'notify' => schedule.notify, 'show_browser' => schedule.show_browser, 'selection' => schedule.selection.to_h,
+                 'next_run_at' => next_run.iso8601, 'os_state' => state, 'last' => last }
+        { json: json, text: line(name, rule(schedule), "next #{next_run.strftime(LIST_TIME)}", last, state) }
+      end
+
+      # This project's OS entries that schedules.yml has no entry for, found by enumerating the OS scheduler
+      def unlisted_rows(listed)
+        (unlisted_names - listed).map do |name|
+          last = last_run(name)
+          json = { 'name' => name, **RULE_KEYS.to_h { |key| [key, nil] }, 'os_state' => UNLISTED, 'last' => last }
+          { json: json, text: line(name, '-', '-', last, UNLISTED) }
+        end
+      end
+
+      def unlisted_names
+        OsEnumerator.new(adapter, schedule_class: Schedule, root: @project.root).names
+      rescue Error
+        []
+      end
+
+      # The ruby first, then the spec files (no need to ask the OS about a schedule that can't run), then the OS
+      def os_state(schedule)
+        return RUBY_NOT_FOUND unless ruby_found?(schedule)
+
+        missing = schedule.selection.missing_file(@project.root)
+        return "test file not found: #{missing}" if missing
+
+        os_entry_state(schedule.os_id)
+      rescue Error => e
+        "unknown (#{Schedules.printable(e.message)})"
+      end
+
+      def rule(schedule)
+        selection = schedule.selection
+        which = case selection.kind
+                when 'tag' then "tag #{selection.tag}"
+                when 'files' then selection.files.size == 1 ? selection.files.first : "#{selection.files.size} files"
+                else 'all tests'
+                end
+        flags = [('notify' if schedule.notify), ('browser shown' if schedule.show_browser)].compact
+        "#{which}, #{schedule.rule_text}#{" (#{flags.join(', ')})" unless flags.empty?}"
+      end
+
+      def last_run(name)
+        last = RunLog.new(@project, name, dir: KIND.dir).last_result
+        last && LAST.to_h { |key| [key, last[key]] }
+      end
+    end
+  end
+end

data/lib/utilities/schedules/scheduler_steps.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RubyRaider
+  module Schedules
+    # The steps every scheduler shares (4.1 shared them too): the yml written after the OS entry with a
+    # rollback, the yml entry removed after the OS one, and the parts of a list row that ask the OS.
+    # The includer gives `adapter` and `store`.
+    module SchedulerSteps
+      RUBY_NOT_FOUND = 'Ruby not found: re-schedule'
+
+      private
+
+      # Writes the yml; when that fails the OS entry just installed is removed, so neither names the schedule
+      def save(schedule)
+        store.save(schedule)
+      rescue Error, SystemCallError => e
+        label = adapter.label
+        begin
+          adapter.remove(schedule.os_id)
+        rescue Error => remove_error
+          raise Error, "#{e.message} (and removing the #{label} entry failed: #{remove_error.message})"
+        end
+        raise Error, "#{e.message}: the #{label} entry was removed too, so #{schedule.name} is not scheduled"
+      end
+
+      # The OS entry is gone by now: say so when the yml can't be written
+      def delete(name, label)
+        store.delete(name)
+      rescue Error, SystemCallError => e
+        raise Error, "#{e.message}: the #{label} entry was already removed, but schedules.yml still lists #{name}"
+      end
+
+      def unreadable_warning(name, label)
+        "The schedules.yml entry for #{name} could not be read: a #{label} entry made from a different project path may remain"
+      end
+
+      # The OS entry runs `<ruby> <bundle> ...`: ruby is executed, bundle is only read by it
+      def ruby_found?(schedule)
+        ruby = schedule.ruby
+        bundle = schedule.bundle
+        File.file?(ruby) && File.executable?(ruby) && File.file?(bundle) && File.readable?(bundle)
+      end
+
+      def os_entry_state(os_id) = adapter.present?(os_id) ? 'ok' : "missing from #{adapter.label}"
+
+      # An entry whose state can't be read is left out: only a listed schedule gets an unknown row
+      def present?(os_id)
+        adapter.present?(os_id)
+      rescue Error
+        false
+      end
+
+      # nil also when there is no OS scheduler to ask (the rows already say unknown)
+      def missed_runs_note
+        current = adapter
+        current.respond_to?(:missed_runs_note) ? current.missed_runs_note : nil
+      rescue Error
+        nil
+      end
+
+      def line(name, rule, next_run, last, state)
+        result = last ? "#{last['status']}  #{last['finished_at']}" : 'never run'
+        "#{name.ljust(30)}  #{rule}  #{next_run}  #{result}  #{state}"
+      end
+    end
+  end
+end

data/lib/utilities/schedules/selection.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+require_relative 'base'
+require_relative 'os/task_scheduler'
+
+module RubyRaider
+  module Schedules
+    # Which tests a schedule runs: all of them, one tag, or listed spec files. Immutable.
+    # Checking is in two steps: the shape and every path's syntax (new, from_h: a schedules.yml entry still
+    # loads when a file was deleted), and whether each file is there (parse for add, check! for run). A file
+    # that is there but resolves outside the project is refused by both.
+    # :reek:MissingSafeMethod { exclude: [ check! ] } -- a check that raises; missing_file is its safe twin
+    # :reek:TooManyConstants { max_constants: 7 } -- the kinds, the tag and file rules, the cap, Windows
+    class Selection
+      KINDS = %w[all tag files].freeze
+      KEYS = %w[kind tag files].freeze
+      TAG = /\A[A-Za-z0-9_:-]+\z/
+      MAX_FILES = 200
+      WINDOWS = /mswin|mingw|cygwin/
+      FILE_RULE = 'use a path inside the project ending in _spec.rb, with no .. and no leading - or /'
+      WINDOWS_RULE = 'Task Scheduler and ruby.exe would expand %...%, *, ?, [ or { in it on Windows: rename the file or use a tag'
+
+      attr_reader :kind, :tag, :files
+
+      def self.all = new(kind: 'all')
+
+      # What `raider schedule add` was given: no files and no tag is all tests; every file must be there
+      def self.parse(files:, tag:, root:, host_os: RbConfig::CONFIG['host_os'])
+        raise Error, 'Invalid spec files: use a list of paths' unless files.is_a?(Array)
+        raise Error, 'Use --tag or spec files, not both' if !tag.nil? && !files.empty?
+
+        selection = if !tag.nil? then new(kind: 'tag', tag: tag)
+                    elsif files.empty? then all
+                    else new(kind: 'files', files: files, host_os: host_os)
+                    end
+        selection.check!(root)
+      end
+
+      # The selection of a schedules.yml entry; a missing file still loads (missing_file names it)
+      def self.from_h(hash, root:, host_os: RbConfig::CONFIG['host_os'])
+        raise Error, 'Invalid selection: use kind all, tag or files' unless hash.is_a?(Hash) && (hash.keys - KEYS).empty?
+
+        selection = new(kind: hash['kind'], tag: hash['tag'], files: hash['files'], host_os: host_os)
+        selection.missing_file(root)
+        selection
+      end
+
+      def initialize(kind:, tag: nil, files: nil, host_os: RbConfig::CONFIG['host_os'])
+        raise Error, "Invalid selection kind #{kind.inspect}: use all, tag or files" unless KINDS.include?(kind)
+
+        @kind = kind.dup.freeze
+        @tag = kind == 'tag' ? checked_tag(tag) : nothing('tag', tag)
+        @files = kind == 'files' ? checked_files(files, host_os.match?(WINDOWS)) : nothing('files', files) || [].freeze
+        freeze
+      end
+
+      # The first listed file that is not in the project (nil when all are there); raises when one resolves
+      # outside the project. root is the project's real path.
+      def missing_file(root) = files.reject { |file| present?(root, file) }.first
+
+      # Itself when every file is there, otherwise raises
+      def check!(root)
+        missing = missing_file(root)
+        raise Error, "#{missing} not found" if missing
+
+        self
+      end
+
+      def to_h
+        case kind
+        when 'tag' then { 'kind' => kind, 'tag' => tag }
+        when 'files' then { 'kind' => kind, 'files' => files.dup }
+        else { 'kind' => kind }
+        end
+      end
+
+      private
+
+      def nothing(label, value)
+        raise Error, "Invalid selection: #{label} is only for kind #{label == 'tag' ? 'tag' : 'files'}" unless value.nil?
+
+        nil
+      end
+
+      def checked_tag(tag)
+        return tag.dup.freeze if tag.is_a?(String) && tag.valid_encoding? && TAG.match?(tag)
+
+        raise Error, "Invalid tag #{Schedules.printable(tag.inspect)}: use letters, digits, _, : and -"
+      end
+
+      # Duplicates removed, order kept, then counted
+      def checked_files(files, windows)
+        raise Error, 'Invalid spec files: use a list of one or more paths' unless files.is_a?(Array) && !files.empty?
+
+        unique = files.map { |file| checked_file(file, windows) }.uniq
+        raise Error, "Too many spec files (#{unique.size}): select at most #{MAX_FILES}, or use a tag" if unique.size > MAX_FILES
+
+        unique.freeze
+      end
+
+      def checked_file(file, windows)
+        raise Error, "Invalid spec file #{Schedules.printable(file.inspect)}: #{FILE_RULE}" unless spec_path?(file, windows)
+        raise Error, "Invalid spec file #{file.inspect}: #{WINDOWS_RULE}" if windows && file.match?(Regexp.union(Os::TaskScheduler::EXPANDS, Os::TaskScheduler::GLOB))
+
+        file.dup.freeze
+      end
+
+      def spec_path?(file, windows)
+        file.is_a?(String) && file.valid_encoding? && !file.match?(/[[:cntrl:]]/) && file.end_with?('_spec.rb') && relative?(file, windows)
+      end
+
+      def relative?(file, windows)
+        return false if file.start_with?('-', '/') || File.absolute_path?(file)
+        return false if windows && file.match?(/\A(?:\\|[A-Za-z]:)/)
+
+        !file.split(windows ? %r{[/\\]} : '/').include?('..')
+      end
+
+      # true when the file is in the project, false when it is not there; raises when it resolves outside
+      def present?(root, file)
+        real = File.realpath(File.join(root, file))
+        raise Error, "#{file} points outside the project" unless real.start_with?("#{root}#{File::SEPARATOR}")
+
+        File.file?(real)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        false
+      rescue SystemCallError => e
+        raise Error, "#{file} can't be read: #{e.message}"
+      end
+    end
+  end
+end

data/lib/utilities/schedules/spawn.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module RubyRaider
+  module Schedules
+    # Runs one rspec process with an argv array and no shell, under the project's own bundle rather
+    # than the one raider runs in, and stops it the way a person would: with exactly one INT.
+    #
+    # rspec stops gracefully on its first INT (it finishes the example, prints the summary and runs at_exit
+    # hooks, where raider_reporter writes run.json) and force-quits on a second one. The child stays in the
+    # terminal's process group (it can read the terminal, and a closed terminal ends it), so a Ctrl-C typed
+    # there already reached it. Hence:
+    # - TERM is always passed on as one INT;
+    # - INT is passed on only with forward_int (true when the INT can't have come from the terminal, e.g.
+    #   stdin is not a TTY); otherwise the child is taken to have had it;
+    # - a signal before the child exists is passed on once it does;
+    # - never more than one INT per run. On Windows the console already sent Ctrl-C to the child.
+    module Spawn
+      # [exit status (nil when it could not start or died of a signal), true when INT or TERM stopped it]
+      def self.call(env, argv, chdir, forward_int: true)
+        state = { pid: nil, stopped: false, interrupted: false }
+        code = run(env, argv, chdir, state, forward_int)
+        [code, state[:stopped] == true]
+      end
+
+      # The exit status, with the traps set from before the spawn (so a stop in between is not lost) to the end
+      def self.run(env, argv, chdir, state, forward_int)
+        previous = %w[INT TERM].to_h { |signal| [signal, trap(signal) { stop(state, signal, forward_int) }] }
+        wait = lambda do
+          pid = state[:pid] = Process.spawn(env, *argv, chdir: chdir)
+          interrupt(state) if state[:stopped]
+          Process.wait(pid)
+          # Reaped: its pid may be reused, so a later signal must not reach it
+          state[:pid] = nil
+          $CHILD_STATUS.exitstatus
+        end
+        defined?(Bundler) ? Bundler.with_unbundled_env(&wait) : wait.call
+      rescue SystemCallError => e
+        warn("Could not start #{argv.first}: #{e.message}")
+        nil
+      ensure
+        previous&.each { |signal, handler| trap(signal, handler || 'DEFAULT') }
+      end
+
+      # Called from the trap: marks the run stopped and passes the signal on as INT when the child needs it
+      def self.stop(state, signal, forward_int)
+        state[:stopped] = true
+        return unless state[:pid] # passed on right after the spawn
+
+        # A terminal Ctrl-C reached the child too: count it as the child's one INT
+        return state[:interrupted] = true if signal == 'INT' && !forward_int
+
+        interrupt(state)
+      end
+
+      # INT, at most once per run
+      def self.interrupt(state)
+        return if state[:interrupted] || Gem.win_platform?
+
+        state[:interrupted] = true
+        Process.kill('INT', state[:pid])
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/utilities/{flows/schedule_store.rb → schedules/store.rb}

@@ -3,15 +3,15 @@
 require 'fileutils'
 require 'securerandom'
 require 'yaml'
-require_relative 'schedule'
+require_relative 'base'
 
 module RubyRaider
-  module Flows
-    # .raider/flows/schedules.yml: the project's scheduled flows, sorted by name. The OS entries are made
+  module Schedules
+    # <kind dir>/schedules.yml: a project's schedules of one kind, sorted by name. The OS entries are made
     # from it; it is written whole through a temp file and a rename, so a reader never sees half a file.
+    # A subclass passes the schedule class (a Rule with from_h, to_h and os_id_for); its Kind names the folder.
     # :reek:MissingSafeMethod { exclude: [ writable! ] } -- a check that raises, with no safe twin to offer
-    class ScheduleStore
-      DIR = '.raider/flows'
+    class Store
       FILE = 'schedules.yml'
       NOFOLLOW = defined?(File::NOFOLLOW) ? File::NOFOLLOW : 0
       NONBLOCK = defined?(File::NONBLOCK) ? File::NONBLOCK : 0
@@ -27,9 +27,11 @@ module RubyRaider
         end
       end
 
-      def initialize(project)
+      def initialize(project, schedule_class)
         @project = project
-        @file = project.path("#{DIR}/#{FILE}")
+        @schedule_class = schedule_class
+        @dir = schedule_class.kind.dir
+        @file = project.path("#{@dir}/#{FILE}")
       end
 
       # Every valid entry, sorted by name; a broken entry or file is skipped
@@ -62,13 +64,15 @@ module RubyRaider
         return nil if named.empty?
 
         write(kept)
-        named.filter_map { |entry| from_entry(entry) }.first || Removed.new(name, Schedule.os_id_for(@project.root, name))
+        named.filter_map { |entry| from_entry(entry) }.first || Removed.new(name, @schedule_class.os_id_for(@project.root, name))
       end
 
       private
 
+      attr_reader :project
+
       def from_entry(entry)
-        Schedule.from_h(entry, @project.root)
+        @schedule_class.from_h(entry, @project.root)
       rescue Error
         nil
       end
@@ -92,7 +96,7 @@ module RubyRaider
 
       # The entries to rewrite, keeping ones this version can't read; refuses to overwrite a broken file
       def writable_entries
-        read_entries || raise(Error, "#{DIR}/#{FILE} is not a schedules file: fix or remove it, then try again")
+        read_entries || raise(Error, "#{@dir}/#{FILE} is not a schedules file: fix or remove it, then try again")
       end
 
       # Read through one handle that is not a link; nil when there is no file, false when it is a link,
@@ -121,11 +125,11 @@ module RubyRaider
         FileUtils.rm_f(temp) if temp && File.exist?(temp)
       end
 
-      # A 0700 folder inside the project that is not a link, as flows/support/run.rb makes it
+      # A 0700 folder inside the project that is not a link
       def private_dir
-        dir = @project.path(DIR)
+        dir = @project.path(@dir)
         FileUtils.mkdir_p(dir)
-        raise Error, "#{DIR} must be a folder, not a link" unless File.lstat(dir).directory?
+        raise Error, "#{@dir} must be a folder, not a link" unless File.lstat(dir).directory?
 
         File.chmod(0o700, dir)
         dir

data/lib/version

@@ -1 +1 @@
-4.1.0
+4.2.0