capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/diagnostic/DiagnosticRegion.kt

@@ -0,0 +1,56 @@
+package io.github.abc15018045126.sora.lang.diagnostic
+
+/**
+ * Class for describing a diagnostic region.
+ *
+ * @author abc15018045126
+ */
+class DiagnosticRegion @JvmOverloads constructor(
+    /**
+     * The start index of the diagnostic
+     */
+    @JvmField var startIndex: Int,
+    /**
+     * The end index of the diagnostic
+     */
+    @JvmField var endIndex: Int,
+    /**
+     * One diagnostic has only one severity specification
+     *
+     * @see SEVERITY_NONE
+     * @see SEVERITY_TYPO
+     * @see SEVERITY_WARNING
+     * @see SEVERITY_ERROR
+     */
+    @JvmField var severity: Short,
+    /**
+     * Id specified by diagnostic provider
+     */
+    @JvmField var id: Long = 0,
+    /**
+     * The detail of the problem
+     */
+    @JvmField var detail: DiagnosticDetail? = null
+) : Comparable<DiagnosticRegion> {
+
+    override fun compareTo(other: DiagnosticRegion): Int {
+        var cmp = startIndex.compareTo(other.startIndex)
+        if (cmp == 0) {
+            cmp = endIndex.compareTo(other.endIndex)
+        }
+        if (cmp == 0) {
+            cmp = severity.compareTo(other.severity)
+        }
+        if (cmp == 0) {
+            cmp = id.compareTo(other.id)
+        }
+        return cmp
+    }
+
+    companion object {
+        const val SEVERITY_NONE: Short = 0
+        const val SEVERITY_TYPO: Short = 1
+        const val SEVERITY_WARNING: Short = 2
+        const val SEVERITY_ERROR: Short = 3
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/diagnostic/DiagnosticsContainer.kt

@@ -0,0 +1,109 @@
+package io.github.abc15018045126.sora.lang.diagnostic
+
+/**
+ * A thread-safe class for containing diagnostics
+ *
+ * @author abc15018045126
+ */
+class DiagnosticsContainer @JvmOverloads constructor(
+    private val shiftEnabled: Boolean = true
+) {
+
+    private val regions = mutableListOf<DiagnosticRegion>()
+
+    /**
+     * Add multiple diagnostics
+     */
+    @Synchronized
+    fun addDiagnostics(regions: Collection<DiagnosticRegion>) {
+        this.regions.addAll(regions)
+    }
+
+    /**
+     * Add single diagnostic item
+     */
+    @Synchronized
+    fun addDiagnostic(diagnostic: DiagnosticRegion) {
+        regions.add(diagnostic)
+    }
+
+    /**
+     * Query diagnostics that can be displayed either partly or fully in the given region
+     *
+     * @param result     Destination of result
+     * @param startIndex Start index of query
+     * @param endIndex   End index of query
+     */
+    @Synchronized
+    fun queryInRegion(result: MutableList<DiagnosticRegion>, startIndex: Int, endIndex: Int) {
+        for (region in regions) {
+            if (region.endIndex > startIndex && region.startIndex <= endIndex) {
+                result.add(region)
+            }
+        }
+    }
+
+    @Synchronized
+    fun shiftOnInsert(insertStart: Int, insertEnd: Int) {
+        if (!shiftEnabled) {
+            return
+        }
+        val length = insertEnd - insertStart
+        for (region in regions) {
+            // Type 1, text is inserted inside a diagnostic
+            if (region.startIndex <= insertStart && region.endIndex >= insertStart) {
+                region.endIndex += length
+            }
+            // Type 2, text is inserted before a diagnostic
+            if (region.startIndex > insertStart) {
+                region.startIndex += length
+                region.endIndex += length
+            }
+        }
+    }
+
+    @Synchronized
+    fun shiftOnDelete(deleteStart: Int, deleteEnd: Int) {
+        if (!shiftEnabled) {
+            return
+        }
+        val length = deleteEnd - deleteStart
+        val garbage = mutableListOf<DiagnosticRegion>()
+        for (region in regions) {
+            // Compute cross length
+            val sharedStart = maxOf(deleteStart, region.startIndex)
+            val sharedEnd = minOf(deleteEnd, region.endIndex)
+            if (sharedEnd <= sharedStart) {
+                // No shared region
+                if (region.startIndex >= deleteEnd) {
+                    // Shift left
+                    region.startIndex -= length
+                    region.endIndex -= length
+                }
+            } else {
+                // Has shared region
+                val sharedLength = sharedEnd - sharedStart
+                region.endIndex -= sharedLength
+                if (region.startIndex > deleteStart) {
+                    // Shift left
+                    val shiftLeftCount = region.startIndex - deleteStart
+                    region.startIndex -= shiftLeftCount
+                    region.endIndex -= shiftLeftCount
+                }
+
+                if (region.startIndex == region.endIndex) {
+                    garbage.add(region)
+                }
+            }
+        }
+        regions.removeAll(garbage)
+    }
+
+    /**
+     * Remove all items
+     */
+    @Synchronized
+    fun reset() {
+        regions.clear()
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/diagnostic/Quickfix.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/folding/FoldingRegion.kt

@@ -0,0 +1,50 @@
+package io.github.abc15018045126.sora.lang.folding
+
+import io.github.abc15018045126.sora.util.IntPair
+
+/**
+ * Indicates a folding region
+ */
+class FoldingRegion internal constructor(
+    private var start: Long,
+    private var end: Long
+) {
+    var isCollapsed: Boolean = false
+    private var children: MutableList<FoldingRegion>? = null
+
+    constructor(startLine: Int, startColumn: Int, endLine: Int, endColumn: Int) : this(
+        IntPair.pack(startLine, startColumn),
+        IntPair.pack(endLine, endColumn)
+    ) {
+        if (startLine > endLine || (startLine == endLine && startColumn > endColumn)) {
+            throw IllegalArgumentException("start > end")
+        }
+    }
+
+    val startLine: Int
+        get() = IntPair.getFirst(start)
+
+    val startColumn: Int
+        get() = IntPair.getSecond(start)
+
+    val endLine: Int
+        get() = IntPair.getFirst(end)
+
+    val endColumn: Int
+        get() = IntPair.getSecond(end)
+
+    fun createChild(startLine: Int, startColumn: Int, endLine: Int, endColumn: Int): FoldingRegion {
+        if (startLine < this.startLine || (startLine == this.startLine && startColumn < this.startColumn)) {
+            throw IllegalArgumentException("child start is before parent start")
+        }
+        if (endLine > this.endLine || (endLine == this.endLine && endColumn > this.endColumn)) {
+            throw IllegalArgumentException("child end is beyond parent end")
+        }
+        val child = FoldingRegion(startLine, startColumn, endLine, endColumn)
+        if (children == null) {
+            children = ArrayList()
+        }
+        children!!.add(child)
+        return child
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/format/AsyncFormatter.kt

@@ -0,0 +1,182 @@
+package io.github.abc15018045126.sora.lang.format
+
+import android.util.Log
+import androidx.annotation.NonNull
+import androidx.annotation.Nullable
+import androidx.annotation.WorkerThread
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.text.Content
+import io.github.abc15018045126.sora.text.TextRange
+import java.lang.ref.WeakReference
+import java.util.concurrent.locks.Condition
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+/**
+ * Base class for formatting code in another thread.
+ */
+abstract class AsyncFormatter : Formatter {
+
+    private val lock = ReentrantLock()
+    private val condition: Condition = lock.newCondition()
+    private var receiver: WeakReference<Formatter.FormatResultReceiver>? = null
+    
+    @Volatile
+    private var text: Content? = null
+    
+    @Volatile
+    private var range: TextRange? = null
+    
+    @Volatile
+    private var cursorRange: TextRange? = null
+
+    private var thread: FormattingThread? = null
+
+    override fun setReceiver(receiver: Formatter.FormatResultReceiver?) {
+        this.receiver = receiver?.let { WeakReference(it) }
+    }
+
+    private fun run() {
+        if (thread == null || thread?.isAlive == false) {
+            // Create new thread
+            Log.v(LOG_TAG, "Starting a new thread for formatting")
+            thread = FormattingThread().apply {
+                isDaemon = true
+                name = "AsyncFormatter-${nextThreadId()}"
+                start()
+            }
+        } else {
+            // Wake up thread
+            Log.v(LOG_TAG, "Waking up thread for formatting")
+            lock.withLock {
+                condition.signal()
+            }
+        }
+    }
+
+    override fun format(@NonNull text: Content, @NonNull cursorRange: TextRange) {
+        this.text = text
+        range = null
+        this.cursorRange = cursorRange
+        run()
+    }
+
+    override fun isRunning(): Boolean {
+        return thread != null && thread?.isAlive == true && lock.isLocked
+    }
+
+    override fun formatRegion(@NonNull text: Content, @NonNull rangeToFormat: TextRange, @NonNull cursorRange: TextRange) {
+        this.text = text
+        range = rangeToFormat
+        this.cursorRange = cursorRange
+        run()
+    }
+
+    /**
+     * like [Formatter.format], but run in background thread.
+     *
+     * Implementation of this method can edit text directly to generate formatted code.
+     *
+     * @return the new cursor range to be applied to the text
+     */
+    @WorkerThread
+    @Nullable
+    abstract fun formatAsync(@NonNull text: Content, @NonNull cursorRange: TextRange): TextRange?
+
+    /**
+     * like [Formatter.formatRegion], but run in background thread
+     *
+     * Implementation of this method can edit text directly to generate formatted code.
+     *
+     * @return the new cursor range to be applied to the text
+     */
+    @WorkerThread
+    @Nullable
+    abstract fun formatRegionAsync(@NonNull text: Content, @NonNull rangeToFormat: TextRange, @NonNull cursorRange: TextRange): TextRange?
+
+    private fun sendUpdate(text: Content?, cursorRange: TextRange?) {
+        if (!Thread.currentThread().isInterrupted) {
+            receiver?.get()?.onFormatSucceed(text.toString(), cursorRange)
+        }
+    }
+
+    private fun sendFailure(throwable: Throwable) {
+        if (!Thread.currentThread().isInterrupted) {
+            receiver?.get()?.onFormatFail(throwable)
+        }
+    }
+
+    override fun cancel() {
+        thread?.let {
+            if (it.isAlive) {
+                it.interrupt()
+            }
+            thread = null
+        }
+    }
+
+    override fun destroy() {
+        if (thread != null && thread?.isAlive == true) {
+            thread?.interrupt()
+        }
+        thread = null
+        receiver = null
+        text = null
+        range = null
+    }
+
+    private inner class FormattingThread : Thread() {
+
+        override fun run() {
+            Log.v(LOG_TAG, "AsyncFormatter thread started")
+            try {
+                while (!isInterrupted) {
+                    lock.lock()
+                    val currentText = text
+                    if (currentText == null) {
+                        lock.unlock()
+                        continue
+                    }
+                    val currentCursorRange = cursorRange ?: TextRange(CharPosition(), CharPosition())
+                    val newRange: TextRange?
+                    val currentRange = range
+                    if (currentRange == null) {
+                        newRange = formatAsync(currentText, currentCursorRange)
+                    } else {
+                        newRange = formatRegionAsync(currentText, currentRange, currentCursorRange)
+                    }
+                    sendUpdate(currentText, newRange)
+                    // un-refer immediately
+                    text = null
+                    range = null
+                    // Wait for next time
+                    try {
+                        condition.await()
+                    } finally {
+                        lock.unlock()
+                    }
+                }
+            } 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)
+                sendFailure(e)
+            } finally {
+                if (lock.isHeldByCurrentThread) {
+                    lock.unlock()
+                }
+            }
+        }
+    }
+
+    companion object {
+        private const val LOG_TAG = "AsyncFormatter"
+        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/format/Formatter.kt

@@ -0,0 +1,72 @@
+package io.github.abc15018045126.sora.lang.format
+
+import io.github.abc15018045126.sora.text.Content
+import io.github.abc15018045126.sora.text.TextRange
+
+/**
+ * Format content for editor
+ */
+interface Formatter {
+
+    /**
+     * Format the given content from [cursorRange] position
+     *
+     * Format the content directly, and call [FormatResultReceiver] to receive the formatted content from the editor when the formatting is complete
+     *
+     * @param text        the content to format, but not the original Content in editor
+     * @param cursorRange the positions of cursor. Start and end position may be the same.
+     */
+    fun format(text: Content, cursorRange: TextRange)
+
+    /**
+     * Format the given content from [rangeToFormat] position
+     *
+     * Format the content directly, and call [FormatResultReceiver] to receive the formatted content from the editor when the formatting is complete
+     *
+     * @param text          the content to format, but not the original Content in editor
+     * @param rangeToFormat the range in text to be formatted
+     * @param cursorRange   the positions of cursor. Start and end position may be the same.
+     */
+    fun formatRegion(text: Content, rangeToFormat: TextRange, cursorRange: TextRange)
+
+    /**
+     * Set the result receiver
+     */
+    fun setReceiver(receiver: FormatResultReceiver?)
+
+    /**
+     * Whether the current formatter is running
+     */
+    fun isRunning(): Boolean
+
+    /**
+     * Destroy the formatter. Release any resources held.
+     * Make sure that you will not call the receiver anymore.
+     */
+    fun destroy()
+
+    /**
+     * Cancel last task if it is still running. Do not send success/failure to editor for last task.
+     */
+    fun cancel() {
+        // Default implementation does nothing
+    }
+
+    interface FormatResultReceiver {
+        /**
+         * Called when the formatting is completed
+         *
+         * @param applyContent the formatted **full** text
+         * @param cursorRange  The range of cursor after formatting. You may pass null for unspecified.
+         *                     Also, the start and end of the range may be the same position.
+         */
+        fun onFormatSucceed(applyContent: CharSequence, cursorRange: TextRange?)
+
+        /**
+         * Called when the formatting is failed
+         *
+         * @param throwable the throwable that caused formatting failed
+         */
+        fun onFormatFail(throwable: Throwable?)
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/smartEnter/NewlineHandleResult.kt

@@ -0,0 +1,18 @@
+package io.github.abc15018045126.sora.lang.smartEnter
+
+class NewlineHandleResult(
+    /**
+     * Text to insert
+     */
+    @JvmField val text: CharSequence,
+    /**
+     * Count to shift left from the end of {@link NewlineHandleResult#text}
+     */
+    @JvmField val shiftLeft: Int
+) {
+    init {
+        if (shiftLeft < 0 || shiftLeft > text.length) {
+            throw IllegalArgumentException("invalid shiftLeft")
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/smartEnter/NewlineHandler.kt

@@ -0,0 +1,32 @@
+package io.github.abc15018045126.sora.lang.smartEnter
+
+import io.github.abc15018045126.sora.lang.styling.Styles
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.text.Content
+
+/**
+ * Perform text processing when user enters '\n' and selection size is 0
+ */
+interface NewlineHandler {
+
+    /**
+     * Checks whether the given input matches the requirement to invoke this handler
+     *
+     * @param text     Current text in editor
+     * @param position The position of cursor
+     * @param style    Current code styles
+     * @return Whether this handler should be called
+     */
+    fun matchesRequirement(text: Content, position: CharPosition, style: Styles?): Boolean
+
+    /**
+     * Handle newline and return processed content to insert
+     *
+     * @param text     Current text in editor
+     * @param position The position of cursor
+     * @param style    Current code styles
+     * @return Actual content to insert
+     */
+    fun handleNewline(text: Content, position: CharPosition, style: Styles?, tabSize: Int): NewlineHandleResult
+
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/styling/BlocksUpdater.kt

@@ -0,0 +1,34 @@
+package io.github.abc15018045126.sora.lang.styling
+
+/**
+ * Update block line positions on edit
+ */
+object BlocksUpdater {
+
+    /**
+     * Update blocks
+     *
+     * @param blocks   Block lines to update
+     * @param restrict Min line to update
+     * @param delta    Delta for line index
+     */
+    @JvmStatic
+    fun update(blocks: MutableList<CodeBlock>, restrict: Int, delta: Int) {
+        if (delta == 0) {
+            return
+        }
+        val itr = blocks.iterator()
+        while (itr.hasNext()) {
+            val block = itr.next()
+            if (block.startLine >= restrict) {
+                block.startLine += delta
+            }
+            if (block.endLine >= restrict) {
+                block.endLine += delta
+            }
+            if (block.startLine >= block.endLine) {
+                itr.remove()
+            }
+        }
+    }
+}