capacitor-sora-editor 1.2.1 → 1.8.2

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

@@ -0,0 +1,156 @@
+package io.github.abc15018045126.sora.langs.textmate.folding
+
+import io.github.abc15018045126.sora.lang.analysis.AsyncIncrementalAnalyzeManager
+import io.github.abc15018045126.sora.text.Content
+import org.eclipse.tm4e.core.internal.oniguruma.OnigRegExp
+
+object IndentRange {
+    const val MAX_LINE_NUMBER = 0xFFFFFF
+    const val MAX_FOLDING_REGIONS = 0xFFFF
+    const val MASK_INDENT = -0x1000000
+
+    // START sora-editor note
+    // Change String to char[] and int
+    // END sora-editor note
+
+    @JvmStatic
+    fun computeStartColumn(line: CharArray, len: Int, tabSize: Int): Int {
+        var column = 0
+        var i = 0
+
+        while (i < len) {
+            val chCode = line[i]
+            if (chCode == ' ') {
+                column++
+            } else if (chCode == '\t') {
+                column += tabSize
+            } else {
+                break
+            }
+            i++
+        }
+
+        if (i == len) {
+            // line only consists of whitespace
+            return -1
+        }
+
+        return column
+    }
+
+    /**
+     * @return :
+     * - -1 => the line consists of whitespace
+     * - otherwise => the indent level is returned value
+     */
+    @JvmStatic
+    fun computeIndentLevel(line: CharArray, len: Int, tabSize: Int): Int {
+        var indent = 0
+        var i = 0
+
+        while (i < len) {
+            val chCode = line[i]
+            if (chCode == ' ') {
+                indent++
+            } else if (chCode == '\t') {
+                indent = indent - indent % tabSize + tabSize
+            } else {
+                break
+            }
+            i++
+        }
+
+        if (i == len) {
+            // line only consists of whitespace
+            return -1
+        }
+
+        return indent
+    }
+
+    @Throws(Exception::class)
+    @JvmStatic
+    fun computeRanges(
+        model: Content,
+        tabSize: Int,
+        offSide: Boolean,
+        helper: FoldingHelper,
+        pattern: OnigRegExp?,
+        delegate: AsyncIncrementalAnalyzeManager<*, *>.CodeBlockAnalyzeDelegate
+    ): FoldingRegions {
+
+        val result = RangesCollector(/*tabSize*/)
+
+        val previousRegions = ArrayList<PreviousRegion>()
+        var line = model.lineCount + 1
+        // sentinel, to make sure there's at least one entry
+        previousRegions.add(PreviousRegion(-1, line, line))
+
+        line = model.lineCount - 1
+        while (line >= 0 && delegate.isNotCancelled()) {
+            val indent =
+                helper.getIndentFor(line)//computeIndentLevel(model.getLine(line).getBackingCharArray(), model.getColumnCount(line), tabSize);
+            var previous = previousRegions[previousRegions.size - 1]
+            if (indent == -1) {
+                if (offSide) {
+                    // for offSide languages, empty lines are associated to the previous block
+                    // note: the next block is already written to the results, so this only
+                    // impacts the end position of the block before
+                    previous.endAbove = line
+                }
+                line--
+                continue // only whitespace
+            }
+            val m = if (pattern != null) helper.getResultFor(line) else null
+            if (pattern != null && m != null) {
+                // folding pattern match
+                if (m.count() >= 2) { // start pattern match
+                    // discard all regions until the folding pattern
+                    var i = previousRegions.size - 1
+                    while (i > 0 && previousRegions[i].indent != -2) {
+                        i--
+                    }
+                    if (i > 0) {
+                        //??? previousRegions.length = i + 1;
+                        previous = previousRegions[i]
+
+                        // new folding range from pattern, includes the end line
+                        result.insertFirst(line, previous.line, indent)
+                        previous.line = line
+                        previous.indent = indent
+                        previous.endAbove = line
+                        line--
+                        continue
+                    } else {
+                        // no end marker found, treat line as a regular line
+                    }
+                } else { // end pattern match
+                    previousRegions.add(PreviousRegion(-2, line, line))
+                    line--
+                    continue
+                }
+            }
+            if (previous.indent > indent) {
+                // discard all regions with larger indent
+                do {
+                    previousRegions.removeAt(previousRegions.size - 1)
+                    previous = previousRegions[previousRegions.size - 1]
+                } while (previous.indent > indent)
+
+                // new folding range
+                val endLineNumber = previous.endAbove - 1
+                if (endLineNumber - line >= 1) { // needs at east size 1
+                    result.insertFirst(line, endLineNumber, indent)
+                }
+            }
+            if (previous.indent == indent) {
+                previous.endAbove = line
+            } else { // previous.indent < indent
+                // new region with a bigger indent
+                previousRegions.add(PreviousRegion(indent, line, line))
+            }
+            line--
+        }
+        return result.toIndentRanges(model)
+    }
+}

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

@@ -0,0 +1,7 @@
+package io.github.abc15018045126.sora.langs.textmate.folding
+
+class PreviousRegion(// indent or -2 if a marker
+    @JvmField var indent: Int, // end line number for the region above
+    @JvmField var endAbove: Int, // start line of the region. Only used for marker regions.
+    @JvmField var line: Int
+)

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

@@ -0,0 +1,25 @@
+package io.github.abc15018045126.sora.langs.textmate.folding
+
+import android.util.SparseIntArray
+import io.github.abc15018045126.sora.text.Content
+
+class RangesCollector(/*int tabSize*/) {
+    private val _startIndexes: SparseIntArray = SparseIntArray()
+    private val _endIndexes: SparseIntArray = SparseIntArray()
+    private var _length: Int = 0
+
+    fun insertFirst(startLineNumber: Int, endLineNumber: Int, indent: Int) {
+        if (startLineNumber > IndentRange.MAX_LINE_NUMBER || endLineNumber > IndentRange.MAX_LINE_NUMBER) {
+            return
+        }
+        val index = this._length
+        this._startIndexes.put(index, startLineNumber)
+        this._endIndexes.put(index, endLineNumber)
+        this._length++
+    }
+
+    @Throws(Exception::class)
+    fun toIndentRanges(model: Content?): FoldingRegions {
+        return FoldingRegions(_startIndexes, _endIndexes)
+    }
+}

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

@@ -0,0 +1,53 @@
+package io.github.abc15018045126.sora.langs.textmate.registry
+
+import io.github.abc15018045126.sora.langs.textmate.registry.provider.FileResolver
+import java.io.InputStream
+
+class FileProviderRegistry private constructor() {
+
+    private val allFileResolvers = mutableListOf<FileResolver>()
+
+    init {
+        allFileResolvers.add(FileResolver.DEFAULT)
+    }
+
+    @Synchronized
+    fun addFileProvider(fileResolver: FileResolver) {
+        if (fileResolver != FileResolver.DEFAULT) {
+            allFileResolvers.add(fileResolver)
+        }
+    }
+
+    @Synchronized
+    fun removeFileProvider(fileResolver: FileResolver) {
+        if (fileResolver != FileResolver.DEFAULT) {
+            allFileResolvers.remove(fileResolver)
+        }
+    }
+
+    fun tryGetInputStream(path: String): InputStream? {
+        for (provider in allFileResolvers) {
+            val stream = provider.resolveStreamByPath(path)
+            if (stream != null) {
+                return stream
+            }
+        }
+        return null
+    }
+
+    fun dispose() {
+        for (provider in allFileResolvers) {
+            provider.dispose()
+        }
+        allFileResolvers.clear()
+    }
+
+    companion object {
+        private val _instance: FileProviderRegistry by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { 
+            FileProviderRegistry() 
+        }
+
+        @JvmStatic
+        fun getInstance(): FileProviderRegistry = _instance
+    }
+}

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

@@ -0,0 +1,222 @@
+package io.github.abc15018045126.sora.langs.textmate.registry
+
+import android.util.Pair
+import io.github.abc15018045126.sora.langs.textmate.registry.dsl.LanguageDefinitionListBuilder
+import io.github.abc15018045126.sora.langs.textmate.registry.model.GrammarDefinition
+import io.github.abc15018045126.sora.langs.textmate.registry.model.ThemeModel
+import io.github.abc15018045126.sora.langs.textmate.registry.reader.LanguageDefinitionReader
+import org.eclipse.tm4e.core.grammar.IGrammar
+import org.eclipse.tm4e.core.registry.Registry
+import org.eclipse.tm4e.languageconfiguration.internal.model.LanguageConfiguration
+import java.io.InputStreamReader
+
+class GrammarRegistry {
+
+    private var registry: Registry? = Registry()
+    private var parent: GrammarRegistry? = null
+
+    private val languageConfigurationMap = LinkedHashMap<String, LanguageConfiguration>()
+    private val scopeName2GrammarId = LinkedHashMap<String, Int>()
+    private val grammarFileName2ScopeName = LinkedHashMap<String, String>()
+    private val scopeName2GrammarDefinition = LinkedHashMap<String, GrammarDefinition>()
+
+    constructor()
+
+    constructor(parent: GrammarRegistry) {
+        this.parent = parent
+    }
+
+    private fun initThemeListener() {
+        val themeRegistry = ThemeRegistry.getInstance()
+        val themeChangeListener = ThemeRegistry.ThemeChangeListener { newTheme ->
+            try {
+                setTheme(newTheme)
+            } catch (e: Exception) {
+                throw RuntimeException(e)
+            }
+        }
+        if (!themeRegistry.hasListener(themeChangeListener)) {
+            themeRegistry.addListener(themeChangeListener)
+        }
+    }
+
+    @JvmOverloads
+    fun findGrammar(scopeName: String, findInParent: Boolean = true): IGrammar? {
+        val grammar = registry?.grammarForScopeName(scopeName)
+        if (grammar != null) {
+            return grammar
+        }
+        if (!findInParent) {
+            return null
+        }
+        return parent?.findGrammar(scopeName, true)
+    }
+
+    @Deprecated("The grammar file and language configuration file should in most cases be on local file")
+    @Synchronized
+    fun languageConfigurationToGrammar(languageConfiguration: LanguageConfiguration, grammar: IGrammar) {
+        languageConfigurationMap[grammar.scopeName] = languageConfiguration
+    }
+
+    @JvmOverloads
+    fun findLanguageConfiguration(scopeName: String, findInParent: Boolean = true): LanguageConfiguration? {
+        val languageConfiguration = languageConfigurationMap[scopeName]
+        if (languageConfiguration != null) {
+            return languageConfiguration
+        }
+        if (!findInParent) {
+            return null
+        }
+        return parent?.findLanguageConfiguration(scopeName, true)
+    }
+
+    fun loadLanguageAndLanguageConfiguration(grammarDefinition: GrammarDefinition): Pair<IGrammar, LanguageConfiguration> {
+        val grammar = loadGrammar(grammarDefinition)
+        val languageConfiguration = findLanguageConfiguration(grammar.scopeName, false)
+            ?: throw IllegalStateException("Language configuration not found for ${grammar.scopeName}")
+        return Pair.create(grammar, languageConfiguration)
+    }
+
+    fun loadGrammars(builder: LanguageDefinitionListBuilder): List<IGrammar> {
+        return loadGrammars(builder.build())
+    }
+
+    fun loadGrammars(list: List<GrammarDefinition>): List<IGrammar> {
+        prepareLoadGrammars(list)
+        return list.map { loadGrammar(it) }
+    }
+
+    fun loadGrammars(jsonPath: String): List<IGrammar> {
+        return loadGrammars(LanguageDefinitionReader.read(jsonPath))
+    }
+
+    @Synchronized
+    fun loadGrammar(grammarDefinition: GrammarDefinition): IGrammar {
+        val languageName = grammarDefinition.name
+        val scopeName = grammarDefinition.scopeName
+        if (grammarFileName2ScopeName.containsKey(languageName) && scopeName != null) {
+            val loaded = registry?.grammarForScopeName(scopeName)
+            if (loaded != null) return loaded
+        }
+
+        val grammar = doLoadGrammar(grammarDefinition)
+        if (scopeName != null) {
+            grammarFileName2ScopeName[languageName] = scopeName
+            scopeName2GrammarDefinition[grammar.scopeName] = grammarDefinition
+        }
+        return grammar
+    }
+
+    @Synchronized
+    private fun doLoadGrammar(grammarDefinition: GrammarDefinition): IGrammar {
+        val languageConfigurationPath = grammarDefinition.languageConfiguration
+        if (languageConfigurationPath != null) {
+            val languageConfigurationStream = FileProviderRegistry.getInstance()
+                .tryGetInputStream(languageConfigurationPath)
+            if (languageConfigurationStream != null) {
+                val languageConfiguration = LanguageConfiguration.load(
+                    InputStreamReader(languageConfigurationStream)
+                )
+                if (languageConfiguration != null) {
+                    languageConfigurationMap[grammarDefinition.scopeName!!] = languageConfiguration
+                }
+            }
+        }
+
+        val reg = registry ?: throw IllegalStateException("Registry is disposed")
+        val grammar: IGrammar
+        if (grammarDefinition.embeddedLanguages.isEmpty()) {
+            grammar = reg.addGrammar(grammarDefinition.grammar)
+        } else {
+            grammar = reg.addGrammar(
+                grammarDefinition.grammar,
+                null,
+                getOrPullGrammarId(grammarDefinition.scopeName!!),
+                findGrammarIds(grammarDefinition.embeddedLanguages)
+            )
+        }
+
+        val targetScopeName = grammarDefinition.scopeName
+        if (targetScopeName != null && grammar.scopeName != targetScopeName) {
+            throw IllegalStateException(
+                "The scope name loaded by the grammar file does not match the declared scope name, it should be $targetScopeName instead of ${grammar.scopeName}"
+            )
+        }
+        return grammar
+    }
+
+    private fun prepareLoadGrammars(grammarDefinitions: List<GrammarDefinition>) {
+        for (grammar in grammarDefinitions) {
+            grammar.scopeName?.let { getOrPullGrammarId(it) }
+        }
+    }
+
+    @Synchronized
+    @Throws(Exception::class)
+    fun setTheme(themeModel: ThemeModel) {
+        val reg = registry ?: throw IllegalStateException("Registry is disposed")
+        if (!themeModel.isLoaded) {
+            themeModel.load(reg.colorMap)
+        }
+        reg.setTheme(themeModel.theme)
+    }
+
+    @Synchronized
+    private fun getOrPullGrammarId(scopeName: String): Int {
+        var id = scopeName2GrammarId[scopeName]
+        if (id == null) {
+            id = scopeName2GrammarId.size + 2
+        }
+        scopeName2GrammarId[scopeName] = id
+        return id
+    }
+
+    @Synchronized
+    private fun findGrammarIds(scopeName2LanguageName: Map<String, String>): Map<String, Int> {
+        val result = HashMap<String, Int>()
+        for ((key, value) in scopeName2LanguageName) {
+            result[key] = getOrPullGrammarId(getGrammarScopeName(value))
+        }
+        return result
+    }
+
+    private fun getGrammarScopeName(name: String): String {
+        if (scopeName2GrammarDefinition.containsKey(name)) {
+            return name
+        }
+        val grammarName = grammarFileName2ScopeName[name]
+        return grammarName ?: name
+    }
+
+    @Synchronized
+    @JvmOverloads
+    fun dispose(closeParent: Boolean = false) {
+        if (registry == null) {
+            return
+        }
+        registry = null
+        grammarFileName2ScopeName.clear()
+        languageConfigurationMap.clear()
+        scopeName2GrammarId.clear()
+        scopeName2GrammarDefinition.clear()
+
+        if (parent != null && closeParent) {
+            parent?.dispose(true)
+        }
+    }
+
+    companion object {
+        @get:Synchronized
+        private var internalInstance: GrammarRegistry? = null
+            get() {
+                if (field == null) {
+                    field = GrammarRegistry()
+                    field!!.initThemeListener()
+                }
+                return field
+            }
+
+        @JvmStatic
+        fun getInstance(): GrammarRegistry = internalInstance!!
+    }
+}

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

@@ -0,0 +1,121 @@
+package io.github.abc15018045126.sora.langs.textmate.registry
+
+import io.github.abc15018045126.sora.langs.textmate.registry.model.ThemeModel
+import org.eclipse.tm4e.core.registry.IThemeSource
+
+class ThemeRegistry {
+
+    private val allListener = mutableListOf<ThemeChangeListener>()
+    private val allThemeModel = mutableListOf<ThemeModel>()
+
+    var currentThemeModel: ThemeModel = ThemeModel.EMPTY
+        private set
+
+    @Throws(Exception::class)
+    @JvmOverloads
+    fun loadTheme(themeSource: IThemeSource, isCurrentTheme: Boolean = true) {
+        loadTheme(ThemeModel(themeSource), isCurrentTheme)
+    }
+
+    @Throws(Exception::class)
+    @JvmOverloads
+    fun loadTheme(themeModel: ThemeModel, isCurrentTheme: Boolean = true) {
+        synchronized(this) {
+            if (!themeModel.isLoaded) {
+                themeModel.load()
+            }
+            val theme = findThemeByThemeName(themeModel.name)
+            if (theme != null) {
+                setTheme(theme)
+                return
+            }
+            allThemeModel.add(themeModel)
+            if (isCurrentTheme) {
+                setTheme(themeModel)
+            }
+        }
+    }
+
+    fun findThemeByFileName(name: String): ThemeModel? {
+        return allThemeModel.find { it.name == name }
+    }
+
+    fun findThemeByThemeName(name: String): ThemeModel? {
+        return allThemeModel.find { it.rawTheme?.name == name }
+    }
+
+    @Synchronized
+    fun setTheme(name: String): Boolean {
+        var targetModel = findThemeByFileName(name)
+        if (targetModel != null) {
+            setTheme(targetModel)
+            return true
+        }
+        targetModel = findThemeByThemeName(name)
+        if (targetModel != null) {
+            setTheme(targetModel)
+            return true
+        }
+        return false
+    }
+
+    fun setTheme(theme: ThemeModel) {
+        currentThemeModel = theme
+        if (!allThemeModel.contains(theme)) {
+            allThemeModel.add(theme)
+        }
+        if (!theme.isLoaded) {
+            try {
+                theme.load()
+            } catch (e: Exception) {
+                throw RuntimeException(e)
+            }
+        }
+        dispatchThemeChange(currentThemeModel)
+    }
+
+    private fun dispatchThemeChange(targetThemeModel: ThemeModel) {
+        val listeners = synchronized(this) { allListener.toList() }
+        for (listener in listeners) {
+            listener.onChangeTheme(targetThemeModel)
+        }
+    }
+
+    fun hasListener(themeChangeListener: ThemeChangeListener): Boolean {
+        return synchronized(this) { allListener.contains(themeChangeListener) }
+    }
+
+    @Synchronized
+    fun addListener(themeChangeListener: ThemeChangeListener) {
+        allListener.add(themeChangeListener)
+    }
+
+    @Synchronized
+    fun removeListener(themeChangeListener: ThemeChangeListener) {
+        allListener.remove(themeChangeListener)
+    }
+
+    fun dispose() {
+        synchronized(this) {
+            allListener.clear()
+        }
+    }
+
+    fun interface ThemeChangeListener {
+        fun onChangeTheme(newTheme: ThemeModel)
+    }
+
+    companion object {
+        @get:Synchronized
+        private var internalInstance: ThemeRegistry? = null
+            get() {
+                if (field == null) {
+                    field = ThemeRegistry()
+                }
+                return field
+            }
+
+        @JvmStatic
+        fun getInstance(): ThemeRegistry = internalInstance!!
+    }
+}

package/android/sora-editor/language-textmate/src/main/java/io/github/abc15018045126/sora/langs/textmate/registry/dsl/GrammarDefinitionDSL.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/language-textmate/src/main/java/io/github/abc15018045126/sora/langs/textmate/registry/model/DefaultGrammarDefinition.kt

@@ -0,0 +1,68 @@
+package io.github.abc15018045126.sora.langs.textmate.registry.model
+
+import io.github.abc15018045126.sora.langs.textmate.utils.StringUtils
+import org.eclipse.tm4e.core.registry.IGrammarSource
+
+class DefaultGrammarDefinition private constructor(
+    override val name: String,
+    override val scopeName: String?,
+    override val grammar: IGrammarSource,
+    override val languageConfiguration: String?,
+    private val _embeddedLanguages: Map<String, String>? = null
+) : GrammarDefinition {
+
+    override val embeddedLanguages: Map<String, String>
+        get() = _embeddedLanguages ?: emptyMap()
+
+    fun withEmbeddedLanguages(embeddedLanguages: Map<String, String>?): GrammarDefinition {
+        if (embeddedLanguages == null) {
+            return this
+        }
+        return DefaultGrammarDefinition(
+            this.name, this.scopeName,
+            this.grammar, this.languageConfiguration,
+            embeddedLanguages
+        )
+    }
+
+    companion object {
+        @JvmStatic
+        fun withGrammarSource(grammarSource: IGrammarSource): DefaultGrammarDefinition {
+            val languageNameByPath = StringUtils.getFileNameWithoutExtension(grammarSource.filePath)
+            return withGrammarSource(grammarSource, languageNameByPath, "source.$languageNameByPath")
+        }
+
+        @JvmStatic
+        fun withLanguageConfiguration(
+            grammarSource: IGrammarSource,
+            languageConfigurationPath: String
+        ): DefaultGrammarDefinition {
+            val languageNameByPath = StringUtils.getFileNameWithoutExtension(grammarSource.filePath)
+            return withLanguageConfiguration(
+                grammarSource,
+                languageConfigurationPath,
+                languageNameByPath,
+                "source.$languageNameByPath"
+            )
+        }
+
+        @JvmStatic
+        fun withLanguageConfiguration(
+            grammarSource: IGrammarSource,
+            languageConfigurationPath: String?,
+            languageName: String,
+            scopeName: String?
+        ): DefaultGrammarDefinition {
+            return DefaultGrammarDefinition(languageName, scopeName, grammarSource, languageConfigurationPath)
+        }
+
+        @JvmStatic
+        fun withGrammarSource(
+            grammarSource: IGrammarSource,
+            languageName: String,
+            scopeName: String?
+        ): DefaultGrammarDefinition {
+            return DefaultGrammarDefinition(languageName, scopeName, grammarSource, null)
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+package io.github.abc15018045126.sora.langs.textmate.registry.model
+
+import org.eclipse.tm4e.core.registry.IGrammarSource
+
+interface GrammarDefinition {
+    val name: String
+    val languageConfiguration: String?
+    val scopeName: String?
+    val embeddedLanguages: Map<String, String>
+        get() = emptyMap()
+    val grammar: IGrammarSource
+}