Minor file matcher improvements

evaluator/src/main/kotlin/ProjectSourceRule.kt

@@ -70,7 +70,7 @@ open class ProjectSourceRule(
     fun projectSourceFindDirectories(vararg patterns: String): List<File> =
         projectSourcesDir.walkBottomUp().filterTo(mutableListOf()) {
             val path = it.relativeTo(projectSourcesDir).invariantSeparatorsPath
-            it.isDirectory && FileMatcher.match(patterns.asList(), path)
+            it.isDirectory && FileMatcher.matches(patterns.asList(), path)
         }
 
     /**
@@ -79,15 +79,15 @@ open class ProjectSourceRule(
     fun projectSourceFindFiles(vararg patterns: String): List<File> =
         projectSourcesDir.walkBottomUp().filterTo(mutableListOf()) {
             val path = it.relativeTo(projectSourcesDir).invariantSeparatorsPath
-            it.isFile && FileMatcher.match(patterns.asList(), path)
+            it.isFile && FileMatcher.matches(patterns.asList(), path)
         }
 
     /**
      * Return the detected licenses for any file matching the given [glob expressions][patterns].
      */
     fun projectSourceGetDetectedLicensesByFilePath(vararg patterns: String): Map<String, Set<String>> =
         detectedLicensesForFilePath.filter { (filePath, _) ->
-            FileMatcher.match(patterns.asList(), filePath)
+            FileMatcher.matches(patterns.asList(), filePath)
         }
 
     /**

helper-cli/src/main/kotlin/commands/ListLicensesCommand.kt

@@ -180,7 +180,7 @@ internal class ListLicensesCommand : OrtHelperCommand(
                     !offendingOnly || license.decompose().any { it in violatedRulesByLicense }
                 }.mapValues { (license, locations) ->
                     locations.filter { location ->
-                        val isAllowedFile = fileAllowList.isEmpty() || FileMatcher.match(fileAllowList, location.path)
+                        val isAllowedFile = fileAllowList.isEmpty() || FileMatcher.matches(fileAllowList, location.path)
 
                         val isIncluded = !omitExcluded || !isPathExcluded(provenance, location.path) ||
                             ignoreExcludedRuleIds.intersect(violatedRulesByLicense[license].orEmpty()).isNotEmpty()

helper-cli/src/main/kotlin/utils/PathExcludeGenerator.kt

@@ -59,7 +59,7 @@ internal object PathExcludeGenerator {
 
         dirs.forEach { dir ->
             val (_, reason) = PATH_EXCLUDES_REASON_FOR_DIR_NAME.find { (pattern, _) ->
-                FileMatcher.match(pattern, File(dir).name, ignoreCase = true)
+                FileMatcher.matches(pattern, File(dir).name, ignoreCase = true)
             } ?: return@forEach
 
             dirsToExclude += dir to reason
@@ -101,7 +101,7 @@ internal object PathExcludeGenerator {
 
     internal fun createExcludePatterns(filenamePattern: String, filePaths: Collection<String>): Set<String> {
         val matchingFiles = filePaths.mapNotNull { filePath ->
-            File(filePath).takeIf { FileMatcher.match(filenamePattern, it.name) }
+            File(filePath).takeIf { FileMatcher.matches(filenamePattern, it.name) }
         }.ifEmpty {
             return emptySet()
         }

model/src/main/kotlin/config/PathExclude.kt

@@ -49,7 +49,7 @@ data class PathExclude(
      * Return true if and only if this [PathExclude] matches the given [path].
      */
     fun matches(path: String) =
-        FileMatcher.match(
+        FileMatcher.matches(
             pattern = pattern.removePrefix("./"),
             path = path
         )

model/src/main/kotlin/utils/FindingCurationMatcher.kt

@@ -34,7 +34,7 @@ class FindingCurationMatcher {
         curation: LicenseFindingCuration,
         relativeFindingPath: String
     ): Boolean =
-        FileMatcher.match(
+        FileMatcher.matches(
             pattern = curation.path,
             path = finding.location.prependedPath(relativeFindingPath)
         )

utils/common/src/main/kotlin/FileMatcher.kt

@@ -22,9 +22,9 @@ package org.ossreviewtoolkit.utils.common
 import org.springframework.util.AntPathMatcher
 
 /**
- * A class to determine whether paths are matched by globs. It can either be used via its static [match] functions, or
- * (in case different paths have to be matched against the same patterns in the same way over and over again) by
- * instantiating it with fixed [patterns], optionally [ignoring case][ignoreCase].
+ * A class to determine whether paths are matched by globs. It can either be used via its static
+ * [match][FileMatcher.Companion.matches] functions, or (in case different paths have to be matched against the same
+ * patterns in the same way over and over again) by instantiating it with fixed [patterns], optionally ignoring case.
  */
 class FileMatcher(
     /**
@@ -47,14 +47,14 @@ class FileMatcher(
          * Return true if [path] is matched by [pattern], false otherwise. The [path] must use '/' as separators, if it
          * contains any.
          */
-        fun match(pattern: String, path: String, ignoreCase: Boolean = false) =
+        fun matches(pattern: String, path: String, ignoreCase: Boolean = false) =
             if (ignoreCase) matchCaseInsensitive(pattern, path) else matchCaseSensitive(pattern, path)
 
         /**
          * Return true if [path] is matched by any of [patterns], false otherwise. The [path] must use '/' as
          * separators, if it contains any.
          */
-        fun match(patterns: Collection<String>, path: String, ignoreCase: Boolean = false): Boolean {
+        fun matches(patterns: Collection<String>, path: String, ignoreCase: Boolean = false): Boolean {
             // Only decide once for all patterns which function to call.
             val match = if (ignoreCase) matchCaseInsensitive else matchCaseSensitive