boring-backup 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 520f4d8e05984b490027c72e0922660b93f73ed22f6d48671ba87b6c4922883e
-  data.tar.gz: 698eeeb6840e35554551cf2d87a2c2a567f8d5b58678a6d0eaed517781dff7db
+  metadata.gz: 90fcf205730a58bf45284b04cd2a7be2604158b5bcd983c2bd3bdaada0fb06c0
+  data.tar.gz: b17bae14e94295a24d68da3592b3baa238bc1a10fb76bcad464ae515bd7cc46c
 SHA512:
-  metadata.gz: c6f7efdd9f7ab1a12a53f84cb3bd539f1d2003f61098dee77a48b48a23bbb9e40814293ff6622477e1397a4857242a19775f2ca6d375df3f026208ef301f4600
-  data.tar.gz: d0351b5626ffbc7b17d88b60682a8d4e3b30bfa12d390d47cff858ca0cb741879f8182d2bace733f5e31f8e3a43e653e9e1ddf43be6f73206c87171c57aaf293
+  metadata.gz: 0317b2fbf1d5768a0b0cfe28e351817d51065579dca37007d6236956c07f474c529297237358c36d4cd572d017bcb1f79209b5c5c4827fb036b169bb2ebc1339
+  data.tar.gz: a3481f64a9c95894830fb1bc92964c154a79796febe716c8e8c27ea09b5de110ce0613386adcdf3703d619a8794730a7470dd09189d504b55cc682b64bea3695

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [0.5.0] - 2026-07-14
+
+- **`aws-sdk-s3` is no longer a dependency of the gem.** apps using the `:s3` store must add `gem
+"aws-sdk-s3"` to their own `Gemfile`.
+- New `bb install` command - wires up the initializer, the Solid Queue schedule and a `bin/bb` binstub
+- New `bb doctor` command - checks pg_dump, versions, database, stores and schedule; exits non-zero on failure
+- `bb backup` now shows a boot spinner, a live progress meter and a coloured summary
+- `config.register(:s3)` no longer requires a block - the store configures itself from the environment
+- `Commands::Backup.execute` accepts a `progress:` callback with the running byte count
+
 ## [0.4.0] - 2026-07-13
 
 - **Renamed the gem from `noop-backup` to `boring-backup`.** Breaking, with no shims:

data/README.md

@@ -20,6 +20,13 @@ gem install boring-backup
 
 The gem requires `pg_dump` to be installed on the machine that is running it.
 
+Storage backends bring their own dependencies, which are not installed by default. To use
+the `:s3` store, add the AWS SDK to your `Gemfile` as well:
+
+```bash
+bundle add aws-sdk-s3
+```
+
 ## Usage
 
 ### Automatic

data/lib/boring_backup/cli.rb

@@ -1,17 +1,348 @@
 require "thor"
+require "pastel"
+require "tty-prompt"
+require "tty-spinner"
 
 module BoringBackup
   class CLI < Thor
+    include Thor::Actions
+
+    INITIALIZER = "config/initializers/boring_backup.rb"
+    RECURRING = "config/recurring.yml"
+    BINSTUB = "bin/bb"
+
+    DEFAULT_SCHEDULE = "every day at 3am"
+    PRODUCTION_ANCHOR = /^production:[ \t]*\r?\n/
+
+    SPINNER = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+    REDRAW_INTERVAL = 0.1
+
+    add_runtime_options!
+
     def self.exit_on_failure? = true
 
+    def self.source_root = File.expand_path("templates", __dir__)
+
     desc "backup", "Create and store a new backup"
     def backup
-      BoringBackup.prepare!
-      result = BoringBackup::Commands::Backup.execute
+      spinner("Booting") { BoringBackup.prepare! }
+
+      say "  #{pastel.bold("Boring Backup")}  #{pastel.dim(BoringBackup.config.pg_env["PGDATABASE"])}"
+
+      result = stream_backup
+
+      result.store_results.each { |store_result| say "  #{store_line(store_result)}" }
+      say "\n  #{verdict(result)}\n"
+
+      exit 1 unless result.success?
+    rescue => e
+      say "  #{pastel.red("✗")} #{e.message}\n"
+      exit 1
+    end
+
+    desc "doctor", "Check that backups are set up correctly"
+    def doctor
+      spinner("Booting") { BoringBackup.prepare! }
+
+      say "  #{pastel.bold("Boring Backup")}  #{pastel.dim("doctor · #{BoringBackup.environment}")}"
+
+      result = spinner("Running checks") { BoringBackup::Commands::Doctor.execute }
+
+      width = result.checks.map { |check| check.name.length }.max
+
+      result.checks.each { |check| say "  #{check_line(check, width)}" }
+      say "\n  #{doctor_verdict(result)}\n"
+
       exit 1 unless result.success?
     rescue => e
-      warn e
+      say "  #{pastel.red("✗")} #{e.message}\n"
       exit 1
     end
+
+    desc "install", "Wire up recurring backups in this app"
+    def install
+      say "\n  #{pastel.bold("Boring Backup")}\n\n"
+
+      preflight
+
+      store = configure_store
+      write_initializer(store)
+      install_schedule
+      install_binstub
+
+      say_next_steps
+    end
+
+    private
+
+    def stream_backup
+      BoringBackup.config.silence_stdout!
+
+      @started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @frame = 0
+
+      BoringBackup::Commands::Backup.execute(progress: meter)
+    ensure
+      clear_line
+    end
+
+    def meter
+      return unless $stdout.tty?
+
+      ->(bytes) { draw_meter(bytes) }
+    end
+
+    def draw_meter(bytes)
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      return if @drawn_at && now - @drawn_at < REDRAW_INTERVAL
+
+      @drawn_at = now
+      elapsed = now - @started
+      rate = elapsed.zero? ? 0 : bytes / elapsed
+      tick = SPINNER[@frame = (@frame + 1) % SPINNER.size]
+
+      $stdout.print "\r  #{pastel.cyan(tick)}  Dumping #{pastel.bold(human(bytes))} " \
+        "#{pastel.dim("· #{human(rate)}/s · #{elapsed.round}s")}\e[K"
+    end
+
+    def clear_line
+      $stdout.print "\r\e[K" if $stdout.tty?
+    end
+
+    def store_line(store_result)
+      if store_result.success
+        "#{pastel.green("✓")} #{pastel.bold(store_result.store.to_s.ljust(6))} " \
+          "#{human(store_result.bytes)} in #{store_result.duration.round(1)}s  #{pastel.dim("→ /#{store_result.key}")}"
+      else
+        "#{pastel.red("✗")} #{pastel.bold(store_result.store.to_s.ljust(6))} #{pastel.red(store_result.error.message)}"
+      end
+    end
+
+    def verdict(result)
+      case result.status
+      when :success then pastel.green.bold("Backed up to #{result.store_results.size} store(s).")
+      when :partial_success then pastel.yellow.bold("Partial: #{result.store_results.count(&:success)}/#{result.store_results.size} stores succeeded.")
+      else pastel.red.bold("Backup failed. #{result.error&.message}")
+      end
+    end
+
+    def human(bytes)
+      BoringBackup.utils.human_size(bytes)
+    end
+
+    CHECK_MARKS = {
+      ok: ["✓", :green],
+      fail: ["✗", :red],
+      skip: ["–", :yellow]
+    }.freeze
+
+    def check_line(check, width)
+      mark, colour = CHECK_MARKS.fetch(check.status)
+
+      "#{pastel.decorate(mark, colour)} #{pastel.bold(check.name.ljust(width))}  #{pastel.dim(check.detail.to_s)}"
+    end
+
+    def doctor_verdict(result)
+      return pastel.red.bold("#{result.failures.size} check(s) failed.") unless result.success?
+
+      skipped = result.checks.count { |check| check.status == :skip }
+
+      if skipped.zero?
+        pastel.green.bold("Everything checks out.")
+      else
+        pastel.green.bold("Checks passed.") + pastel.dim(" #{skipped} skipped — run this where the credentials live to verify the bucket.")
+      end
+    end
+
+    def preflight
+      check "Rails app", rails? && "config/environment.rb"
+      check "Scheduler", solid_queue? && "Solid Queue (#{RECURRING})", hint: "no supported scheduler found"
+      check "Database", database, hint: "could not read ActiveRecord config"
+      check "Store", configured_store_summary, hint: "none configured"
+
+      say ""
+    end
+
+    def check(label, value, hint: "not found")
+      mark = value ? pastel.green("✓") : pastel.yellow("✗")
+      detail = value ? pastel.dim(value.to_s) : pastel.dim(hint)
+
+      say "  #{mark} #{label.to_s.ljust(10)} #{detail}"
+    end
+
+    def rails?
+      File.exist?("config/environment.rb")
+    end
+
+    def solid_queue?
+      File.exist?(RECURRING) && gemfile_lock.include?("solid_queue")
+    end
+
+    def gemfile_lock
+      @gemfile_lock ||= File.exist?("Gemfile.lock") ? read("Gemfile.lock") : ""
+    end
+
+    def read(path)
+      File.read(path, mode: "r:UTF-8")
+    end
+
+    def database
+      return @database if defined?(@database)
+
+      @database = spinner("Reading database config") do
+        BoringBackup.prepare!
+        BoringBackup.config.pg_env["PGDATABASE"]
+      rescue
+        nil
+      end
+    end
+
+    def spinner(message)
+      return yield unless $stdout.tty?
+
+      spinner = TTY::Spinner.new("  #{pastel.dim(message)} :spinner", format: :dots, clear: true, output: $stdout)
+      spinner.auto_spin
+
+      yield
+    ensure
+      spinner&.stop
+      clear_line
+    end
+
+    def env_store?
+      !ENV["AWS_S3_BUCKET"].to_s.empty?
+    end
+
+    def configured_store_summary
+      return "S3 — s3://#{ENV["AWS_S3_BUCKET"]} (from ENV)" if env_store?
+
+      "S3 — #{INITIALIZER}" if File.exist?(INITIALIZER)
+    end
+
+    def configure_store
+      return if File.exist?(INITIALIZER)
+      return if env_store? && prompt.yes?("Use the S3 bucket already in ENV (#{ENV["AWS_S3_BUCKET"]})?")
+
+      prompt.select("Where should backups go?") do |menu|
+        menu.choice "S3 (or S3-compatible: R2, MinIO, Spaces)", :s3
+      end
+
+      {
+        bucket: prompt.ask("Bucket name:", required: true),
+        region: prompt.ask("Region:", default: ENV.fetch("AWS_REGION", "us-east-1"))
+      }
+    end
+
+    def write_initializer(store)
+      unless store
+        if File.exist?(INITIALIZER)
+          say_status :identical, INITIALIZER, :blue
+        else
+          say_status :skip, "#{INITIALIZER} not needed — the S3 store reads its config from ENV", :blue
+        end
+
+        return
+      end
+
+      create_file INITIALIZER, initializer_body(store)
+
+      say_credentials_note
+    end
+
+    def initializer_body(store)
+      <<~RUBY
+        BoringBackup.configure do |config|
+          config.register(:s3) do |store|
+            store.bucket = #{store[:bucket].inspect}
+            store.region = #{store[:region].inspect}
+          end
+        end
+      RUBY
+    end
+
+    def say_credentials_note
+      say_status :note, "credentials come from AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY in the backup environment, or an IAM role", :blue
+      say "  #{pastel.dim("Keep them out of #{INITIALIZER} — it's committed.")}\n"
+    end
+
+    def install_schedule
+      return print_manual_schedule unless solid_queue?
+
+      recurring = read(RECURRING)
+
+      if recurring.include?("BoringBackup::BackupJob")
+        say_status :identical, "#{RECURRING} already runs BoringBackup::BackupJob", :blue
+        return
+      end
+
+      unless recurring.match?(PRODUCTION_ANCHOR)
+        say_status :skip, "#{RECURRING} has no `production:` block", :yellow
+        return print_manual_schedule
+      end
+
+      schedule = prompt.ask("Schedule:", default: DEFAULT_SCHEDULE)
+
+      return unless prompt.yes?("Add the backup job to #{RECURRING} under `production:`?")
+
+      inject_schedule(recurring, schedule)
+
+      say_status :insert, RECURRING, :green
+      say_status :note, "backups run in production only — dev and staging are untouched", :blue
+    end
+
+    def inject_schedule(recurring, schedule)
+      entry = <<~YAML.gsub(/^(?=.)/, "  ")
+        boring_backup:
+          class: BoringBackup::BackupJob
+          schedule: #{schedule}
+      YAML
+
+      updated = recurring.sub(PRODUCTION_ANCHOR) { |anchor| "#{anchor}#{entry}" }
+
+      File.write(RECURRING, updated, mode: "w:UTF-8")
+    end
+
+    def print_manual_schedule
+      say "\n  #{pastel.yellow("No supported scheduler detected.")} Run the backup from cron instead:\n\n"
+      say "#{pastel.dim("    0 3 * * *  cd /path/to/app && #{backup_command}")}\n\n"
+    end
+
+    def install_binstub
+      return unless File.directory?("bin")
+
+      if binstub?
+        say_status :identical, BINSTUB, :blue
+        return
+      end
+
+      return unless prompt.yes?("Add a #{BINSTUB} binstub? (drops the `bundle exec` prefix)")
+
+      run "bundle binstubs boring-backup"
+    end
+
+    def binstub?
+      File.exist?(BINSTUB)
+    end
+
+    def backup_command
+      binstub? ? "#{BINSTUB} backup" : "bundle exec bb backup"
+    end
+
+    def say_next_steps
+      say "\n  #{pastel.bold("Next:")} #{pastel.cyan(doctor_command)}   #{pastel.dim("# check the setup before it runs at 3am")}\n\n"
+    end
+
+    def doctor_command
+      binstub? ? "#{BINSTUB} doctor" : "bundle exec bb doctor"
+    end
+
+    def prompt
+      @prompt ||= TTY::Prompt.new
+    end
+
+    def pastel
+      @pastel ||= Pastel.new
+    end
   end
 end

data/lib/boring_backup/commands/backup.rb

@@ -26,16 +26,17 @@ module BoringBackup::Commands
   end
 
   class Backup
-    def self.execute(report: BoringBackup.config.report?)
-      result = new.execute
+    def self.execute(report: BoringBackup.config.report?, progress: nil)
+      result = new(progress: progress).execute
 
       result.report if report
 
       result
     end
 
-    def initialize
+    def initialize(progress: nil)
       @key = generate_key
+      @progress = progress
       @store_results = []
       @sinks = []
     end
@@ -45,8 +46,8 @@ module BoringBackup::Commands
 
       commands = [config.dump_command]
 
-      # Pipe pg_dump through pv if installed for a basic progress report
-      commands << ["pv", "-btra"] if config.report? && system("which", "pv", out: File::NULL, err: File::NULL)
+      # Pipe pg_dump through pv only when the caller isn't counting bytes itself
+      commands << ["pv", "-btra"] if @progress.nil? && config.report? && system("which", "pv", out: File::NULL, err: File::NULL)
 
       Open3.pipeline_r(*commands) do |last_stdout, wait_threads|
         @sinks = config.stores.map do |store|
@@ -64,7 +65,7 @@ module BoringBackup::Commands
           BoringBackup::Tee::Sink.new(store:, writer:, thread:)
         end
 
-        sinks_fanout = BoringBackup::Tee.new(@sinks)
+        sinks_fanout = BoringBackup::Tee.new(@sinks, progress: @progress)
 
         begin
           IO.copy_stream(last_stdout, sinks_fanout)

data/lib/boring_backup/commands/doctor.rb

@@ -0,0 +1,135 @@
+module BoringBackup::Commands
+  Check = Struct.new(:name, :status, :detail, keyword_init: true) do
+    def failed? = status == :fail
+  end
+
+  DoctorResult = Struct.new(:checks, keyword_init: true) do
+    def success? = checks.none?(&:failed?)
+
+    def failures = checks.select(&:failed?)
+  end
+
+  class Doctor
+    RECURRING = "config/recurring.yml"
+
+    def self.execute = new.execute
+
+    def execute
+      checks = [
+        pg_dump_present,
+        pg_dump_version,
+        database_resolved,
+        stores_registered,
+        *config.stores.flat_map { |store| store_checks(store) },
+        schedule_registered
+      ]
+
+      DoctorResult.new(checks: checks.compact)
+    end
+
+    private
+
+    def check(name, status, detail = nil)
+      Check.new(name: name, status: status, detail: detail)
+    end
+
+    def pg_dump_present
+      if pg_dump_path
+        check("pg_dump", :ok, pg_dump_path)
+      else
+        check("pg_dump", :fail, "not found on PATH")
+      end
+    end
+
+    def pg_dump_path
+      return @pg_dump_path if defined?(@pg_dump_path)
+
+      @pg_dump_path = ENV.fetch("PATH", "").split(File::PATH_SEPARATOR)
+        .map { |dir| File.join(dir, "pg_dump") }
+        .find { |path| File.executable?(path) }
+    end
+
+    def pg_dump_version
+      return unless pg_dump_path
+
+      client = major_version(`#{pg_dump_path} --version`)
+      server = major_version(server_version)
+
+      return check("versions", :skip, "could not read server version") unless server
+      return check("versions", :skip, "could not read pg_dump version") unless client
+
+      if client >= server
+        check("versions", :ok, "pg_dump #{client}, server #{server}")
+      else
+        check("versions", :fail, "pg_dump #{client} is older than server #{server} — the dump may not restore")
+      end
+    end
+
+    def major_version(string)
+      string.to_s[/(\d+)/, 1]&.to_i
+    end
+
+    def server_version
+      return unless defined?(::ActiveRecord)
+
+      ::ActiveRecord::Base.connection.select_value("SHOW server_version")
+    rescue
+      nil
+    end
+
+    def database_resolved
+      database = config.pg_env["PGDATABASE"]
+
+      if database.to_s.empty?
+        check("database", :fail, "could not resolve PGDATABASE")
+      else
+        check("database", :ok, database)
+      end
+    end
+
+    def stores_registered
+      if config.stores.empty?
+        check("stores", :fail, "no stores registered")
+      else
+        check("stores", :ok, "#{config.stores.size} registered")
+      end
+    end
+
+    def store_checks(store)
+      store.validate!
+
+      [check(store.name, :ok, store.description)]
+    rescue => e
+      [check(store.name, :fail, e.message)]
+    end
+
+    def schedule_registered
+      return check("schedule", :skip, "no #{RECURRING} — using cron or another scheduler?") unless File.exist?(RECURRING)
+
+      unless File.read(RECURRING, mode: "r:UTF-8").include?("BoringBackup::BackupJob")
+        return check("schedule", :fail, "#{RECURRING} does not run BoringBackup::BackupJob")
+      end
+
+      unless backup_job_loadable?
+        return check("schedule", :fail, "BoringBackup::BackupJob won't load — is activejob in the Gemfile?")
+      end
+
+      check("schedule", :ok, "#{RECURRING} runs BoringBackup::BackupJob")
+    end
+
+    def backup_job_loadable?
+      return false unless defined?(::ActiveJob)
+
+      Object.const_get("ActiveJob::Base")
+      require "boring_backup/jobs/backup_job"
+
+      true
+    rescue LoadError, NameError
+      false
+    end
+
+    def config
+      @config ||= BoringBackup.config
+    end
+  end
+end

data/lib/boring_backup/configuration.rb

@@ -47,6 +47,10 @@ module BoringBackup
       [*@notifiers, sentinel].compact
     end
 
+    def silence_stdout!
+      @notifiers.reject! { |notifier| notifier.is_a?(BoringBackup::Notifiers::Stdout) }
+    end
+
     def ignore_tables
       Array(@ignore_tables).map { |table| table.to_s.strip }.reject(&:empty?).uniq
     end
@@ -62,17 +66,17 @@ module BoringBackup
     end
 
     def register(store_type)
-      raise BoringBackup::ConfigurationError, "`config.register` requires a block" unless block_given?
-
       store =
         case store_type.to_sym
-        when :s3 then BoringBackup::Stores::S3.new
+        when :s3 then build_s3_store
         else raise BoringBackup::ConfigurationError, "unknown store type: #{store_type}"
         end
 
       @stores << store
 
-      yield store
+      yield store if block_given?
+
+      store
     end
 
     def notifier(type)
@@ -87,6 +91,15 @@ module BoringBackup
       end
     end
 
+    def build_s3_store
+      require_relative "stores/s3"
+
+      BoringBackup::Stores::S3.new
+    rescue LoadError
+      raise BoringBackup::ConfigurationError,
+        "the :s3 store needs the aws-sdk-s3 gem. Add `gem \"aws-sdk-s3\"` to your Gemfile."
+    end
+
     def pg_env
       {
         "PGHOST" => (pg_host || db_config[:host])&.to_s,

data/lib/boring_backup/stores/s3.rb

@@ -37,6 +37,12 @@ module BoringBackup::Stores
       value.empty? ? nil : value.to_sym
     end
 
+    def name = "s3"
+
+    def description
+      [bucket.to_s.empty? ? "no bucket" : "s3://#{bucket}", region].compact.join(" ")
+    end
+
     # Prefer Aws::S3::TransferManager for streaming uploads if available.
     # Aws::S3::Resource.upload_stream is deprecated in newer versions
     def backup!(key, stream)

data/lib/boring_backup/stores/store.rb

@@ -1,5 +1,13 @@
 module BoringBackup::Stores
   class Store
+    def name
+      self.class.name.split("::").last.downcase
+    end
+
+    def description
+      name
+    end
+
     private
 
     def config

data/lib/boring_backup/stores.rb

@@ -1,3 +1,2 @@
 require_relative "stores/store"
 require_relative "stores/result"
-require_relative "stores/s3" # TODO: load conditionally

data/lib/boring_backup/tee.rb

@@ -22,11 +22,20 @@ module BoringBackup
       end
     end
 
-    def initialize(sinks) = @sinks = sinks
+    attr_reader :bytes
+
+    def initialize(sinks, progress: nil)
+      @sinks = sinks
+      @progress = progress
+      @bytes = 0
+    end
 
     def write(chunk)
       @sinks.each { |sink| sink.write(chunk) }
 
+      @bytes += chunk.bytesize
+      @progress&.call(@bytes)
+
       chunk.bytesize
     end
   end

data/lib/boring_backup/version.rb

@@ -1,3 +1,3 @@
 module BoringBackup
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/boring_backup.rb

@@ -4,6 +4,7 @@ require_relative "boring_backup/tee"
 require_relative "boring_backup/utils"
 require_relative "boring_backup/stores"
 require_relative "boring_backup/commands/backup"
+require_relative "boring_backup/commands/doctor"
 require_relative "boring_backup/notifiers/slack"
 require_relative "boring_backup/notifiers/stdout"
 require_relative "boring_backup/notifiers/sentinel"
@@ -53,6 +54,16 @@ module BoringBackup
       require env_file if File.exist?(env_file)
     end
 
+    def environment
+      return ::Rails.env.to_s if defined?(::Rails) && ::Rails.respond_to?(:env)
+
+      ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+    end
+
+    def production?
+      environment == "production"
+    end
+
     def notify(result)
       config.notifiers.each do |notifier|
         notifier.notify(result)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boring-backup
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Georgi Mitrev
@@ -24,19 +24,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: aws-sdk-s3
+  name: pastel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
 description: The simplest way to add recurring database backups to your project with
   minimal setup required.
 email:
@@ -55,6 +83,7 @@ files:
 - lib/boring_backup.rb
 - lib/boring_backup/cli.rb
 - lib/boring_backup/commands/backup.rb
+- lib/boring_backup/commands/doctor.rb
 - lib/boring_backup/configuration.rb
 - lib/boring_backup/jobs/backup_job.rb
 - lib/boring_backup/notifiers/sentinel.rb