Name the database each command uses on stderr (closes #111)

scan, report and trees now print one line on stderr before anything
else, naming the database as an absolute path and saying whether the
path is the default or comes from SFDUPES_DATABASE; scan also says when
no database file exists yet. report and trees print it before opening
the database, so a missing-database error follows it. databasePath in
db.go now returns the absolute path and its source, and every command
uses that absolute path throughout, so errors and the lock file name it
too. README "Database" lists when scan writes each file, from the lock
file to the -wal and -shm files going away.

Unverified: the line on a terminal has no test of its own; it is
printed before any progress display, the same way in both cases.

Model: opus-5-5

README.md

@@ -269,10 +269,9 @@ All three subcommands operate on a single SQLite database file:
   directory.
 - Each subcommand first prints one line on stderr naming the database it uses,
   before anything else it prints (progress displays included), whether or not
-  stderr is a terminal. The line gives the path with the working directory put
+  stderr is a terminal. The line gives the path made absolute against the
-  in front of it when it is relative, and otherwise as set (a `..` in it stays,
+  working directory, escaped like the paths in a report (see "Report output
-  so the line names the same file), escaped like the paths in a report (see
+  format"), and says where the path came from:
-  "Report output format"), and says where the path came from:
 
     ```
     scan: new database /var/lib/sfdupes/db.sqlite (default)

db.go

@@ -11,7 +11,6 @@ import (
 	"path/filepath"
 	"slices"
 	"strconv"
-	"strings"
 	"time"
 
 	"golang.org/x/sys/unix"
@@ -93,30 +92,21 @@ var errScanRunning = errors.New("another scan is running")
 
 // databasePath resolves the database location: SFDUPES_DATABASE when
 // set and non-empty, the compiled-in default otherwise. It returns the
-// path, with the working directory put in front of it when it is
+// path made absolute against the working directory, and where the path
-// relative, and where the path came from, "default" or "from
+// came from, "default" or "from SFDUPES_DATABASE", for the line each
-// SFDUPES_DATABASE", for the line each subcommand prints first on
+// subcommand prints first on stderr.
-// stderr.
 func databasePath() (string, string, error) {
 	path, source := defaultDatabasePath, "default"
 	if p := os.Getenv(databaseEnv); p != "" {
 		path, source = p, "from "+databaseEnv
 	}
 
-	if filepath.IsAbs(path) {
+	abs, err := filepath.Abs(path)
-		return path, source, nil
-	}
-
-	wd, err := os.Getwd()
 	if err != nil {
 		return "", "", fmt.Errorf("resolve database path %s: %w", path, err)
 	}
 
-	// Not filepath.Abs or filepath.Join: they clean the path, which
+	return abs, source, nil
-	// drops each ".." together with the directory name before it. When
-	// that directory is a symlink, the cleaned path names another file.
-	// The working directory ends in "/" only when it is the root.
-	return strings.TrimSuffix(wd, "/") + "/" + path, source, nil
 }
 
 // scanParams are the connection parameters for scan: read-write, with

db_test.go

@@ -45,8 +45,7 @@ func openTestDB(t *testing.T) *sql.DB {
 //nolint:paralleltest // changes the process-wide working directory
 func TestDatabasePath(t *testing.T) {
 	// README §Database: SFDUPES_DATABASE when set and non-empty, the
-	// default otherwise, with the working directory put in front of a
+	// default otherwise, made absolute against the working directory.
-	// relative path. Nothing is cleaned, so a ".." stays.
 	dir := t.TempDir()
 	t.Chdir(dir)
 
@@ -56,10 +55,7 @@ func TestDatabasePath(t *testing.T) {
 	}{
 		{"", defaultDatabasePath, "default"},
 		{"/custom/place.sqlite", "/custom/place.sqlite", fromEnv},
-		{"/custom/link/../place.sqlite", "/custom/link/../place.sqlite",
+		{"sub/place.sqlite", filepath.Join(dir, "sub/place.sqlite"), fromEnv},
-			fromEnv},
-		{"sub/place.sqlite", dir + "/sub/place.sqlite", fromEnv},
-		{"link/../place.sqlite", dir + "/link/../place.sqlite", fromEnv},
 	}
 
 	for _, tc := range cases {
@@ -71,16 +67,6 @@ func TestDatabasePath(t *testing.T) {
 				databaseEnv, tc.env, path, source, err, tc.path, tc.source)
 		}
 	}
-
-	// In the root directory the path gets one slash in front, not two.
-	t.Chdir("/")
-	t.Setenv(databaseEnv, "place.sqlite")
-
-	path, _, err := databasePath()
-	if err != nil || path != "/place.sqlite" {
-		t.Errorf("databasePath() in / = %q, %v; want %q",
-			path, err, "/place.sqlite")
-	}
 }
 
 func TestOpenScanDatabaseCreates(t *testing.T) {

main_test.go

@@ -352,72 +352,6 @@ func TestRunNamesRelativeDatabase(t *testing.T) {
 	}
 }
 
-func TestRunUsesDatabaseThroughSymlinkedDirectory(t *testing.T) {
-	// README §Database: the path names the file exactly. With link a
-	// symlink to the directory real/sub, link/../db.sqlite names
-	// real/db.sqlite, not db.sqlite beside link. Every subcommand must
-	// use that file, relative or absolute, and its first line must name
-	// the path as set, with the working directory put in front of a
-	// relative one.
-	dir := t.TempDir()
-	t.Chdir(dir)
-
-	err := os.MkdirAll(filepath.Join(dir, "real", "sub"), 0o750)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = os.Symlink(filepath.Join(dir, "real", "sub"),
-		filepath.Join(dir, "link"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	named := dir + "/link/../db.sqlite"
-	from := " (from " + databaseEnv + ")\n"
-	tree := t.TempDir()
-
-	t.Setenv(databaseEnv, "link/../db.sqlite")
-
-	want := "scan: new database " + named + from
-	if got := scanOK(t, tree); !strings.HasPrefix(got, want) {
-		t.Errorf("relative scan stderr = %q, want it to start %q", got, want)
-	}
-
-	// The absolute path names the database the relative one created.
-	t.Setenv(databaseEnv, named)
-
-	want = "scan: database " + named + from
-	if got := scanOK(t, tree); !strings.HasPrefix(got, want) {
-		t.Errorf("absolute scan stderr = %q, want it to start %q", got, want)
-	}
-
-	for _, name := range []string{cmdReport, cmdTrees} {
-		stderr := captureStderr(t)
-
-		code := run([]string{name}, io.Discard, os.Stderr)
-
-		want = name + ": database " + named + from
-		if got := stderr(); code != exitOK || !strings.HasPrefix(got, want) {
-			t.Errorf("run(%s) = %d with stderr %q, want %d and it to "+
-				"start %q", name, code, got, exitOK, want)
-		}
-	}
-
-	_, err = os.Stat(filepath.Join(dir, "real", "db.sqlite"))
-	if err != nil {
-		t.Errorf("database the path names: %v", err)
-	}
-
-	// With no file at the cleaned path, report and trees succeeded on
-	// the database in real.
-	_, err = os.Stat(filepath.Join(dir, "db.sqlite"))
-	if !errors.Is(err, fs.ErrNotExist) {
-		t.Errorf("database at the cleaned path: stat error %v, want it "+
-			"missing", err)
-	}
-}
-
 func TestRunNamesDefaultDatabase(t *testing.T) {
 	// README §Database: with SFDUPES_DATABASE empty, each subcommand's
 	// first line on stderr names the default database. A database may