go-nestedtext

nestedtext.go (4650B)

---

 package main
 
 import (
 	"bufio"
 	"encoding/json"
 	"fmt"
 	"io"
 	"log"
 	"os"
 	"regexp"
 	"strings"
 )
 
 // TODO: Impl negative lookahead of ': ' for reKey{Value,Empty}
 
 var (
 	reLeadingWs = regexp.MustCompile(`^\s*`)
 	reComment   = regexp.MustCompile(`^\s*(#.*)?$`)
 	reKeyValue  = regexp.MustCompile(`^\s*[^:]*: .*$`)
 	reKeyEmpty  = regexp.MustCompile(`^\s*[^:]*:$`)
 	reListValue = regexp.MustCompile(`^\s*- .*$`)
 	reListEmpty = regexp.MustCompile(`^\s*- ?$`)
 	reMultiline = regexp.MustCompile(`^\s*>( .*)?$`)
 )
 
 type BlockType int
 
 const (
 	Unknown BlockType = iota
 	Dict
 	List
 	Multiline
 )
 
 func main() {
 	doc, err := UnmarshalNestedText(os.Stdin)
 	must(err)
 	jsonRepr, err := json.MarshalIndent(doc, "", "\t")
 	must(err)
 	fmt.Println(string(jsonRepr))
 }
 
 func UnmarshalNestedText(r io.Reader) (interface{}, error) {
 	scanner := bufio.NewScanner(r)
 	lineNumber := 0
 	return parseNestedText(scanner, &lineNumber, "", Unknown)
 }
 
 func parseNestedText(
 	scanner *bufio.Scanner, lineNum *int, parentIndent string, parentType BlockType,
 ) (interface{}, error) {
 	var blockType BlockType = Unknown
 	var dict map[string]interface{}
 	var list []interface{}
 	var multiline string
 
 	var localIndentDefined bool
 	var localIndent string
 	var skipNextScan bool
 
 	for {
 		if skipNextScan {
 			skipNextScan = false
 		} else {
 			ok := scanner.Scan()
 			if !ok {
 				break
 			}
 			*lineNum++
 		}
 
 		rawLine := scanner.Text()
 
 		if reComment.MatchString(rawLine) {
 			continue
 		}
 
 		currentIndent := reLeadingWs.FindString(rawLine)
 		if !localIndentDefined {
 			localIndent = currentIndent
 			localIndentDefined = true
 		} else if currentIndent != localIndent {
 			// indented leftwards, leaf has finished.
 			break
 		}
 
 		if parentType != Unknown && currentIndent == parentIndent {
 			// previous line was a list '-\n' or key ':\n' marker
 			// but this line is not the value of the previous line
 			// as it is on the same indentation level.
 			// As such, that list element or key's value should be
 			// interpreted as "".
 			return "", nil
 		}
 
 		// the effective current line
 		line := strings.TrimPrefix(rawLine, localIndent)
 
 		// determine the blocktype from the current linetype
 		errmsg := "ERROR: inconsistent linetypes - line %d: \"%s\""
 		switch {
 		case reKeyValue.MatchString(line) || reKeyEmpty.MatchString(line):
 			if blockType == Unknown {
 				blockType = Dict
 				dict = make(map[string]interface{})
 			} else if blockType != Dict {
 				err := fmt.Errorf(errmsg, *lineNum, line)
 				return nil, err
 			}
 		case reListValue.MatchString(line) || reListEmpty.MatchString(line):
 			if blockType == Unknown {
 				blockType = List
 				list = []interface{}{}
 			} else if blockType != List {
 				err := fmt.Errorf(errmsg, *lineNum, line)
 				return nil, err
 			}
 		case reMultiline.MatchString(line):
 			if blockType == Unknown {
 				blockType = Multiline
 			} else if blockType != Multiline {
 				err := fmt.Errorf(errmsg, *lineNum, line)
 				return nil, err
 			}
 		}
 
 		// parse line according to linetype, then continue to next cycle
 		switch {
 		case reKeyValue.MatchString(line):
 			// TODO optimise with regex?
 			ls := strings.Split(line, ": ")
 			key, v := ls[0], ls[1:]
 			key = strings.TrimSpace(key)
 			value := strings.Join(v, ": ")
 			dict[key] = value
 
 		case reKeyEmpty.MatchString(line):
 			var key string
 			switch {
 			case strings.HasSuffix(line, ":"):
 				key = strings.TrimSuffix(line, ":")
 			case strings.HasSuffix(line, ": "):
 				key = strings.TrimSuffix(line, ": ")
 			}
 			key = strings.TrimSpace(key)
 
 			child, err := parseNestedText(scanner, lineNum, localIndent, blockType)
 			if err != nil {
 				return nil, err
 			}
 			dict[key] = child
 			skipNextScan = true
 
 		case reListValue.MatchString(line):
 			value := strings.TrimPrefix(line, "- ")
 			list = append(list, value)
 
 		case reListEmpty.MatchString(line):
 			child, err := parseNestedText(scanner, lineNum, localIndent, blockType)
 			if err != nil {
 				return nil, err
 			}
 			list = append(list, child)
 			skipNextScan = true
 
 		case reMultiline.MatchString(line):
 			var oneline string
 			if line != ">" {
 				oneline = strings.TrimPrefix(line, "> ")
 			}
 			multiline += oneline + "\n"
 
 		default:
 			errmsg := "Internal error - unknown linetype of line %d"
 			return nil, fmt.Errorf(errmsg, *lineNum)
 		}
 	}
 
 	if err := scanner.Err(); err != nil {
 		log.Println(err)
 	}
 
 	switch blockType {
 	case Dict:
 		return dict, nil
 	case List:
 		return list, nil
 	case Multiline:
 		return multiline, nil
 	default:
 		return nil, fmt.Errorf("Internal error - line %d", *lineNum)
 	}
 }
 
 func must(err error) {
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
 	}
 }