yobi 0.1.0

data/lib/yobi/repository/cat.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Yobi
+  class Repository
+    # `restic cat snapshot ID`: one snapshot's own raw stored record.
+    #
+    # @param id [String, Yobi::Snapshot]
+    # @return [Hash]
+    def cat_snapshot(id)
+      id = id.id if id.is_a?(Yobi::Snapshot)
+      execution = run_restic(build_argv("cat", "snapshot", id))
+      JSON.parse(execution[:output].to_s)
+    end
+
+    # `restic cat index ID`: one index file's own raw contents. IDs come
+    # from `list(:index)`.
+    #
+    # @param id [String]
+    # @return [Hash]
+    def cat_index(id)
+      execution = run_restic(build_argv("cat", "index", id))
+      JSON.parse(execution[:output].to_s)
+    end
+
+    # `restic cat key ID`: one key's own raw stored record.
+    #
+    # @param id [String, Yobi::Key]
+    # @return [Hash]
+    def cat_key(id)
+      id = id.id if id.is_a?(Yobi::Key)
+      execution = run_restic(build_argv("cat", "key", id))
+      JSON.parse(execution[:output].to_s)
+    end
+
+    # `restic cat tree snapshot:subfolder`: the raw tree object at a
+    # snapshot's root, or at `subfolder` within it.
+    #
+    # @param snapshot_id [String, Yobi::Snapshot] also accepts Restic's own `"snapshotID:subfolder"` form directly
+    # @param subfolder [String, nil]
+    # @return [Hash]
+    def cat_tree(snapshot_id, subfolder: nil)
+      snapshot_id = snapshot_id.id if snapshot_id.is_a?(Yobi::Snapshot)
+      target = if subfolder.nil?
+        snapshot_id
+      else
+        "#{snapshot_id}:#{subfolder}"
+      end
+      execution = run_restic(build_argv("cat", "tree", target))
+      JSON.parse(execution[:output].to_s)
+    end
+
+    # `restic cat pack ID`: one pack file's raw, still-encrypted bytes.
+    # IDs come from `list(:packs)`. Same block/handle shape as {#dump}.
+    #
+    # @param id [String]
+    # @yieldparam io [IO]
+    # @return [Yobi::IOHandle] if no block is given
+    def cat_pack(id, &block)
+      run_restic_dump(build_argv("cat", "pack", id), &block)
+    end
+
+    # `restic cat blob ID`: one data blob's raw, decrypted bytes. IDs come
+    # from {#cat_tree}'s own node `"content"` arrays. Same block/handle
+    # shape as {#dump}.
+    #
+    # @param id [String]
+    # @yieldparam io [IO]
+    # @return [Yobi::IOHandle] if no block is given
+    def cat_blob(id, &block)
+      run_restic_dump(build_argv("cat", "blob", id), &block)
+    end
+
+    # `restic cat masterkey`: this repository's own encryption/MAC key
+    # material. Extremely sensitive: this is the actual key, not a
+    # redacted reference to it, and there is no operation that rotates it;
+    # every other key/password management method here only manages
+    # different ways to unlock this same master key.
+    #
+    # @return [Hash]
+    def cat_masterkey_and_game_over_if_this_leaks
+      execution = run_restic(build_argv("cat", "masterkey"))
+      JSON.parse(execution[:output].to_s)
+    end
+  end
+end

data/lib/yobi/repository/check.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "json"
+require "delegate"
+
+module Yobi
+  class Repository
+    # `restic check`: tests the repository for errors.
+    #
+    # @param hosts [Array<String>, String] filter by hostname(s)
+    # @param paths [Array<String>, String] filter by originally backed-up path(s)
+    # @param read_data [Boolean] read and verify pack file contents, not just structure
+    # @param read_data_subset [String, nil] read and verify only a subset of packs, e.g. `"5%"`
+    # @param tags [Array<String>, String] filter by tag(s)
+    # @param with_cache [Boolean] use the local cache
+    # @return [Yobi::CheckOutcome]
+    def check(hosts: [], paths: [], read_data: false, read_data_subset: nil, tags: [], with_cache: false)
+      argv = build_argv("check") do |a|
+        a.repeat_flag(:host, hosts)
+        a.repeat_flag(:path, paths)
+        a.flag(:read_data) if read_data
+        a.flag(:read_data_subset, read_data_subset) unless read_data_subset.nil?
+        a.repeat_flag(:tag, tags)
+        a.flag(:with_cache) if with_cache
+      end
+      execution = run_restic(argv)
+      CheckOutcome.new(execution[:exit_code], execution[:output])
+    end
+  end
+
+  # The outcome of one {Yobi::Repository#check} call.
+  class CheckOutcome < Struct.new(:exit_code, :output)
+    # @return [Hash] Restic's own `"summary"` fields (`"num_errors"`, `"broken_packs"`, ...)
+    def report
+      @report ||= summary_hash
+    end
+
+    # @return [Enumerable<Yobi::CheckError>]
+    def errors
+      @errors ||= CheckErrors.new(output)
+    end
+
+    private
+
+    def summary_hash
+      line = output.last_line
+      hash = line && JSON.parse(line)
+      if hash && hash["message_type"] == "summary"
+        hash
+      else
+        find_summary || {}
+      end
+    end
+
+    def find_summary
+      output.each_line do |line|
+        next if line.strip.empty?
+
+        hash = JSON.parse(line)
+        return hash if hash["message_type"] == "summary"
+      end
+
+      nil
+    end
+  end
+
+  # One `"error"` message from a check run.
+  # https://restic.readthedocs.io/en/stable/075_scripting.html#error
+  class CheckError < SimpleDelegator
+    # @return [String]
+    def message
+      self["message"]
+    end
+  end
+
+  # Enumerable over every {Yobi::CheckError} in a run.
+  class CheckErrors
+    include Enumerable
+
+    # @param output [Yobi::ResticOutput]
+    def initialize(output)
+      @output = output
+    end
+
+    # @yieldparam error [Yobi::CheckError]
+    # @return [Enumerator] if no block is given
+    def each
+      return enum_for(:each) unless block_given?
+
+      @output.index["error"].each do |offset|
+        line = @output.read_line_at(offset)
+        yield CheckError.new(JSON.parse(line))
+      end
+    end
+  end
+end

data/lib/yobi/repository/copy.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Yobi
+  class Repository
+    # `restic copy`: replicates snapshots from another repository into
+    # this one. Already-copied snapshots are skipped automatically.
+    #
+    # @param from_repo [String, Yobi::Repository] the source repository, or its URL
+    #   (given a `Repository`, its own `#url`/`#password` are used automatically)
+    # @param from_password [String, Array, Symbol, #call, nil] the source
+    #   repository's password, same shape as {#initialize}'s `password:`
+    # @param snapshot_ids [Array<String>, String] snapshots to copy; all of them if empty
+    # @param from_key_hint [String, nil]
+    # @param from_repository_file [String, nil] read the source repository's URL from a file
+    # @param hosts [Array<String>, String] filter by hostname(s)
+    # @param paths [Array<String>, String] filter by originally backed-up path(s)
+    # @param tags [Array<String>, String] filter by tag(s)
+    # @return [true]
+    def copy(from_repo:, from_password: nil, snapshot_ids: [], from_key_hint: nil,
+      from_repository_file: nil, hosts: [], paths: [], tags: [])
+      if from_repo.is_a?(Repository)
+        from_password = from_repo.password if from_password.nil?
+        from_repo = from_repo.url
+      end
+
+      argv = build_argv("copy", snapshot_ids) do |a|
+        a.flag(:from_repo, from_repo)
+        a.flag(:from_insecure_no_password) if from_password == :insecure_no_password
+        a.flag(:from_key_hint, from_key_hint) unless from_key_hint.nil?
+        a.flag(:from_repository_file, from_repository_file) unless from_repository_file.nil?
+        a.repeat_flag(:host, hosts)
+        a.repeat_flag(:path, paths)
+        a.repeat_flag(:tag, tags)
+      end
+      run_restic(argv, extra_env: password_env(from_password, "RESTIC_FROM_PASSWORD"))
+      true
+    end
+  end
+end

data/lib/yobi/repository/diff.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "json"
+require "delegate"
+
+module Yobi
+  class Repository
+    # `restic diff`: compares two snapshots.
+    #
+    # @param from [String] snapshot ID
+    # @param to [String] snapshot ID
+    # @param metadata [Boolean] also report metadata-only changes (access mode, timestamps, ...)
+    # @return [Yobi::DiffOutcome]
+    def diff(from:, to:, metadata: false)
+      argv = build_argv("diff", from, to) do |a|
+        a.flag(:metadata) if metadata
+      end
+      execution = run_restic(argv)
+      DiffOutcome.new(execution[:exit_code], execution[:output])
+    end
+  end
+
+  # The outcome of one {Yobi::Repository#diff} call.
+  class DiffOutcome < Struct.new(:exit_code, :output)
+    # @return [Hash] Restic's own `"statistics"` fields (`"changed_files"`, `"added"`, `"removed"`, ...)
+    def report
+      @report ||= summary_hash
+    end
+
+    # @return [Enumerable<Yobi::DiffChange>]
+    def changes
+      @changes ||= DiffChanges.new(output)
+    end
+
+    private
+
+    def summary_hash
+      line = output.last_line
+      hash = line && JSON.parse(line)
+      if hash && hash["message_type"] == "statistics"
+        hash
+      else
+        find_summary || {}
+      end
+    end
+
+    def find_summary
+      output.each_line do |line|
+        next if line.strip.empty?
+
+        hash = JSON.parse(line)
+        return hash if hash["message_type"] == "statistics"
+      end
+
+      nil
+    end
+  end
+
+  # One `"change"` message from a diff run. `modifier` is Restic's own
+  # single-character code: `"+"` added, `"-"` removed, `"U"` metadata
+  # updated, `"M"` content modified, `"T"` type changed, `"?"` bitrot detected.
+  class DiffChange < SimpleDelegator
+    # @return [String]
+    def path
+      self["path"]
+    end
+
+    # @return [String]
+    def modifier
+      self["modifier"]
+    end
+  end
+
+  # Enumerable over every {Yobi::DiffChange} in a run.
+  class DiffChanges
+    include Enumerable
+
+    # @param output [Yobi::ResticOutput]
+    def initialize(output)
+      @output = output
+    end
+
+    # @yieldparam change [Yobi::DiffChange]
+    # @return [Enumerator] if no block is given
+    def each
+      return enum_for(:each) unless block_given?
+
+      @output.index["change"].each do |offset|
+        line = @output.read_line_at(offset)
+        yield DiffChange.new(JSON.parse(line))
+      end
+    end
+  end
+end

data/lib/yobi/repository/dump.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module Yobi
+  class Repository
+    # Valid `archive:` values for {#dump}, as both String and Symbol.
+    ARCHIVE_TYPES = Set.new(%w[tar zip].flat_map { [_1, _1.to_sym] }).freeze
+
+    # `restic dump`: extracts a file/folder from a snapshot. A single file's
+    # raw bytes are written as-is; a folder is written as a tar/zip archive.
+    # Give at most one of `target:` or a block.
+    #
+    # @param snapshot_id [String] also accepts Restic's own `"snapshotID:subfolder"` form directly
+    # @param file [String] path within the snapshot to extract; `"/"` dumps the whole snapshot
+    # @param target [String, nil] write straight to this file path instead of yielding a block
+    # @param archive [String, Symbol, nil] `"tar"` (default) or `"zip"`, when `file` is a folder
+    # @param hosts [Array<String>, String] only relevant when `snapshot_id` is `"latest"`
+    # @param paths [Array<String>, String] only relevant when `snapshot_id` is `"latest"`
+    # @param tags [Array<String>, String] only relevant when `snapshot_id` is `"latest"`
+    # @yieldparam io [IO]
+    # @return [true] if `target:` was given
+    # @return [Yobi::IOHandle] if no block is given
+    # @raise [ArgumentError] if given both `target:` and a block
+    def dump(snapshot_id:, file:, target: nil, archive: nil, hosts: [], paths: [], tags: [], &block)
+      raise ArgumentError, "give at most one of target: or a block, not both" if target && block
+
+      argv = build_argv("dump", snapshot_id) do |a|
+        a.flag(:archive, archive) if ARCHIVE_TYPES.include?(archive)
+        a.repeat_flag(:host, hosts)
+        a.repeat_flag(:path, paths)
+        a.repeat_flag(:tag, tags)
+        a.flag(:target, target) unless target.nil?
+        a.end_of_options.append(file)
+      end
+
+      if target
+        run_restic(argv)
+        true
+      else
+        run_restic_dump(argv, &block)
+      end
+    end
+
+    private
+
+    def run_restic_dump(argv, &block)
+      @restic.run_dump(argv, extra_env: env, &block)
+    end
+  end
+end

data/lib/yobi/repository/find.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "delegate"
+
+module Yobi
+  class Repository
+    # `restic find`: searches for files/directories across snapshots by
+    # name pattern.
+    #
+    # @param patterns [Array<String>, String] glob patterns to match
+    # @param blob [Boolean] match blob IDs instead of file names
+    # @param pack [Boolean] match pack IDs instead of file names
+    # @param tree [Boolean] match tree IDs instead of file names
+    # @param hosts [Array<String>, String] filter by hostname(s)
+    # @param human_readable [Boolean] format sizes for humans
+    # @param ignore_case [Boolean] case-insensitive matching
+    # @param long [Boolean] include long listing format
+    # @param newest [String, nil] only consider snapshots at or before this time
+    # @param oldest [String, nil] only consider snapshots at or after this time
+    # @param paths [Array<String>, String] filter by originally backed-up path(s)
+    # @param reverse [Boolean] reverse sort order
+    # @param show_pack_id [Boolean] include the pack ID each match is stored in
+    # @param snapshot_ids [Array<String>, String] restrict to these snapshot ID(s)
+    # @param tags [Array<String>, String] filter by tag(s)
+    # @return [Enumerable<Yobi::MatchesPerSnapshot>]
+    def find(patterns:, blob: false, pack: false, tree: false, hosts: [], human_readable: false,
+      ignore_case: false, long: false, newest: nil, oldest: nil, paths: [], reverse: false,
+      show_pack_id: false, snapshot_ids: [], tags: [])
+      argv = build_argv("find") do |a|
+        a.flag(:blob) if blob
+        a.flag(:pack) if pack
+        a.flag(:tree) if tree
+        a.repeat_flag(:host, hosts)
+        a.flag(:human_readable) if human_readable
+        a.flag(:ignore_case) if ignore_case
+        a.flag(:long) if long
+        a.flag(:newest, newest) unless newest.nil?
+        a.flag(:oldest, oldest) unless oldest.nil?
+        a.repeat_flag(:path, paths)
+        a.flag(:reverse) if reverse
+        a.flag(:show_pack_id) if show_pack_id
+        a.repeat_flag(:snapshot, snapshot_ids)
+        a.repeat_flag(:tag, tags)
+        a.end_of_options.append(patterns)
+      end
+      execution = run_restic(argv)
+      FindMatches.new(execution[:output])
+    end
+  end
+
+  # One matched file/directory from a {Yobi::Repository#find} call.
+  class FindMatch < SimpleDelegator
+    # @return [String]
+    def path
+      self["path"]
+    end
+
+    # @return [String]
+    def type
+      self["type"]
+    end
+
+    # @return [Integer]
+    def size
+      self["size"]
+    end
+
+    # @return [String]
+    def permissions
+      self["permissions"]
+    end
+
+    # @return [Integer]
+    def uid
+      self["uid"]
+    end
+
+    # @return [Integer]
+    def gid
+      self["gid"]
+    end
+
+    # @return [String]
+    def user
+      self["user"]
+    end
+
+    # @return [String]
+    def group
+      self["group"]
+    end
+
+    # @return [Integer]
+    def inode
+      self["inode"]
+    end
+
+    # @return [Time]
+    def mtime
+      @mtime ||= Time.parse(self["mtime"])
+    end
+
+    # @return [Time]
+    def atime
+      @atime ||= Time.parse(self["atime"])
+    end
+
+    # @return [Time]
+    def ctime
+      @ctime ||= Time.parse(self["ctime"])
+    end
+  end
+
+  # One snapshot's worth of matches from a {Yobi::Repository#find} call.
+  class MatchesPerSnapshot < SimpleDelegator
+    # @return [Hash]
+    def snapshot
+      self["snapshot"]
+    end
+
+    # @return [Integer]
+    def hits
+      self["hits"]
+    end
+
+    # @return [Array<Yobi::FindMatch>]
+    def matches
+      @matches ||= (self["matches"] || []).map { |raw| Yobi::FindMatch.new(raw) }
+    end
+  end
+
+  # Enumerable over every {Yobi::MatchesPerSnapshot} in one {Yobi::Repository#find} call.
+  class FindMatches
+    include Enumerable
+
+    # @return [Yobi::ResticOutput]
+    attr_reader :output
+
+    # @param output [Yobi::ResticOutput]
+    def initialize(output)
+      @output = output
+    end
+
+    # @yieldparam matches [Yobi::MatchesPerSnapshot]
+    # @return [Enumerator] if no block is given
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      matches_per_snapshot.each(&block)
+    end
+
+    private
+
+    def matches_per_snapshot
+      @matches_per_snapshot ||= JSON.parse(output.to_s).map { |raw| Yobi::MatchesPerSnapshot.new(raw) }
+    end
+  end
+end

data/lib/yobi/repository/forget.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "json"
+require "delegate"
+
+module Yobi
+  class Repository
+    # `restic forget`: applies a retention policy, removing snapshots
+    # that don't match any `keep_*` rule.
+    #
+    # @param keep_last [Integer, nil] always keep this many of the most recent snapshots
+    # @param keep_hourly [Integer, nil]
+    # @param keep_daily [Integer, nil]
+    # @param keep_weekly [Integer, nil]
+    # @param keep_monthly [Integer, nil]
+    # @param keep_yearly [Integer, nil]
+    # @param keep_within [String, nil] keep all snapshots within this duration, e.g. `"30d"`
+    # @param keep_within_hourly [String, nil]
+    # @param keep_within_daily [String, nil]
+    # @param keep_within_weekly [String, nil]
+    # @param keep_within_monthly [String, nil]
+    # @param keep_within_yearly [String, nil]
+    # @param keep_tags [Array<String>, String] always keep snapshots carrying any of these tags
+    # @param hosts [Array<String>, String] filter by hostname(s)
+    # @param tags [Array<String>, String] filter by tag(s)
+    # @param paths [Array<String>, String] filter by originally backed-up path(s)
+    # @param compact [Boolean] compact the printed policy summary
+    # @param group_by [String, nil] grouping used to apply the policy, e.g. `"host,paths"`
+    # @param dry_run [Boolean] report what would happen without doing it
+    # @param prune [Boolean] also reclaim disk space (equivalent to `restic forget --prune`)
+    # @param unsafe_allow_remove_all [Boolean] allow removing every snapshot
+    # @param max_unused [String, nil] passed through to the implied prune, e.g. `"10%"`
+    # @param max_repack_size [String, nil] passed through to the implied prune
+    # @param repack_cacheable_only [Boolean] passed through to the implied prune
+    # @param repack_uncompressed [Boolean] passed through to the implied prune
+    # @param repack_smaller_than [String, nil] passed through to the implied prune
+    # @return [Enumerable<Yobi::ForgetGroup>]
+    def forget(keep_last: nil, keep_hourly: nil, keep_daily: nil, keep_weekly: nil, keep_monthly: nil,
+      keep_yearly: nil, keep_within: nil, keep_within_hourly: nil, keep_within_daily: nil,
+      keep_within_weekly: nil, keep_within_monthly: nil, keep_within_yearly: nil, keep_tags: [],
+      hosts: [], tags: [], paths: [], compact: false, group_by: nil, dry_run: false, prune: false,
+      unsafe_allow_remove_all: false, max_unused: nil, max_repack_size: nil,
+      repack_cacheable_only: false, repack_uncompressed: false, repack_smaller_than: nil)
+      argv = build_argv("forget") do |a|
+        a.flag(:keep_last, keep_last) unless keep_last.nil?
+        a.flag(:keep_hourly, keep_hourly) unless keep_hourly.nil?
+        a.flag(:keep_daily, keep_daily) unless keep_daily.nil?
+        a.flag(:keep_weekly, keep_weekly) unless keep_weekly.nil?
+        a.flag(:keep_monthly, keep_monthly) unless keep_monthly.nil?
+        a.flag(:keep_yearly, keep_yearly) unless keep_yearly.nil?
+        a.flag(:keep_within, keep_within) unless keep_within.nil?
+        a.flag(:keep_within_hourly, keep_within_hourly) unless keep_within_hourly.nil?
+        a.flag(:keep_within_daily, keep_within_daily) unless keep_within_daily.nil?
+        a.flag(:keep_within_weekly, keep_within_weekly) unless keep_within_weekly.nil?
+        a.flag(:keep_within_monthly, keep_within_monthly) unless keep_within_monthly.nil?
+        a.flag(:keep_within_yearly, keep_within_yearly) unless keep_within_yearly.nil?
+        a.repeat_flag(:keep_tag, keep_tags)
+        a.repeat_flag(:host, hosts)
+        a.repeat_flag(:tag, tags)
+        a.repeat_flag(:path, paths)
+        a.flag(:compact) if compact
+        a.flag(:group_by, group_by) unless group_by.nil?
+        a.flag(:dry_run) if dry_run
+        a.flag(:prune) if prune
+        a.flag(:unsafe_allow_remove_all) if unsafe_allow_remove_all
+        a.flag(:max_unused, max_unused) unless max_unused.nil?
+        a.flag(:max_repack_size, max_repack_size) unless max_repack_size.nil?
+        a.flag(:repack_cacheable_only) if repack_cacheable_only
+        a.flag(:repack_uncompressed) if repack_uncompressed
+        a.flag(:repack_smaller_than, repack_smaller_than) unless repack_smaller_than.nil?
+      end
+      execution = run_restic(argv)
+      ForgetGroups.new(execution[:exit_code], execution[:output])
+    end
+  end
+
+  # The outcome of one {Yobi::Repository#forget} call.
+  class ForgetGroups
+    include Enumerable
+
+    # @return [Integer]
+    attr_reader :exit_code
+    # @return [Yobi::ResticOutput]
+    attr_reader :output
+
+    # @param exit_code [Integer]
+    # @param output [Yobi::ResticOutput]
+    def initialize(exit_code, output)
+      @exit_code = exit_code
+      @output = output
+    end
+
+    # @yieldparam group [Yobi::ForgetGroup]
+    # @return [Enumerator] if no block is given
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      groups.each(&block)
+    end
+
+    # @return [Boolean]
+    def success?
+      exit_code.zero?
+    end
+
+    # @return [Boolean]
+    def partial?
+      exit_code == 3
+    end
+
+    private
+
+    def groups
+      @groups ||= JSON.parse(output.to_s).map { |raw| Yobi::ForgetGroup.new(raw) }
+    end
+  end
+
+  # One grouping Restic's forget policy was evaluated against (by default,
+  # grouped by host+paths).
+  class ForgetGroup < SimpleDelegator
+    # @return [String]
+    def host
+      self["host"]
+    end
+
+    # @return [Array<String>]
+    def tags
+      @tags ||= self["tags"] || []
+    end
+
+    # @return [Array<String>]
+    def paths
+      self["paths"]
+    end
+
+    # @return [Array<Yobi::Snapshot>]
+    def keep
+      @keep ||= (self["keep"] || []).map { |entry| Yobi::Snapshot.new(entry) }
+    end
+
+    # @return [Array<Yobi::Snapshot>]
+    def remove
+      @remove ||= (self["remove"] || []).map { |entry| Yobi::Snapshot.new(entry) }
+    end
+
+    # @return [Array<Yobi::ForgetReason>] one per kept snapshot, explaining which policy rule(s) kept it
+    def reasons
+      @reasons ||= (self["reasons"] || []).map { |entry| Yobi::ForgetReason.new(entry) }
+    end
+  end
+
+  # Why one snapshot survived a {Yobi::Repository#forget} run.
+  class ForgetReason < SimpleDelegator
+    # @return [Yobi::Snapshot]
+    def snapshot
+      @snapshot ||= Yobi::Snapshot.new(self["snapshot"])
+    end
+
+    # @return [Array<String>] Restic's own human-readable rule-match strings, e.g. `"last snapshot"`
+    def matches
+      @matches ||= self["matches"] || []
+    end
+  end
+end