yobi 0.3.0 → 1.0.0

data/lib/yobi/restic.rb

@@ -7,87 +7,68 @@ module Yobi
   # A specific Restic binary, plus its process-level settings that apply
   # regardless of which repository is being operated on.
   # Repository-specific identity (url, credentials) lives on
-  # {Yobi::Repository} instead.
+  # Yobi::Repository instead.
   class Restic
-    # The oldest Restic version {#run}/{#run_dump}/{#run_mount} verify the
+    # The oldest Restic version #run/#run_dump/#run_mount verify the
     # installed binary meets before executing a real command. See
-    # {Yobi::UnsupportedResticVersion}.
-    MINIMUM_VERSION = Gem::Version.new("0.17.1")
+    # Yobi::UnsupportedResticVersion.
+    MINIMUM_VERSION = Gem::Version.new("0.18.0") # :nodoc:
 
-    # Env vars {#inspect} shows in the clear; anything else is redacted.
-    ALLOWED_ENV_VARS = %w[
+    # Env vars #inspect shows in the clear; anything else is redacted.
+    ALLOWED_ENV_VARS = %w[ # :nodoc:
       RESTIC_REPOSITORY RESTIC_CACHE_DIR RESTIC_COMPRESSION RESTIC_PACK_SIZE
       RESTIC_READ_CONCURRENCY RESTIC_HOST RESTIC_PROGRESS_FPS RESTIC_CACERT
       RESTIC_TLS_CLIENT_CERT RESTIC_KEY_HINT TMPDIR TMP AWS_DEFAULT_REGION
       AWS_SHARED_CREDENTIALS_FILE AZURE_ENDPOINT_SUFFIX AZURE_FORCE_CLI_CREDENTIAL
-      RCLONE_BWLIMIT
-    ].to_set.freeze
+      RCLONE_BWLIMIT].to_set.freeze
 
-    # @return [String] path to the Restic binary
-    attr_reader :restic_path
-    # @return [String, nil] `$RESTIC_CACHE_DIR`
+    # Path to the Restic binary.
+    attr_accessor :restic_path
+    # +$RESTIC_CACHE_DIR+
     attr_accessor :cache_dir
-    # @return [String, nil] `$RESTIC_COMPRESSION`
+    # +$RESTIC_COMPRESSION+
     attr_accessor :compression
-    # @return [Integer, nil] `$RESTIC_PACK_SIZE`
+    # +$RESTIC_PACK_SIZE+
     attr_accessor :pack_size
-    # @return [Integer, nil] `$RESTIC_READ_CONCURRENCY`
+    # +$RESTIC_READ_CONCURRENCY+
     attr_accessor :read_concurrency
-    # @return [String, nil] `$RESTIC_HOST`
+    # +$RESTIC_HOST+
     attr_accessor :host
-    # @return [Integer, nil] `$RESTIC_PROGRESS_FPS`
+    # +$RESTIC_PROGRESS_FPS+
     attr_accessor :progress_fps
-    # @return [String, nil] `$RESTIC_CACERT`
+    # +$RESTIC_CACERT+
     attr_accessor :cacert
-    # @return [String, nil] `$RESTIC_TLS_CLIENT_CERT`
+    # +$RESTIC_TLS_CLIENT_CERT+
     attr_accessor :tls_client_cert
-    # @return [String, nil] `$RESTIC_KEY_HINT`
+    # +$RESTIC_KEY_HINT+
     attr_accessor :key_hint
-    # @return [String, nil] `--limit-download`
+    # +--limit-download+
     attr_accessor :limit_download
-    # @return [String, nil] `--limit-upload`
+    # +--limit-upload+
     attr_accessor :limit_upload
-    # @return [String, nil] `--retry-lock`
+    # +--retry-lock+
     attr_accessor :retry_lock
-    # @return [Boolean] `--no-lock`
+    # +--no-lock+
     attr_accessor :no_lock
-    # @return [Boolean] `--no-cache`
+    # +--no-cache+
     attr_accessor :no_cache
-    # @return [Boolean] `--cleanup-cache`
+    # +--cleanup-cache+
     attr_accessor :cleanup_cache
-    # @return [Boolean] `--no-extra-verify`
+    # +--no-extra-verify+
     attr_accessor :no_extra_verify
-    # @return [String, nil] `--stuck-request-timeout`
+    # +--stuck-request-timeout+
     attr_accessor :stuck_request_timeout
-    # @return [Array<String>] `--option`, one per element
+    # +--option+, one per element.
     attr_accessor :options
-    # @return [String, nil] `--http-user-agent`
+    # +--http-user-agent+
     attr_accessor :http_user_agent
-    # @return [Boolean] `--quiet`
+    # +--quiet+
     attr_accessor :quiet
 
-    # @param restic_path [String, nil] defaults to `$RESTIC_PATH`, then `"restic"`
-    # @param env [Hash{String => String}] extra env vars, merged over the named settings below
-    # @param cache_dir [String, nil]
-    # @param compression [String, nil]
-    # @param pack_size [Integer, nil]
-    # @param read_concurrency [Integer, nil]
-    # @param host [String, nil]
-    # @param progress_fps [Integer, nil]
-    # @param cacert [String, nil]
-    # @param tls_client_cert [String, nil]
-    # @param key_hint [String, nil]
-    # @param limit_download [String, nil]
-    # @param limit_upload [String, nil]
-    # @param retry_lock [String, nil]
-    # @param no_lock [Boolean]
-    # @param no_cache [Boolean]
-    # @param cleanup_cache [Boolean]
-    # @param no_extra_verify [Boolean]
-    # @param stuck_request_timeout [String, nil]
-    # @param options [Array<String>]
-    # @param http_user_agent [String, nil]
-    # @param quiet [Boolean]
+    # Builds a Restic executor. +restic_path+ defaults to +$RESTIC_PATH+,
+    # then +"restic"+. +env:+ is extra env vars merged over the named
+    # settings below (env-var-backed accessors like +cache_dir:+,
+    # +compression:+, etc.).
     def initialize(restic_path = nil, env: {}, cache_dir: nil, compression: nil, pack_size: nil,
       read_concurrency: nil, host: nil, progress_fps: nil, cacert: nil, tls_client_cert: nil,
       key_hint: nil, limit_download: nil, limit_upload: nil, retry_lock: nil, no_lock: false,
@@ -118,10 +99,8 @@ module Yobi
     end
 
     # The env-var-backed settings above, computed fresh from their current
-    # accessor values on every call. `env:` given at construction wins over
+    # accessor values on every call. +env:+ given at construction wins over
     # any of these on key collision.
-    #
-    # @return [Hash{String => String}]
     def env
       {
         "RESTIC_CACHE_DIR" => cache_dir,
@@ -137,12 +116,9 @@ module Yobi
     end
 
     # Appends the CLI-only global flags (the ones above with no env var
-    # equivalent) to a builder. Called from both {#build_argv} and
-    # `Repository#build_argv`.
-    #
-    # @param a [Yobi::ArgvBuilder]
-    # @return [void]
-    def append_global_flags(a)
+    # equivalent) to a builder. Called from both #build_argv and
+    # Repository#build_argv.
+    def append_global_flags(a) # :nodoc:
       a.flag(:limit_download, limit_download) unless limit_download.nil?
       a.flag(:limit_upload, limit_upload) unless limit_upload.nil?
       a.flag(:retry_lock, retry_lock) unless retry_lock.nil?
@@ -156,26 +132,22 @@ module Yobi
       a.flag(:quiet) if quiet
     end
 
-    # @return [String]
+    # Redacts sensitive env values so a stray +pp+/+puts+/log call never
+    # prints a credential in plaintext.
     def inspect
       "#<#{self.class} restic_path=#{restic_path.inspect} env=#{redacted_env.inspect}>"
     end
 
-    # `restic version`: the installed binary's own version info.
-    #
-    # @return [Yobi::ResticVersion]
+    # +restic version+: the installed binary's own version info. Returns a
+    # Yobi::ResticVersion.
     def version
       execution = run(build_argv("version"), skip_version_check: true)
       Yobi::ResticVersion.new(parse_version_output(execution[:output].to_s))
     end
 
-    # `restic cache`: lists and optionally cleans local cache directories.
-    # Not repository-scoped.
-    #
-    # @param cleanup [Boolean] `--cleanup`
-    # @param max_age [String, nil] `--max-age`
-    # @param no_size [Boolean] `--no-size`
-    # @return [true]
+    # +restic cache+: lists and optionally cleans local cache directories.
+    # Not repository-scoped. +cleanup:+ triggers +--cleanup+, +max_age:+
+    # sets +--max-age+, +no_size:+ triggers +--no-size+. Returns +true+.
     def cache(cleanup: false, max_age: nil, no_size: false)
       argv = build_argv("cache") do |a|
         a.flag(:cleanup) if cleanup
@@ -186,19 +158,19 @@ module Yobi
       true
     end
 
-    # Runs argv against this Restic binary, merging extra_env with this
-    # instance's own global env.
+    # Runs +argv+ against this Restic binary, merging +extra_env:+ with
+    # this instance's own global env. +output:+ takes a caller-configured
+    # Yobi::ResticOutput (e.g. with its own +transform:+); passing one forces
+    # streaming even without a block. When a block is given, each parsed
+    # message is yielded live as the command runs.
     #
-    # @param argv [Array<String>]
-    # @param extra_env [Hash{String => String}]
-    # @param skip_version_check [Boolean] used internally by {#version} to avoid recursing into {#ensure_minimum_version!}
-    # @param output [Yobi::ResticOutput, nil] a caller-configured one (e.g. with its own `transform:`),
-    #   used instead of a plain one this creates itself; forces streaming even without a block
-    # @yieldparam message [Object] each message, live, as the command runs - transformed via
-    #   `output`'s own `transform:` if it has one, the raw parsed Hash otherwise
-    # @return [Hash] `{exit_code:, output:, argv:}` on exit code 0/3
-    # @raise [Yobi::RepositoryNotFound, Yobi::RepositoryLocked, Yobi::AuthenticationFailed, Yobi::ResticCommandFailed]
-    def run(argv, extra_env: {}, skip_version_check: false, output: nil, &block)
+    # +skip_version_check:+ is used internally by #version to avoid recursing
+    # into #ensure_minimum_version!
+    #
+    # Returns +{exit_code:, output:, argv:}+ on exit code 0 or 3.
+    # Raises Yobi::RepositoryNotFound, Yobi::RepositoryLocked,
+    # Yobi::AuthenticationFailed, or Yobi::ResticCommandFailed otherwise.
+    def run(argv, extra_env: {}, skip_version_check: false, output: nil, &block) # :nodoc:
       ensure_minimum_version! unless skip_version_check
       execution = if output || block
         execute_with_streaming(argv, extra_env, output: output, &block)
@@ -208,10 +180,9 @@ module Yobi
       self.class.dispatch(execution)
     end
 
-    # @param execution [Hash] `{exit_code:, output:, argv:}`
-    # @return [Hash] `execution`, unchanged, on exit code 0/3
-    # @raise [Yobi::RepositoryNotFound, Yobi::RepositoryLocked, Yobi::AuthenticationFailed, Yobi::ResticCommandFailed]
-    def self.dispatch(execution)
+    # Maps Restic's exit codes to Yobi's typed errors. Returns +execution+
+    # unchanged on 0/3.
+    def self.dispatch(execution) # :nodoc:
       case execution[:exit_code]
       when 0, 3
         execution
@@ -227,21 +198,15 @@ module Yobi
     end
 
     # For commands whose success output is raw bytes with no JSON message
-    # framing (currently only `Repository#dump`). Spawns Restic with
-    # stdout wired to a pipe.
+    # framing (currently only Repository#dump). Spawns Restic with stdout
+    # wired to a pipe.
     #
-    # Without a block, returns a {Yobi::IOHandle} immediately; closing,
+    # Without a block, returns a Yobi::IOHandle immediately; closing,
     # reaping, and exit-code dispatch are the caller's own responsibility.
     # With one, yields the pipe's read end; it's always closed and the
     # process always reaped once the block returns or raises, before any
     # exit-code dispatch runs.
-    #
-    # @param argv [Array<String>]
-    # @param extra_env [Hash{String => String}]
-    # @yieldparam io [IO]
-    # @return [Yobi::IOHandle] if no block is given
-    # @return [Object] the block's own return value, otherwise
-    def run_dump(argv, extra_env: {})
+    def run_dump(argv, extra_env: {}) # :nodoc:
       ensure_minimum_version!
       output = Yobi::ResticOutput.new
       read_end, write_end = IO.pipe
@@ -266,13 +231,11 @@ module Yobi
       raise Yobi::ResticNotFound.new(restic_path: restic_path, argv: argv)
     end
 
-    # Verifies the installed Restic binary meets {MINIMUM_VERSION}, once
-    # per instance (memoized). {#run}/{#run_dump}/{#run_mount} call this
+    # Verifies the installed Restic binary meets MINIMUM_VERSION, once per
+    # instance (memoized). #run/#run_dump/#run_mount call this
     # automatically before executing a real command; public so a caller
-    # can also call it explicitly to fail fast.
-    #
-    # @return [void]
-    # @raise [Yobi::UnsupportedResticVersion]
+    # can also call it explicitly to fail fast. Raises
+    # Yobi::UnsupportedResticVersion when too old.
     def ensure_minimum_version!
       return if defined?(@version_checked)
       @version_checked = true
@@ -288,7 +251,7 @@ module Yobi
     # An old enough Restic ignores --json for `version` entirely and
     # prints plain text instead (e.g. "restic 0.9.6 compiled with
     # go1.13.4 on linux/amd64"), which JSON.parse can't handle.
-    VERSION_LINE_PATTERN = /restic\s+(\d+\.\d+\.\d+\S*)/
+    VERSION_LINE_PATTERN = /restic\s+(\d+\.\d+\.\d+\S*)/ # :nodoc:
 
     def parse_version_output(raw)
       JSON.parse(raw)
@@ -357,24 +320,24 @@ module Yobi
     end
   end
 
-  # The result of one {Yobi::Restic#version} call.
+  # The result of one Yobi::Restic#version call.
   class ResticVersion < Yobi::FancyHash
-    # @return [String]
+    # The Restic version string, e.g. +"0.19.1"+.
     def version
       self["version"]
     end
 
-    # @return [String, nil]
+    # The Go compiler version Restic was built with, if reported.
     def go_version
       self["go_version"]
     end
 
-    # @return [String, nil]
+    # The OS Restic was built for, if reported.
     def go_os
       self["go_os"]
     end
 
-    # @return [String, nil]
+    # The CPU architecture Restic was built for, if reported.
     def go_arch
       self["go_arch"]
     end

data/lib/yobi/restic_output.rb

@@ -4,21 +4,11 @@ require "json"
 require "tempfile"
 
 module Yobi
-  # Wraps the tempfile a repository operation's stdout+stderr are both
-  # written to, with random access so a caller asking only for the last
-  # line (see {#last_line}) doesn't have to read the entire output.
-  #
-  # @private
-  class ResticOutput
-    # Default read window size, in bytes, for {#last_line}.
+  class ResticOutput # :nodoc:
     DEFAULT_TAIL_CHUNK_SIZE = 4096
 
-    # @return [File] a fresh, already-unlinked tempfile of its own
     attr_reader :file
 
-    # @param tail_chunk_size [Integer] read window size for {#last_line}
-    # @param transform [Proc, nil] used by {#write_and_parse} during a streaming run to transform
-    #   each message, and as {#messages}' default transform afterward, when no explicit one is given
     def initialize(tail_chunk_size: DEFAULT_TAIL_CHUNK_SIZE, transform: nil)
       @file = Tempfile.new("yobi-restic-output")
       @file.unlink
@@ -28,25 +18,15 @@ module Yobi
       @stderr_offsets = []
     end
 
-    # Byte offsets of every line, grouped by message_type. Built once and
-    # memoized.
-    #
-    # @return [Hash{String => Array<Integer>}]
     def index
       @index ||= build_index
     end
 
-    # @param offset [Integer] a byte offset, as recorded by {#index}
-    # @return [String] the line starting at that offset
     def read_line_at(offset)
       @file.seek(offset)
       @file.gets
     end
 
-    # The last non-blank line, found by seeking backward from the end of
-    # the file.
-    #
-    # @return [String, nil]
     def last_line
       size = @file.size
       return nil if size.zero?
@@ -66,8 +46,6 @@ module Yobi
       end
     end
 
-    # @yieldparam line [String]
-    # @return [Enumerator] if no block is given
     def each_line(&block)
       return enum_for(:each_line) unless block_given?
 
@@ -75,17 +53,6 @@ module Yobi
       @file.each_line(&block)
     end
 
-    # Every message recorded in {#index}, restricted to one +message_type+
-    # if given, in file order. Without an explicit transform block, uses
-    # the +transform:+ given to {#initialize} (if any); with neither, just
-    # yields/returns the raw parsed Hash. Whenever a transform (explicit
-    # or the stored one) applies, wraps the result in a {LazyList}
-    # instead of yielding.
-    #
-    # @param message_type [String, nil] every message, if omitted
-    # @yieldparam message [Hash] the raw parsed message, to transform
-    # @return [Yobi::ResticOutput::LazyList] if a transform block (or a stored transform) applies
-    # @return [Enumerator] of raw Hashes, otherwise
     def messages(message_type = nil, &transform)
       transform ||= @transform
       return raw_messages(message_type) unless transform
@@ -94,27 +61,12 @@ module Yobi
       LazyList.new(self, offsets, transform)
     end
 
-    # Every line known to have arrived on stderr rather than stdout during
-    # a streaming run (see {#write_and_parse}), in file order.
-    #
-    # @yieldparam line [String]
-    # @return [Enumerator] if no block is given
     def stderr_lines
       return enum_for(:stderr_lines) unless block_given?
 
       @stderr_offsets.each { |offset| yield read_line_at(offset) }
     end
 
-    # Called once per line read from a live streaming run's stdout/stderr.
-    # Writes it to the file, parses it, and - if it's a JSON message -
-    # indexes it by message_type and returns it transformed via the
-    # +transform:+ given to {#initialize} (or the raw parsed Hash, if none
-    # was given). A non-JSON line's offset is recorded in {#stderr_lines}
-    # instead, if +origin+ is +:stderr+; either way, returns nil.
-    #
-    # @param line [String]
-    # @param origin [:stdout, :stderr]
-    # @return [Object, nil]
     def write_and_parse(line, origin)
       offset = @file.pos
       @file.write(line)
@@ -134,13 +86,11 @@ module Yobi
       end
     end
 
-    # @return [String] the full captured output
     def to_s
       @file.rewind
       @file.read
     end
 
-    # @return [String]
     def inspect
       "#<#{self.class} #{@file.size} bytes>"
     end
@@ -179,32 +129,17 @@ module Yobi
       index
     end
 
-    # A lazily-transformed view over a set of {#index} offsets, printing
-    # like a plain Array (bounded to a preview, unlike one). Returned by
-    # {ResticOutput#messages} when given a transform block.
-    # #inspect/#pretty_print's preview is memoized, and #each reuses it
-    # rather than re-reading/re-transforming those same offsets again
-    # when the caller iterates the whole thing.
-    #
-    # @private
-    class LazyList
+    class LazyList # :nodoc:
       include Enumerable
 
-      # Items #inspect/#pretty_print show before truncating with "...".
-      # One louder than ActiveRecord::Relation#inspect's own preview size.
       INSPECT_PREVIEW_SIZE = 11
 
-      # @param output [Yobi::ResticOutput]
-      # @param offsets [Array<Integer>]
-      # @param transform [Proc] applied to each offset's raw parsed Hash
       def initialize(output, offsets, transform)
         @output = output
         @offsets = offsets
         @transform = transform
       end
 
-      # @yieldparam item [Object]
-      # @return [Enumerator] if no block is given
       def each
         return enum_for(:each) unless block_given?
 
@@ -212,23 +147,17 @@ module Yobi
         @offsets[preview.size..].each { |offset| yield transform_at(offset) }
       end
 
-      # The number of messages, known upfront from {#index} - unlike
-      # +Enumerable#count+, doesn't read/transform a single one to answer.
-      #
-      # @return [Integer]
       def size
         @offsets.size
       end
       alias_method :length, :size
 
-      # @return [String]
       def inspect
         shown = preview.first(INSPECT_PREVIEW_SIZE).map(&:inspect).join(", ")
         shown += ", ..." if preview.size > INSPECT_PREVIEW_SIZE
         "[#{shown}]"
       end
 
-      # @return [void]
       def pretty_print(q)
         q.group(1, "[", "]") do
           q.seplist(preview.first(INSPECT_PREVIEW_SIZE)) { |item| q.pp item }
@@ -238,7 +167,6 @@ module Yobi
 
       private
 
-      # @return [Array<Object>]
       def preview
         @preview ||= @offsets.first(INSPECT_PREVIEW_SIZE + 1).map { |offset| transform_at(offset) }
       end

data/lib/yobi/snapshot.rb

@@ -3,120 +3,108 @@
 require "time"
 
 module Yobi
-  # One snapshot, as Restic reports it. Shared across {Yobi::Repository#snapshots},
-  # {Yobi::Repository#ls}, and {Yobi::Repository#forget}'s keep/remove entries.
+  # One snapshot, as Restic reports it. Shared across Yobi::Repository#snapshots,
+  # Yobi::Repository#ls, and Yobi::Repository#forget's keep/remove entries.
   class Snapshot < Yobi::FancyHash
-    # @return [String]
+    # Full snapshot ID (64-char hex).
     def id
       self["id"]
     end
 
-    # @return [String]
+    # First 8 chars of #id.
     def short_id
       self["short_id"]
     end
 
-    # @return [Time]
+    # When the snapshot was created.
     def time
       @time ||= Time.parse(self["time"])
     end
 
-    # @return [String]
+    # Hostname recorded on the snapshot.
     def host
       self["hostname"]
     end
 
-    # @return [Array<String>]
+    # Tags recorded on the snapshot.
     def tags
       @tags ||= self["tags"] || []
     end
 
-    # @return [Array<String>]
+    # Paths backed up in the snapshot.
     def paths
       self["paths"]
     end
 
-    # @return [String, nil]
+    # Parent snapshot's #id, if any.
     def parent_id
       self["parent"]
     end
 
-    # @return [Yobi::SnapshotSummary]
+    # A Yobi::SnapshotSummary of the snapshot's stats at creation time.
     def summary
       @summary ||= SnapshotSummary.new(self["summary"] || {})
     end
   end
 
-  # The `"summary"` field of a {Yobi::Snapshot}, the stats recorded when it
-  # was created.
-  # https://restic.readthedocs.io/en/stable/075_scripting.html#snapshotsummary-object
+  # The +"summary"+ field of a Yobi::Snapshot, the stats recorded when it
+  # was created. See
+  # https://restic.readthedocs.io/en/stable/075_scripting.html#snapshotsummary-object.
   class SnapshotSummary < Yobi::FancyHash
-    # @return [Time, nil]
+    # When the backup started.
     def backup_start
       @backup_start ||= Time.parse(self["backup_start"]) if self["backup_start"]
     end
 
-    # @return [Time, nil]
+    # When the backup finished.
     def backup_end
       @backup_end ||= Time.parse(self["backup_end"]) if self["backup_end"]
     end
 
-    # @return [Integer]
     def files_new
       self["files_new"] || 0
     end
 
-    # @return [Integer]
     def files_changed
       self["files_changed"] || 0
     end
 
-    # @return [Integer]
     def files_unmodified
       self["files_unmodified"] || 0
     end
 
-    # @return [Integer]
     def dirs_new
       self["dirs_new"] || 0
     end
 
-    # @return [Integer]
     def dirs_changed
       self["dirs_changed"] || 0
     end
 
-    # @return [Integer]
     def dirs_unmodified
       self["dirs_unmodified"] || 0
     end
 
-    # @return [Integer]
     def data_blobs
       self["data_blobs"] || 0
     end
 
-    # @return [Integer]
     def tree_blobs
       self["tree_blobs"] || 0
     end
 
-    # @return [Integer]
     def data_added
       self["data_added"] || 0
     end
 
-    # @return [Integer]
     def data_added_packed
       self["data_added_packed"] || 0
     end
 
-    # @return [Integer]
     def total_files_processed
       self["total_files_processed"] || 0
     end
 
-    # @return [Integer]
     def total_bytes_processed
       self["total_bytes_processed"] || 0
     end

data/lib/yobi/version.rb

@@ -3,6 +3,5 @@
 # A Ruby library for the Restic backup program, wrapping the `restic` CLI in
 # plain Ruby objects instead of shelling out to flags and raw JSON by hand.
 module Yobi
-  # @return [String]
-  VERSION = "0.3.0"
+  VERSION = "1.0.0"
 end

data/sig/yobi.rbs

@@ -227,7 +227,7 @@ module Yobi
     MINIMUM_VERSION: Gem::Version
     ALLOWED_ENV_VARS: Set[String]
 
-    attr_reader restic_path: String
+    attr_accessor restic_path: String
     attr_accessor cache_dir: String?
     attr_accessor compression: String?
     attr_accessor pack_size: Integer?
@@ -287,9 +287,9 @@ module Yobi
   end
 
   class Repository
-    attr_reader url: String
-    attr_reader password: password
-    attr_reader backend_credentials: backend_credentials
+    attr_accessor url: String
+    attr_accessor password: password
+    attr_accessor backend_credentials: backend_credentials
 
     def initialize: (url: String, password: password, ?backend_credentials: backend_credentials, ?restic: restic_or_path) -> void