list.go

package parser

import (
	"bytes"
	"github.com/bouncepaw/mycomarkup/blocks"
	"github.com/bouncepaw/mycomarkup/mycocontext"
	"sync"
)

// Call only if there is a list item on the line.
func nextList(ctx mycocontext.Context) (list blocks.List, eof bool) {
	var contents []interface{}
	list = blocks.List{
		Items: make([]blocks.ListItem, 0),
	}
	for !eof {
		marker, level, found := markerOnNextLine(ctx)
		if !found {
			break
		}

		mycocontext.EatUntilSpace(ctx)
		contents, eof = nextListItem(ctx)
		item := blocks.ListItem{
			Marker:   marker,
			Level:    level,
			Contents: contents,
		}

		list.Items = append(list.Items, item)
	}
	list.Marker = list.Items[0].Marker // There should be at least one item!
	return list, eof
}

func readNextListItemsContents(ctx mycocontext.Context) (text bytes.Buffer, eof bool) {
	var (
		onNewLine       = true
		escaping        = false
		curlyBracesOpen = 0
		b               byte
	)
walker: // Read all item's contents
	for !eof {
		b, eof = mycocontext.NextByte(ctx)
	stateMachine: // I'm extremely sorry
		switch {
		case onNewLine && b != ' ':
			onNewLine = false
			goto stateMachine
		case onNewLine: // We just ignore spaces on line beginnings
		case escaping:
			escaping = false
			if b == '\n' && curlyBracesOpen == 0 {
				break walker
			}
			text.WriteByte(b)
		case b == '\\':
			escaping = true
			text.WriteByte('\\')

		case b == '{':
			if curlyBracesOpen > 0 {
				text.WriteByte('{')
			}
			curlyBracesOpen++
		case b == '}':
			if curlyBracesOpen != 1 {
				text.WriteByte('}')
			}
			if curlyBracesOpen >= 0 {
				curlyBracesOpen--
			}
		case b == '\n' && curlyBracesOpen == 0:
			break walker
		case b == '\n':
			text.WriteByte(b)
			onNewLine = true
		default:
			text.WriteByte(b)
		}
	}
	return text, eof
}

func nextListItem(ctx mycocontext.Context) (contents []interface{}, eof bool) {
	// Parse the text as a separate mycodoc
	var (
		text     bytes.Buffer
		blocksCh = make(chan interface{})
		blocks   = make([]interface{}, 0)
		wg       sync.WaitGroup
	)
	text, eof = readNextListItemsContents(ctx)

	wg.Add(1)
	go func() {
		Parse(mycocontext.WithBuffer(ctx, &text), blocksCh)
		wg.Done()
	}()
	for block := range blocksCh {
		blocks = append(blocks, block)
	}
	wg.Wait()

	return blocks, eof
}

func looksLikeList(ctx mycocontext.Context) bool {
	_, level, found := markerOnNextLine(ctx)
	return found && level == 1
}

func markerOnNextLine(ctx mycocontext.Context) (m blocks.ListMarker, level uint, found bool) {
	var (
		onStart            = true
		onAsterisk         = false
		onSpecialCharacter = false
	)
	for _, b := range ctx.Input().Bytes() {
		switch {
		case onStart && b != '*':
			return blocks.MarkerUnordered, 0, false
		case onStart:
			level = 1
			onStart = false
			onAsterisk = true

		case onAsterisk && b == '*':
			level++
		case onAsterisk && b == ' ':
			return m, level, true
		case onAsterisk && (b == 'v' || b == 'x' || b == '.'):
			onAsterisk = false
			onSpecialCharacter = true
			switch b {
			case 'v':
				m = blocks.MarkerTodoDone
			case 'x':
				m = blocks.MarkerTodo
			case '.':
				m = blocks.MarkerOrdered
			}
		case onAsterisk:
			return blocks.MarkerUnordered, 0, false

		case onSpecialCharacter && b != ' ':
			return blocks.MarkerUnordered, 0, false
		case onSpecialCharacter:
			return m, level, true
		}
	}
	return blocks.MarkerUnordered, 0, false
}