capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/analysis/SimpleAnalyzeManager.kt

@@ -0,0 +1,194 @@
+package io.github.abc15018045126.sora.lang.analysis
+
+import android.os.Bundle
+import android.util.Log
+import io.github.abc15018045126.sora.lang.styling.Styles
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.text.ContentReference
+
+/**
+ * Built-in implementation of [AnalyzeManager].
+ *
+ * This is a simple version without any incremental actions.
+ *
+ * The analysis will always re-run when the text changes. Hopefully, it will stop previous outdated
+ * runs by provide a [Delegate] object.
+ *
+ * @param <V> The shared object type that we get for auto-completion.
+ */
+abstract class SimpleAnalyzeManager<V> : AnalyzeManager {
+
+    private val lock = Object()
+
+    override var receiver: StyleReceiver? = null
+
+    @Volatile
+    private var ref: ContentReference? = null
+
+    /**
+     * Get extra arguments set by [io.github.abc15018045126.sora.widget.CodeEditor.setText]
+     */
+    var extraArguments: Bundle? = null
+        private set
+
+    @Volatile
+    private var newestRequestId: Long = 0
+    private var thread: AnalyzeThread? = null
+
+    /**
+     * Get data set by analyze thread
+     */
+    var data: V? = null
+        private set
+
+    override fun reset(content: ContentReference, extraArguments: Bundle) {
+        this.ref = content
+        this.extraArguments = extraArguments
+        rerun()
+    }
+
+    override fun insert(start: CharPosition, end: CharPosition, insertedContent: CharSequence) {
+        rerun()
+    }
+
+    override fun delete(start: CharPosition, end: CharPosition, deletedContent: CharSequence) {
+        rerun()
+    }
+
+    @Synchronized
+    override fun rerun() {
+        newestRequestId++
+        val currentThread = thread
+        if (currentThread == null || !currentThread.isAlive) {
+            // Create new thread
+            Log.v(LOG_TAG, "Starting a new thread for analysis")
+            val newThread = AnalyzeThread()
+            newThread.isDaemon = true
+            newThread.name = "SplAnalyzer-" + nextThreadId()
+            newThread.start()
+            thread = newThread
+        }
+        synchronized(lock) {
+            lock.notify()
+        }
+    }
+
+    override fun destroy() {
+        ref = null
+        extraArguments = null
+        newestRequestId = 0
+        data = null
+        thread?.let {
+            if (it.isAlive) {
+                it.interrupt()
+            }
+        }
+        thread = null
+        receiver = null
+    }
+
+    /**
+     * Analyze the given input.
+     *
+     * @param text     A [StringBuilder] instance containing the text in editor. DO NOT SAVE THE INSTANCE OR
+     * UPDATE IT. It is continuously used by this analyzer.
+     * @param delegate A delegate used to check whether this invocation is outdated. You should stop your logic
+     * if [Delegate.isCancelled] returns true.
+     * @return Styles created according to the text.
+     */
+    protected abstract fun analyze(text: StringBuilder, delegate: Delegate<V>): Styles?
+
+    /**
+     * Analyze thread.
+     *
+     * The thread will keep alive unless there is any exception or [AnalyzeManager.destroy]
+     * is called.
+     */
+    private inner class AnalyzeThread : Thread() {
+
+        /**
+         * Single instance for text storing
+         */
+        private val textContainer = StringBuilder()
+
+        override fun run() {
+            Log.v(LOG_TAG, "Analyze thread started")
+            try {
+                while (!isInterrupted) {
+                    val text = ref
+                    if (text != null) {
+                        var requestId: Long
+                        var result: Styles? = null
+                        var newData: V? = null
+                        // Do the analysis, until the requestId matches
+                        do {
+                            val currentText = ref ?: break
+                            requestId = newestRequestId
+                            val delegate = Delegate<V>(requestId)
+
+                            // Collect line contents
+                            textContainer.setLength(0)
+                            textContainer.ensureCapacity(currentText.lineCount * 10) // estimate
+                            for (i in 0 until currentText.lineCount) {
+                                if (requestId != newestRequestId) break
+                                if (i != 0) {
+                                    textContainer.append(currentText.getLineSeparator(i - 1))
+                                }
+                                currentText.appendLineTo(textContainer, i)
+                            }
+
+                            if (requestId != newestRequestId) {
+                                result = null
+                                newData = null
+                                continue
+                            }
+
+                            // Invoke the implementation
+                            result = analyze(textContainer, delegate)
+                            newData = delegate.data
+                        } while (requestId != newestRequestId)
+                        
+                        // Send result
+                        result?.let {
+                            receiver?.setStyles(this@SimpleAnalyzeManager, it)
+                        }
+                        this@SimpleAnalyzeManager.data = newData
+                    }
+                    // Wait for next time
+                    synchronized(lock) {
+                        lock.wait()
+                    }
+                }
+            } catch (e: InterruptedException) {
+                Log.v(LOG_TAG, "Thread is interrupted.")
+            } catch (e: Exception) {
+                Log.e(LOG_TAG, "Unexpected exception is thrown in the thread.", e)
+            }
+        }
+    }
+
+    /**
+     * Delegate between manager and analysis implementation
+     */
+    inner class Delegate<T>(private val myRequestId: Long) {
+        var data: T? = null
+
+        /**
+         * Check whether the operation is cancelled
+         */
+        fun isCancelled(): Boolean {
+            return myRequestId != newestRequestId
+        }
+    }
+
+    companion object {
+        private const val LOG_TAG = "SimpleAnalyzeManager"
+        private var sThreadId = 0
+
+        @Synchronized
+        private fun nextThreadId(): Int {
+            sThreadId++
+            return sThreadId
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/analysis/StyleReceiver.kt

@@ -0,0 +1,63 @@
+package io.github.abc15018045126.sora.lang.analysis
+
+import io.github.abc15018045126.sora.lang.brackets.BracketsProvider
+import io.github.abc15018045126.sora.lang.diagnostic.DiagnosticsContainer
+import io.github.abc15018045126.sora.lang.styling.Styles
+
+/**
+ * A [StyleReceiver] receives spans and other styles from analyzers.
+ *
+ * The implementations of the class must make sure its code can be safely run. For example, update
+ * UI by posting its actions to UI thread, but not here.
+ *
+ * Also, the implementations of the class should pay attention to concurrent invocations due not to
+ * corrupt the information it maintains.
+ *
+ * @author abc15018045126
+ */
+interface StyleReceiver {
+
+    /**
+     * Send the styles to the receiver. You can call it in any thread.
+     * The implementation of this method should make sure that concurrent invocations to it are safe.
+     *
+     * @param sourceManager Source AnalyzeManager. The receiver may ignore the request if some checks on
+     * the sourceManager fail
+     */
+    fun setStyles(sourceManager: AnalyzeManager, styles: Styles?)
+
+    /**
+     * Send the styles to the receiver. You can call it in any thread.
+     * The implementation of this method should make sure that concurrent invocations to it are safe.
+     *
+     * @param sourceManager Source AnalyzeManager. The receiver may ignore the request if some checks on
+     * the sourceManager fail
+     * @param action Sometimes you may need to synchronize your action in main thread. This ensures the given action is executed
+     * on main thread before the style updates.
+     */
+    fun setStyles(sourceManager: AnalyzeManager, styles: Styles?, action: Runnable?)
+
+    /**
+     * Notify the receiver the given styles object is updated, and line range is given by `range`
+     *
+     * @param sourceManager Source AnalyzeManager. The receiver may ignore the request if some checks on
+     * the sourceManager fail
+     * @param styles        The Styles object previously set by [setStyles]
+     * @param range         The line range of this update
+     */
+    fun updateStyles(sourceManager: AnalyzeManager, styles: Styles, range: StyleUpdateRange) {
+        setStyles(sourceManager, styles)
+    }
+
+    /**
+     * Specify new diagnostics. You can call it in any thread.
+     * The implementation of this method should make sure that concurrent invocations to it are safe.
+     */
+    fun setDiagnostics(sourceManager: AnalyzeManager, diagnostics: DiagnosticsContainer?)
+
+    /**
+     * Set new provider for brackets highlighting
+     */
+    fun updateBracketProvider(sourceManager: AnalyzeManager, provider: BracketsProvider?)
+
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/analysis/StyleUpdateRange.kt

@@ -18,7 +18,7 @@
  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  *     USA
  *
- *     Please contact abc15018045126 by email 2073412493@qq.com if you need
+ *     Please contact abc15018045126 by email abc15018045126@gmail.com if you need
  *     additional information or have any questions
  ******************************************************************************/
 

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/brackets/BracketsProvider.kt

@@ -0,0 +1,21 @@
+package io.github.abc15018045126.sora.lang.brackets
+
+import io.github.abc15018045126.sora.text.Content
+
+/**
+ * Interface for providing paired brackets
+ *
+ * @author abc15018045126
+ */
+interface BracketsProvider {
+
+    /**
+     * Get left and right brackets position in text
+     *
+     * @param text  The text in editor
+     * @param index Index of cursor in text
+     * @return Paired positions or null if not matched
+     */
+    fun getPairedBracketAt(text: Content, index: Int): PairedBracket?
+
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/brackets/OnlineBracketsMatcher.kt

@@ -0,0 +1,83 @@
+package io.github.abc15018045126.sora.lang.brackets
+
+import io.github.abc15018045126.sora.text.Content
+
+/**
+ * Compute paired bracket when queried
+ *
+ * @author abc15018045126
+ */
+class OnlineBracketsMatcher(
+    private val pairs: CharArray,
+    private val limit: Int
+) : BracketsProvider {
+
+    init {
+        if ((pairs.size and 1) != 0) {
+            throw IllegalArgumentException("pairs must have even length")
+        }
+    }
+
+    private fun findIndex(ch: Char): Int {
+        for (i in pairs.indices) {
+            if (ch == pairs[i]) {
+                return i
+            }
+        }
+        return -1
+    }
+
+    private fun tryComputePaired(text: Content, index: Int): PairedBracket? {
+        val a = text[index]
+        val symbolIndex = findIndex(a)
+        if (symbolIndex != -1) {
+            val b = pairs[symbolIndex xor 1]
+            var stack = 0
+            if ((symbolIndex and 1) == 0) {
+                // Find forward
+                var i = index + 1
+                while (i < text.length && i - index < limit) {
+                    val ch = text[i]
+                    if (ch == b) {
+                        if (stack <= 0) {
+                            return PairedBracket(leftIndex = index, rightIndex = i)
+                        } else {
+                            stack--
+                        }
+                    } else if (ch == a) {
+                        stack++
+                    }
+                    i++
+                }
+            } else {
+                // Find backward
+                var i = index - 1
+                while (i >= 0 && index - i < limit) {
+                    val ch = text[i]
+                    if (ch == b) {
+                        if (stack <= 0) {
+                            return PairedBracket(leftIndex = i, rightIndex = index)
+                        } else {
+                            stack--
+                        }
+                    } else if (ch == a) {
+                        stack++
+                    }
+                    i--
+                }
+            }
+        }
+        return null
+    }
+
+    override fun getPairedBracketAt(text: Content, index: Int): PairedBracket? {
+        var pairedBracket: PairedBracket? = null
+        if (index > 0) {
+            pairedBracket = tryComputePaired(text, index - 1)
+        }
+        if (pairedBracket == null && index < text.length) {
+            pairedBracket = tryComputePaired(text, index)
+        }
+        return pairedBracket
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/brackets/PairedBracket.kt

@@ -0,0 +1,13 @@
+package io.github.abc15018045126.sora.lang.brackets
+
+/**
+ * Describes paired brackets
+ *
+ * @author abc15018045126
+ */
+class PairedBracket @JvmOverloads constructor(
+    @JvmField val leftIndex: Int,
+    @JvmField val leftLength: Int = 1,
+    @JvmField val rightIndex: Int,
+    @JvmField val rightLength: Int = 1
+)

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/brackets/SimpleBracketsCollector.kt

@@ -0,0 +1,53 @@
+package io.github.abc15018045126.sora.lang.brackets
+
+import android.util.SparseIntArray
+import io.github.abc15018045126.sora.text.Content
+
+/**
+ * Collect brackets for simple languages. Not very effective. Not thread-safe.
+ *
+ * @author abc15018045126
+ */
+class SimpleBracketsCollector : BracketsProvider {
+
+    private val mapping = SparseIntArray()
+
+    /**
+     * Add new pair
+     */
+    fun add(start: Int, end: Int) {
+        // add 1 to avoid zeros
+        mapping.put(start + 1, end + 1)
+        mapping.put(end + 1, start + 1)
+    }
+
+    /**
+     * Remove all pairs
+     */
+    fun clear() {
+        mapping.clear()
+    }
+
+    private fun getForIndex(index: Int): PairedBracket? {
+        var another = mapping.get(index + 1) - 1
+        var currentIndex = index
+        if (another > currentIndex) {
+            val tmp = currentIndex
+            currentIndex = another
+            another = tmp
+        }
+        return if (another != -1) {
+            PairedBracket(leftIndex = currentIndex, rightIndex = another)
+        } else {
+            null
+        }
+    }
+
+    override fun getPairedBracketAt(text: Content, index: Int): PairedBracket? {
+        var res = if (index - 1 >= 0) getForIndex(index - 1) else null
+        if (res == null) {
+            res = getForIndex(index)
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,14 @@
+package io.github.abc15018045126.sora.lang.completion
+
+/**
+ * Thrown when the thread is abandoned by the editor framework because the editor do not need its
+ * new items anymore.
+ * <p>
+ * This can be thrown by {@link io.github.abc15018045126.sora.text.ContentReference} and
+ * {@link CompletionPublisher}.
+ *
+ * @author abc15018045126
+ */
+class CompletionCancelledException @JvmOverloads constructor(
+    message: String? = null
+) : RuntimeException(message)

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

@@ -0,0 +1,48 @@
+package io.github.abc15018045126.sora.lang.completion
+
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.text.ContentReference
+import io.github.abc15018045126.sora.widget.component.EditorAutoCompletion
+
+/**
+ * Helper class for completion
+ *
+ * @author abc15018045126
+ */
+object CompletionHelper {
+
+    /**
+     * Searches backward on the line, with the given checker to check chars.
+     * Returns the longest text that matches the requirement
+     */
+    @JvmStatic
+    fun computePrefix(ref: ContentReference, pos: CharPosition, checker: PrefixChecker): String {
+        var begin = pos.column
+        val line = ref.getLine(pos.line)
+        while (begin > 0) {
+            if (!checker.check(line[begin - 1])) {
+                break
+            }
+            begin--
+        }
+        return line.substring(begin, pos.column)
+    }
+
+    /**
+     * Check whether the thread is abandoned by editor.
+     * Return true if it is cancelled by editor.
+     */
+    @JvmStatic
+    fun checkCancelled(): Boolean {
+        val thread = Thread.currentThread()
+        return if (thread is EditorAutoCompletion.CompletionThread) {
+            thread.isCancelled
+        } else {
+            false
+        }
+    }
+
+    fun interface PrefixChecker {
+        fun check(ch: Char): Boolean
+    }
+}

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

@@ -0,0 +1,131 @@
+package io.github.abc15018045126.sora.lang.completion
+
+import android.graphics.drawable.Drawable
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.text.Content
+import io.github.abc15018045126.sora.widget.CodeEditor
+
+/**
+ * The class used to save auto complete result items.
+ * For functionality, this class only manages the information to be displayed in list view.
+ * You can implement {@link CompletionItem#performCompletion(CodeEditor, Content, int, int)} or
+ * {@link CompletionItem#performCompletion(CodeEditor, Content, CharPosition)} to customize
+ * your own completion method so that you can develop complex actions.
+ * <p>
+ * For the simplest usage, see {@link SimpleCompletionItem}
+ *
+ * @author abc15018045126
+ * @see SimpleCompletionItem
+ */
+abstract class CompletionItem {
+
+    /**
+     * Icon for displaying in adapter
+     */
+    @JvmField
+    var icon: Drawable? = null
+
+    /**
+     * Text to display as title in adapter
+     */
+    @JvmField
+    var label: CharSequence? = null
+
+    /**
+     * Text to display as description in adapter
+     */
+    @JvmField
+    var desc: CharSequence? = null
+
+    /**
+     * The kind of this completion item. Based on the kind
+     * an icon is chosen by the editor.
+     */
+    @JvmField
+    var kind: CompletionItemKind? = null
+
+    /**
+     * Use for default sort
+     */
+    @JvmField
+    var prefixLength: Int = 0
+
+    /**
+     * A string that should be used when comparing this item
+     * with other items. When null the {@link #label label}
+     * is used.
+     */
+    @JvmField
+    var sortText: String? = null
+
+    /**
+     * A string that should be used when comparing this item
+     * with other items. When null the {@link #sortText sortText}
+     * is used.
+     */
+    @JvmField
+    var filterText: String? = null
+
+    @JvmField
+    var extra: Any? = null
+
+    constructor(label: CharSequence) : this(label, null)
+
+    constructor(label: CharSequence, desc: CharSequence?) : this(label, desc, null)
+
+    constructor(label: CharSequence, desc: CharSequence?, icon: Drawable?) {
+        this.label = label
+        this.desc = desc
+        this.icon = icon
+    }
+
+    open fun label(label: CharSequence): CompletionItem {
+        this.label = label
+        return this
+    }
+
+    open fun desc(desc: CharSequence): CompletionItem {
+        this.desc = desc
+        return this
+    }
+
+    open fun kind(kind: CompletionItemKind): CompletionItem {
+        this.kind = kind
+        return this
+    }
+
+    open fun icon(icon: Drawable): CompletionItem {
+        this.icon = icon
+        return this
+    }
+
+    /**
+     * Perform this completion.
+     * You can implement custom logic to make your completion better(by updating selection and text
+     * from here).
+     * To make it considered as a single action, the editor will enter batch edit state before invoking
+     * this method. Feel free to update the text by multiple calls to {@code text}.
+     *
+     * @param editor   The editor. You can set cursor position with that.
+     * @param text     The text in editor. You can make modifications to it.
+     * @param position The requested completion position (the one passed to completion thread)
+     */
+    open fun performCompletion(editor: CodeEditor, text: Content, position: CharPosition) {
+        performCompletion(editor, text, position.line, position.column)
+    }
+
+    /**
+     * Perform this completion.
+     * You can implement custom logic to make your completion better(by updating selection and text
+     * from here).
+     * To make it considered as a single action, the editor will enter batch edit state before invoking
+     * this method. Feel free to update the text by multiple calls to {@code text}.
+     *
+     * @param editor The editor. You can set cursor position with that.
+     * @param text   The text in editor. You can make modifications to it.
+     * @param line   The auto-completion line
+     * @param column The auto-completion column
+     * @see #performCompletion(CodeEditor, Content, CharPosition) Editor calls this method to do completion
+     */
+    abstract fun performCompletion(editor: CodeEditor, text: Content, line: Int, column: Int)
+}

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

@@ -18,7 +18,7 @@
  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  *     USA
  *
- *     Please contact abc15018045126 by email 2073412493@qq.com if you need
+ *     Please contact abc15018045126 by email abc15018045126@gmail.com if you need
  *     additional information or have any questions
  ******************************************************************************/