5464ab37d2
Since writers are normally only used synchronously (i.e. to write one document
at a time), we don't guard modifications to their internal
state (e.g. temporarily replacing the string.Builder in WriteNodesAsString)
against race conditions.
The package global `orgWriter` and corresponding use cases of it (`org.String`,
`$node.String`) break that pattern - the writer is potentially used from
multiple go routines at the same time. This results in race conditions that
manifest as error messages like e.g.
could not write output: runtime error: invalid memory address or nil pointer dereference. Using unrendered content.
Additionally, since we catch panics in `Document.Write`, the corresponding
stack trace is lost and dependents of go-org never know what hit them.
As using a writer across simultaneously across go routines is not a standard
pattern, we'll sync the use of the global `orgWriter` instead of trying to make
the actual writer threadsafe; less code noise for the common use case.
47 lines
1.4 KiB
Go
47 lines
1.4 KiB
Go
package org
|
|
|
|
import (
|
|
"math"
|
|
"regexp"
|
|
"strings"
|
|
)
|
|
|
|
type Paragraph struct{ Children []Node }
|
|
type HorizontalRule struct{}
|
|
|
|
var horizontalRuleRegexp = regexp.MustCompile(`^(\s*)-{5,}\s*$`)
|
|
var plainTextRegexp = regexp.MustCompile(`^(\s*)(.*)`)
|
|
|
|
func lexText(line string) (token, bool) {
|
|
if m := plainTextRegexp.FindStringSubmatch(line); m != nil {
|
|
return token{"text", len(m[1]), m[2], m}, true
|
|
}
|
|
return nilToken, false
|
|
}
|
|
|
|
func lexHorizontalRule(line string) (token, bool) {
|
|
if m := horizontalRuleRegexp.FindStringSubmatch(line); m != nil {
|
|
return token{"horizontalRule", len(m[1]), "", m}, true
|
|
}
|
|
return nilToken, false
|
|
}
|
|
|
|
func (d *Document) parseParagraph(i int, parentStop stopFn) (int, Node) {
|
|
lines, start := []string{d.tokens[i].content}, i
|
|
stop := func(d *Document, i int) bool {
|
|
return parentStop(d, i) || d.tokens[i].kind != "text" || d.tokens[i].content == ""
|
|
}
|
|
for i += 1; !stop(d, i); i++ {
|
|
lvl := math.Max(float64(d.tokens[i].lvl-d.baseLvl), 0)
|
|
lines = append(lines, strings.Repeat(" ", int(lvl))+d.tokens[i].content)
|
|
}
|
|
consumed := i - start
|
|
return consumed, Paragraph{d.parseInline(strings.Join(lines, "\n"))}
|
|
}
|
|
|
|
func (d *Document) parseHorizontalRule(i int, parentStop stopFn) (int, Node) {
|
|
return 1, HorizontalRule{}
|
|
}
|
|
|
|
func (n Paragraph) String() string { return String(n) }
|
|
func (n HorizontalRule) String() string { return String(n) }
|