JQL refactoring draft

src/main/kotlin/com/atlassian/performance/tools/jiraactions/api/jql/Jql.kt

@@ -0,0 +1,19 @@
+package com.atlassian.performance.tools.jiraactions.api.jql
+
+import com.atlassian.performance.tools.jiraactions.api.SeededRandom
+import com.atlassian.performance.tools.jiraactions.api.page.IssuePage
+
+interface JqlContext {
+    fun seededRandom(): SeededRandom
+    fun issuePage(): IssuePage?
+}
+
+interface JqlSupplier {
+    fun get(context: JqlContext): Jql?
+    fun uniqueName(): String
+}
+
+interface Jql {
+    fun query(): String
+    fun supplier(): JqlSupplier
+}

src/main/kotlin/com/atlassian/performance/tools/jiraactions/api/memories/JqlMemory2.kt

@@ -0,0 +1,12 @@
+package com.atlassian.performance.tools.jiraactions.api.memories
+
+import com.atlassian.performance.tools.jiraactions.api.jql.Jql
+import com.atlassian.performance.tools.jiraactions.api.page.IssuePage
+import java.util.function.Predicate
+
+interface JqlMemory2 : Memory<Jql> {
+
+    fun observe(issuePage: IssuePage)
+    fun recall(filter: Predicate<Jql>): Jql?
+
+}

src/main/kotlin/com/atlassian/performance/tools/jiraactions/api/memories/adaptive/AdaptiveJqlMemory2.kt

@@ -0,0 +1,68 @@
+package com.atlassian.performance.tools.jiraactions.api.memories.adaptive
+
+import com.atlassian.performance.tools.jiraactions.api.SeededRandom
+import com.atlassian.performance.tools.jiraactions.api.jql.Jql
+import com.atlassian.performance.tools.jiraactions.api.jql.JqlSupplier
+import com.atlassian.performance.tools.jiraactions.api.memories.JqlMemory
+import com.atlassian.performance.tools.jiraactions.api.memories.JqlMemory2
+import com.atlassian.performance.tools.jiraactions.api.memories.adaptive.jql.JqlPrescription
+import com.atlassian.performance.tools.jiraactions.api.memories.adaptive.jql.JqlPrescriptions
+import com.atlassian.performance.tools.jiraactions.api.page.IssuePage
+import com.atlassian.performance.tools.jiraactions.jql.BuiltInJQL
+import com.atlassian.performance.tools.jiraactions.jql.JqlContextImpl
+import org.apache.logging.log4j.LogManager
+import org.apache.logging.log4j.Logger
+import java.util.function.Predicate
+
+class AdaptiveJqlMemory2(
+    private val random: SeededRandom
+) : JqlMemory2 {
+
+    private val logger: Logger = LogManager.getLogger(this::class.java)
+
+    companion object {
+        fun getBuiltInJqlSuppliers(): List<JqlSupplier> = BuiltInJQL.values().toList()
+    }
+
+    private val preparedQueries = mutableListOf<Jql>();
+
+    init {
+        BuiltInJQL.RESOLVED.get(JqlContextImpl(random))?.let { preparedQueries.add(it) }
+        BuiltInJQL.GENERIC_WIDE.get(JqlContextImpl(random))?.let { preparedQueries.add(it) }
+    }
+
+    private val availableJqlSuppliers = mutableSetOf(
+        BuiltInJQL.PRIORITIES,
+        BuiltInJQL.PROJECT,
+        BuiltInJQL.ASSIGNEE,
+        BuiltInJQL.REPORTERS,
+        BuiltInJQL.PROJECT_ASSIGNEE,
+        BuiltInJQL.GIVEN_WORD
+    )
+
+    override fun observe(issuePage: IssuePage) {
+        val jql = availableJqlSuppliers.asSequence()
+            .map { it.get(JqlContextImpl(random, issuePage)) }
+            .filter { it != null }
+            .firstOrNull()
+
+        jql?.let {
+            logger.debug("Rendered a new jql query: <<${it.query()!!}>>")
+            preparedQueries.add(it)
+            availableJqlSuppliers.remove(it.supplier())
+        }
+    }
+
+    override fun recall(): Jql? {
+        return random.pick(preparedQueries)
+    }
+
+    override fun remember(memories: Collection<Jql>) {
+        preparedQueries.addAll(memories)
+    }
+
+    override fun recall(filter: Predicate<Jql>): Jql? {
+        return random.pick(preparedQueries.filter {filter.test(it) }.toList())
+    }
+}
+

src/main/kotlin/com/atlassian/performance/tools/jiraactions/jql/JqlImpl.kt

@@ -0,0 +1,87 @@
+package com.atlassian.performance.tools.jiraactions.jql
+
+import com.atlassian.performance.tools.jiraactions.api.SeededRandom
+import com.atlassian.performance.tools.jiraactions.api.jql.Jql
+import com.atlassian.performance.tools.jiraactions.api.jql.JqlContext
+import com.atlassian.performance.tools.jiraactions.api.jql.JqlSupplier
+import com.atlassian.performance.tools.jiraactions.api.page.IssuePage
+
+internal class JqlImpl(private val query: String,
+                       private val supplier: JqlSupplier): Jql {
+    override fun query(): String = this.query
+    override fun supplier(): JqlSupplier = this.supplier
+}
+
+internal class JqlContextImpl(private val rnd: SeededRandom, private val page: IssuePage?) : JqlContext {
+    constructor(rnd: SeededRandom) : this(rnd, null)
+    override fun seededRandom(): SeededRandom = this.rnd
+    override fun issuePage(): IssuePage? = this.page
+}
+
+internal enum class BuiltInJQL(private val sup: (JqlContext) -> String?) : JqlSupplier {
+    GENERIC_WIDE({ "text ~ \"a*\" order by summary" }),
+    RESOLVED({ "resolved is not empty order by description" }),
+    PRIORITIES({
+        ctx -> ctx.issuePage()?.getPossiblePriorities()
+        ?.let { ctx.seededRandom().pickMany(it, 3) }
+        ?.joinToString()
+        ?.let { "priority in ($it) order by reporter" }
+    }),
+    PROJECT({
+        ctx -> ctx.issuePage()?.getProject()?.let { "project = ${it.key} order by status" }
+    }),
+    ASSIGNEE({
+        ctx -> ctx.issuePage()?.getAssignee()?.let { "assignee = $it order by project" }
+    }),
+    REPORTERS({
+        ctx -> ctx.issuePage()?.getReporter()?.let { "reporter was $it order by description" }
+    }),
+    PROJECT_ASSIGNEE({
+        ctx -> ctx.issuePage()?.let {
+        val userName = it.getAssignee()
+        val project =  it.getProject()
+        if (userName != null && project != null) {
+            "project = ${project.key} and assignee = $userName order by reporter"
+        } else {
+            null
+        }
+    }
+
+    }),
+
+    /**
+     * Creates a JQL based on the words used in fields of this issue.
+     * What we need is to pick a word that will get us a non-empty jql, preferably that will return more issues in
+     * the search result.
+     * Warning! Current implementation will work only with locales that use Latin alphabet.
+     */
+    GIVEN_WORD({
+        ctx -> ctx.issuePage()?.let {
+            val whitespacesPattern = Regex("\\s")
+            val lettersOnly = Regex("\\w+")
+
+            // in order to find a word that's neither long or short, with a chance of it being just a regular word,
+            // we're looking for a word with three vowels.
+            val description = it.getDescription()
+            val summary = it.getSummary()
+
+            val vowels = setOf('a', 'e', 'i', 'o', 'u', 'y')
+            fun numVowels(s: String): Int {
+                return s.toCharArray().asSequence().filter { vowels.contains(it) }.count()
+            }
+
+            "$description $summary"
+                .split(whitespacesPattern)
+                .filter { it.isNotBlank() }
+                .shuffled(ctx.seededRandom().random)
+                .asSequence()
+                .filter { it.matches(lettersOnly) }
+                .filter { numVowels(it) == 3 }
+                .firstOrNull()
+                ?.let { """text ~ "$it" order by key""" }
+        }
+    });
+
+    override fun uniqueName(): String = this.name
+    override fun get(context: JqlContext): Jql? = sup.invoke(context)?.let { JqlImpl(it, this) }
+}