413 lines
11 KiB
Go
413 lines
11 KiB
Go
package extend
|
|
|
|
import (
|
|
"bytes"
|
|
"math/rand"
|
|
"regexp"
|
|
"strconv"
|
|
"time"
|
|
|
|
c "github.com/Azareal/Gosora/common"
|
|
)
|
|
|
|
var bbcodeRandom *rand.Rand
|
|
var bbcodeInvalidNumber []byte
|
|
var bbcodeNoNegative []byte
|
|
var bbcodeMissingTag []byte
|
|
|
|
var bbcodeBold *regexp.Regexp
|
|
var bbcodeItalic *regexp.Regexp
|
|
var bbcodeUnderline *regexp.Regexp
|
|
var bbcodeStrike *regexp.Regexp
|
|
var bbcodeH1 *regexp.Regexp
|
|
var bbcodeURL *regexp.Regexp
|
|
var bbcodeURLLabel *regexp.Regexp
|
|
var bbcodeQuotes *regexp.Regexp
|
|
var bbcodeCode *regexp.Regexp
|
|
var bbcodeSpoiler *regexp.Regexp
|
|
|
|
func init() {
|
|
c.Plugins.Add(&c.Plugin{UName: "bbcode", Name: "BBCode", Author: "Azareal", URL: "https://github.com/Azareal", Init: InitBbcode, Deactivate: deactivateBbcode})
|
|
}
|
|
|
|
func InitBbcode(pl *c.Plugin) error {
|
|
pl.AddHook("parse_assign", BbcodeFullParse)
|
|
|
|
bbcodeInvalidNumber = []byte("<red>[Invalid Number]</red>")
|
|
bbcodeNoNegative = []byte("<red>[No Negative Numbers]</red>")
|
|
bbcodeMissingTag = []byte("<red>[Missing Tag]</red>")
|
|
|
|
bbcodeBold = regexp.MustCompile(`(?s)\[b\](.*)\[/b\]`)
|
|
bbcodeItalic = regexp.MustCompile(`(?s)\[i\](.*)\[/i\]`)
|
|
bbcodeUnderline = regexp.MustCompile(`(?s)\[u\](.*)\[/u\]`)
|
|
bbcodeStrike = regexp.MustCompile(`(?s)\[s\](.*)\[/s\]`)
|
|
bbcodeH1 = regexp.MustCompile(`(?s)\[h1\](.*)\[/h1\]`)
|
|
urlpattern := `(http|https|ftp|mailto*)(:??)\/\/([\.a-zA-Z\/]+)`
|
|
bbcodeURL = regexp.MustCompile(`\[url\]` + urlpattern + `\[/url\]`)
|
|
bbcodeURLLabel = regexp.MustCompile(`(?s)\[url=` + urlpattern + `\](.*)\[/url\]`)
|
|
bbcodeQuotes = regexp.MustCompile(`\[quote\](.*)\[/quote\]`)
|
|
bbcodeCode = regexp.MustCompile(`\[code\](.*)\[/code\]`)
|
|
bbcodeSpoiler = regexp.MustCompile(`\[spoiler\](.*)\[/spoiler\]`)
|
|
|
|
bbcodeRandom = rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
return nil
|
|
}
|
|
|
|
func deactivateBbcode(pl *c.Plugin) {
|
|
pl.RemoveHook("parse_assign", BbcodeFullParse)
|
|
}
|
|
|
|
func BbcodeRegexParse(msg string) string {
|
|
msg = bbcodeBold.ReplaceAllString(msg, "<b>$1</b>")
|
|
msg = bbcodeItalic.ReplaceAllString(msg, "<i>$1</i>")
|
|
msg = bbcodeUnderline.ReplaceAllString(msg, "<u>$1</u>")
|
|
msg = bbcodeStrike.ReplaceAllString(msg, "<s>$1</s>")
|
|
msg = bbcodeURL.ReplaceAllString(msg, "<a href=''$1$2//$3' rel='ugc'>$1$2//$3</i>")
|
|
msg = bbcodeURLLabel.ReplaceAllString(msg, "<a href=''$1$2//$3' rel='ugc'>$4</i>")
|
|
msg = bbcodeQuotes.ReplaceAllString(msg, "<blockquote>$1</blockquote>")
|
|
msg = bbcodeSpoiler.ReplaceAllString(msg, "<spoiler>$1</spoiler>")
|
|
msg = bbcodeH1.ReplaceAllString(msg, "<h2>$1</h2>")
|
|
//msg = bbcodeCode.ReplaceAllString(msg,"<span class='codequotes'>$1</span>")
|
|
return msg
|
|
}
|
|
|
|
// Only does the simple BBCode like [u], [b], [i] and [s]
|
|
func bbcodeSimpleParse(msg string) string {
|
|
var hasU, hasB, hasI, hasS bool
|
|
mbytes := []byte(msg)
|
|
for i := 0; (i + 2) < len(mbytes); i++ {
|
|
if mbytes[i] == '[' && mbytes[i+2] == ']' {
|
|
ch := mbytes[i+1]
|
|
if ch == 'b' && !hasB {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasB = true
|
|
} else if ch == 'i' && !hasI {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasI = true
|
|
} else if ch == 'u' && !hasU {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasU = true
|
|
} else if ch == 's' && !hasS {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasS = true
|
|
}
|
|
i += 2
|
|
}
|
|
}
|
|
|
|
// There's an unclosed tag in there x.x
|
|
if hasI || hasU || hasB || hasS {
|
|
closeUnder := []byte("</u>")
|
|
closeItalic := []byte("</i>")
|
|
closeBold := []byte("</b>")
|
|
closeStrike := []byte("</s>")
|
|
if hasI {
|
|
mbytes = append(mbytes, closeItalic...)
|
|
}
|
|
if hasU {
|
|
mbytes = append(mbytes, closeUnder...)
|
|
}
|
|
if hasB {
|
|
mbytes = append(mbytes, closeBold...)
|
|
}
|
|
if hasS {
|
|
mbytes = append(mbytes, closeStrike...)
|
|
}
|
|
}
|
|
return string(mbytes)
|
|
}
|
|
|
|
// Here for benchmarking purposes. Might add a plugin setting for disabling [code] as it has it's paws everywhere
|
|
func BbcodeParseWithoutCode(msg string) string {
|
|
var hasU, hasB, hasI, hasS bool
|
|
var complexBbc bool
|
|
mbytes := []byte(msg)
|
|
for i := 0; (i + 3) < len(mbytes); i++ {
|
|
if mbytes[i] == '[' {
|
|
if mbytes[i+2] != ']' {
|
|
if mbytes[i+1] == '/' {
|
|
if mbytes[i+3] == ']' {
|
|
switch mbytes[i+2] {
|
|
case 'b':
|
|
mbytes[i] = '<'
|
|
mbytes[i+3] = '>'
|
|
hasB = false
|
|
case 'i':
|
|
mbytes[i] = '<'
|
|
mbytes[i+3] = '>'
|
|
hasI = false
|
|
case 'u':
|
|
mbytes[i] = '<'
|
|
mbytes[i+3] = '>'
|
|
hasU = false
|
|
case 's':
|
|
mbytes[i] = '<'
|
|
mbytes[i+3] = '>'
|
|
hasS = false
|
|
}
|
|
i += 3
|
|
} else {
|
|
complexBbc = true
|
|
}
|
|
} else {
|
|
complexBbc = true
|
|
}
|
|
} else {
|
|
ch := mbytes[i+1]
|
|
if ch == 'b' && !hasB {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasB = true
|
|
} else if ch == 'i' && !hasI {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasI = true
|
|
} else if ch == 'u' && !hasU {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasU = true
|
|
} else if ch == 's' && !hasS {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasS = true
|
|
}
|
|
i += 2
|
|
}
|
|
}
|
|
}
|
|
|
|
// There's an unclosed tag in there x.x
|
|
if hasI || hasU || hasB || hasS {
|
|
closeUnder := []byte("</u>")
|
|
closeItalic := []byte("</i>")
|
|
closeBold := []byte("</b>")
|
|
closeStrike := []byte("</s>")
|
|
if hasI {
|
|
mbytes = append(bytes.TrimSpace(mbytes), closeItalic...)
|
|
}
|
|
if hasU {
|
|
mbytes = append(bytes.TrimSpace(mbytes), closeUnder...)
|
|
}
|
|
if hasB {
|
|
mbytes = append(bytes.TrimSpace(mbytes), closeBold...)
|
|
}
|
|
if hasS {
|
|
mbytes = append(bytes.TrimSpace(mbytes), closeStrike...)
|
|
}
|
|
}
|
|
|
|
// Copy the new complex parser over once the rough edges have been smoothed over
|
|
if complexBbc {
|
|
msg = string(mbytes)
|
|
msg = bbcodeURL.ReplaceAllString(msg, "<a href='$1$2//$3' rel='ugc'>$1$2//$3</i>")
|
|
msg = bbcodeURLLabel.ReplaceAllString(msg, "<a href='$1$2//$3' rel='ugc'>$4</i>")
|
|
msg = bbcodeSpoiler.ReplaceAllString(msg, "<spoiler>$1</spoiler>")
|
|
msg = bbcodeQuotes.ReplaceAllString(msg, "<blockquote>$1</blockquote>")
|
|
return bbcodeCode.ReplaceAllString(msg, "<span class='codequotes'>$1</span>")
|
|
}
|
|
return string(mbytes)
|
|
}
|
|
|
|
// Does every type of BBCode
|
|
func BbcodeFullParse(msg string) string {
|
|
var hasU, hasB, hasI, hasS, hasC bool
|
|
var complexBbc bool
|
|
|
|
mbytes := []byte(msg)
|
|
mbytes = append(mbytes, c.SpaceGap...)
|
|
for i := 0; i < len(mbytes); i++ {
|
|
if mbytes[i] == '[' {
|
|
if mbytes[i+2] != ']' {
|
|
if mbytes[i+1] == '/' {
|
|
if mbytes[i+3] == ']' {
|
|
if !hasC {
|
|
switch mbytes[i+2] {
|
|
case 'b':
|
|
mbytes[i] = '<'
|
|
mbytes[i+3] = '>'
|
|
hasB = false
|
|
case 'i':
|
|
mbytes[i] = '<'
|
|
mbytes[i+3] = '>'
|
|
hasI = false
|
|
case 'u':
|
|
mbytes[i] = '<'
|
|
mbytes[i+3] = '>'
|
|
hasU = false
|
|
case 's':
|
|
mbytes[i] = '<'
|
|
mbytes[i+3] = '>'
|
|
hasS = false
|
|
}
|
|
i += 3
|
|
}
|
|
} else {
|
|
if mbytes[i+6] == ']' && mbytes[i+2] == 'c' && mbytes[i+3] == 'o' && mbytes[i+4] == 'd' && mbytes[i+5] == 'e' {
|
|
hasC = false
|
|
i += 7
|
|
}
|
|
complexBbc = true
|
|
}
|
|
} else {
|
|
// Put the biggest index first to avoid unnecessary bounds checks
|
|
if mbytes[i+5] == ']' && mbytes[i+1] == 'c' && mbytes[i+2] == 'o' && mbytes[i+3] == 'd' && mbytes[i+4] == 'e' {
|
|
hasC = true
|
|
i += 6
|
|
}
|
|
complexBbc = true
|
|
}
|
|
} else if !hasC {
|
|
ch := mbytes[i+1]
|
|
if ch == 'b' && !hasB {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasB = true
|
|
} else if ch == 'i' && !hasI {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasI = true
|
|
} else if ch == 'u' && !hasU {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasU = true
|
|
} else if ch == 's' && !hasS {
|
|
mbytes[i] = '<'
|
|
mbytes[i+2] = '>'
|
|
hasS = true
|
|
}
|
|
i += 2
|
|
}
|
|
}
|
|
}
|
|
|
|
// There's an unclosed tag in there somewhere x.x
|
|
if hasI || hasU || hasB || hasS {
|
|
closeUnder := []byte("</u>")
|
|
closeItalic := []byte("</i>")
|
|
closeBold := []byte("</b>")
|
|
closeStrike := []byte("</s>")
|
|
if hasI {
|
|
mbytes = append(bytes.TrimSpace(mbytes), closeItalic...)
|
|
}
|
|
if hasU {
|
|
mbytes = append(bytes.TrimSpace(mbytes), closeUnder...)
|
|
}
|
|
if hasB {
|
|
mbytes = append(bytes.TrimSpace(mbytes), closeBold...)
|
|
}
|
|
if hasS {
|
|
mbytes = append(bytes.TrimSpace(mbytes), closeStrike...)
|
|
}
|
|
mbytes = append(mbytes, c.SpaceGap...)
|
|
}
|
|
|
|
if complexBbc {
|
|
i := 0
|
|
var start, lastTag int
|
|
var outbytes []byte
|
|
for ; i < len(mbytes); i++ {
|
|
if mbytes[i] == '[' {
|
|
if mbytes[i+1] == 'u' {
|
|
if mbytes[i+4] == ']' && mbytes[i+2] == 'r' && mbytes[i+3] == 'l' {
|
|
i, start, lastTag, outbytes = bbcodeParseURL(i, start, lastTag, mbytes, outbytes)
|
|
continue
|
|
}
|
|
} else if mbytes[i+1] == 'r' {
|
|
if bytes.Equal(mbytes[i+2:i+6], []byte("and]")) {
|
|
i, start, lastTag, outbytes = bbcodeParseRand(i, start, lastTag, mbytes, outbytes)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if lastTag != i {
|
|
outbytes = append(outbytes, mbytes[lastTag:]...)
|
|
}
|
|
|
|
if len(outbytes) != 0 {
|
|
msg = string(outbytes[0 : len(outbytes)-10])
|
|
} else {
|
|
msg = string(mbytes[0 : len(mbytes)-10])
|
|
}
|
|
|
|
// TODO: Optimise these
|
|
//msg = bbcode_url.ReplaceAllString(msg,"<a href=\"$1$2//$3\" rel=\"ugc\">$1$2//$3</i>")
|
|
msg = bbcodeURLLabel.ReplaceAllString(msg, "<a href='$1$2//$3' rel='ugc'>$4</i>")
|
|
msg = bbcodeQuotes.ReplaceAllString(msg, "<blockquote>$1</blockquote>")
|
|
msg = bbcodeCode.ReplaceAllString(msg, "<span class='codequotes'>$1</span>")
|
|
msg = bbcodeSpoiler.ReplaceAllString(msg, "<spoiler>$1</spoiler>")
|
|
msg = bbcodeH1.ReplaceAllString(msg, "<h2>$1</h2>")
|
|
} else {
|
|
msg = string(mbytes[0 : len(mbytes)-10])
|
|
}
|
|
|
|
return msg
|
|
}
|
|
|
|
// TODO: Strip the containing [url] so the media parser can work it's magic instead? Or do we want to allow something like [url=]label[/url] here?
|
|
func bbcodeParseURL(i int, start int, lastTag int, mbytes []byte, outbytes []byte) (int, int, int, []byte) {
|
|
start = i + 5
|
|
outbytes = append(outbytes, mbytes[lastTag:i]...)
|
|
i = start
|
|
i += c.PartialURLStringLen2(string(mbytes[start:]))
|
|
if !bytes.Equal(mbytes[i:i+6], []byte("[/url]")) {
|
|
outbytes = append(outbytes, c.InvalidURL...)
|
|
return i, start, lastTag, outbytes
|
|
}
|
|
|
|
outbytes = append(outbytes, c.URLOpen...)
|
|
outbytes = append(outbytes, mbytes[start:i]...)
|
|
outbytes = append(outbytes, c.URLOpen2...)
|
|
outbytes = append(outbytes, mbytes[start:i]...)
|
|
outbytes = append(outbytes, c.URLClose...)
|
|
i += 6
|
|
lastTag = i
|
|
|
|
return i, start, lastTag, outbytes
|
|
}
|
|
|
|
func bbcodeParseRand(i int, start int, lastTag int, msgbytes []byte, outbytes []byte) (int, int, int, []byte) {
|
|
outbytes = append(outbytes, msgbytes[lastTag:i]...)
|
|
start = i + 6
|
|
i = start
|
|
for ; ; i++ {
|
|
if msgbytes[i] == '[' {
|
|
if !bytes.Equal(msgbytes[i+1:i+7], []byte("/rand]")) {
|
|
outbytes = append(outbytes, bbcodeMissingTag...)
|
|
return i, start, lastTag, outbytes
|
|
}
|
|
break
|
|
} else if (len(msgbytes) - 1) < (i + 10) {
|
|
outbytes = append(outbytes, bbcodeMissingTag...)
|
|
return i, start, lastTag, outbytes
|
|
}
|
|
}
|
|
|
|
number, err := strconv.ParseInt(string(msgbytes[start:i]), 10, 64)
|
|
if err != nil {
|
|
outbytes = append(outbytes, bbcodeInvalidNumber...)
|
|
return i, start, lastTag, outbytes
|
|
}
|
|
|
|
// TODO: Add support for negative numbers?
|
|
if number < 0 {
|
|
outbytes = append(outbytes, bbcodeNoNegative...)
|
|
return i, start, lastTag, outbytes
|
|
}
|
|
|
|
var dat []byte
|
|
if number == 0 {
|
|
dat = []byte("0")
|
|
} else {
|
|
dat = []byte(strconv.FormatInt((bbcodeRandom.Int63n(number)), 10))
|
|
}
|
|
|
|
outbytes = append(outbytes, dat...)
|
|
i += 7
|
|
lastTag = i
|
|
return i, start, lastTag, outbytes
|
|
}
|