Transpiling everything in netarch now

cmd/transpile/main.go

@@ -1,71 +1,113 @@
 package main
 
 import (
-	"gopkg.in/russross/blackfriday.v2"
-	"gopkg.in/yaml.v2"
 	"bufio"
 	"bytes"
+	"encoding/json"
 	"flag"
 	"fmt"
-	"log"
+	"gopkg.in/russross/blackfriday.v2"
+	"gopkg.in/yaml.v2"
 	"io"
-	"os"
+	"log"
 	"net/mail"
+	"os"
 	"strings"
 )
 
-type Header struct {
+type Attachment struct {
-	Pre struct {
+	Filename       string // Filename presented as part of puzzle
-		Authors []string
+	FilesystemPath string // Filename in backing FS (URL, mothball, or local FS)
-	}
+	Listed         bool   // Whether this file is listed as an attachment
-	Answers []string
-	Post struct {
-		Objective string
-	}
-	Debug struct {
-		Log []string
-		Error string
-	}
 }
 
-type HeaderParser func([]byte) (*Header, error)
+type Puzzle struct {
+	Pre struct {
+		Authors       []string
+		Attachments   []Attachment
+		AnswerPattern string
+		Body          string
+	}
+	Post struct {
+		Objective string
+		Success   struct {
+			Acceptable string
+			Mastery    string
+		}
+		KSAs []string
+	}
+	Debug struct {
+		Log     []string
+		Errors  []string
+		Hints   []string
+		Summary string
+	}
+	Answers []string
+}
 
-func YamlParser(input []byte) (*Header, error) {
+type HeaderParser func([]byte) (*Puzzle, error)
-	header := new(Header)
+
-	
+func YamlParser(input []byte) (*Puzzle, error) {
-	err := yaml.Unmarshal(input, header)
+	puzzle := new(Puzzle)
+
+	err := yaml.Unmarshal(input, puzzle)
 	if err != nil {
 		return nil, err
 	}
-	return header, nil
+	return puzzle, nil
 }
 
-func Rfc822Parser(input []byte) (*Header, error) {
+func Rfc822Parser(input []byte) (*Puzzle, error) {
 	msgBytes := append(input, '\n')
 	r := bytes.NewReader(msgBytes)
 	m, err := mail.ReadMessage(r)
 	if err != nil {
 		return nil, err
 	}
-	
+
-	header := new(Header)
+	puzzle := new(Puzzle)
 	for key, val := range m.Header {
 		key = strings.ToLower(key)
 		switch key {
-			case "author":
+		case "author":
-				header.Pre.Authors = val
+			puzzle.Pre.Authors = val
-			case "answer":
+		case "pattern":
-				header.Answers = val
+			puzzle.Pre.AnswerPattern = val[0]
-			default:
+		case "answer":
-				return nil, fmt.Errorf("Unknown header field: %s", key)
+			puzzle.Answers = val
+		case "summary":
+			puzzle.Debug.Summary = val[0]
+		case "hint":
+			puzzle.Debug.Hints = val
+		case "ksa":
+			puzzle.Post.KSAs = val
+		case "file":
+			for _, txt := range val {
+				parts := strings.SplitN(txt, " ", 3)
+				attachment := Attachment{}
+				attachment.FilesystemPath = parts[0]
+				if len(parts) > 1 {
+					attachment.Filename = parts[1]
+				} else {
+					attachment.Filename = attachment.FilesystemPath
+				}
+				if (len(parts) > 2) && (parts[2] == "hidden") {
+					attachment.Listed = false
+				} else {
+					attachment.Listed = true
+				}
+
+				puzzle.Pre.Attachments = append(puzzle.Pre.Attachments, attachment)
+			}
+		default:
+			return nil, fmt.Errorf("Unknown header field: %s", key)
 		}
 	}
 
-	return header, nil
+	return puzzle, nil
 }
 
-
+func parse(r io.Reader) error {
-func parse(r io.Reader) (error) {
 	headerEnd := ""
 	headerBuf := new(bytes.Buffer)
 	headerParser := Rfc822Parser
@@ -90,7 +132,7 @@ func parse(r io.Reader) (error) {
 		headerBuf.WriteString(line)
 		headerBuf.WriteRune('\n')
 	}
-	
+
 	bodyBuf := new(bytes.Buffer)
 	for scanner.Scan() {
 		line := scanner.Text()
@@ -98,37 +140,42 @@ func parse(r io.Reader) (error) {
 		bodyBuf.WriteString(line)
 		bodyBuf.WriteRune('\n')
 	}
-	
+
-	header, err := headerParser(headerBuf.Bytes())
+	puzzle, err := headerParser(headerBuf.Bytes())
 	if err != nil {
 		return err
 	}
-	
+
-	headerB, _ := yaml.Marshal(header)
 	bodyB := blackfriday.Run(bodyBuf.Bytes())
-	fmt.Println(string(headerB))
+
-	fmt.Println("")
+	if (puzzle.Pre.Body != "") && (len(bodyB) > 0) {
-	fmt.Println(string(bodyB))
+		log.Print("Body specified in header; overwriting...")
+	}
+	puzzle.Pre.Body = string(bodyB)
+
+	puzzleB, _ := json.MarshalIndent(puzzle, "", "  ")
+
+	fmt.Println(string(puzzleB))
 
 	return nil
 }
 
 func main() {
 	flag.Parse()
-	
+
 	if flag.NArg() < 1 {
 		fmt.Fprintf(flag.CommandLine.Output(), "Error: no files to parse\n\n")
 		flag.PrintDefaults()
 		os.Exit(1)
 	}
-	
+
-	for _,filename := range flag.Args() {
+	for _, filename := range flag.Args() {
 		f, err := os.Open(filename)
 		if err != nil {
 			log.Fatal(err)
 		}
 		defer f.Close()
-		
+
 		if err := parse(f); err != nil {
 			log.Fatal(err)
 		}