fix(cmd,csync): anchor --exclude patterns at the sync root regardless of filename

Summary
nextcloudcmd --exclude <path> silently produced zero exclusions for
every pattern in the file, unless <path> happened to be literally
named "sync-exclude.lst" -- with no warning or error anywhere. Any
other filename (a typo'd extension, a descriptive name, a per-tool
name like myapp-exclude.lst) caused every single pattern to be
matched against the wrong base directory, so none of them ever
excluded anything under the sync root.

Root cause
ExcludedFiles::addExcludeFilePath() in src/csync/csync_exclude.cpp
anchors patterns either at the sync root (_localPath) or at the
exclude file's own containing directory, based on a filename check:
literally "sync-exclude.lst" -> sync root, anything else -> own
directory. That heuristic was introduced in 5788f35 (2020-12-09,
"Skip sync exclude file from list of exclude files if it doesn't
exist") to merge two previously-separate code paths: the GUI's
global exclude list (always named sync-exclude.lst, lives outside
any sync folder, needs sync-root anchoring) and a per-directory
.sync-exclude.lst discovered during traversal (needs anchoring at
its own directory). It was a side effect of that merge, not a
deliberate choice -- the commit's own description and linked issue
are unrelated to anchoring behavior.

src/cmd/cmd.cpp passes the CLI's --exclude value into the same
function unconditionally, so it inherited this GUI-specific
heuristic even though CLI users can name their exclude file
anything. Reported independently by multiple users:
#2916, #7682, and a comment
diagnosing the exact same filename dependency on #2916.

Fix
Add an explicit anchorToLocalPath parameter to addExcludeFilePath()
(default false, preserving current behavior everywhere else) and set
it for the CLI's --exclude option in cmd.cpp, so its patterns are
always anchored at the sync root regardless of the file's name.

Test plan
- [x] New unit test:
      testAddExcludeFilePath_anchorToLocalPath_bypassesFilenameHeuristic
- [x] Full ExcludedFilesTest suite: 25 passed, 0 failed
- [x] Manual repro against a live Nextcloud account: an --exclude file
      not named sync-exclude.lst previously had zero effect (excluded
      directories were downloaded anyway); after this fix they are
      correctly skipped (FileIgnored) with no behavior change for
      GUI-managed exclude lists.

Signed-off-by: Thomas Mosandl <mosandl@concreativ.de>
Assisted-by: ClaudeCode:claude-sonnet-5

Author: mosandlconcreativ

src/cmd/cmd.cpp

@@ -556,7 +556,9 @@ int main(int argc, char **argv)
             qFatal("Exclude list file supplied via --exclude does not exist: %s", qUtf8Printable(options.exclude));
             return EXIT_FAILURE;
         }
-        engine.excludedFiles().addExcludeFilePath(options.exclude);
+        // Anchor patterns at the sync root regardless of the file's own name,
+        // see ExcludedFiles::addExcludeFilePath().
+        engine.excludedFiles().addExcludeFilePath(options.exclude, ExcludedFiles::ExcludeFileAnchor::SyncRoot);
     }
     // Load the system list if available, or if there's no user-provided list
     if (!hasUserExcludeFile || QFile::exists(systemExcludeFile)) {

src/csync/csync_exclude.cpp

@@ -242,11 +242,11 @@ ExcludedFiles::ExcludedFiles(const QString &localPath)
 
 ExcludedFiles::~ExcludedFiles() = default;
 
-void ExcludedFiles::addExcludeFilePath(const QString &path)
+void ExcludedFiles::addExcludeFilePath(const QString &path, ExcludeFileAnchor anchor)
 {
     const QFileInfo excludeFileInfo(path);
     const auto fileName = excludeFileInfo.fileName();
-    const auto basePath = fileName.compare(QStringLiteral("sync-exclude.lst"), Qt::CaseInsensitive) == 0
+    const auto basePath = anchor == ExcludeFileAnchor::SyncRoot || fileName.compare(QStringLiteral("sync-exclude.lst"), Qt::CaseInsensitive) == 0
                                                                     ? _localPath
                                                                     : leftIncludeLast(path, QLatin1Char('/'));
     auto &excludeFilesLocalPath = _excludeFiles[basePath];

src/csync/csync_exclude.h

@@ -62,15 +62,38 @@ class OCSYNC_EXPORT ExcludedFiles : public QObject
 public:
     using Version = std::tuple<int, int, int>;
 
+    /**
+     * Where a caller-supplied exclude file's patterns are anchored, see
+     * addExcludeFilePath().
+     */
+    enum class ExcludeFileAnchor {
+        FileDirectory, // anchor at the exclude file's own containing directory
+        SyncRoot // anchor at the sync root (_localPath), regardless of the file's name
+    };
+
     explicit ExcludedFiles(const QString &localPath = QStringLiteral("/"));
     ~ExcludedFiles() override;
 
     /**
      * Adds a new path to a file containing exclude patterns.
      *
      * Does not load the file. Use reloadExcludeFiles() afterwards.
+     *
+     * By default (ExcludeFileAnchor::FileDirectory) the patterns are
+     * anchored at the directory the exclude file itself lives in, unless
+     * that file is literally named "sync-exclude.lst" (case-insensitive),
+     * in which case they're anchored at the sync root (_localPath)
+     * regardless. That heuristic exists to distinguish the GUI's global
+     * exclude list (always named sync-exclude.lst, but stored outside any
+     * sync folder) from a per-directory .sync-exclude.lst discovered
+     * during traversal.
+     *
+     * It does not fit a caller-supplied exclude file of arbitrary name,
+     * such as nextcloudcmd's --exclude option: pass
+     * ExcludeFileAnchor::SyncRoot there to force sync-root anchoring
+     * regardless of the file's name.
      */
-    void addExcludeFilePath(const QString &path);
+    void addExcludeFilePath(const QString &path, ExcludeFileAnchor anchor = ExcludeFileAnchor::FileDirectory);
 
     /**
      * Whether conflict files shall be excluded.

test/testexcludedfiles.cpp

@@ -759,7 +759,31 @@ private slots:
         QCOMPARE(excludedFiles->_excludeFiles[folder1].first(), folder1ExcludeList);
         QCOMPARE(excludedFiles->_excludeFiles[folder2].first(), folder2ExcludeList);
     }
-    
+
+    // A caller-supplied exclude file not literally named "sync-exclude.lst"
+    // must still anchor its patterns at the sync root when
+    // ExcludeFileAnchor::SyncRoot is requested.
+    void testAddExcludeFilePath_syncRootAnchor_bypassesFilenameHeuristic()
+    {
+        const QString basePath("syncFolder/");
+        excludedFiles.reset(new ExcludedFiles(basePath));
+
+        const QString customExcludeList("home/thomas/.config/my-custom-exclude.lst");
+
+        // Default (as used for per-directory .sync-exclude.lst discovery):
+        // anchored at the exclude file's own directory, since its name isn't
+        // literally "sync-exclude.lst".
+        excludedFiles->addExcludeFilePath(customExcludeList);
+        QCOMPARE(excludedFiles->_excludeFiles.contains(basePath), false);
+        QCOMPARE(excludedFiles->_excludeFiles[QString("home/thomas/.config/")].first(), customExcludeList);
+
+        // ExcludeFileAnchor::SyncRoot (as used for nextcloudcmd's --exclude
+        // option): anchored at the sync root regardless of the file's name.
+        excludedFiles.reset(new ExcludedFiles(basePath));
+        excludedFiles->addExcludeFilePath(customExcludeList, ExcludedFiles::ExcludeFileAnchor::SyncRoot);
+        QCOMPARE(excludedFiles->_excludeFiles[basePath].first(), customExcludeList);
+    }
+
     void testReloadExcludeFiles_fileDoesNotExist_returnTrue() {
         excludedFiles.reset(new ExcludedFiles());
         const QString nonExistingFile("directory/.sync-exclude.lst");