yobi 0.3.1 → 1.1.0

data/lib/yobi/cancellation.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Yobi
+  # A cancellation token for a long-running Restic run.
+  #
+  # Pass one to Yobi::Repository#with_cancellation, then call #cancel! from
+  # another thread to stop whichever long-running method (#backup,
+  # #restore, #check, #prune, #forget, #copy) is running on the repository
+  # it returns:
+  #
+  #   token = Yobi::Cancellation.new
+  #   Thread.new { token.cancel! if user_clicked_cancel }
+  #   repo.with_cancellation(token).backup(source: "/data")
+  #   # => raises Yobi::Cancelled
+  #
+  # #cancel! sends the Restic process SIGINT rather than SIGKILL, so Restic
+  # removes its own repository lock on the way out and no +restic unlock+ is
+  # needed afterwards. An interrupted +backup+ writes no snapshot; data it had
+  # already uploaded is generally left unreferenced until the next +prune+
+  # rather than being reused, so cancelling does discard in-progress work.
+  #
+  # Safe to call #cancel! before the run starts (the run then raises without
+  # spawning Restic at all), after it has finished (a no-op), and from any
+  # thread. A token tracks one run at a time and is not reusable once
+  # cancelled.
+  class Cancellation
+    # The signal sent to Restic by #cancel! unless overridden.
+    DEFAULT_SIGNAL = "INT"
+
+    def initialize
+      @mutex = Mutex.new
+      @cancelled = false
+      @signal = DEFAULT_SIGNAL
+      @pid = nil
+    end
+
+    # True once #cancel! has been called.
+    def cancelled?
+      @mutex.synchronize { @cancelled }
+    end
+
+    # Requests cancellation, signalling the attached Restic process if one is
+    # currently running. Returns true the first time, false if this token was
+    # already cancelled. Idempotent and thread-safe.
+    #
+    # +signal:+ overrides the signal sent; the SIGINT default is what lets
+    # Restic clean up its lock, so override it only when you have a reason to.
+    def cancel!(signal: DEFAULT_SIGNAL)
+      pid = nil
+      @mutex.synchronize do
+        return false if @cancelled
+
+        @cancelled = true
+        @signal = signal
+        pid = @pid
+      end
+      signal_pid(pid, signal)
+      true
+    end
+
+    # Attaches a freshly spawned Restic process. If #cancel! already landed
+    # before the spawn, the process is signalled immediately. Called by
+    # Yobi::Restic; not part of the public API.
+    def attach(pid) # :nodoc:
+      cancelled, signal = @mutex.synchronize do
+        @pid = pid
+        [@cancelled, @signal]
+      end
+      signal_pid(pid, signal) if cancelled
+    end
+
+    # Detaches the current process once it has been reaped, so a later
+    # #cancel! can't signal a recycled PID. Called by Yobi::Restic; not part
+    # of the public API.
+    def detach # :nodoc:
+      @mutex.synchronize { @pid = nil }
+    end
+
+    def inspect
+      "#<#{self.class} cancelled=#{cancelled?}>"
+    end
+
+    private
+
+    # Errno::ESRCH means Restic already exited between the cancel and the
+    # signal, which is exactly the outcome cancelling wanted.
+    def signal_pid(pid, signal)
+      return if pid.nil?
+
+      begin
+        Process.kill(signal, pid)
+      rescue Errno::ESRCH
+        nil
+      end
+    end
+  end
+end

data/lib/yobi/errors.rb

@@ -6,53 +6,73 @@ module Yobi
   # Base class for all errors raised by Yobi.
   class Error < StandardError; end
 
-  # The `exit_error` message from a fatal Restic run, if one was printed.
-  # https://restic.readthedocs.io/en/stable/075_scripting.html#exit-errors
+  # The +exit_error+ message from a fatal Restic run, if one was printed.
+  # See https://restic.readthedocs.io/en/stable/075_scripting.html#exit-errors.
   class ExitError < Yobi::FancyHash
-    # @private
-    LINE_PATTERN = /"message_type"\s*:\s*"exit_error"/
+    LINE_PATTERN = /"message_type"\s*:\s*"exit_error"/ # :nodoc:
 
-    # @param output [Yobi::ResticOutput]
-    # @return [Yobi::ExitError, nil] `nil` if no `exit_error` line is present
+    # Builds an ExitError from a Yobi::ResticOutput, or +nil+ if no
+    # +exit_error+ line is present in it.
     def self.from_output(output)
       line = output.each_line.find { |candidate| LINE_PATTERN.match?(candidate) }
       new(JSON.parse(line)) if line
     end
 
-    # @return [String, nil]
+    # Restic's own +exit_error+ code String, if present.
     def code
       self["code"]
     end
 
-    # @return [String, nil]
+    # Restic's own +exit_error+ message String, if present.
     def message
       self["message"]
     end
   end
 
   # Raised when the installed Restic binary is older than
-  # {Yobi::Restic::MINIMUM_VERSION}.
+  # Yobi::Restic::MINIMUM_VERSION.
   class UnsupportedResticVersion < Error
-    # @return [String]
     attr_reader :installed_version, :minimum_version
 
-    # @private
-    def initialize(installed_version:, minimum_version:)
+    def initialize(installed_version:, minimum_version:) # :nodoc:
       @installed_version = installed_version
       @minimum_version = minimum_version
       super("Restic #{installed_version} does not meet the minimum supported version #{minimum_version}")
     end
   end
 
+  # Raised when a run was stopped through a Yobi::Cancellation token.
+  #
+  # Distinct from Yobi::ResticExecutionError and its subclasses: the run did
+  # not fail, the caller stopped it on purpose. Rescue this to record a
+  # cancellation without treating it as a backup failure.
+  class Cancelled < Error
+    # The raw +{exit_code:, output:, argv:}+ result. +exit_code:+ and
+    # +output:+ are +nil+ when the token was already cancelled before
+    # Restic was spawned at all.
+    attr_reader :execution
+
+    def initialize(execution) # :nodoc:
+      @execution = execution
+      super("Restic run was cancelled")
+    end
+
+    # The argv of the run that was cancelled.
+    def argv
+      execution[:argv]
+    end
+
+    # True when the token was cancelled before Restic even started.
+    def before_start?
+      execution[:exit_code].nil?
+    end
+  end
+
   # Raised when the Restic binary itself can't be found or executed.
   class ResticNotFound < Error
-    # @return [String]
-    attr_reader :restic_path
-    # @return [Array<String>]
-    attr_reader :argv
+    attr_reader :restic_path, :argv
 
-    # @private
-    def initialize(restic_path:, argv:)
+    def initialize(restic_path:, argv:) # :nodoc:
       @restic_path = restic_path
       @argv = argv
       super("Restic binary not found: #{restic_path.inspect} (tried to run #{argv.inspect})")
@@ -62,13 +82,12 @@ module Yobi
   # Raised when Restic exits with a failure code. Base class for the
   # specific typed errors below.
   class ResticExecutionError < Error
-    # @return [Hash] the raw `{exit_code:, output:, argv:}` execution result
+    # The raw +{exit_code:, output:, argv:}+ execution result.
     attr_reader :execution
-    # @return [Yobi::ExitError, nil]
+    # A Yobi::ExitError parsed out of the output, if one is present.
     attr_reader :exit_error
 
-    # @private
-    def initialize(execution)
+    def initialize(execution) # :nodoc:
       @execution = execution
       @exit_error = Yobi::ExitError.from_output(execution[:output])
       super(exit_error&.message || "Restic exited with status #{execution[:exit_code]}: #{execution[:output]}")
@@ -87,16 +106,12 @@ module Yobi
   # Raised when Restic exits with a failure code not otherwise classified above.
   class ResticCommandFailed < ResticExecutionError; end
 
-  # Raised by {Yobi::Repository#mount} when Restic doesn't report itself
-  # ready within `ready_timeout:` seconds.
+  # Raised by Yobi::Repository#mount when Restic doesn't report itself
+  # ready within +ready_timeout:+ seconds.
   class MountTimeout < Error
-    # @return [Array<String>]
-    attr_reader :argv
-    # @return [Numeric]
-    attr_reader :timeout
+    attr_reader :argv, :timeout
 
-    # @private
-    def initialize(argv:, timeout:)
+    def initialize(argv:, timeout:) # :nodoc:
       @argv = argv
       @timeout = timeout
       super("Restic mount didn't report readiness within #{timeout}s (tried to run #{argv.inspect})")

data/lib/yobi/fancy_hash.rb

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
 
 module Yobi
-  # Base class for every wrapper around one raw Restic JSON object.
-  class FancyHash < Hash
-    # @private
+  class FancyHash < Hash # :nodoc:
     def initialize(raw)
       super()
       replace(raw)
     end
 
-    # @return [String]
     def inspect
       "#<#{self.class} #{super}>"
     end
 
-    # @return [void]
     def pretty_print(q)
       q.object_group(self) do
         each do |key, value|

data/lib/yobi/io_handle.rb

@@ -2,14 +2,13 @@
 
 module Yobi
   # A live Restic process streaming raw bytes to its own stdout, returned by
-  # {Yobi::Restic#run_dump} when no block is given. Satisfies Rack's Body
-  # contract (`#each`, `#close`).
+  # Yobi::Restic#run_dump when no block is given. Satisfies Rack's Body
+  # contract (+#each+, +#close+).
   #
-  # Unlike the block form, nothing closes this automatically. Call {#close}
-  # yourself once done reading, in an `ensure`, so it still runs if reading
+  # Unlike the block form, nothing closes this automatically. Call #close
+  # yourself once done reading, in an +ensure+, so it still runs if reading
   # raises:
   #
-  # @example
   #   handle = repo.dump(snapshot_id: "latest", file: "/etc/hosts")
   #   begin
   #     IO.copy_stream(handle.io, "/tmp/hosts")
@@ -17,13 +16,12 @@ module Yobi
   #     handle.close
   #   end
   class IOHandle
-    # @return [IO] the readable end of the pipe Restic's stdout is wired to
+    # The readable end of the pipe Restic's stdout is wired to.
     attr_reader :io
-    # @return [Integer] the Restic process's pid
+    # The Restic process's pid.
     attr_reader :pid
 
-    # @private
-    def initialize(io, pid:, output:, argv:)
+    def initialize(io, pid:, output:, argv:) # :nodoc:
       @io = io
       @pid = pid
       @output = output
@@ -31,20 +29,17 @@ module Yobi
       @closed = false
     end
 
-    # @return [Boolean]
+    # +true+ once #close has run.
     def closed?
       @closed
     end
 
-    # @return [String]
     def inspect
       "#<#{self.class} pid=#{pid} closed=#{closed?}>"
     end
 
     # Reaps the Restic process and raises based on its exit code. Safe to
     # call more than once.
-    #
-    # @return [void]
     def close
       return if @closed
 
@@ -54,10 +49,7 @@ module Yobi
       Restic.dispatch(exit_code: status.exitstatus, output: @output, argv: @argv)
     end
 
-    # Yields binary-safe chunks of {#io} until EOF, then calls {#close}.
-    #
-    # @yieldparam chunk [String]
-    # @return [void]
+    # Yields binary-safe chunks of #io until EOF, then calls #close.
     def each
       loop do
         yield @io.readpartial(64 * 1024)

data/lib/yobi/mount_handle.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
 module Yobi
-  # A live Restic mount process, returned by {Yobi::Restic#run_mount} once
+  # A live Restic mount process, returned by Yobi::Restic#run_mount once
   # Restic has reported itself ready. The mounted filesystem itself is
-  # browsed with ordinary file I/O at {#mountpoint}; this object only
+  # browsed with ordinary file I/O at #mountpoint; this object only
   # manages the Restic process's lifetime.
   class MountHandle
-    # @return [String] the path the repository is mounted at
+    # The path the repository is mounted at.
     attr_reader :mountpoint
 
-    # @private
-    def initialize(wait_thr:, mountpoint:, pipe:, output:, argv:)
+    def initialize(wait_thr:, mountpoint:, pipe:, output:, argv:) # :nodoc:
       @wait_thr = wait_thr
       @mountpoint = mountpoint
       @pipe = pipe
@@ -19,17 +18,16 @@ module Yobi
       @stopped = false
     end
 
-    # @return [Integer] the Restic process's pid
+    # The Restic process's pid.
     def pid
       @wait_thr.pid
     end
 
-    # @return [Boolean]
+    # +true+ once #stop has run.
     def stopped?
       @stopped
     end
 
-    # @return [String]
     def inspect
       "#<#{self.class} pid=#{pid} mountpoint=#{mountpoint.inspect} stopped=#{stopped?}>"
     end
@@ -37,9 +35,7 @@ module Yobi
     # Sends the Restic process SIGINT, waits for it to unmount and exit,
     # then raises based on its exit code. Safe to call more than once, and
     # safe to call after the mount has already been stopped externally
-    # (e.g. via `kill -INT` or the OS's own `umount`/`fusermount`).
-    #
-    # @return [void]
+    # (e.g. via +kill -INT+ or the OS's own +umount+/+fusermount+).
     def stop
       return if @stopped
 

data/lib/yobi/repository/backup.rb

@@ -5,41 +5,46 @@ require "shellwords"
 
 module Yobi
   class Repository
-    # `restic backup`: creates a new snapshot from a source path.
+    # +restic backup+: creates a new snapshot from a source path.
     #
-    # @param source [String, Array] a path to back up, or a
-    #   `[:stdin_from_command, command]`/`[:stdin_from_command, command, filename]`
-    #   tuple. Restic spawns and executes `command` itself (a String,
-    #   tokenized with `Shellwords.split`, or an Array of already-discrete
-    #   arguments), capturing its stdout as the backup content
-    # @param excludes [Array<String>, String] exclude files matching these glob patterns
-    # @param exclude_files [Array<String>, String] path(s) to file(s) listing exclude patterns, one per line
-    # @param exclude_if_present [Array<String>, String] skip a directory containing a marker file with this name (optionally `name:content`)
-    # @param exclude_larger_than [String, nil] skip files larger than this size, e.g. `"1G"`
-    # @param files_from [Array<String>, String] read the files/dirs to back up from a file, one per line
-    # @param files_from_raw [Array<String>, String] like `files_from`, NUL-separated
-    # @param files_from_verbatim [Array<String>, String] like `files_from`, paths taken literally with no glob expansion
-    # @param iexcludes [Array<String>, String] like `excludes`, case-insensitive
-    # @param iexclude_files [Array<String>, String] like `exclude_files`, case-insensitive
-    # @param tags [Array<String>, String] tags to attach to the new snapshot
-    # @param dry_run [Boolean] report what would happen without doing it
-    # @param exclude_caches [Boolean] skip directories containing a CACHEDIR.TAG marker
-    # @param exclude_cloud_files [Boolean] skip files not fully present on disk (e.g. OneDrive placeholders)
-    # @param force [Boolean] back up unchanged files instead of skipping them
-    # @param group_by [String, nil] grouping used to find the parent snapshot, e.g. `"host,paths"`
-    # @param host [String, nil] hostname to record on the new snapshot, instead of the OS hostname
-    # @param ignore_ctime [Boolean] relax change detection to ignore ctime
-    # @param ignore_inode [Boolean] relax change detection to ignore inode number
-    # @param no_scan [Boolean] skip the pre-backup scan (disables percentage progress)
-    # @param one_file_system [Boolean] don't cross filesystem boundaries
-    # @param parent [String, nil] snapshot ID to use as the parent instead of the latest one
-    # @param read_concurrency [Integer, nil] number of concurrent file reads
-    # @param skip_if_unchanged [Boolean] don't create a snapshot if nothing changed
-    # @param time [String, nil] timestamp to record instead of now
-    # @param verbose [Boolean] stream a {Yobi::BackupVerboseStatus} per file to the block
-    # @param with_atime [Boolean] also store files' access times
-    # @yieldparam message [Yobi::BackupStatus, Yobi::BackupError, Yobi::BackupVerboseStatus, Yobi::BackupSummary]
-    # @return [Yobi::BackupOutcome]
+    # +source:+ is either a path to back up, or a
+    # +[:stdin_from_command, command]+ / +[:stdin_from_command, command, filename]+
+    # tuple. Restic spawns and executes +command+ itself (a String tokenized
+    # with +Shellwords.split+, or an Array of already-discrete arguments),
+    # capturing its stdout as the backup content.
+    #
+    # +excludes:+, +exclude_files:+, +exclude_if_present:+, +iexcludes:+ and
+    # +iexclude_files:+ each accept a single value or an Array. +i+-prefixed
+    # variants are case-insensitive.
+    #
+    # +exclude_larger_than:+ skips files larger than a given size (e.g.
+    # +"1G"+). +exclude_caches:+ skips directories containing a
+    # +CACHEDIR.TAG+ marker. +exclude_cloud_files:+ skips files not fully
+    # present on disk (e.g. OneDrive placeholders).
+    #
+    # +files_from:+, +files_from_raw:+ and +files_from_verbatim:+ read the
+    # files/dirs to back up from a file, one per line - +_raw+ NUL-separated,
+    # +_verbatim+ taken literally with no glob expansion.
+    #
+    # +tags:+ attaches tags to the new snapshot. +host:+ overrides the OS
+    # hostname recorded on it. +time:+ overrides its creation timestamp.
+    # +parent:+ pins the parent snapshot ID; +group_by:+ (e.g. +"host,paths"+)
+    # picks the grouping used to find the parent otherwise.
+    #
+    # +dry_run:+ reports what would happen without doing it. +force:+ backs
+    # up unchanged files instead of skipping them. +skip_if_unchanged:+
+    # doesn't create a snapshot if nothing changed. +ignore_ctime:+ and
+    # +ignore_inode:+ relax change detection. +with_atime:+ also stores
+    # files' access times.
+    #
+    # +one_file_system:+ doesn't cross filesystem boundaries. +no_scan:+
+    # skips the pre-backup scan (which disables percentage progress).
+    # +read_concurrency:+ sets the number of concurrent file reads.
+    #
+    # When +verbose: true+, a Yobi::BackupVerboseStatus is streamed to the
+    # block per file. The block also receives Yobi::BackupStatus,
+    # Yobi::BackupError, and Yobi::BackupSummary messages as they arrive.
+    # Returns a Yobi::BackupOutcome.
     def backup(source:, excludes: [], exclude_files: [], exclude_if_present: [], exclude_larger_than: nil,
       files_from: [], files_from_raw: [], files_from_verbatim: [], iexcludes: [], iexclude_files: [],
       tags: [], dry_run: false, exclude_caches: false, exclude_cloud_files: false, force: false,
@@ -107,16 +112,7 @@ module Yobi
     end
   end
 
-  # Classifies a raw backup message Hash by its own message_type, wrapping
-  # it in the matching typed class. Used both by {Yobi::Repository#backup}
-  # (as the {Yobi::ResticOutput} `transform:` for a live streaming run) and
-  # by {Yobi::BackupOutcome}'s own post-hoc accessors.
-  #
-  # @private
-  module BackupMessageWrapper
-    # @param raw [Hash]
-    # @return [Yobi::BackupStatus, Yobi::BackupError, Yobi::BackupVerboseStatus, Yobi::BackupSummary, Hash]
-    #   the raw Hash itself for a message_type this version of Yobi doesn't recognize
+  module BackupMessageWrapper # :nodoc:
     def self.call(raw)
       case raw["message_type"]
       when "status" then BackupStatus.new(raw)
@@ -128,36 +124,31 @@ module Yobi
     end
   end
 
-  # The outcome of one {Yobi::Repository#backup} call.
+  # The outcome of one Yobi::Repository#backup call.
   class BackupOutcome
-    # @private
-    COMMAND_OUTPUT_LINE_PATTERN = /\Asubprocess [^:]+: (.*)/
+    COMMAND_OUTPUT_LINE_PATTERN = /\Asubprocess [^:]+: (.*)/ # :nodoc:
 
-    # @return [Yobi::ResticOutput]
+    # The Yobi::ResticOutput backing this outcome.
     attr_reader :output
 
-    # @private
-    def initialize(execution)
+    def initialize(execution) # :nodoc:
       @output = execution[:output]
     end
 
-    # @return [Enumerable<Yobi::BackupError>]
+    # Every Yobi::BackupError message from the run.
     def errors
       @errors ||= output.messages("error")
     end
 
     # Every message from the run, in file order, each wrapped in its own
-    # {Yobi::BackupStatus}/{Yobi::BackupError}/{Yobi::BackupVerboseStatus}/{Yobi::BackupSummary}.
-    #
-    # @return [Enumerable<Yobi::BackupStatus, Yobi::BackupError, Yobi::BackupVerboseStatus, Yobi::BackupSummary>]
+    # Yobi::BackupStatus / Yobi::BackupError / Yobi::BackupVerboseStatus /
+    # Yobi::BackupSummary.
     def messages
       @messages ||= output.messages
     end
 
-    # The `source: [:stdin_from_command, ...]` subprocess's own stderr, if any, de-prefixed.
-    #
-    # @yieldparam line [String]
-    # @return [Enumerator] if no block is given
+    # The +source: [:stdin_from_command, ...]+ subprocess's own stderr, if
+    # any, de-prefixed.
     def command_output
       return enum_for(:command_output) unless block_given?
 
@@ -167,13 +158,12 @@ module Yobi
       end
     end
 
-    # @return [Yobi::BackupSummary] Restic's own `"summary"` fields
+    # The Yobi::BackupSummary of Restic's own +"summary"+ fields.
     def summary
       @summary ||= output.messages("summary").first || BackupSummary.new({})
     end
     alias_method :report, :summary
 
-    # @return [void]
     def pretty_print(q)
       q.object_group(self) do
         q.breakable
@@ -184,119 +174,98 @@ module Yobi
     end
   end
 
-  # The `"summary"` message from a backup run, the final result once the
-  # command finishes. Dispatched to {Yobi::Repository#backup}'s block, and
-  # also what {Yobi::BackupOutcome#summary} returns.
-  # https://restic.readthedocs.io/en/stable/075_scripting.html#summary
+  # The +"summary"+ message from a backup run, the final result once the
+  # command finishes. Dispatched to Yobi::Repository#backup's block, and
+  # also what Yobi::BackupOutcome#summary returns. See
+  # https://restic.readthedocs.io/en/stable/075_scripting.html#summary.
   class BackupSummary < Yobi::FancyHash
-    # @return [Time, nil]
     def backup_start
       @backup_start ||= Time.parse(self["backup_start"]) if self["backup_start"]
     end
 
-    # @return [Time, nil]
     def backup_end
       @backup_end ||= Time.parse(self["backup_end"]) if self["backup_end"]
     end
   end
 
-  # One `"status"` message from a live backup run.
-  # https://restic.readthedocs.io/en/stable/075_scripting.html#status
+  # One +"status"+ message from a live backup run. See
+  # https://restic.readthedocs.io/en/stable/075_scripting.html#status.
   class BackupStatus < Yobi::FancyHash
-    # @return [Float, nil]
     def percent_done
       self["percent_done"]
     end
 
-    # @return [Integer, nil]
     def total_files
       self["total_files"]
     end
 
-    # @return [Integer, nil]
     def files_done
       self["files_done"]
     end
 
-    # @return [Integer, nil]
     def total_bytes
       self["total_bytes"]
     end
 
-    # @return [Integer, nil]
     def bytes_done
       self["bytes_done"]
     end
 
-    # @return [Array<String>]
     def current_files
       self["current_files"] || []
     end
 
-    # @return [Integer]
     def error_count
       self["error_count"] || 0
     end
   end
 
-  # One `"error"` message from a backup run.
-  # https://restic.readthedocs.io/en/stable/075_scripting.html#error
+  # One +"error"+ message from a backup run.
   class BackupError < Yobi::FancyHash
-    # @return [String, nil]
     def message
       dig("error", "message")
     end
 
-    # @return [String, nil]
     def during
       self["during"]
     end
 
-    # @return [String, nil]
     def item
       self["item"]
     end
   end
 
-  # One `"verbose_status"` message from a backup run, one per file. Only
-  # emitted when `verbose: true` is passed to {Yobi::Repository#backup}.
+  # One +"verbose_status"+ message from a backup run, one per file. Only
+  # emitted when +verbose: true+ is passed to Yobi::Repository#backup.
   class BackupVerboseStatus < Yobi::FancyHash
-    # @return [String]
     def action
       self["action"]
     end
 
-    # @return [String]
     def item
       self["item"]
     end
 
-    # @return [Integer]
     def duration
       self["duration"]
     end
 
-    # @return [Integer]
     def data_size
       self["data_size"]
     end
 
-    # @return [Integer]
     def data_size_in_repo
       self["data_size_in_repo"]
     end
 
-    # @return [Integer]
     def metadata_size
       self["metadata_size"]
     end
 
-    # @return [Integer]
     def metadata_size_in_repo
       self["metadata_size_in_repo"]
     end
 
-    # @return [Integer]
     def total_files
       self["total_files"]
     end