gosora/extend/plugin_markdown.go

package extend

import (
	"strings"

	c "git.tuxpa.in/a/gosora/common"
)

var markdownMaxDepth = 25 // How deep the parser will go when parsing Markdown strings
var markdownUnclosedElement []byte

var markdownBoldTagOpen []byte
var markdownBoldTagClose []byte
var markdownItalicTagOpen []byte
var markdownItalicTagClose []byte
var markdownUnderlineTagOpen []byte
var markdownUnderlineTagClose []byte
var markdownStrikeTagOpen []byte
var markdownStrikeTagClose []byte
var markdownQuoteTagOpen []byte
var markdownQuoteTagClose []byte
var markdownSpoilerTagOpen []byte
var markdownSpoilerTagClose []byte
var markdownH1TagOpen []byte
var markdownH1TagClose []byte

func init() {
    c.Plugins.Add(&c.Plugin{UName: "markdown", Name: "Markdown", Author: "Azareal", URL: "https://github.com/Azareal", Init: InitMarkdown, Deactivate: deactivateMarkdown})
}

func InitMarkdown(pl *c.Plugin) error {
    markdownUnclosedElement = []byte("<red>[Unclosed Element]</red>")

    markdownBoldTagOpen = []byte("<b>")
    markdownBoldTagClose = []byte("</b>")
    markdownItalicTagOpen = []byte("<i>")
    markdownItalicTagClose = []byte("</i>")
    markdownUnderlineTagOpen = []byte("<u>")
    markdownUnderlineTagClose = []byte("</u>")
    markdownStrikeTagOpen = []byte("<s>")
    markdownStrikeTagClose = []byte("</s>")
    markdownQuoteTagOpen = []byte("<blockquote>")
    markdownQuoteTagClose = []byte("</blockquote>")
    markdownSpoilerTagOpen = []byte("<spoiler>")
    markdownSpoilerTagClose = []byte("</spoiler>")
    markdownH1TagOpen = []byte("<h2>")
    markdownH1TagClose = []byte("</h2>")

    pl.AddHook("parse_assign", MarkdownParse)
    return nil
}

func deactivateMarkdown(pl *c.Plugin) {
    pl.RemoveHook("parse_assign", MarkdownParse)
}

// An adapter for the parser, so that the parser can call itself recursively.
// This is less for the simple Markdown elements like bold and italics and more for the really complicated ones I plan on adding at some point.
func MarkdownParse(msg string) string {
    msg = _markdownParse(msg+" ", 0)
    if msg[len(msg)-1] == ' ' {
        msg = msg[:len(msg)-1]
    }
    return msg
}

// Under Construction!
func _markdownParse(msg string, n int) string {
    if n > markdownMaxDepth {
        return "<red>[Markdown Error: Overflowed the max depth of 20]</red>"
    }

    var outbytes []byte
    var lastElement int
    breaking := false
    //c.DebugLogf("Initial Msg: %+v\n", strings.Replace(msg, "\r", "\\r", -1))

    for index := 0; index < len(msg); index++ {
        simpleMatch := func(char byte, o []byte, c []byte) {
            startIndex := index
            if (index + 1) >= len(msg) {
                breaking = true
                return
            }

            index++
            index = markdownSkipUntilChar(msg, index, char)
            if (index-(startIndex+1)) < 1 || index >= len(msg) {
                breaking = true
                return
            }

            sIndex := startIndex + 1
            lIndex := index
            index++

            outbytes = append(outbytes, msg[lastElement:startIndex]...)
            outbytes = append(outbytes, o...)
            // TODO: Implement this without as many type conversions
            outbytes = append(outbytes, []byte(_markdownParse(msg[sIndex:lIndex], n+1))...)
            outbytes = append(outbytes, c...)

            lastElement = index
            index--
        }

        startLine := func() {
            startIndex := index
            if (index + 1) >= len(msg) /*|| (index + 2) >= len(msg)*/ {
                breaking = true
                return
            }
            index++

            index = markdownSkipUntilNotChar(msg, index, 32)
            if (index + 1) >= len(msg) {
                breaking = true
                return
            }
            //index++

            index = markdownSkipUntilStrongSpace(msg, index)
            sIndex := startIndex + 1
            lIndex := index
            index++

            outbytes = append(outbytes, msg[lastElement:startIndex]...)
            outbytes = append(outbytes, markdownH1TagOpen...)
            // TODO: Implement this without as many type conversions
            //fmt.Println("msg[sIndex:lIndex]:", string(msg[sIndex:lIndex]))
            // TODO: Quick hack to eliminate trailing spaces...
            outbytes = append(outbytes, []byte(strings.TrimSpace(_markdownParse(msg[sIndex:lIndex], n+1)))...)
            outbytes = append(outbytes, markdownH1TagClose...)

            lastElement = index
            index--
        }

        uniqueWord := func(i int) bool {
            if i == 0 {
                return true
            }
            return msg[i-1] <= 32
        }

        switch msg[index] {
        // TODO: Do something slightly less hacky for skipping URLs
        case '/':
            if len(msg) > (index+2) && msg[index+1] == '/' {
                for ; index < len(msg) && msg[index] != ' '; index++ {
                }
                index--
                continue
            }
        case '_':
            if !uniqueWord(index) {
                break
            }
            simpleMatch('_', markdownUnderlineTagOpen, markdownUnderlineTagClose)
            if breaking {
                break
            }
        case '~':
            simpleMatch('~', markdownStrikeTagOpen, markdownStrikeTagClose)
            if breaking {
                break
            }
        case '*':
            startIndex := index
            italic := true
            bold := false
            if (index + 2) < len(msg) {
                if msg[index+1] == '*' {
                    bold = true
                    index++
                    if msg[index+1] != '*' {
                        italic = false
                    } else {
                        index++
                    }
                }
            }

            // Does the string terminate abruptly?
            if (index + 1) >= len(msg) {
                break
            }
            index++

            index = markdownSkipUntilAsterisk(msg, index)
            if index >= len(msg) {
                break
            }

            preBreak := func() {
                outbytes = append(outbytes, msg[lastElement:startIndex]...)
                lastElement = startIndex
            }

            sIndex := startIndex
            lIndex := index
            if bold && italic {
                if (index + 3) >= len(msg) {
                    preBreak()
                    break
                }
                index += 3
                sIndex += 3
            } else if bold {
                if (index + 2) >= len(msg) {
                    preBreak()
                    break
                }
                index += 2
                sIndex += 2
            } else {
                if (index + 1) >= len(msg) {
                    preBreak()
                    break
                }
                index++
                sIndex++
            }

            if lIndex <= sIndex {
                preBreak()
                break
            }
            if sIndex < 0 || lIndex < 0 {
                preBreak()
                break
            }
            outbytes = append(outbytes, msg[lastElement:startIndex]...)

            if bold {
                outbytes = append(outbytes, markdownBoldTagOpen...)
            }
            if italic {
                outbytes = append(outbytes, markdownItalicTagOpen...)
            }

            // TODO: Implement this without as many type conversions
            outbytes = append(outbytes, []byte(_markdownParse(msg[sIndex:lIndex], n+1))...)

            if italic {
                outbytes = append(outbytes, markdownItalicTagClose...)
            }
            if bold {
                outbytes = append(outbytes, markdownBoldTagClose...)
            }

            lastElement = index
            index--
        case '\\':
            if (index + 1) < len(msg) {
                if isMarkdownStartChar(msg[index+1]) && msg[index+1] != '\\' {
                    outbytes = append(outbytes, msg[lastElement:index]...)
                    index++
                    lastElement = index
                }
            }
        // TODO: Add a inline quote variant
        case '`':
            simpleMatch('`', markdownQuoteTagOpen, markdownQuoteTagClose)
            if breaking {
                break
            }
        // TODO: Might need to be double pipe
        case '|':
            simpleMatch('|', markdownSpoilerTagOpen, markdownSpoilerTagClose)
            if breaking {
                break
            }
        case 10: // newline
            if (index + 1) >= len(msg) {
                break
            }
            index++

            if msg[index] != '#' {
                continue
            }
            startLine()
            if breaking {
                break
            }
        case '#':
            if index != 0 {
                continue
            }
            startLine()
            if breaking {
                break
            }
        }
    }

    if len(outbytes) == 0 {
        return msg
    } else if lastElement < (len(msg) - 1) {
        msg = string(outbytes) + msg[lastElement:]
        return msg
    }
    return string(outbytes)
}

func isMarkdownStartChar(ch byte) bool { // char
    return ch == '\\' || ch == '~' || ch == '_' || ch == 10 || ch == '`' || ch == '*' || ch == '|'
}

func markdownFindChar(data string, index int, char byte) bool {
    for ; index < len(data); index++ {
        item := data[index]
        if item > 32 {
            return (item == char)
        }
    }
    return false
}

func markdownSkipUntilChar(data string, index int, char byte) int {
    for ; index < len(data); index++ {
        if data[index] == char {
            break
        }
    }
    return index
}

func markdownSkipUntilNotChar(data string, index int, char byte) int {
    for ; index < len(data); index++ {
        if data[index] != char {
            break
        }
    }
    return index
}

func markdownSkipUntilStrongSpace(data string, index int) int {
    inSpace := false
    for ; index < len(data); index++ {
        if inSpace && data[index] == 32 {
            index--
            break
        } else if data[index] == 32 {
            inSpace = true
        } else if data[index] < 32 {
            break
        } else {
            inSpace = false
        }
    }
    return index
}

func markdownSkipUntilAsterisk(data string, index int) int {
SwitchLoop:
    for ; index < len(data); index++ {
        switch data[index] {
        case 10:
            if ((index + 1) < len(data)) && markdownFindChar(data, index, '*') {
                index = markdownSkipList(data, index)
            }
        case '*':
            break SwitchLoop
        }
    }
    return index
}

// plugin_markdown doesn't support lists yet, but I want it to be easy to have nested lists when we do have them
func markdownSkipList(data string, index int) int {
    var lastNewline int
    datalen := len(data)
    for ; index < datalen; index++ {
    SkipListInnerLoop:
        if data[index] == 10 {
            lastNewline = index
            for ; index < datalen; index++ {
                if data[index] > 32 {
                    break
                } else if data[index] == 10 {
                    goto SkipListInnerLoop
                }
            }
            if index >= datalen {
                if data[index] != '*' && data[index] != '-' {
                    if (lastNewline + 1) < datalen {
                        return lastNewline + 1
                    }
                    return lastNewline
                }
            }
        }
    }

    return index
}