Glob matcher added

Author: oxgl

build.gradle.kts

@@ -7,7 +7,7 @@ plugins {
 }
 
 group = "com.oxyggen.net"
-version = "1.0.7"
+version = "1.0.8"
 
 
 repositories {

src/main/kotlin/com/oxyggen/io/Path.kt

@@ -1,5 +1,7 @@
 package com.oxyggen.io
 
+import java.nio.file.FileSystems
+
 /**
  * Path object
  *

src/main/kotlin/com/oxyggen/matcher/GlobMatcher.kt

@@ -0,0 +1,102 @@
+package com.oxyggen.matcher
+
+class GlobMatcher(globPattern: String) : RegexMatcher(globToRegexPattern(globPattern)) {
+
+    companion object {
+        /**
+         * Converts glob pattern to regular expression
+         * Java source found on https://stackoverflow.com/questions/1247772/is-there-an-equivalent-of-java-util-regex-for-glob-type-patterns
+         * created by Neil Traft, so I've converted to Kotlin code
+         * @param globPattern the glob pattern
+         * @return regular expression string
+         */
+
+        private fun globToRegexPattern(globPattern: String): String {
+            var result = ""
+
+            var index = 0
+            val groupIndex = mutableListOf<Int>()
+            val classIndex = mutableListOf<Int>()
+
+            while (index < globPattern.length) {
+                val ch = globPattern[index]
+
+                result += when (ch) {
+                    '\\' ->
+                        if (++index >= globPattern.length) {  // If it's last character, not an escape char
+                            ch
+                        } else {
+                            val nch = globPattern[index]
+                            when (nch) {
+                                ',' -> nch                 // Escape character not needed
+                                'Q', 'E' -> "\\\\$nch"     // \Q \E are special delimiters in regex for quoting literals
+                                else -> "\\$nch"           // Escape any other character
+                            }
+                        }
+
+                    '*' ->
+                        if (classIndex.isEmpty()) {
+                            ".*"
+                        } else {
+                            "*"
+                        }
+
+                    '?' ->
+                        if (classIndex.isEmpty()) {
+                            "."
+                        } else {
+                            "?"
+                        }
+
+                    '[' -> {
+                        classIndex.add(index)
+                        "["
+                    }
+
+                    ']' -> {
+                        classIndex.dropLast(1)
+                        "]"
+                    }
+
+                    '{' -> {
+                        groupIndex.add(index)
+                        "("
+                    }
+
+                    '}' -> {
+                        groupIndex.dropLast(1)
+                        ")"
+                    }
+
+                    '.', '(', ')', '+', '|', '^', '$', '@', '%' ->
+                        if (classIndex.isEmpty() || (classIndex.last() + 1 == index && ch == '^')) {
+                            "\\$ch"
+                        } else {
+                            ch
+                        }
+
+                    '!' ->
+                        if (classIndex.isNotEmpty() && classIndex.last() + 1 == index) {
+                            "^"
+                        } else {
+                            "!"
+                        }
+
+                    ',' ->
+                        if (groupIndex.isNotEmpty()) {
+                            "|"
+                        } else {
+                            ","
+                        }
+
+                    else -> ch
+                }
+
+                index++
+            }
+
+            return result
+        }
+    }
+
+}

src/main/kotlin/com/oxyggen/matcher/Matcher.kt

@@ -0,0 +1,5 @@
+package com.oxyggen.matcher
+
+abstract class Matcher() {
+    abstract fun matches(str: CharSequence): Boolean
+}

src/main/kotlin/com/oxyggen/matcher/RegexMatcher.kt

@@ -0,0 +1,11 @@
+package com.oxyggen.matcher
+
+open class RegexMatcher(regexPattern: String) : Matcher() {
+
+    private val regex: Regex = Regex(regexPattern)
+
+    open fun toRegex() = regex
+
+    override fun matches(str: CharSequence): Boolean = regex.matches(str)
+
+}

src/test/kotlin/com/oxyggen/matcher/GlobMatcherTest.kt

@@ -0,0 +1,19 @@
+package com.oxyggen.matcher
+
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+internal class GlobMatcherTest {
+    @Test
+    fun `glob to regexp tester`() {
+        val gm = GlobMatcher("*/*.txt")
+
+        println(gm.toRegex().pattern)
+
+        Assertions.assertTrue(gm.matches("hello.txt"))
+        Assertions.assertFalse(gm.matches("hello.txt.exe"))
+
+        Assertions.assertTrue(gm.matches("abc/hello.txt"))
+    }
+
+}