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

@@ -547,7 +547,15 @@ int main(int argc, char **argv)
 
     // Always try to load the user-provided exclude list if one is specified
     if (hasUserExcludeFile) {
-        engine.excludedFiles().addExcludeFilePath(options.exclude);
+        // Anchor patterns at the sync root regardless of the file's own name.
+        // Without this, addExcludeFilePath() only anchors at _localPath when the
+        // file is literally named "sync-exclude.lst" (a heuristic that exists to
+        // distinguish the GUI's global exclude list from a per-directory
+        // .sync-exclude.lst); any other --exclude filename silently anchored
+        // patterns at the exclude file's own directory instead, so none of them
+        // ever matched anything under the sync root. See nextcloud/desktop#2916,
+        // #7682.
+        engine.excludedFiles().addExcludeFilePath(options.exclude, /*anchorToLocalPath=*/true);
     }
     // 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, bool anchorToLocalPath)
 {
     const QFileInfo excludeFileInfo(path);
     const auto fileName = excludeFileInfo.fileName();
-    const auto basePath = fileName.compare(QStringLiteral("sync-exclude.lst"), Qt::CaseInsensitive) == 0
+    const auto basePath = anchorToLocalPath || fileName.compare(QStringLiteral("sync-exclude.lst"), Qt::CaseInsensitive) == 0
                                                                     ? _localPath
                                                                     : leftIncludeLast(path, QLatin1Char('/'));
     auto &excludeFilesLocalPath = _excludeFiles[basePath];

src/csync/csync_exclude.h

@@ -69,8 +69,20 @@ class OCSYNC_EXPORT ExcludedFiles : public QObject
      * Adds a new path to a file containing exclude patterns.
      *
      * Does not load the file. Use reloadExcludeFiles() afterwards.
+     *
+     * By default 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). 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 anchorToLocalPath=true
+     * there to force sync-root anchoring regardless of the file's name.
      */
-    void addExcludeFilePath(const QString &path);
+    void addExcludeFilePath(const QString &path, bool anchorToLocalPath = false);
 
     /**
      * Whether conflict files shall be excluded.

test/testexcludedfiles.cpp

@@ -759,7 +759,34 @@ 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" -
+    // e.g. nextcloudcmd's --exclude <path> - must still anchor its patterns at
+    // the sync root when anchorToLocalPath is requested (nextcloud/desktop#2916,
+    // #7682: without this, --exclude with a custom filename silently anchored
+    // patterns at the exclude file's own directory instead, so none of them
+    // ever matched anything under the sync root).
+    void testAddExcludeFilePath_anchorToLocalPath_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);
+
+        // anchorToLocalPath=true (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, /*anchorToLocalPath=*/true);
+        QCOMPARE(excludedFiles->_excludeFiles[basePath].first(), customExcludeList);
+    }
+
     void testReloadExcludeFiles_fileDoesNotExist_returnTrue() {
         excludedFiles.reset(new ExcludedFiles());
         const QString nonExistingFile("directory/.sync-exclude.lst");