diff options
Diffstat (limited to 'vendor/github.com/yuin/goldmark/text')
| -rw-r--r-- | vendor/github.com/yuin/goldmark/text/package.go | 2 | ||||
| -rw-r--r-- | vendor/github.com/yuin/goldmark/text/reader.go | 660 | ||||
| -rw-r--r-- | vendor/github.com/yuin/goldmark/text/segment.go | 239 |
3 files changed, 0 insertions, 901 deletions
diff --git a/vendor/github.com/yuin/goldmark/text/package.go b/vendor/github.com/yuin/goldmark/text/package.go deleted file mode 100644 index d241ac693..000000000 --- a/vendor/github.com/yuin/goldmark/text/package.go +++ /dev/null @@ -1,2 +0,0 @@ -// Package text provides functionalities to manipulate texts. -package text diff --git a/vendor/github.com/yuin/goldmark/text/reader.go b/vendor/github.com/yuin/goldmark/text/reader.go deleted file mode 100644 index b3f97fb56..000000000 --- a/vendor/github.com/yuin/goldmark/text/reader.go +++ /dev/null @@ -1,660 +0,0 @@ -package text - -import ( - "bytes" - "io" - "regexp" - "unicode/utf8" - - "github.com/yuin/goldmark/util" -) - -const invalidValue = -1 - -// EOF indicates the end of file. -const EOF = byte(0xff) - -// A Reader interface provides abstracted method for reading text. -type Reader interface { - io.RuneReader - - // Source returns a source of the reader. - Source() []byte - - // ResetPosition resets positions. - ResetPosition() - - // Peek returns a byte at current position without advancing the internal pointer. - Peek() byte - - // PeekLine returns the current line without advancing the internal pointer. - PeekLine() ([]byte, Segment) - - // PrecendingCharacter returns a character just before current internal pointer. - PrecendingCharacter() rune - - // Value returns a value of the given segment. - Value(Segment) []byte - - // LineOffset returns a distance from the line head to current position. - LineOffset() int - - // Position returns current line number and position. - Position() (int, Segment) - - // SetPosition sets current line number and position. - SetPosition(int, Segment) - - // SetPadding sets padding to the reader. - SetPadding(int) - - // Advance advances the internal pointer. - Advance(int) - - // AdvanceAndSetPadding advances the internal pointer and add padding to the - // reader. - AdvanceAndSetPadding(int, int) - - // AdvanceLine advances the internal pointer to the next line head. - AdvanceLine() - - // SkipSpaces skips space characters and returns a non-blank line. - // If it reaches EOF, returns false. - SkipSpaces() (Segment, int, bool) - - // SkipSpaces skips blank lines and returns a non-blank line. - // If it reaches EOF, returns false. - SkipBlankLines() (Segment, int, bool) - - // Match performs regular expression matching to current line. - Match(reg *regexp.Regexp) bool - - // Match performs regular expression searching to current line. - FindSubMatch(reg *regexp.Regexp) [][]byte - - // FindClosure finds corresponding closure. - FindClosure(opener, closer byte, options FindClosureOptions) (*Segments, bool) -} - -// FindClosureOptions is options for Reader.FindClosure. -type FindClosureOptions struct { - // CodeSpan is a flag for the FindClosure. If this is set to true, - // FindClosure ignores closers in codespans. - CodeSpan bool - - // Nesting is a flag for the FindClosure. If this is set to true, - // FindClosure allows nesting. - Nesting bool - - // Newline is a flag for the FindClosure. If this is set to true, - // FindClosure searches for a closer over multiple lines. - Newline bool - - // Advance is a flag for the FindClosure. If this is set to true, - // FindClosure advances pointers when closer is found. - Advance bool -} - -type reader struct { - source []byte - sourceLength int - line int - peekedLine []byte - pos Segment - head int - lineOffset int -} - -// NewReader return a new Reader that can read UTF-8 bytes . -func NewReader(source []byte) Reader { - r := &reader{ - source: source, - sourceLength: len(source), - } - r.ResetPosition() - return r -} - -func (r *reader) FindClosure(opener, closer byte, options FindClosureOptions) (*Segments, bool) { - return findClosureReader(r, opener, closer, options) -} - -func (r *reader) ResetPosition() { - r.line = -1 - r.head = 0 - r.lineOffset = -1 - r.AdvanceLine() -} - -func (r *reader) Source() []byte { - return r.source -} - -func (r *reader) Value(seg Segment) []byte { - return seg.Value(r.source) -} - -func (r *reader) Peek() byte { - if r.pos.Start >= 0 && r.pos.Start < r.sourceLength { - if r.pos.Padding != 0 { - return space[0] - } - return r.source[r.pos.Start] - } - return EOF -} - -func (r *reader) PeekLine() ([]byte, Segment) { - if r.pos.Start >= 0 && r.pos.Start < r.sourceLength { - if r.peekedLine == nil { - r.peekedLine = r.pos.Value(r.Source()) - } - return r.peekedLine, r.pos - } - return nil, r.pos -} - -// io.RuneReader interface. -func (r *reader) ReadRune() (rune, int, error) { - return readRuneReader(r) -} - -func (r *reader) LineOffset() int { - if r.lineOffset < 0 { - v := 0 - for i := r.head; i < r.pos.Start; i++ { - if r.source[i] == '\t' { - v += util.TabWidth(v) - } else { - v++ - } - } - r.lineOffset = v - r.pos.Padding - } - return r.lineOffset -} - -func (r *reader) PrecendingCharacter() rune { - if r.pos.Start <= 0 { - if r.pos.Padding != 0 { - return rune(' ') - } - return rune('\n') - } - i := r.pos.Start - 1 - for ; i >= 0; i-- { - if utf8.RuneStart(r.source[i]) { - break - } - } - rn, _ := utf8.DecodeRune(r.source[i:]) - return rn -} - -func (r *reader) Advance(n int) { - r.lineOffset = -1 - if n < len(r.peekedLine) && r.pos.Padding == 0 { - r.pos.Start += n - r.peekedLine = nil - return - } - r.peekedLine = nil - l := r.sourceLength - for ; n > 0 && r.pos.Start < l; n-- { - if r.pos.Padding != 0 { - r.pos.Padding-- - continue - } - if r.source[r.pos.Start] == '\n' { - r.AdvanceLine() - continue - } - r.pos.Start++ - } -} - -func (r *reader) AdvanceAndSetPadding(n, padding int) { - r.Advance(n) - if padding > r.pos.Padding { - r.SetPadding(padding) - } -} - -func (r *reader) AdvanceLine() { - r.lineOffset = -1 - r.peekedLine = nil - r.pos.Start = r.pos.Stop - r.head = r.pos.Start - if r.pos.Start < 0 { - return - } - r.pos.Stop = r.sourceLength - for i := r.pos.Start; i < r.sourceLength; i++ { - c := r.source[i] - if c == '\n' { - r.pos.Stop = i + 1 - break - } - } - r.line++ - r.pos.Padding = 0 -} - -func (r *reader) Position() (int, Segment) { - return r.line, r.pos -} - -func (r *reader) SetPosition(line int, pos Segment) { - r.lineOffset = -1 - r.line = line - r.pos = pos -} - -func (r *reader) SetPadding(v int) { - r.pos.Padding = v -} - -func (r *reader) SkipSpaces() (Segment, int, bool) { - return skipSpacesReader(r) -} - -func (r *reader) SkipBlankLines() (Segment, int, bool) { - return skipBlankLinesReader(r) -} - -func (r *reader) Match(reg *regexp.Regexp) bool { - return matchReader(r, reg) -} - -func (r *reader) FindSubMatch(reg *regexp.Regexp) [][]byte { - return findSubMatchReader(r, reg) -} - -// A BlockReader interface is a reader that is optimized for Blocks. -type BlockReader interface { - Reader - // Reset resets current state and sets new segments to the reader. - Reset(segment *Segments) -} - -type blockReader struct { - source []byte - segments *Segments - segmentsLength int - line int - pos Segment - head int - last int - lineOffset int -} - -// NewBlockReader returns a new BlockReader. -func NewBlockReader(source []byte, segments *Segments) BlockReader { - r := &blockReader{ - source: source, - } - if segments != nil { - r.Reset(segments) - } - return r -} - -func (r *blockReader) FindClosure(opener, closer byte, options FindClosureOptions) (*Segments, bool) { - return findClosureReader(r, opener, closer, options) -} - -func (r *blockReader) ResetPosition() { - r.line = -1 - r.head = 0 - r.last = 0 - r.lineOffset = -1 - r.pos.Start = -1 - r.pos.Stop = -1 - r.pos.Padding = 0 - if r.segmentsLength > 0 { - last := r.segments.At(r.segmentsLength - 1) - r.last = last.Stop - } - r.AdvanceLine() -} - -func (r *blockReader) Reset(segments *Segments) { - r.segments = segments - r.segmentsLength = segments.Len() - r.ResetPosition() -} - -func (r *blockReader) Source() []byte { - return r.source -} - -func (r *blockReader) Value(seg Segment) []byte { - line := r.segmentsLength - 1 - ret := make([]byte, 0, seg.Stop-seg.Start+1) - for ; line >= 0; line-- { - if seg.Start >= r.segments.At(line).Start { - break - } - } - i := seg.Start - for ; line < r.segmentsLength; line++ { - s := r.segments.At(line) - if i < 0 { - i = s.Start - } - ret = s.ConcatPadding(ret) - for ; i < seg.Stop && i < s.Stop; i++ { - ret = append(ret, r.source[i]) - } - i = -1 - if s.Stop > seg.Stop { - break - } - } - return ret -} - -// io.RuneReader interface. -func (r *blockReader) ReadRune() (rune, int, error) { - return readRuneReader(r) -} - -func (r *blockReader) PrecendingCharacter() rune { - if r.pos.Padding != 0 { - return rune(' ') - } - if r.segments.Len() < 1 { - return rune('\n') - } - firstSegment := r.segments.At(0) - if r.line == 0 && r.pos.Start <= firstSegment.Start { - return rune('\n') - } - l := len(r.source) - i := r.pos.Start - 1 - for ; i < l && i >= 0; i-- { - if utf8.RuneStart(r.source[i]) { - break - } - } - if i < 0 || i >= l { - return rune('\n') - } - rn, _ := utf8.DecodeRune(r.source[i:]) - return rn -} - -func (r *blockReader) LineOffset() int { - if r.lineOffset < 0 { - v := 0 - for i := r.head; i < r.pos.Start; i++ { - if r.source[i] == '\t' { - v += util.TabWidth(v) - } else { - v++ - } - } - r.lineOffset = v - r.pos.Padding - } - return r.lineOffset -} - -func (r *blockReader) Peek() byte { - if r.line < r.segmentsLength && r.pos.Start >= 0 && r.pos.Start < r.last { - if r.pos.Padding != 0 { - return space[0] - } - return r.source[r.pos.Start] - } - return EOF -} - -func (r *blockReader) PeekLine() ([]byte, Segment) { - if r.line < r.segmentsLength && r.pos.Start >= 0 && r.pos.Start < r.last { - return r.pos.Value(r.source), r.pos - } - return nil, r.pos -} - -func (r *blockReader) Advance(n int) { - r.lineOffset = -1 - - if n < r.pos.Stop-r.pos.Start && r.pos.Padding == 0 { - r.pos.Start += n - return - } - - for ; n > 0; n-- { - if r.pos.Padding != 0 { - r.pos.Padding-- - continue - } - if r.pos.Start >= r.pos.Stop-1 && r.pos.Stop < r.last { - r.AdvanceLine() - continue - } - r.pos.Start++ - } -} - -func (r *blockReader) AdvanceAndSetPadding(n, padding int) { - r.Advance(n) - if padding > r.pos.Padding { - r.SetPadding(padding) - } -} - -func (r *blockReader) AdvanceLine() { - r.SetPosition(r.line+1, NewSegment(invalidValue, invalidValue)) - r.head = r.pos.Start -} - -func (r *blockReader) Position() (int, Segment) { - return r.line, r.pos -} - -func (r *blockReader) SetPosition(line int, pos Segment) { - r.lineOffset = -1 - r.line = line - if pos.Start == invalidValue { - if r.line < r.segmentsLength { - s := r.segments.At(line) - r.head = s.Start - r.pos = s - } - } else { - r.pos = pos - if r.line < r.segmentsLength { - s := r.segments.At(line) - r.head = s.Start - } - } -} - -func (r *blockReader) SetPadding(v int) { - r.lineOffset = -1 - r.pos.Padding = v -} - -func (r *blockReader) SkipSpaces() (Segment, int, bool) { - return skipSpacesReader(r) -} - -func (r *blockReader) SkipBlankLines() (Segment, int, bool) { - return skipBlankLinesReader(r) -} - -func (r *blockReader) Match(reg *regexp.Regexp) bool { - return matchReader(r, reg) -} - -func (r *blockReader) FindSubMatch(reg *regexp.Regexp) [][]byte { - return findSubMatchReader(r, reg) -} - -func skipBlankLinesReader(r Reader) (Segment, int, bool) { - lines := 0 - for { - line, seg := r.PeekLine() - if line == nil { - return seg, lines, false - } - if util.IsBlank(line) { - lines++ - r.AdvanceLine() - } else { - return seg, lines, true - } - } -} - -func skipSpacesReader(r Reader) (Segment, int, bool) { - chars := 0 - for { - line, segment := r.PeekLine() - if line == nil { - return segment, chars, false - } - for i, c := range line { - if util.IsSpace(c) { - chars++ - r.Advance(1) - continue - } - return segment.WithStart(segment.Start + i + 1), chars, true - } - } -} - -func matchReader(r Reader, reg *regexp.Regexp) bool { - oldline, oldseg := r.Position() - match := reg.FindReaderSubmatchIndex(r) - r.SetPosition(oldline, oldseg) - if match == nil { - return false - } - r.Advance(match[1] - match[0]) - return true -} - -func findSubMatchReader(r Reader, reg *regexp.Regexp) [][]byte { - oldLine, oldSeg := r.Position() - match := reg.FindReaderSubmatchIndex(r) - r.SetPosition(oldLine, oldSeg) - if match == nil { - return nil - } - var bb bytes.Buffer - bb.Grow(match[1] - match[0]) - for i := 0; i < match[1]; { - r, size, _ := readRuneReader(r) - i += size - bb.WriteRune(r) - } - bs := bb.Bytes() - var result [][]byte - for i := 0; i < len(match); i += 2 { - if match[i] < 0 { - result = append(result, []byte{}) - continue - } - result = append(result, bs[match[i]:match[i+1]]) - } - - r.SetPosition(oldLine, oldSeg) - r.Advance(match[1] - match[0]) - return result -} - -func readRuneReader(r Reader) (rune, int, error) { - line, _ := r.PeekLine() - if line == nil { - return 0, 0, io.EOF - } - rn, size := utf8.DecodeRune(line) - if rn == utf8.RuneError { - return 0, 0, io.EOF - } - r.Advance(size) - return rn, size, nil -} - -func findClosureReader(r Reader, opener, closer byte, opts FindClosureOptions) (*Segments, bool) { - opened := 1 - codeSpanOpener := 0 - closed := false - orgline, orgpos := r.Position() - var ret *Segments - - for { - bs, seg := r.PeekLine() - if bs == nil { - goto end - } - i := 0 - for i < len(bs) { - c := bs[i] - if opts.CodeSpan && codeSpanOpener != 0 && c == '`' { - codeSpanCloser := 0 - for ; i < len(bs); i++ { - if bs[i] == '`' { - codeSpanCloser++ - } else { - i-- - break - } - } - if codeSpanCloser == codeSpanOpener { - codeSpanOpener = 0 - } - } else if codeSpanOpener == 0 && c == '\\' && i < len(bs)-1 && util.IsPunct(bs[i+1]) { - i += 2 - continue - } else if opts.CodeSpan && codeSpanOpener == 0 && c == '`' { - for ; i < len(bs); i++ { - if bs[i] == '`' { - codeSpanOpener++ - } else { - i-- - break - } - } - } else if (opts.CodeSpan && codeSpanOpener == 0) || !opts.CodeSpan { - if c == closer { - opened-- - if opened == 0 { - if ret == nil { - ret = NewSegments() - } - ret.Append(seg.WithStop(seg.Start + i)) - r.Advance(i + 1) - closed = true - goto end - } - } else if c == opener { - if !opts.Nesting { - goto end - } - opened++ - } - } - i++ - } - if !opts.Newline { - goto end - } - r.AdvanceLine() - if ret == nil { - ret = NewSegments() - } - ret.Append(seg) - } -end: - if !opts.Advance { - r.SetPosition(orgline, orgpos) - } - if closed { - return ret, true - } - return nil, false -} diff --git a/vendor/github.com/yuin/goldmark/text/segment.go b/vendor/github.com/yuin/goldmark/text/segment.go deleted file mode 100644 index 93fbf1994..000000000 --- a/vendor/github.com/yuin/goldmark/text/segment.go +++ /dev/null @@ -1,239 +0,0 @@ -package text - -import ( - "bytes" - - "github.com/yuin/goldmark/util" -) - -var space = []byte(" ") - -// A Segment struct holds information about source positions. -type Segment struct { - // Start is a start position of the segment. - Start int - - // Stop is a stop position of the segment. - // This value should be excluded. - Stop int - - // Padding is a padding length of the segment. - Padding int - - // ForceNewline is true if the segment should be ended with a newline. - // Some elements(i.e. CodeBlock, FencedCodeBlock) does not trim trailing - // newlines. Spec defines that EOF is treated as a newline, so we need to - // add a newline to the end of the segment if it is not empty. - // - // i.e.: - // - // ```go - // const test = "test" - // - // This code does not close the code block and ends with EOF. In this case, - // we need to add a newline to the end of the last line like `const test = "test"\n`. - ForceNewline bool -} - -// NewSegment return a new Segment. -func NewSegment(start, stop int) Segment { - return Segment{ - Start: start, - Stop: stop, - Padding: 0, - } -} - -// NewSegmentPadding returns a new Segment with the given padding. -func NewSegmentPadding(start, stop, n int) Segment { - return Segment{ - Start: start, - Stop: stop, - Padding: n, - } -} - -// Value returns a value of the segment. -func (t *Segment) Value(buffer []byte) []byte { - var result []byte - if t.Padding == 0 { - result = buffer[t.Start:t.Stop] - } else { - result = make([]byte, 0, t.Padding+t.Stop-t.Start+1) - result = append(result, bytes.Repeat(space, t.Padding)...) - result = append(result, buffer[t.Start:t.Stop]...) - } - if t.ForceNewline && len(result) > 0 && result[len(result)-1] != '\n' { - result = append(result, '\n') - } - return result -} - -// Len returns a length of the segment. -func (t *Segment) Len() int { - return t.Stop - t.Start + t.Padding -} - -// Between returns a segment between this segment and the given segment. -func (t *Segment) Between(other Segment) Segment { - if t.Stop != other.Stop { - panic("invalid state") - } - return NewSegmentPadding( - t.Start, - other.Start, - t.Padding-other.Padding, - ) -} - -// IsEmpty returns true if this segment is empty, otherwise false. -func (t *Segment) IsEmpty() bool { - return t.Start >= t.Stop && t.Padding == 0 -} - -// TrimRightSpace returns a new segment by slicing off all trailing -// space characters. -func (t *Segment) TrimRightSpace(buffer []byte) Segment { - v := buffer[t.Start:t.Stop] - l := util.TrimRightSpaceLength(v) - if l == len(v) { - return NewSegment(t.Start, t.Start) - } - return NewSegmentPadding(t.Start, t.Stop-l, t.Padding) -} - -// TrimLeftSpace returns a new segment by slicing off all leading -// space characters including padding. -func (t *Segment) TrimLeftSpace(buffer []byte) Segment { - v := buffer[t.Start:t.Stop] - l := util.TrimLeftSpaceLength(v) - return NewSegment(t.Start+l, t.Stop) -} - -// TrimLeftSpaceWidth returns a new segment by slicing off leading space -// characters until the given width. -func (t *Segment) TrimLeftSpaceWidth(width int, buffer []byte) Segment { - padding := t.Padding - for ; width > 0; width-- { - if padding == 0 { - break - } - padding-- - } - if width == 0 { - return NewSegmentPadding(t.Start, t.Stop, padding) - } - text := buffer[t.Start:t.Stop] - start := t.Start - for _, c := range text { - if start >= t.Stop-1 || width <= 0 { - break - } - if c == ' ' { - width-- - } else if c == '\t' { - width -= 4 - } else { - break - } - start++ - } - if width < 0 { - padding = width * -1 - } - return NewSegmentPadding(start, t.Stop, padding) -} - -// WithStart returns a new Segment with same value except Start. -func (t *Segment) WithStart(v int) Segment { - return NewSegmentPadding(v, t.Stop, t.Padding) -} - -// WithStop returns a new Segment with same value except Stop. -func (t *Segment) WithStop(v int) Segment { - return NewSegmentPadding(t.Start, v, t.Padding) -} - -// ConcatPadding concats the padding to the given slice. -func (t *Segment) ConcatPadding(v []byte) []byte { - if t.Padding > 0 { - return append(v, bytes.Repeat(space, t.Padding)...) - } - return v -} - -// Segments is a collection of the Segment. -type Segments struct { - values []Segment -} - -// NewSegments return a new Segments. -func NewSegments() *Segments { - return &Segments{ - values: nil, - } -} - -// Append appends the given segment after the tail of the collection. -func (s *Segments) Append(t Segment) { - if s.values == nil { - s.values = make([]Segment, 0, 20) - } - s.values = append(s.values, t) -} - -// AppendAll appends all elements of given segments after the tail of the collection. -func (s *Segments) AppendAll(t []Segment) { - if s.values == nil { - s.values = make([]Segment, 0, 20) - } - s.values = append(s.values, t...) -} - -// Len returns the length of the collection. -func (s *Segments) Len() int { - if s.values == nil { - return 0 - } - return len(s.values) -} - -// At returns a segment at the given index. -func (s *Segments) At(i int) Segment { - return s.values[i] -} - -// Set sets the given Segment. -func (s *Segments) Set(i int, v Segment) { - s.values[i] = v -} - -// SetSliced replace the collection with a subsliced value. -func (s *Segments) SetSliced(lo, hi int) { - s.values = s.values[lo:hi] -} - -// Sliced returns a subslice of the collection. -func (s *Segments) Sliced(lo, hi int) []Segment { - return s.values[lo:hi] -} - -// Clear delete all element of the collection. -func (s *Segments) Clear() { - s.values = nil -} - -// Unshift insert the given Segment to head of the collection. -func (s *Segments) Unshift(v Segment) { - s.values = append(s.values[0:1], s.values[0:]...) - s.values[0] = v -} - -// Value returns a string value of the collection. -func (s *Segments) Value(buffer []byte) []byte { - var result []byte - for _, v := range s.values { - result = append(result, v.Value(buffer)...) - } - return result -} |