081f4a5123
* WIP: trim markdown for push notification * fix: golangci * fix: table regex * fix: regex code block * doc: add license * WIP: custom renderer with goldmark * WIP: update goldmark version to 1.38 * fix: use goldmark as parser * fix: remove table extension * fix: change buf to `strings.Builder` * fix: return original string, log warning if error * refactor: change `WriteString` to `WriteByte` * refactor: change if condition * refactor: use assertion * refactor: move to inline * fix: remove handle multiline Already handled by mobile * refactor: wrap same function * refactor: move strip markdown to `sendPushNotificationSync` * refactor: renaming variable aren't used * fix: move log to func `sendPushNotificationSync` * docs: add comment to `StripMarkdown` * fix: move assign message to else * appErr to err rename Co-authored-by: Agniva De Sarker <agnivade@yahoo.co.in> Co-authored-by: Mattermod <mattermod@users.noreply.github.com>
104 строки
2.9 KiB
Go
104 строки
2.9 KiB
Go
package parser
|
|
|
|
import (
|
|
"bytes"
|
|
"regexp"
|
|
|
|
"github.com/yuin/goldmark/ast"
|
|
"github.com/yuin/goldmark/text"
|
|
"github.com/yuin/goldmark/util"
|
|
)
|
|
|
|
type rawHTMLParser struct {
|
|
}
|
|
|
|
var defaultRawHTMLParser = &rawHTMLParser{}
|
|
|
|
// NewRawHTMLParser return a new InlineParser that can parse
|
|
// inline htmls
|
|
func NewRawHTMLParser() InlineParser {
|
|
return defaultRawHTMLParser
|
|
}
|
|
|
|
func (s *rawHTMLParser) Trigger() []byte {
|
|
return []byte{'<'}
|
|
}
|
|
|
|
func (s *rawHTMLParser) Parse(parent ast.Node, block text.Reader, pc Context) ast.Node {
|
|
line, _ := block.PeekLine()
|
|
if len(line) > 1 && util.IsAlphaNumeric(line[1]) {
|
|
return s.parseMultiLineRegexp(openTagRegexp, block, pc)
|
|
}
|
|
if len(line) > 2 && line[1] == '/' && util.IsAlphaNumeric(line[2]) {
|
|
return s.parseMultiLineRegexp(closeTagRegexp, block, pc)
|
|
}
|
|
if bytes.HasPrefix(line, []byte("<!--")) {
|
|
return s.parseMultiLineRegexp(commentRegexp, block, pc)
|
|
}
|
|
if bytes.HasPrefix(line, []byte("<?")) {
|
|
return s.parseSingleLineRegexp(processingInstructionRegexp, block, pc)
|
|
}
|
|
if len(line) > 2 && line[1] == '!' && line[2] >= 'A' && line[2] <= 'Z' {
|
|
return s.parseSingleLineRegexp(declRegexp, block, pc)
|
|
}
|
|
if bytes.HasPrefix(line, []byte("<![CDATA[")) {
|
|
return s.parseMultiLineRegexp(cdataRegexp, block, pc)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var tagnamePattern = `([A-Za-z][A-Za-z0-9-]*)`
|
|
var attributePattern = `(?:\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\s*=\s*(?:[^\"'=<>` + "`" + `\x00-\x20]+|'[^']*'|"[^"]*"))?)`
|
|
var openTagRegexp = regexp.MustCompile("^<" + tagnamePattern + attributePattern + `*\s*/?>`)
|
|
var closeTagRegexp = regexp.MustCompile("^</" + tagnamePattern + `\s*>`)
|
|
var commentRegexp = regexp.MustCompile(`^<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->`)
|
|
var processingInstructionRegexp = regexp.MustCompile(`^(?:<\?).*?(?:\?>)`)
|
|
var declRegexp = regexp.MustCompile(`^<![A-Z]+\s+[^>]*>`)
|
|
var cdataRegexp = regexp.MustCompile(`<!\[CDATA\[[\s\S]*?\]\]>`)
|
|
|
|
func (s *rawHTMLParser) parseSingleLineRegexp(reg *regexp.Regexp, block text.Reader, pc Context) ast.Node {
|
|
line, segment := block.PeekLine()
|
|
match := reg.FindSubmatchIndex(line)
|
|
if match == nil {
|
|
return nil
|
|
}
|
|
node := ast.NewRawHTML()
|
|
node.Segments.Append(segment.WithStop(segment.Start + match[1]))
|
|
block.Advance(match[1])
|
|
return node
|
|
}
|
|
|
|
func (s *rawHTMLParser) parseMultiLineRegexp(reg *regexp.Regexp, block text.Reader, pc Context) ast.Node {
|
|
sline, ssegment := block.Position()
|
|
if block.Match(reg) {
|
|
node := ast.NewRawHTML()
|
|
eline, esegment := block.Position()
|
|
block.SetPosition(sline, ssegment)
|
|
for {
|
|
line, segment := block.PeekLine()
|
|
if line == nil {
|
|
break
|
|
}
|
|
l, _ := block.Position()
|
|
start := segment.Start
|
|
if l == sline {
|
|
start = ssegment.Start
|
|
}
|
|
end := segment.Stop
|
|
if l == eline {
|
|
end = esegment.Start
|
|
}
|
|
|
|
node.Segments.Append(text.NewSegment(start, end))
|
|
if l == eline {
|
|
block.Advance(end - start)
|
|
break
|
|
} else {
|
|
block.AdvanceLine()
|
|
}
|
|
}
|
|
return node
|
|
}
|
|
return nil
|
|
}
|