file-digests 0.0.17 → 0.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27ef5c07b544bb7e63a8b9ca9d8b99d0b46588b45311ef940d7431691178b99c
-  data.tar.gz: b1febf1fbdabab014eca65a86e3beee4cfaf4478ead18a5da071b045ae0ab56a
+  metadata.gz: f08714e86e275eb74108da01c667d403134366e6d7e9c5e8b08278d8c8842ba8
+  data.tar.gz: 57802538edae099807ede5460a07d6fd7ea6a5d0810f40d306db8f330435631d
 SHA512:
-  metadata.gz: f4d0db5b5ca2a29adaac1fa9aaefd276977f39d0c6e7e17e5432586d63a91a5bb20bd4af8c955e4e5c625460102ae1431b33947e5c40cc9351c5bb858f28974b
-  data.tar.gz: 3dc1ec4ac2224a84d1cc914b81314ccfba5580a11ca179ac9b4ca9201a599f57a52edb997af8adc369861124a733d1030f5dcb2a234dbf3c10a68b03690a5b3a
+  metadata.gz: 4c642c5aaf06d903114aabc65ec13ae3c5eb04c807b167c7eb1f3c63e8f56144ff3d93964fdc55cbcb33fad743cad635cfa61284171c94ed3b7a9a42c3efbca6
+  data.tar.gz: eebb6b444c6d0921f638200a27f97af5e9026ab0cf21b7b43b3e58f6f13ccc6323f482f93594ae993637a18b7611514469848307defe3796f412dd453c08b932

data/bin/file-digests

@@ -2,4 +2,4 @@
 
 require 'file-digests'
 
-FileDigests.perform_check
+FileDigests.run_cli_utility

data/lib/file-digests.rb

@@ -1,283 +1,520 @@
 require 'date'
-require 'set'
 require 'digest'
 require 'fileutils'
+require 'openssl'
+require 'optparse'
 require 'pathname'
+require 'set'
 require 'sqlite3'
 
-module FileDigests
+class FileDigests
+  DIGEST_ALGORITHMS=["BLAKE2b512", "SHA3-256", "SHA512-256"]
+
+  def self.canonical_digest_algorithm_name(string)
+    if string
+      index = DIGEST_ALGORITHMS.map(&:downcase).index(string.downcase)
+      index && DIGEST_ALGORITHMS[index]
+    end
+  end
 
-  def self.perform_check
-    options = {
-      auto: (ENV["AUTO"] == "true"),
-      quiet: (ENV["QUIET"] == "true"),
-      test_only: (ENV["TEST_ONLY"] == "true")
-    }
-    checker = Checker.new ARGV[0], ARGV[1], options
-    checker.perform_check
+  def canonical_digest_algorithm_name string
+    self.class.canonical_digest_algorithm_name string
   end
 
-  class DigestDatabase
-    def initialize path, options = {}
-      @options = options
+  def self.digest_algorithms_list_text
+    "Digest algorithm should be one of the following: #{DIGEST_ALGORITHMS.join ", "}"
+  end
+
+  def self.parse_cli_options
+    options = {}
+    
+    OptionParser.new do |opts|
+      opts.banner = [
+        "Usage: file-digests [options] [path/to/directory] [path/to/database_file]",
+        "       By default the current directory will be operated upon, and the database file will be placed to the current directory as well.",
+        "       Should you wish to check current directory but place the database elsewhere, you could provide \".\" as a first argument, and the path to a database_file as a second."
+      ].join "\n"
+    
+      opts.on("-a", "--auto", "Do not ask for any confirmation") do
+        options[:auto] = true
+      end
+
+      opts.on(
+        '--digest=DIGEST',
+        'Select a digest algorithm to use. Default is "BLAKE2b512".',
+        'You might also consider to use slower "SHA512-256" or even more slower "SHA3-256".',
+        "#{digest_algorithms_list_text}.",
+        'You only need to specify an algorithm on the first run, your choice will be saved to a database.',
+        'Any time later you could specify a new algorithm to change the current one.',
+        'Transition to a new algorithm will only occur if all files pass the check by digests which were stored using the old one.'
+      ) do |value|
+        digest_algorithm = canonical_digest_algorithm_name(value)
+        unless digest_algorithm
+          STDERR.puts "ERROR: #{digest_algorithms_list_text}" 
+          exit 1
+        end
+        options[:digest_algorithm] = digest_algorithm
+      end
 
-      @db = SQLite3::Database.new path.to_s
-      @db.results_as_hash = true
+      opts.on("-d", "--duplicates", "Show the list of duplicate files, based on the information out of the database") do
+        options[:action] = :show_duplicates
+      end
+
+      opts.on("-t", "--test", "Perform only the test, do not modify the digest database") do
+        options[:test_only] = true
+      end
+
+      opts.on("-q", "--quiet", "Less verbose output, stil report any found issues") do
+        options[:quiet] = true
+      end
+
+      opts.on("-v", "--verbose", "More verbose output") do
+        options[:verbose] = true
+      end
+
+      opts.on("-h", "--help", "Prints this help") do
+        puts opts
+        exit
+      end
+    end.parse!
+    options
+  end
 
-      execute 'PRAGMA journal_mode = "WAL"'
-      execute 'PRAGMA synchronous = "NORMAL"'
-      execute 'PRAGMA locking_mode = "EXCLUSIVE"'
-      execute 'PRAGMA cache_size = "5000"'
+  def self.run_cli_utility
+    options = parse_cli_options
 
-      unless execute("SELECT name FROM sqlite_master WHERE type='table' AND name = 'digests'").length == 1
-        execute 'PRAGMA encoding = "UTF-8"'
+    file_digests = self.new ARGV[0], ARGV[1], options
+    file_digests.send(options[:action] || :perform_check)
+  end
+
+  def initialize files_path, digest_database_path, options = {}
+    @options = options
+
+    initialize_paths files_path, digest_database_path
+    initialize_database
+
+    if @digest_algorithm = canonical_digest_algorithm_name(get_metadata("digest_algorithm"))
+      if @options[:digest_algorithm] && @options[:digest_algorithm] != @digest_algorithm
+        @new_digest_algorithm = @options[:digest_algorithm]
+      end
+    else
+      @digest_algorithm = (@options[:digest_algorithm] || "BLAKE2b512")
+      set_metadata "digest_algorithm", @digest_algorithm
+    end
+
+    puts "Using #{@digest_algorithm} digest algorithm" if @options[:verbose]
+  end
+
+  def initialize_paths files_path, digest_database_path
+    @files_path = cleanup_path(files_path || ".")
+
+    raise "Files path must be a readable directory" unless (File.directory?(@files_path) && File.readable?(@files_path))
+
+    @digest_database_path = digest_database_path ? cleanup_path(digest_database_path) : @files_path
+    @digest_database_path += '.file-digests.sqlite' if File.directory?(@digest_database_path)
+    ensure_dir_exists @digest_database_path.dirname
+
+    if @options[:verbose]
+      puts "Target directory: #{@files_path}"
+      puts "Database location: #{@digest_database_path}"
+    end
+  end
+
+  def initialize_database
+    @db = SQLite3::Database.new @digest_database_path.to_s
+    @db.results_as_hash = true
+
+    file_digests_gem_version = Gem.loaded_specs["file-digests"]&.version&.to_s
+
+    execute 'PRAGMA encoding = "UTF-8"'
+    execute 'PRAGMA journal_mode = "WAL"'
+    execute 'PRAGMA synchronous = "NORMAL"'
+    execute 'PRAGMA locking_mode = "EXCLUSIVE"'
+    execute 'PRAGMA cache_size = "5000"'
+
+    @db.transaction(:exclusive) do
+      unless table_exist?("metadata")
+        execute "CREATE TABLE metadata (
+          key TEXT NOT NULL PRIMARY KEY,
+          value TEXT)"
+        execute "CREATE UNIQUE INDEX metadata_key ON metadata(key)"
+        set_metadata("metadata_table_created_by_gem_version", file_digests_gem_version) if file_digests_gem_version
+      end
+
+      prepare_method :set_metadata_query, "INSERT INTO metadata (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value=excluded.value"
+      prepare_method :get_metadata_query, "SELECT value FROM metadata WHERE key = ?"
+
+      # Heuristic to detect database version 1 (metadata was not stored back then)
+      unless get_metadata("database_version")
+        if table_exist?("digests")
+          set_metadata "database_version", "1"
+        end
+      end
+
+      unless table_exist?("digests")
         execute "CREATE TABLE digests (
-          id INTEGER PRIMARY KEY,
-          filename TEXT,
+          id INTEGER NOT NULL PRIMARY KEY,
+          filename TEXT NOT NULL,
           mtime TEXT,
-          digest TEXT,
-          digest_check_time TEXT)"
+          digest TEXT NOT NULL,
+          digest_check_time TEXT NOT NULL)"
         execute "CREATE UNIQUE INDEX digests_filename ON digests(filename)"
+        set_metadata("digests_table_created_by_gem_version", file_digests_gem_version) if file_digests_gem_version
       end
 
-      @missing_files = Hash[@db.prepare("SELECT filename, digest FROM digests").execute!]
-      @new_files = {}
-
       prepare_method :insert, "INSERT INTO digests (filename, mtime, digest, digest_check_time) VALUES (?, ?, ?, datetime('now'))"
-      prepare_method :find_by_filename, "SELECT id, mtime, digest FROM digests WHERE filename = ?"
+      prepare_method :find_by_filename_query, "SELECT id, mtime, digest FROM digests WHERE filename = ?"
       prepare_method :touch_digest_check_time, "UPDATE digests SET digest_check_time = datetime('now') WHERE id = ?"
       prepare_method :update_mtime_and_digest, "UPDATE digests SET mtime = ?, digest = ?, digest_check_time = datetime('now') WHERE id = ?"
       prepare_method :update_mtime, "UPDATE digests SET mtime = ?, digest_check_time = datetime('now') WHERE id = ?"
       prepare_method :delete_by_filename, "DELETE FROM digests WHERE filename = ?"
-    end
+      prepare_method :query_duplicates, "SELECT digest, filename FROM digests WHERE digest IN (SELECT digest FROM digests GROUP BY digest HAVING count(*) > 1) ORDER BY digest, filename;"
+      prepare_method :update_digest_to_new_digest, "UPDATE digests SET digest = ? WHERE digest = ?"
 
-    def insert_or_update file_path, mtime, digest, counters
-      result = find_by_filename file_path
-
-      if found = result.next_hash
-        raise "Multiple records found" if result.next
-
-        @missing_files.delete(file_path)
+      unless get_metadata("database_version")
+        set_metadata "database_version", "2"
+      end
 
-        if found['digest'] == digest
-          counters[:good] += 1
-          # puts "GOOD: #{file_path}" unless @options[:quiet]
-          unless @options[:test_only]
-            if found['mtime'] == mtime
-              touch_digest_check_time found['id']
-            else
-              update_mtime mtime, found['id']
-            end
-          end
-        else
-          if found['mtime'] == mtime # Digest is different and mtime is the same
-            counters[:likely_damaged] += 1
-            STDERR.puts "LIKELY DAMAGED: #{file_path}"
+      # Convert database from 1st to 2nd version
+      unless get_metadata("digest_algorithm")
+        if get_metadata("database_version") == "1"
+          if File.exist?(@digest_database_path.dirname + '.file-digests.sha512')
+            set_metadata("digest_algorithm", "SHA512")
           else
-            counters[:updated] += 1
-            puts "UPDATED: #{file_path}" unless @options[:quiet]
-            unless @options[:test_only]
-              update_mtime_and_digest mtime, digest, found['id']
-            end
+            set_metadata("digest_algorithm", "SHA256")
           end
-        end
-      else
-        counters[:new] += 1
-        puts "NEW: #{file_path}" unless @options[:quiet]
-        unless @options[:test_only]
-          @new_files[file_path] = digest
-          insert file_path, mtime, digest
+          set_metadata "database_version", "2"
         end
       end
+
     end
+  end
 
-    def track_renames counters
-      @missing_files.delete_if do |filename, digest|
-        if @new_files.value?(digest)
-          counters[:renamed] += 1
-          unless @options[:test_only]
-            delete_by_filename filename
-          end
-          true
+  def perform_check
+    perhaps_transaction(@new_digest_algorithm, :exclusive) do
+      @counters = {good: 0, updated: 0, new: 0, renamed: 0, likely_damaged: 0, exceptions: 0}
+      @new_files = {}
+      @new_digests = {}
+
+      @missing_files = Hash[@db.prepare("SELECT filename, digest FROM digests").execute!]
+
+      measure_time do
+        walk_files do |filename|
+          process_file filename
         end
       end
-      counters[:missing] = @missing_files.length
-    end
-
-    def any_missing_files?
-      @missing_files.length > 0
-    end
 
-    def print_missing_files
-      puts "\nMISSING FILES:"
-      @missing_files.sort.to_h.each do |filename, digest|
-        puts filename
+      track_renames
+      
+      if any_missing_files?
+        if any_exceptions?
+          STDERR.puts "Due to previously occurred errors, database cleanup from missing files will be skipped this time."
+        else
+          print_missing_files
+          if !@options[:test_only] && (@options[:auto] || confirm("Remove missing files from the database"))
+            remove_missing_files
+          end
+        end
       end
-    end
 
-    def remove_missing_files
-      @db.transaction do
-        @missing_files.each do |filename, digest|
-          delete_by_filename filename
+      if @new_digest_algorithm && !@options[:test_only]
+        if any_missing_files? || any_likely_damaged? || any_exceptions?
+          STDERR.puts "ERROR: New digest algorithm will not be in effect until there are files that are missing, likely damaged, or processed with an exception."
+        else
+          @new_digests.each do |old_digest, new_digest|
+            update_digest_to_new_digest new_digest, old_digest
+          end
+          set_metadata "digest_algorithm", @new_digest_algorithm
         end
       end
-    end
 
-    private
+      if any_likely_damaged? || any_exceptions?
+        STDERR.puts "PLEASE REVIEW ERRORS THAT WERE OCCURRED!"
+      end
+
+      set_metadata(@options[:test_only] ? "latest_test_only_check_time" : "latest_complete_check_time", time_to_database(Time.now))
 
-    def execute *args, &block
-      @db.execute *args, &block
+      print_counters
     end
+  end
 
-    def prepare_method name, query
-      variable = "@#{name}"
-      instance_variable_set(variable, @db.prepare(query))
-      define_singleton_method name do |*args, &block|
-        instance_variable_get(variable).execute(*args, &block)
+  def show_duplicates
+    current_digest = nil
+    query_duplicates.each do |found|
+      if current_digest != found['digest']
+        puts "" if current_digest
+        current_digest = found['digest']
+        puts "#{found['digest']}:"
       end
+      puts "  #{found['filename']}"
     end
   end
 
-  class Checker
-    def initialize files_path, digest_database_path, options = {}
-      @options = options
-      @files_path = cleanup_path(files_path || ".")
-      @prefix_to_remove = @files_path.to_s + '/'
+  private
 
-      raise "Files path must be a readable directory" unless (File.directory?(@files_path) && File.readable?(@files_path))
+  def process_file filename
+    return if File.symlink? filename
 
-      @digest_database_path = if digest_database_path
-        cleanup_path(digest_database_path)
-      else
-        @files_path + '.file-digests.sqlite'
-      end
+    stat = File.stat filename
 
-      if File.directory?(@digest_database_path)
-        @digest_database_path = @digest_database_path + '.file-digests.sqlite'
-      end
+    return if stat.blockdev?
+    return if stat.chardev?
+    return if stat.directory?
+    return if stat.pipe?
+    return if stat.socket?
 
-      if @files_path == @digest_database_path.dirname
-        @skip_file_digests_sqlite = true
-      end
+    raise "File is not readable" unless stat.readable?
 
-      ensure_dir_exists @digest_database_path.dirname
+    if filename == "#{@digest_database_path}" ||
+       filename == "#{@digest_database_path}-wal" ||
+       filename == "#{@digest_database_path}-shm"
+      puts "SKIPPING DATABASE FILE: #{filename}" if @options[:verbose]
+      return
+    end
 
-      # Please do not use this flag, support for sha512 is here for backward compatibility, and one day it will be removed.
-      if File.exist?(@digest_database_path.dirname + '.file-digests.sha512')
-        @use_sha512 = true
-      end
+    normalized_filename = filename.delete_prefix("#{@files_path.to_s}/").encode('utf-8', universal_newline: true).unicode_normalize(:nfkc)
+    mtime_string = time_to_database stat.mtime
+
+    process_file_indeed normalized_filename, mtime_string, get_file_digest(filename)
+
+  rescue => exception
+    @counters[:exceptions] += 1
+    print_file_exception exception, filename
+  end
 
-      @digest_database = DigestDatabase.new @digest_database_path, @options
-      @counters = {good: 0, updated: 0, new: 0, missing: 0, renamed: 0, likely_damaged: 0, exceptions: 0}
+  def process_file_indeed filename, mtime, digest
+    if found = find_by_filename(filename)
+      process_previously_seen_file found, filename, mtime, digest
+    else
+      process_new_file filename, mtime, digest
     end
+  end
 
-    def perform_check
-      measure_time do
-        walk_files do |filename|
-          process_file filename
+  def process_previously_seen_file found, filename, mtime, digest
+    @missing_files.delete(filename)
+    if found['digest'] == digest
+      @counters[:good] += 1
+      puts "GOOD: #{filename}" if @options[:verbose]
+      unless @options[:test_only]
+        if found['mtime'] == mtime
+          touch_digest_check_time found['id']
+        else
+          update_mtime mtime, found['id']
         end
       end
+    else
+      if found['mtime'] == mtime # Digest is different and mtime is the same
+        @counters[:likely_damaged] += 1
+        STDERR.puts "LIKELY DAMAGED: #{filename}"
+      else
+        @counters[:updated] += 1
+        puts "UPDATED: #{filename}" unless @options[:quiet]
+        unless @options[:test_only]
+          update_mtime_and_digest mtime, digest, found['id']
+        end
+      end
+    end
+  end
+
+  def process_new_file filename, mtime, digest
+    @counters[:new] += 1
+    puts "NEW: #{filename}" unless @options[:quiet]
+    unless @options[:test_only]
+      @new_files[filename] = digest
+      insert filename, mtime, digest
+    end
+  end
+
 
-      @digest_database.track_renames @counters
+  # Renames and missing files
 
-      if @digest_database.any_missing_files?
-        @digest_database.print_missing_files
-        if !@options[:test_only] && (@options[:auto] || confirm("Remove missing files from the database"))
-          @digest_database.remove_missing_files
+  def track_renames
+    @missing_files.delete_if do |filename, digest|
+      if @new_files.value?(digest)
+        @counters[:renamed] += 1
+        unless @options[:test_only]
+          delete_by_filename filename
         end
+        true
       end
+    end
+  end
 
-      if @counters[:likely_damaged] > 0 || @counters[:exceptions] > 0
-        STDERR.puts "ERRORS WERE OCCURRED"
-      end
+  def print_missing_files
+    puts "\nMISSING FILES:"
+    @missing_files.sort.to_h.each do |filename, digest|
+      puts filename
+    end
+  end
 
-      puts @counters.inspect
+  def remove_missing_files
+    nested_transaction do
+      @missing_files.each do |filename, digest|
+        delete_by_filename filename
+      end
+      @missing_files = {}
     end
+  end
+
 
-    private
+  # Database helpers
 
+  def execute *args, &block
+    @db.execute *args, &block
+  end
 
-    def confirm text
-      if STDIN.tty? && STDOUT.tty?
-        puts "#{text} (y/n)?"
-        STDIN.gets.strip.downcase == "y"
+  def nested_transaction(mode)
+    if @db.transaction_active?
+      yield
+    else
+      @db.transaction(mode) do
+        yield
       end
     end
+  end
 
-    def process_file filename
-      return if File.symlink? filename
+  def perhaps_transaction(condition, mode)
+    if condition
+      @db.transaction(mode) do
+        yield
+      end
+    else
+      yield
+    end
+  end
 
-      stat = File.stat filename
+  def table_exist? table_name
+    execute("SELECT name FROM sqlite_master WHERE type='table' AND name = '#{table_name}'").length == 1
+  end
 
-      return if stat.blockdev?
-      return if stat.chardev?
-      return if stat.directory?
-      return if stat.pipe?
-      unless stat.readable?
-        raise "File is not readable"
-      end
-      return if stat.socket?
-
-      if @skip_file_digests_sqlite
-        basename = File.basename(filename)
-        return if basename == '.file-digests.sha512'
-        return if basename == '.file-digests.sqlite'
-        return if basename == '.file-digests.sqlite-wal'
-        return if basename == '.file-digests.sqlite-shm'
-      end
+  def prepare_method name, query
+    variable = "@#{name}"
 
-      @digest_database.insert_or_update(
-        filename.delete_prefix(@prefix_to_remove).encode('utf-8', universal_newline: true).unicode_normalize(:nfkc),
-        stat.mtime.utc.strftime('%Y-%m-%d %H:%M:%S'),
-        get_file_digest(filename),
-        @counters
-        )
-    rescue => exception
-      @counters[:exceptions] += 1
-      STDERR.puts "EXCEPTION: #{filename.encode('utf-8', universal_newline: true)}: #{exception.message}"
-    end
+    instance_variable_set(variable, @db.prepare(query))
 
-    def patch_path_string path
-      Gem.win_platform? ? path.gsub(/\\/, '/') : path
+    define_singleton_method name do |*args, &block|
+      instance_variable_get(variable).execute(*args, &block)
     end
 
-    def cleanup_path path
-      Pathname.new(patch_path_string(path)).cleanpath
+    define_singleton_method "#{name}!" do |*args, &block|
+      instance_variable_get(variable).execute!(*args, &block)
     end
+  end
 
-    def ensure_dir_exists path
-      if File.exist?(path)
-        unless File.directory?(path)
-          raise "#{path} is not a directory"
-        end
-      else
-        FileUtils.mkdir_p path
+  def set_metadata key, value
+    set_metadata_query key, value
+    puts "#{key} set to: #{value}" if @options[:verbose]
+    value
+  end
+
+  def get_metadata key
+    get_metadata_query!(key)&.first&.first
+  end
+
+  def find_by_filename filename
+    result = find_by_filename_query filename
+    found = result.next
+    raise "Multiple records found" if result.next
+    found
+  end
+
+  def time_to_database time
+    time.utc.strftime('%Y-%m-%d %H:%M:%S')
+  end
+
+
+  # Filesystem-related helpers
+
+  def patch_path_string path
+    Gem.win_platform? ? path.gsub(/\\/, '/') : path
+  end
+
+  def cleanup_path path
+    Pathname.new(patch_path_string(path)).cleanpath
+  end
+
+  def ensure_dir_exists path
+    if File.exist?(path)
+      unless File.directory?(path)
+        raise "#{path} is not a directory"
       end
+    else
+      FileUtils.mkdir_p path
     end
+  end
 
-    def walk_files
-      Dir.glob(@files_path + '**' + '*', File::FNM_DOTMATCH) do |filename|
-        yield filename
-      end
+  def walk_files
+    Dir.glob(@files_path + '**' + '*', File::FNM_DOTMATCH) do |filename|
+      yield filename
     end
+  end
 
-    def get_file_digest filename
-      File.open(filename, 'rb') do |io|
-        digest = (@use_sha512 ? Digest::SHA512 : Digest::SHA256).new
-        buffer = ""
-        while io.read(40960, buffer)
-          digest.update(buffer)
-        end
-        return digest.hexdigest
+  def get_file_digest filename
+    File.open(filename, 'rb') do |io|
+      digest = OpenSSL::Digest.new(@digest_algorithm)
+      new_digest = OpenSSL::Digest.new(@new_digest_algorithm) if @new_digest_algorithm
+
+      buffer = ""
+      while io.read(409600, buffer) # 409600 seems like a sweet spot
+        digest.update(buffer)
+        new_digest.update(buffer) if @new_digest_algorithm
       end
+      @new_digests[digest.hexdigest] = new_digest.hexdigest if @new_digest_algorithm
+      return digest.hexdigest
     end
+  end
 
-    def measure_time
-      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      yield
-      elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start).to_i
-      puts "Elapsed time: #{elapsed / 3600}h #{(elapsed % 3600) / 60}m #{elapsed % 60}s" unless @options[:quiet]
+
+  # Runtime state helpers
+
+  def any_missing_files?
+    @missing_files.length > 0
+  end
+
+  def any_exceptions?
+    @counters[:exceptions] > 0
+  end
+
+  def any_likely_damaged?
+    @counters[:likely_damaged] > 0
+  end
+
+  # UI helpers
+
+  def confirm text
+    if STDIN.tty? && STDOUT.tty?
+      puts "#{text} (y/n)?"
+      STDIN.gets.strip.downcase == "y"
+    end
+  end
+
+  def measure_time
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    yield
+    elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start)
+    puts "Elapsed time: #{elapsed.to_i / 3600}h #{(elapsed.to_i % 3600) / 60}m #{'%.3f' % (elapsed % 60)}s" unless @options[:quiet]
+  end
+
+  def print_file_exception exception, filename
+    STDERR.print "EXCEPTION: #{exception.message}, processing file: "
+    begin
+      STDERR.print filename.encode('utf-8', universal_newline: true)
+    rescue
+      STDERR.print "(Unable to encode file name to utf-8) "
+      STDERR.print filename
     end
+    STDERR.print "\n"
+    STDERR.flush
+    exception.backtrace.each { |line| STDERR.puts "  " + line }
+  end
 
+  def print_counters
+    puts "#{@counters[:good]} file(s) passes digest check" if @counters[:good] > 0
+    puts "#{@counters[:updated]} file(s) are updated" if @counters[:updated] > 0
+    puts "#{@counters[:new]} file(s) are new" if @counters[:new] > 0
+    puts "#{@counters[:renamed]} file(s) are renamed" if @counters[:renamed] > 0
+    puts "#{@missing_files.length} file(s) are missing" if @missing_files.length > 0
+    puts "#{@counters[:likely_damaged]} file(s) are likely damaged (!)" if @counters[:likely_damaged] > 0
+    puts "#{@counters[:exceptions]} file(s) had exceptions occured during processing (!)" if @counters[:exceptions] > 0
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: file-digests
 version: !ruby/object:Gem::Version
-  version: 0.0.17
+  version: 0.0.22
 platform: ruby
 authors:
 - Stanislav Senotrusov
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-08 00:00:00.000000000 Z
+date: 2020-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
@@ -24,22 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
 description: Calculate file digests and check for the possible file corruption
 email: stan@senotrusov.com
 executables:
 - file-digests
-- file-digests-test
 extensions: []
 extra_rdoc_files: []
 files:
 - bin/file-digests
-- bin/file-digests-test
 - lib/file-digests.rb
 homepage: https://github.com/senotrusov/file-digests
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -55,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key:
+signing_key: 
 specification_version: 4
 summary: file-digests
 test_files: []

data/bin/file-digests-test

@@ -1,7 +0,0 @@
-#!/usr/bin/env ruby
-
-ENV["TEST_ONLY"] = "true"
-
-require 'file-digests'
-
-FileDigests.perform_check