capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/completion/CompletionPublisher.kt

@@ -0,0 +1,250 @@
+package io.github.abc15018045126.sora.lang.completion
+
+import android.os.Handler
+import java.util.ArrayList
+import java.util.Collections
+import java.util.concurrent.locks.Lock
+import java.util.concurrent.locks.ReentrantLock
+import io.github.abc15018045126.sora.lang.Language
+
+/**
+ * CompletionPublisher manages completion items to be added in one completion analyzing process.
+ *
+ * You can only add items to the publisher, but no deletion is allowed. As you add more items, the
+ * publisher will update the list in UI from time to time, which is related to your threshold
+ * settings.([CompletionPublisher.setUpdateThreshold]).
+ * There will usually be some items not displayed in screen when the thread is still running. Even
+ * when the actual pending item count exceeds the threshold you set, there may still be some items
+ * not committed because of lock failures. You can use [CompletionPublisher.updateList]
+ * with forced flag to command the UI thread update the completion list, by waiting for the lock from
+ * your side to release.
+ * If you want to disable this feature, you may want to set it to [Integer.MAX_VALUE]
+ *
+ * You can set a comparator by [CompletionPublisher.setComparator] to sort your
+ * result items, but you should not make it too complex, which will cause laggy in UI thread. It is
+ * recommended that you set the comparator before all your actions.
+ * Leaving the comparator null results the completion to be unsorted. They will be ordered by the order
+ * you add them.
+ *
+ * After all you additions, you do not need to explicitly invoke [CompletionPublisher.updateList].
+ * This will automatically be called by editor framework.
+ *
+ * Note that your actions may be interrupted because of [Thread.interrupted].
+ */
+class CompletionPublisher(
+    private val handler: Handler,
+    private val callback: Runnable,
+    private val languageInterruptionLevel: Int
+) {
+
+    companion object {
+        /**
+         * Default value for [CompletionPublisher.setUpdateThreshold]
+         */
+        const val DEFAULT_UPDATE_THRESHOLD = 5
+    }
+
+    private val items: MutableList<CompletionItem> = ArrayList()
+    private val candidates: MutableList<CompletionItem> = ArrayList()
+    private val lock: Lock = ReentrantLock(true)
+    private var comparator: Comparator<CompletionItem>? = null
+    private var updateThreshold: Int = DEFAULT_UPDATE_THRESHOLD
+    private var invalid = false
+
+    /**
+     * Check whether the completion is cancelled
+     */
+    val isCancelled: Boolean
+        get() = invalid
+
+    /**
+     * Checks whether there is data
+     */
+    fun hasData(): Boolean {
+        return items.size + candidates.size > 0
+    }
+
+    /**
+     * Get items currently in display
+     */
+    @io.github.abc15018045126.sora.annotations.UnsupportedUserUsage
+    fun getItems(): List<CompletionItem> {
+        return items
+    }
+
+    /**
+     * Set the max pending items in analyzing thread.
+     * See class javadoc for more information.
+     */
+    fun setUpdateThreshold(updateThreshold: Int) {
+        this.updateThreshold = updateThreshold
+    }
+
+    /**
+     * Set the result's comparator.
+     *
+     * The comparator is used when publishing the completion to user.
+     */
+    fun setComparator(comparator: Comparator<CompletionItem>?) {
+        checkCancelled()
+        if (invalid) {
+            return
+        }
+        this.comparator = comparator
+        if (items.isNotEmpty() && comparator != null) {
+            handler.post {
+                if (invalid) {
+                    return@post
+                }
+                Collections.sort(items, comparator)
+                callback.run()
+            }
+        }
+    }
+
+    /**
+     * Add items in the completion list.
+     *
+     * According to your settings and the lock's state, these items may not immediately
+     * be displayed to the user.
+     *
+     * @see CompletionPublisher.setUpdateThreshold
+     */
+    fun addItems(items: Collection<CompletionItem>) {
+        checkCancelled()
+        if (invalid) {
+            return
+        }
+        lock.lock()
+        try {
+            candidates.addAll(items)
+        } finally {
+            lock.unlock()
+        }
+        if (candidates.size >= updateThreshold) {
+            updateList()
+        }
+    }
+
+    /**
+     * Add a single item in completion list.
+     *
+     * According to your settings and the lock's state, this item may not immediately
+     * be displayed to the user.
+     *
+     * @see CompletionPublisher.setUpdateThreshold
+     */
+    fun addItem(item: CompletionItem) {
+        checkCancelled()
+        if (invalid) {
+            return
+        }
+        lock.lock()
+        try {
+            candidates.add(item)
+        } finally {
+            lock.unlock()
+        }
+        if (candidates.size >= updateThreshold) {
+            updateList()
+        }
+    }
+
+    /**
+     * Try to update completion in main thread.
+     *
+     * If [Lock.tryLock] failed, nothing will happen.
+     */
+    fun updateList() {
+        updateList(false)
+    }
+
+    /**
+     * Update completion items on main thread
+     *
+     * @param forced If true, the main thread will wait for the lock. Otherwise, when the lock is
+     *               currently available for the thread, the update will be executed.
+     */
+    fun updateList(forced: Boolean) {
+        if (invalid) {
+            return
+        }
+        handler.post {
+            // Lock the candidate list accordingly
+            if (invalid) {
+                callback.run()
+                return@post
+            }
+            var locked = false
+            if (forced) {
+                lock.lock()
+                locked = true
+            } else {
+                locked = lock.tryLock()
+            }
+
+            if (locked) {
+                try {
+                    if (candidates.isEmpty()) {
+                        callback.run()
+                        return@post
+                    }
+                    val comparator = this.comparator
+                    if (comparator != null) {
+                        while (candidates.isNotEmpty()) {
+                            val candidate = candidates.removeAt(0)
+                            // Insert the value by binary search
+                            var left = 0
+                            var right = items.size
+                            val size = right
+                            while (left <= right) {
+                                val mid = (left + right) / 2
+                                if (mid < 0 || mid >= size) {
+                                    left = mid
+                                    break
+                                }
+                                val cmp = comparator.compare(items[mid], candidate)
+                                if (cmp < 0) {
+                                    left = mid + 1
+                                } else if (cmp > 0) {
+                                    right = mid - 1
+                                } else {
+                                    left = mid
+                                    break
+                                }
+                            }
+                            left = kotlin.math.max(0, kotlin.math.min(size, left))
+                            items.add(left, candidate)
+                        }
+                    } else {
+                        items.addAll(candidates)
+                        candidates.clear()
+                    }
+                    callback.run()
+                } finally {
+                    lock.unlock()
+                }
+            }
+        }
+    }
+
+    /**
+     * Cancel the completion
+     */
+    fun cancel() {
+        invalid = true
+    }
+
+    /**
+     * Check whether the completion is cancelled. If so, an instance of [CompletionCancelledException]
+     * is thrown.
+     */
+    fun checkCancelled() {
+        if (Thread.interrupted() || invalid) {
+            invalid = true
+            if (languageInterruptionLevel <= Language.INTERRUPTION_LEVEL_SLIGHT) {
+                throw CompletionCancelledException()
+            }
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/completion/IdentifierAutoComplete.kt

@@ -0,0 +1,352 @@
+package io.github.abc15018045126.sora.lang.completion
+
+import android.os.Build
+import android.os.Bundle
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.text.ContentReference
+import io.github.abc15018045126.sora.text.TextUtils
+import io.github.abc15018045126.sora.util.MutableInt
+import java.util.ArrayList
+import java.util.Collections
+import java.util.HashMap
+import java.util.Locale
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.locks.Lock
+import java.util.concurrent.locks.ReentrantLock
+
+/**
+ * Identifier auto-completion.
+ *
+ * You can use it to provide identifiers, but you can't update the given [CompletionPublisher]
+ * if it is used. If you have to mix the result, then you should call [CompletionPublisher.setComparator]
+ * with null first. Otherwise, your completion list may be corrupted. And in that case, you must do the sorting
+ * work by yourself and then add your items.
+ *
+ * @author abc15018045126
+ */
+class IdentifierAutoComplete {
+
+    companion object {
+        /**
+         * @deprecated Use [Comparators]
+         */
+        @Deprecated("")
+        private val COMPARATOR = Comparator<CompletionItem> { p1, p2 ->
+            val cmp1 = asString(p1.desc).compareTo(asString(p2.desc))
+            if (cmp1 < 0) {
+                return@Comparator 1
+            } else if (cmp1 > 0) {
+                return@Comparator -1
+            }
+            asString(p1.label).compareTo(asString(p2.label))
+        }
+
+        private fun asString(str: CharSequence?): String {
+            return if (str is String) str else str.toString()
+        }
+    }
+
+    private var keywords: Array<String>? = null
+    private var keywordsAreLowCase: Boolean = false
+    private var keywordMap: Map<String, Any>? = null
+
+    constructor()
+
+    constructor(keywords: Array<String>) {
+        setKeywords(keywords, true)
+    }
+
+    fun setKeywords(keywords: Array<String>?, lowCase: Boolean) {
+        this.keywords = keywords
+        keywordsAreLowCase = lowCase
+        val map = HashMap<String, Any>()
+        if (keywords != null) {
+            for (keyword in keywords) {
+                map[keyword] = true
+            }
+        }
+        keywordMap = map
+    }
+
+    fun getKeywords(): Array<String>? {
+        return keywords
+    }
+
+    /**
+     * Make completion items for the given arguments.
+     * Provide the required arguments passed by [io.github.abc15018045126.sora.lang.Language.requireAutoComplete]
+     *
+     * @param prefix The prefix to make completions for.
+     */
+    fun requireAutoComplete(
+        reference: ContentReference,
+        position: CharPosition,
+        prefix: String,
+        publisher: CompletionPublisher,
+        userIdentifiers: Identifiers?
+    ) {
+        val completionItemList = filterCompletionItems(
+            reference, position, createCompletionItemList(prefix, userIdentifiers)
+        )
+
+        val comparator = createCompletionItemComparator(completionItemList)
+
+        publisher.addItems(completionItemList)
+
+        publisher.setComparator(comparator)
+    }
+
+    fun createCompletionItemList(
+        prefix: String,
+        userIdentifiers: Identifiers?
+    ): List<CompletionItem> {
+        val prefixLength = prefix.length
+        if (prefixLength == 0) {
+            return Collections.emptyList()
+        }
+        val result = ArrayList<CompletionItem>()
+        val keywordArray = keywords
+        val lowCase = keywordsAreLowCase
+        val keywordMap = this.keywordMap
+        val match = prefix.lowercase(Locale.ROOT)
+
+        if (keywordArray != null) {
+            if (lowCase) {
+                for (kw in keywordArray) {
+                    val fuzzyScore = fuzzyScoreGracefulAggressive(
+                        prefix,
+                        prefix.lowercase(Locale.ROOT),
+                        0, kw, kw.lowercase(Locale.ROOT), 0, FuzzyScoreOptions.default
+                    )
+
+                    val score = fuzzyScore?.score ?: -100
+
+                    if (kw.startsWith(match) || score >= -20) {
+                        result.add(
+                            SimpleCompletionItem(kw, "Keyword", prefixLength, kw)
+                                .kind(CompletionItemKind.Keyword)
+                        )
+                    }
+                }
+            } else {
+                for (kw in keywordArray) {
+                    val fuzzyScore = fuzzyScoreGracefulAggressive(
+                        prefix,
+                        prefix.lowercase(Locale.ROOT),
+                        0, kw, kw.lowercase(Locale.ROOT), 0, FuzzyScoreOptions.default
+                    )
+
+                    val score = fuzzyScore?.score ?: -100
+
+                    if (kw.lowercase(Locale.ROOT).startsWith(match) || score >= -20) {
+                        result.add(
+                            SimpleCompletionItem(kw, "Keyword", prefixLength, kw)
+                                .kind(CompletionItemKind.Keyword)
+                        )
+                    }
+                }
+            }
+        }
+        if (userIdentifiers != null) {
+            val dest = ArrayList<String>()
+
+            userIdentifiers.filterIdentifiers(prefix, dest)
+            for (word in dest) {
+                if (keywordMap == null || !keywordMap.containsKey(word))
+                    result.add(
+                        SimpleCompletionItem(word, "Identifier", prefixLength, word)
+                            .kind(CompletionItemKind.Identifier)
+                    )
+            }
+        }
+        return result
+    }
+
+    /**
+     * Make completion items for the given arguments.
+     * Provide the required arguments passed by [io.github.abc15018045126.sora.lang.Language.requireAutoComplete]
+     *
+     * @param prefix The prefix to make completions for.
+     */
+    @Deprecated("")
+    fun requireAutoComplete(
+        prefix: String,
+        publisher: CompletionPublisher,
+        userIdentifiers: Identifiers?
+    ) {
+        publisher.setComparator(COMPARATOR)
+        publisher.setUpdateThreshold(0)
+        publisher.addItems(createCompletionItemList(prefix, userIdentifiers))
+    }
+
+    /**
+     * Interface for saving identifiers
+     *
+     * @author abc15018045126
+     * @see IdentifierAutoComplete.DisposableIdentifiers
+     */
+    interface Identifiers {
+
+        /**
+         * Filter identifiers with the given prefix
+         *
+         * @param prefix The prefix to filter
+         * @param dest   Result list
+         */
+        fun filterIdentifiers(prefix: String, dest: MutableList<String>)
+    }
+
+    /**
+     * This object is used only once. In other words, the object is generated every time the
+     * text changes, and is abandoned when next time the text change.
+     *
+     * In this case, the frequent allocation of memory is unavoidable.
+     * And also, this class is not thread-safe.
+     *
+     * @author abc15018045126
+     */
+    class DisposableIdentifiers : Identifiers {
+
+        companion object {
+            private val SIGN = Any()
+        }
+
+        private val identifiers = ArrayList<String>(128)
+        private var cache: HashMap<String, Any>? = null
+
+        fun addIdentifier(identifier: String) {
+            if (cache == null) {
+                throw IllegalStateException("begin() has not been called")
+            }
+            if (cache!!.put(identifier, SIGN) == SIGN) {
+                return
+            }
+            identifiers.add(identifier)
+        }
+
+        /**
+         * Start building the identifiers
+         */
+        fun beginBuilding() {
+            cache = HashMap()
+        }
+
+        /**
+         * Free memory and finish building
+         */
+        fun finishBuilding() {
+            cache?.clear()
+            cache = null
+        }
+
+        override fun filterIdentifiers(prefix: String, dest: MutableList<String>) {
+            for (identifier in identifiers) {
+                val fuzzyScore = fuzzyScoreGracefulAggressive(
+                    prefix,
+                    prefix.lowercase(Locale.ROOT),
+                    0, identifier, identifier.lowercase(Locale.ROOT), 0, FuzzyScoreOptions.default
+                )
+
+                val score = fuzzyScore?.score ?: -100
+
+                if ((TextUtils.startsWith(identifier, prefix, true) || score >= -20) && !(prefix.length == identifier.length && TextUtils.startsWith(
+                        prefix,
+                        identifier,
+                        false
+                    ))
+                ) {
+                    dest.add(identifier)
+                }
+            }
+        }
+    }
+
+    class SyncIdentifiers : Identifiers {
+
+        private val lock: Lock = ReentrantLock(true)
+        private val identifierMap: MutableMap<String, MutableInt> = HashMap()
+
+        fun clear() {
+            lock.lock()
+            try {
+                identifierMap.clear()
+            } finally {
+                lock.unlock()
+            }
+        }
+
+        fun identifierIncrease(identifier: String) {
+            lock.lock()
+            try {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                    identifierMap.computeIfAbsent(identifier) { MutableInt(0) }.increase()
+                } else {
+                    var counter = identifierMap[identifier]
+                    if (counter == null) {
+                        counter = MutableInt(0)
+                        identifierMap[identifier] = counter
+                    }
+                    counter.increase()
+                }
+            } finally {
+                lock.unlock()
+            }
+        }
+
+        fun identifierDecrease(identifier: String) {
+            lock.lock()
+            try {
+                val count = identifierMap[identifier]
+                if (count != null) {
+                    if (count.decreaseAndGet() <= 0) {
+                        identifierMap.remove(identifier)
+                    }
+                }
+            } finally {
+                lock.unlock()
+            }
+        }
+
+        override fun filterIdentifiers(prefix: String, dest: MutableList<String>) {
+            filterIdentifiers(prefix, dest, false)
+        }
+
+        fun filterIdentifiers(prefix: String, dest: MutableList<String>, waitForLock: Boolean) {
+            val acquired: Boolean
+            if (waitForLock) {
+                lock.lock()
+                acquired = true
+            } else {
+                acquired = try {
+                    lock.tryLock(3, TimeUnit.MILLISECONDS)
+                } catch (e: InterruptedException) {
+                    false
+                }
+            }
+            if (acquired) {
+                try {
+                    for (s in identifierMap.keys) {
+                        val fuzzyScore = fuzzyScoreGracefulAggressive(
+                            prefix,
+                            prefix.lowercase(Locale.ROOT),
+                            0, s, s.lowercase(Locale.ROOT), 0, FuzzyScoreOptions.default
+                        )
+
+                        val score = fuzzyScore?.score ?: -100
+
+                        if ((TextUtils.startsWith(s, prefix, true) || score >= -20) && !(prefix.length == s.length && TextUtils.startsWith(
+                                prefix,
+                                s,
+                                false
+                            ))
+                        ) {
+                            dest.add(s)
+                        }
+                    }
+                } finally {
+                    lock.unlock()
+                }
+            }
+        }
+    }
+}