capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/language-textmate/src/main/java/io/github/abc15018045126/sora/langs/textmate/TextMateNewlineHandler.kt

@@ -0,0 +1,268 @@
+package io.github.abc15018045126.sora.langs.textmate
+
+import android.util.Pair
+import androidx.annotation.NonNull
+import androidx.annotation.Nullable
+import io.github.abc15018045126.sora.lang.smartEnter.NewlineHandleResult
+import io.github.abc15018045126.sora.lang.smartEnter.NewlineHandler
+import io.github.abc15018045126.sora.lang.styling.Styles
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.text.Content
+import org.eclipse.tm4e.languageconfiguration.internal.model.CompleteEnterAction
+import org.eclipse.tm4e.languageconfiguration.internal.model.EnterAction
+import org.eclipse.tm4e.languageconfiguration.internal.model.LanguageConfiguration
+import org.eclipse.tm4e.languageconfiguration.internal.supports.IndentRulesSupport
+import org.eclipse.tm4e.languageconfiguration.internal.supports.OnEnterSupport
+import org.eclipse.tm4e.languageconfiguration.internal.utils.TextUtils
+import java.util.*
+
+class TextMateNewlineHandler(private val language: TextMateLanguage) : NewlineHandler {
+
+    private var enterSupport: OnEnterSupport? = null
+    private var indentRulesSupport: IndentRulesSupport? = null
+    private var enterAction: CompleteEnterAction? = null
+    private var indentForEnter: Pair<String, String>? = null
+    var isEnabled = true
+    private var languageConfiguration: LanguageConfiguration? = language.languageConfiguration
+
+    init {
+        val config = languageConfiguration
+        if (config != null) {
+            val enterRules = config.onEnterRules
+            val brackets = config.brackets
+            val indentationRules = config.indentationRules
+
+            if (enterRules != null) {
+                enterSupport = OnEnterSupport(brackets, enterRules)
+            }
+            if (indentationRules != null) {
+                indentRulesSupport = IndentRulesSupport(indentationRules)
+            }
+        }
+    }
+
+    override fun matchesRequirement(@NonNull text: Content, @NonNull position: CharPosition, @Nullable style: Styles?): Boolean {
+        if (!isEnabled) return false
+
+        enterAction = getEnterAction(text, position)
+        indentForEnter = null
+
+        if (enterAction == null) {
+            indentForEnter = getIndentForEnter(text, position)
+        }
+
+        return enterAction != null || indentForEnter != null
+    }
+
+    @NonNull
+    override fun handleNewline(
+        @NonNull text: Content,
+        @NonNull position: CharPosition,
+        @Nullable style: Styles?,
+        tabSize: Int
+    ): NewlineHandleResult {
+        val delim = "\n"
+        val indentForEnter = this.indentForEnter
+        if (indentForEnter != null) {
+            val normalIndent = normalizeIndentation(indentForEnter.second)
+            return NewlineHandleResult(delim + normalIndent, 0)
+        }
+
+        val action = enterAction ?: return NewlineHandleResult("", 0)
+        return when (action.indentAction) {
+            EnterAction.IndentAction.None, EnterAction.IndentAction.Indent -> {
+                val increasedIndent = normalizeIndentation(action.indentation + action.appendText)
+                NewlineHandleResult(delim + increasedIndent, 0)
+            }
+            EnterAction.IndentAction.IndentOutdent -> {
+                val normalIndent = normalizeIndentation(action.indentation)
+                val increasedIndent = normalizeIndentation(action.indentation + action.appendText)
+                val typeText = delim + increasedIndent + delim + normalIndent
+                val caretOffset = normalIndent.length + 1
+                NewlineHandleResult(typeText, caretOffset)
+            }
+            EnterAction.IndentAction.Outdent -> {
+                val indentation = TextUtils.getIndentationFromWhitespace(action.indentation, language.tabSize, language.useTab())
+                val outdentedText = outdentString(normalizeIndentation(indentation + action.appendText))
+                val caretOffset = outdentedText.length + 1
+                NewlineHandleResult(outdentedText, caretOffset)
+            }
+            else -> NewlineHandleResult("", 0)
+        }
+    }
+
+    protected fun getIndentForEnter(text: Content, position: CharPosition): Pair<String, String>? {
+        val currentLineText = text.getLineString(position.line)
+        val beforeEnterText = currentLineText.substring(0, position.column)
+        val afterEnterText = currentLineText.substring(position.column)
+
+        val rulesSupport = indentRulesSupport ?: return null
+
+        val beforeEnterIndent = TextUtils.getLeadingWhitespace(beforeEnterText, 0, beforeEnterText.length)
+        val afterEnterAction = getInheritIndentForLine(WrapperContentImp(text, position.line, beforeEnterText), true, position.line + 1)
+
+        if (afterEnterAction == null) {
+            return Pair(beforeEnterIndent, beforeEnterIndent)
+        }
+
+        var afterEnterIndent = afterEnterAction.indentation
+        val indent = if (language.useTab()) "\t" else " ".repeat(language.tabSize)
+
+        if (afterEnterAction.action == EnterAction.IndentAction.Indent) {
+            afterEnterIndent = beforeEnterIndent + indent
+        }
+
+        if (rulesSupport.shouldDecrease(afterEnterText)) {
+            afterEnterIndent = beforeEnterIndent.substring(0, Math.max(0, beforeEnterIndent.length - indent.length))
+        }
+
+        return Pair(beforeEnterIndent, afterEnterIndent)
+    }
+
+    private fun getInheritIndentForLine(wrapperContent: WrapperContent, honorIntentionalIndent: Boolean, line: Int): InheritIndentResult? {
+        if (line <= 0) return InheritIndentResult("", null)
+
+        val precedingUnIgnoredLine = getPrecedingValidLine(wrapperContent, line)
+        if (precedingUnIgnoredLine <= -1) return null
+
+        val rulesSupport = indentRulesSupport ?: return null
+        val precedingUnIgnoredLineContent = wrapperContent.getLineContent(precedingUnIgnoredLine)
+
+        if (rulesSupport.shouldIncrease(precedingUnIgnoredLineContent) || rulesSupport.shouldIndentNextLine(precedingUnIgnoredLineContent)) {
+            return InheritIndentResult(TextUtils.getLeadingWhitespace(precedingUnIgnoredLineContent), EnterAction.IndentAction.Indent, precedingUnIgnoredLine)
+        } else if (rulesSupport.shouldDecrease(precedingUnIgnoredLineContent)) {
+            return InheritIndentResult(TextUtils.getLeadingWhitespace(precedingUnIgnoredLineContent), null, precedingUnIgnoredLine)
+        } else {
+            if (precedingUnIgnoredLine == 0) {
+                return InheritIndentResult(TextUtils.getLeadingWhitespace(wrapperContent.getLineContent(precedingUnIgnoredLine)), null, precedingUnIgnoredLine)
+            }
+
+            val previousLine = precedingUnIgnoredLine - 1
+            val previousLineIndentMetadata = rulesSupport.getIndentMetadata(wrapperContent.getLineContent(previousLine))
+
+            if (((previousLineIndentMetadata and (IndentRulesSupport.IndentConsts.INCREASE_MASK or IndentRulesSupport.IndentConsts.DECREASE_MASK)) == 0) &&
+                (previousLineIndentMetadata and IndentRulesSupport.IndentConsts.INDENT_NEXTLINE_MASK) == 0 && previousLineIndentMetadata > 0
+            ) {
+                var stopLine = 0
+                for (i in previousLine - 1 downTo 1) {
+                    if (rulesSupport.shouldIndentNextLine(wrapperContent.getLineContent(i))) continue
+                    stopLine = i
+                    break
+                }
+                return InheritIndentResult(TextUtils.getLeadingWhitespace(wrapperContent.getLineContent(stopLine + 1)), null, stopLine + 1)
+            }
+
+            if (honorIntentionalIndent) {
+                return InheritIndentResult(TextUtils.getLeadingWhitespace(wrapperContent.getLineContent(precedingUnIgnoredLine)), null, precedingUnIgnoredLine)
+            }
+
+            for (i in precedingUnIgnoredLine downTo 1) {
+                val lineContent = wrapperContent.getLineContent(i)
+                if (rulesSupport.shouldIncrease(lineContent)) {
+                    return InheritIndentResult(TextUtils.getLeadingWhitespace(lineContent), EnterAction.IndentAction.Indent, i)
+                } else if (rulesSupport.shouldIndentNextLine(lineContent)) {
+                    var stopLine = 0
+                    for (j in i - 1 downTo 1) {
+                        if (rulesSupport.shouldIndentNextLine(wrapperContent.getLineContent(i))) continue
+                        stopLine = j
+                        break
+                    }
+                    return InheritIndentResult(TextUtils.getLeadingWhitespace(wrapperContent.getLineContent(stopLine + 1)), null, stopLine + 1)
+                } else if (rulesSupport.shouldDecrease(lineContent)) {
+                    return InheritIndentResult(TextUtils.getLeadingWhitespace(lineContent), null, i)
+                }
+            }
+            return InheritIndentResult(TextUtils.getLeadingWhitespace(wrapperContent.getLineContent(1)), null, 1)
+        }
+    }
+
+    internal fun getPrecedingValidLine(content: WrapperContent, lineNumber: Int): Int {
+        val rulesSupport = indentRulesSupport ?: return -1
+        if (lineNumber > 0) {
+            for (lastLineNumber in lineNumber - 1 downTo 0) {
+                val text = content.getLineContent(lastLineNumber)
+                if (rulesSupport.shouldIgnore(text) || text.isEmpty()) continue
+                return lastLineNumber
+            }
+        }
+        return -1
+    }
+
+    @Nullable
+    fun getEnterAction(content: Content, position: CharPosition): CompleteEnterAction? {
+        var indentation = TextUtils.getLinePrefixingWhitespaceAtPosition(content, position)
+        val onEnterSupport = enterSupport ?: return null
+
+        val scopedLineText = content.getLineString(position.line)
+        val beforeEnterText = scopedLineText.substring(0, position.column)
+        val afterEnterText = scopedLineText.substring(position.column)
+
+        var previousLineText = ""
+        if (position.line > 0) {
+            previousLineText = content.getLineString(position.line - 1)
+        }
+
+        val enterResult: EnterAction = try {
+            onEnterSupport.onEnter(previousLineText, beforeEnterText, afterEnterText)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            null
+        } ?: return null
+
+        val indentAction = enterResult.indentAction
+        var appendText = enterResult.appendText
+        val removeText = enterResult.removeText
+
+        if (appendText == null) {
+            appendText = if (indentAction == EnterAction.IndentAction.Indent || indentAction == EnterAction.IndentAction.IndentOutdent) {
+                "\t"
+            } else {
+                ""
+            }
+        } else if (indentAction == EnterAction.IndentAction.Indent) {
+            appendText = "\t" + appendText
+        }
+
+        if (removeText != null) {
+            indentation = indentation.substring(0, indentation.length - removeText)
+        }
+
+        return CompleteEnterAction(indentAction, appendText, removeText, indentation)
+    }
+
+    private fun outdentString(str: String): String {
+        if (str.startsWith("\t")) return str.substring(1)
+
+        if (!language.useTab()) {
+            val spaces = " ".repeat(language.tabSize)
+            if (str.startsWith(spaces)) return str.substring(spaces.length)
+        }
+        return str
+    }
+
+    private fun normalizeIndentation(str: String): String {
+        return TextUtils.normalizeIndentation(str, language.tabSize, !language.useTab())
+    }
+
+    internal class InheritIndentResult(
+        var indentation: String,
+        var action: EnterAction.IndentAction?,
+        var line: Int = 0
+    )
+
+    private open class WrapperContentImp(
+        private val content: Content,
+        private val line: Int,
+        private val currentLineContent: String
+    ) : WrapperContent {
+        override fun getOrigin(): Content = content
+        override fun getLineContent(line: Int): String {
+            return if (line == this.line) currentLineContent else content.getLineString(line)
+        }
+    }
+
+    internal interface WrapperContent {
+        fun getOrigin(): Content
+        fun getLineContent(line: Int): String
+    }
+}

package/android/sora-editor/language-textmate/src/main/java/io/github/abc15018045126/sora/langs/textmate/TextMateSymbolPairMatch.kt

@@ -0,0 +1,167 @@
+package io.github.abc15018045126.sora.langs.textmate
+
+import io.github.abc15018045126.sora.lang.styling.Span
+import io.github.abc15018045126.sora.text.Content
+import io.github.abc15018045126.sora.text.ContentLine
+import io.github.abc15018045126.sora.widget.CodeEditor
+import io.github.abc15018045126.sora.widget.SymbolPairMatch
+import org.eclipse.tm4e.core.internal.grammar.tokenattrs.StandardTokenType
+import org.eclipse.tm4e.languageconfiguration.internal.model.AutoClosingPairConditional
+import java.util.*
+
+class TextMateSymbolPairMatch(private val language: TextMateLanguage) : SymbolPairMatch(DefaultSymbolPairs()) {
+
+    private var enabled = true
+
+    init {
+        updatePair()
+    }
+
+    fun setEnabled(enabled: Boolean) {
+        this.enabled = enabled
+        if (!enabled) {
+            removeAllPairs()
+        } else {
+            updatePair()
+        }
+    }
+
+    fun updatePair() {
+        if (!enabled) return
+
+        val config = language.languageConfiguration ?: return
+
+        removeAllPairs()
+
+        val surroundingPairs = config.surroundingPairs
+        val autoClosingPairs = config.autoClosingPairs
+        val mergePairs = ArrayList<AutoClosingPairConditional>()
+
+        if (autoClosingPairs != null) {
+            mergePairs.addAll(autoClosingPairs)
+        }
+
+        if (surroundingPairs != null) {
+            for (surroundingPair in surroundingPairs) {
+                val newPair = AutoClosingPairConditional(
+                    surroundingPair.open, surroundingPair.close,
+                    SURROUNDING_PAIR_FLAG_LIST
+                )
+                mergePairs.add(newPair)
+            }
+        }
+
+        for (pair in mergePairs) {
+            putPair(pair.open, SymbolPair(pair.open, pair.close, SymbolPairExImpl(pair)))
+        }
+    }
+
+    private class SymbolPairExImpl(pair: AutoClosingPairConditional) : SymbolPair.SymbolPairEx {
+        private var notInTokenTypeArray: IntArray? = null
+        private var isSurroundingPair = false
+
+        init {
+            val notInList = pair.notIn
+            if (notInList == null || notInList.isEmpty()) {
+                notInTokenTypeArray = null
+            } else {
+                val mutableNotInList = ArrayList(notInList)
+                if (mutableNotInList.contains(SURROUNDING_PAIR_FLAG)) {
+                    isSurroundingPair = true
+                    if (mutableNotInList.size == 1) {
+                        notInTokenTypeArray = null
+                    } else {
+                        mutableNotInList.remove(SURROUNDING_PAIR_FLAG)
+                    }
+                }
+                
+                if (!isSurroundingPair || mutableNotInList.isNotEmpty()) {
+                    notInTokenTypeArray = IntArray(mutableNotInList.size)
+                    for (i in mutableNotInList.indices) {
+                        val notInValue = mutableNotInList[i].lowercase()
+                        var notInTokenType = StandardTokenType.String
+                        when (notInValue) {
+                            "string" -> notInTokenType = StandardTokenType.String
+                            "comment" -> notInTokenType = StandardTokenType.Comment
+                            "regex" -> notInTokenType = StandardTokenType.RegEx
+                        }
+                        notInTokenTypeArray!![i] = notInTokenType
+                    }
+                    notInTokenTypeArray!!.sort()
+                }
+            }
+        }
+
+        override fun shouldReplace(editor: CodeEditor, contentLine: ContentLine, leftColumn: Int): Boolean {
+            if (editor.cursor!!.isSelected()) {
+
+                return isSurroundingPair
+            }
+            if (isSurroundingPair) {
+                return false
+            }
+
+            val array = notInTokenTypeArray ?: return true
+
+            val cursor = editor.cursor!!
+            val currentLine = cursor.leftLine
+            val currentColumn = cursor.leftColumn
+
+
+            val spansOnCurrentLine = editor.getSpansForLine(currentLine) ?: return true
+            val currentSpan = binarySearchSpan(spansOnCurrentLine.filterNotNull(), currentColumn) ?: return true
+
+            val extra = currentSpan.extra
+
+            if (extra is Int) {
+                val index = Arrays.binarySearch(array, extra)
+                return index < 0
+            }
+
+            return true
+        }
+
+        private fun checkIndex(index: Int, max: Int): Int {
+            return Math.max(Math.min(index, max), 0)
+        }
+
+        private fun binarySearchSpan(spanList: List<Span>, column: Int): Span? {
+            if (spanList.isEmpty()) return null
+            var start = 0
+            var end = spanList.size - 1
+            val size = spanList.size - 1
+
+            while (start <= end) {
+                val middle = (start + end) / 2
+                val currentSpan = spanList[middle]
+                if (currentSpan.column == column) {
+                    return currentSpan
+                }
+
+                if (currentSpan.column < column) {
+                    val nextSpan = spanList[checkIndex(middle + 1, size)]
+                    if (nextSpan.column > column) {
+                        return currentSpan
+                    }
+                    start++
+                } else {
+                    val previousSpan = spanList[checkIndex(middle - 1, size)]
+                    if (previousSpan.column < column) {
+                        return currentSpan
+                    }
+                    end--
+                }
+            }
+            return spanList[Math.min(start, size)]
+        }
+
+        override fun shouldDoAutoSurround(content: Content): Boolean {
+            return isSurroundingPair && content.cursor.isSelected()
+        }
+    }
+
+    companion object {
+        private const val SURROUNDING_PAIR_FLAG = "surroundingPair"
+        private val SURROUNDING_PAIR_FLAG_LIST = listOf(SURROUNDING_PAIR_FLAG)
+    }
+}

package/android/sora-editor/{editor/src/main/java/io/github/abc15018045126/sora/event/EventReceiver.java → language-textmate/src/main/java/io/github/abc15018045126/sora/langs/textmate/folding/FoldingHelper.kt}

@@ -18,16 +18,17 @@
  *     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 io.github.abc15018045126.sora.event;
+package io.github.abc15018045126.sora.langs.textmate.folding
 
-import androidx.annotation.NonNull;
+import org.eclipse.tm4e.core.internal.oniguruma.OnigResult
 
-public interface EventReceiver<T extends Event> {
+interface FoldingHelper {
 
-    void onReceive(@NonNull T event, @NonNull Unsubscribe unsubscribe);
+    fun getResultFor(line: Int): OnigResult?
 
-}
+    fun getIndentFor(line: Int): Int
 
+}

package/android/sora-editor/{editor/src/main/java/io/github/abc15018045126/sora/util/MutableInt.java → language-textmate/src/main/java/io/github/abc15018045126/sora/langs/textmate/folding/FoldingRegion.kt}

@@ -18,26 +18,24 @@
  *     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 io.github.abc15018045126.sora.util;
+package io.github.abc15018045126.sora.langs.textmate.folding
 
-public class MutableInt {
+class FoldingRegion(private val ranges: FoldingRegions, private val index: Int) {
 
-    public int value;
+    val startLineNumber: Int
+        get() = this.ranges.getStartLineNumber(this.index)
 
-    public MutableInt(int v) {
-        value = v;
-    }
+    val endLineNumber: Int
+        get() = this.ranges.getEndLineNumber(this.index)
 
-    public int decreaseAndGet() {
-        return --value;
-    }
+    val regionIndex: Int
+        get() = this.index
 
-    public void increase() {
-        value++;
+    @Throws(Exception::class)
+    fun getParentIndex(): Int {
+        return this.ranges.getParentIndex(this.index)
     }
-
 }
-

package/android/sora-editor/language-textmate/src/main/java/io/github/abc15018045126/sora/langs/textmate/folding/FoldingRegions.kt

@@ -0,0 +1,93 @@
+/*
+ *    sora-editor - the awesome code editor for Android
+ *    https://github.com/abc15018045126/sora-editor
+ *    Copyright (C) 2020-2024  abc15018045126
+ *
+ *     This library is free software; you can redistribute it and/or
+ *     modify it under the terms of the GNU Lesser General Public
+ *     License as published by the Free Software Foundation; either
+ *     version 2.1 of the License, or (at your option) any later version.
+ *
+ *     This library is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *     Lesser General Public License for more details.
+ *
+ *     You should have received a copy of the GNU Lesser General Public
+ *     License along with this library; if not, write to the Free Software
+ *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+ *     USA
+ *
+ *     Please contact abc15018045126 by email abc15018045126@gmail.com if you need
+ *     additional information or have any questions
+ */
+package io.github.abc15018045126.sora.langs.textmate.folding
+
+import android.util.SparseIntArray
+import java.util.Stack
+
+class FoldingRegions(private val _startIndexes: SparseIntArray, private val _endIndexes: SparseIntArray) {
+    private var _parentsComputed: Boolean = false
+
+    init {
+        if (_startIndexes.size() != _endIndexes.size() || _startIndexes.size() > IndentRange.MAX_FOLDING_REGIONS) {
+            throw Exception("invalid startIndexes or endIndexes size")
+        }
+        this._parentsComputed = false
+    }
+
+    fun length(): Int {
+        return this._startIndexes.size()
+    }
+
+    fun getStartLineNumber(index: Int): Int {
+        return this._startIndexes.get(index) and IndentRange.MAX_LINE_NUMBER
+    }
+
+    fun getEndLineNumber(index: Int): Int {
+        return this._endIndexes.get(index) and IndentRange.MAX_LINE_NUMBER
+    }
+
+
+    fun toRegion(index: Int): FoldingRegion {
+        return FoldingRegion(this, index)
+    }
+
+    private fun isInsideLast(parentIndexes: Stack<Int>, startLineNumber: Int, endLineNumber: Int): Boolean {
+        val index = parentIndexes[parentIndexes.size - 1]
+        return this.getStartLineNumber(index) <= startLineNumber && this.getEndLineNumber(index) >= endLineNumber
+
+    }
+
+    @Throws(Exception::class)
+    private fun ensureParentIndices() {
+        if (!this._parentsComputed) {
+            this._parentsComputed = true
+            val parentIndexes = Stack<Int>()
+            for (i in 0 until this._startIndexes.size()) {
+                val startLineNumber = this._startIndexes.get(i)
+                val endLineNumber = this._endIndexes.get(i)
+                if (startLineNumber > IndentRange.MAX_LINE_NUMBER || endLineNumber > IndentRange.MAX_LINE_NUMBER) {
+                    throw Exception("startLineNumber or endLineNumber must not exceed " + IndentRange.MAX_LINE_NUMBER)
+                }
+                while (parentIndexes.isNotEmpty() && !isInsideLast(parentIndexes, startLineNumber, endLineNumber)) {
+                    parentIndexes.pop()
+                }
+                val parentIndex = if (parentIndexes.isNotEmpty()) parentIndexes[parentIndexes.size - 1] else -1
+                parentIndexes.push(i)
+                this._startIndexes.put(i, startLineNumber + (parentIndex and 0xFF shl 24))
+                this._endIndexes.put(i, endLineNumber + (parentIndex and 0xFF00 shl 16))
+            }
+        }
+    }
+
+    @Throws(Exception::class)
+    fun getParentIndex(index: Int): Int {
+        this.ensureParentIndices()
+        val parent =
+            (this._startIndexes.get(index) and IndentRange.MASK_INDENT ushr 24) + (this._endIndexes.get(index) and IndentRange.MASK_INDENT ushr 16)
+        return if (parent == IndentRange.MAX_FOLDING_REGIONS) {
+            -1
+        } else parent
+    }
+}