AndyG

open class Node {
  
  private var children: MutableCollection<Node>? = null
  
  fun getChildren(): Collection<Node>? = children
  
  fun hasChildren(): Boolean = children?.isNotEmpty() == true
  
  fun addChild(child: Node) {
    children = (children ?: ArrayList()).apply {

AndyG

abstract class Rule(val pattern: Pattern) {
  abstract fun parse(matcher: Matcher, parser: Parser): Node
}

AndyG

class Parser(private val rules: List<Rule>) {

  fun parse(source: CharSequence): List<Node> {
    val ast = ArrayList<Node>()
    var mutableSource = source

    while (mutableSource.isNotEmpty()) {      
      
      // Find a rule that matches the source.
      for (rule in rules) {

AndyG

for (rule in rules) {
  val matcher = rule.pattern.matcher(mutableSource)
  if (matcher.find()) {
    // Do stuff with the rule that matched the text
  }
}

AndyG

for (rule in rules) {
  val matcher = rule.matcher.reset(mutableSource) // Faster than creating a new Matcher
  if (matcher.find()) {
    // Do stuff with the rule that matched the text
  }
}

AndyG

class TextNode(val content: String) : SpannableRenderableNode() {
  override fun render(builder: SpannableStringBuilder, context: Context?) {
    builder.append(content)
  }
}

AndyG

class StyleNode(val styles: List<CharacterStyle>) : SpannableRenderableNode() {
  override fun render(builder: SpannableStringBuilder, context: Context?) {
    // No matter what happens in this world, never forget where you came from.
    val startIndex = builder.length

    // First render all child nodes, as these are the nodes we want to apply the styles to.
    getChildren()?.forEach { (it as SpannableRenderableNode).render(builder, context) }

    styles.forEach { builder.setSpan(it, startIndex, builder.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE) }
  }

AndyG

// Matches: **This text should be bold.**
val PATTERN_BOLD = Pattern.compile("^\\*\\*([\\s\\S]+?)\\*\\*(?!\\*)")

class BoldRule : Parser.Rule(PATTERN_BOLD) {
  override fun parse(matcher: Matcher, parser: Parser): Node {
    val boldSpan = StyleSpan(Typeface.BOLD)
    
    // Recursively parse inside the **delimiters**
    val childNodes = parser.parse(matcher.group(1))
    return StyleNode(StyleSpan(Typeface.BOLD, childNodes))

AndyG

// **This text should be bold.**
val PATTERN_BOLD = Pattern.compile("^\\*\\*([\\s\\S]+?)\\*\\*(?!\\*)")

class BoldRule : Rule(PATTERN_BOLD) {
  override fun parse(matcher: Matcher, parser: Parser): ParseSpec {
    val boldNode = StyleNode(StyleSpan(Typeface.BOLD))
    val innerParseStartIndex = matcher.start(1)
    val innerParseEndIndex = matcher.end(1)

    // Don't actually recursively parse, just return a ParseSpec that informs the Parser

AndyG

" Allow filetype-specific plugins.
filetype plugin on

" Update faster (mainly for git stuff).
set updatetime=100

" Split navigation with tab and backspace.
nnoremap <Tab> <c-w>w
nnoremap <bs> <c-w>W