refactor(utils)!: Rename FileMatcher.matches to match

This aligns the name of the class function with the static functions
which are also called `match`.

Signed-off-by: Martin Nonnenmacher <martin.nonnenmacher@bosch.com>

Author: mnonnenmacher

model/src/main/kotlin/ScanSummary.kt

@@ -140,10 +140,10 @@ data class ScanSummary(
         val matcher = FileMatcher(ignorePatterns)
 
         return copy(
-            licenseFindings = licenseFindings.filterTo(mutableSetOf()) { !matcher.matches(it.location.path) },
-            copyrightFindings = copyrightFindings.filterTo(mutableSetOf()) { !matcher.matches(it.location.path) },
-            snippetFindings = snippetFindings.filterTo(mutableSetOf()) { !matcher.matches(it.sourceLocation.path) },
-            issues = issues.filter { it.affectedPath == null || !matcher.matches(it.affectedPath) }
+            licenseFindings = licenseFindings.filterTo(mutableSetOf()) { !matcher.match(it.location.path) },
+            copyrightFindings = copyrightFindings.filterTo(mutableSetOf()) { !matcher.match(it.location.path) },
+            snippetFindings = snippetFindings.filterTo(mutableSetOf()) { !matcher.match(it.sourceLocation.path) },
+            issues = issues.filter { it.affectedPath == null || !matcher.match(it.affectedPath) }
         )
     }
 }

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

@@ -77,7 +77,7 @@ class FileArchiver(
             directory.packZip(zipFile, overwrite = true) { file ->
                 val relativePath = file.relativeTo(directory).invariantSeparatorsPath
 
-                matcher.matches(relativePath).also { result ->
+                matcher.match(relativePath).also { result ->
                     logger.debug {
                         if (result) {
                             "Adding '$relativePath' to archive."

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

@@ -78,7 +78,7 @@ class PathLicenseMatcher(licenseFilePatterns: LicenseFilePatterns = LicenseFileP
         require(relativeFilePaths.none { it.startsWith("/") })
 
         fun filePathsByDir(matcher: FileMatcher): Map<String, Set<String>> =
-            relativeFilePaths.filter { matcher.matches("/$it") }.groupBy {
+            relativeFilePaths.filter { matcher.match("/$it") }.groupBy {
                 File("/$it").parentFile.invariantSeparatorsPath
             }.mapValues { it.value.toSet() }
 

scanner/src/main/kotlin/utils/FileListResolver.kt

@@ -97,7 +97,7 @@ private val IGNORED_DIRECTORY_MATCHER by lazy {
 
 private fun createFileList(dir: File): FileList {
     val files = dir.walk().onEnter {
-        !IGNORED_DIRECTORY_MATCHER.matches(it.relativeTo(dir).invariantSeparatorsPath) && !it.isSymbolicLink()
+        !IGNORED_DIRECTORY_MATCHER.match(it.relativeTo(dir).invariantSeparatorsPath) && !it.isSymbolicLink()
     }.filter {
         it.isFile && !it.isSymbolicLink()
     }.mapTo(mutableSetOf()) {

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

@@ -70,5 +70,5 @@ class FileMatcher(
      * Return true if [path] is matched by any of [patterns], false otherwise. The [path] must use '/' as separators,
      * if it contains any.
      */
-    fun matches(path: String): Boolean = patterns.any { pattern -> match(pattern, path) }
+    fun match(path: String): Boolean = patterns.any { pattern -> match(pattern, path) }
 }

utils/common/src/test/kotlin/FileMatcherTest.kt

@@ -27,66 +27,66 @@ class FileMatcherTest : StringSpec({
         val matcher = FileMatcher("a/LICENSE", "b/LICENSE")
 
         with(matcher) {
-            matches("a/LICENSE") shouldBe true
-            matches("b/LICENSE") shouldBe true
-            matches("c/LICENSE") shouldBe false
+            match("a/LICENSE") shouldBe true
+            match("b/LICENSE") shouldBe true
+            match("c/LICENSE") shouldBe false
         }
     }
 
     "Patterns with globs should be matched" {
         val matcher = FileMatcher("*.md", "dir/*.txt")
 
         with(matcher) {
-            matches("README.md") shouldBe true
-            matches("dir/info.txt") shouldBe true
-            matches("root.txt") shouldBe false
-            matches("dir/doc.md") shouldBe false
+            match("README.md") shouldBe true
+            match("dir/info.txt") shouldBe true
+            match("root.txt") shouldBe false
+            match("dir/doc.md") shouldBe false
         }
     }
 
     "A globstar should match zero or more directories" {
         val matcher = FileMatcher("**/src/**")
 
         with(matcher) {
-            matches("project/src/main") shouldBe true
-            matches("project/src") shouldBe true
-            matches("src/main") shouldBe true
-            matches("a/project/src/main/kotlin") shouldBe true
-            matches("src") shouldBe true
-            matches("./src") shouldBe true
-            matches("srcs") shouldBe false
+            match("project/src/main") shouldBe true
+            match("project/src") shouldBe true
+            match("src/main") shouldBe true
+            match("a/project/src/main/kotlin") shouldBe true
+            match("src") shouldBe true
+            match("./src") shouldBe true
+            match("srcs") shouldBe false
         }
     }
 
     "Glob and globstar can be combined" {
         val matcher = FileMatcher("*/**/examples")
 
         with(matcher) {
-            matches("project/examples") shouldBe true
-            matches("project/subproject/examples") shouldBe true
-            matches("examples") shouldBe false
-            matches("project/examples/hello") shouldBe false
+            match("project/examples") shouldBe true
+            match("project/subproject/examples") shouldBe true
+            match("examples") shouldBe false
+            match("project/examples/hello") shouldBe false
         }
     }
 
     "Matching should adhere ignoring case" {
         FileMatcher("LICENSE", ignoreCase = false).apply {
-            matches("LICENSE") shouldBe true
-            matches("license") shouldBe false
+            match("LICENSE") shouldBe true
+            match("license") shouldBe false
         }
 
         FileMatcher("LICENSE", ignoreCase = true).apply {
-            matches("LICENSE") shouldBe true
-            matches("license") shouldBe true
+            match("LICENSE") shouldBe true
+            match("license") shouldBe true
         }
     }
 
     "Groups of subpatterns can be matched" {
         FileMatcher("*.{:java|class}", ignoreCase = false).apply {
-            matches("x.java") shouldBe true
-            matches("x.class") shouldBe true
-            matches("x.cpp") shouldBe false
-            matches("dir/x.java") shouldBe false
+            match("x.java") shouldBe true
+            match("x.class") shouldBe true
+            match("x.cpp") shouldBe false
+            match("dir/x.java") shouldBe false
         }
     }
 })