Keep going past unreadable files with check --continue (closes #11)

With --continue, check stopped at the first file whose content or
checksum attribute it could not read, and at the first directory it
could not list. Each of these now counts as failed, its error, which
names the path, goes to stderr, and the walk goes on; the run still
exits non-zero. The count that sizes the progress bar leaves such a
path out, so the bar stays. The walk and the count, shared with sum
and clear, take the continue setting; those commands pass false and
still stop at the first error. Without --continue the first such error
still stops the run, and the summary printed before it now counts an
unreadable checksum attribute as failed, as it already did for
unreadable content.

Model: opus-5-5

attrsum.go

@@ -179,9 +179,9 @@ type processFunc func(
 // countAndBar counts the files under paths and returns a progress bar sized
 // to that total. It always returns either a non-nil bar or a non-nil error.
 func countAndBar(
-	opts *options, paths []string, desc string,
+	opts *options, paths []string, desc string, cont bool,
 ) (*progressbar.ProgressBar, error) {
-	total, err := countFilesMultiple(opts, paths)
+	total, err := countFilesMultiple(opts, paths, cont)
 	if err != nil {
 		return nil, err
 	}
@@ -211,7 +211,7 @@ func runOverPaths(
 	var bar *progressbar.ProgressBar
 
 	if !opts.quiet {
-		bar, err = countAndBar(opts, paths, desc)
+		bar, err = countAndBar(opts, paths, desc, false)
 		if err != nil {
 			return err
 		}
@@ -468,10 +468,8 @@ func runCheck(opts *options, args []string, cont bool) error {
 	var bar *progressbar.ProgressBar
 
 	if !opts.quiet {
-		// With --continue, a path the count cannot read leaves the run
+		bar, err = countAndBar(opts, paths, "Verifying checksums", cont)
-		// without a progress bar; the walk below reports it as failed.
+		if err != nil {
-		bar, err = countAndBar(opts, paths, "Verifying checksums")
-		if err != nil && !cont {
 			return err
 		}
 	}
@@ -607,12 +605,18 @@ func reportCheck(opts *options, p, actual string, ok bool) {
 ///////////////////////////////////////////////////////////////////////////////
 
 // countFiles counts the total number of regular files that will be processed.
-func countFiles(opts *options, root string) (int64, error) {
+// With cont, a path it cannot read is left out of the count instead of ending
+// it; the walk that follows reports that path as failed.
+func countFiles(opts *options, root string, cont bool) (int64, error) {
 	var count int64
 
 	root = filepath.Clean(root)
 
 	err := filepath.Walk(root, func(p string, info os.FileInfo, err error) error {
+		if err != nil && cont {
+			return nil
+		}
+
 		if err != nil {
 			return err
 		}
@@ -647,11 +651,11 @@ func countFiles(opts *options, root string) (int64, error) {
 }
 
 // countFilesMultiple counts files across multiple roots.
-func countFilesMultiple(opts *options, roots []string) (int64, error) {
+func countFilesMultiple(opts *options, roots []string, cont bool) (int64, error) {
 	var total int64
 
 	for _, root := range roots {
-		count, err := countFiles(opts, root)
+		count, err := countFiles(opts, root, cont)
 		if err != nil {
 			return total, err
 		}

attrsum_test.go

@@ -319,4 +319,12 @@ func TestCheckContinuePastUnreadable(t *testing.T) {
 		t.Fatalf("expected 2 verified and 2 failed, got %d and %d",
 			stats.FilesProcessed, stats.FilesFailed)
 	}
+
+	// Without --quiet, runCheck counts the files for the progress bar
+	// before it checks any, so the count reaches the unlistable directory
+	// first.
+	err = runCheck(opts, []string{dir}, true)
+	if !errors.Is(err, errVerification) {
+		t.Fatalf("expected verification error from runCheck, got %v", err)
+	}
 }