Transpiling everything in netarch now

This commit is contained in:
Neale Pickett 2019-08-17 13:09:09 -06:00
parent b5424fb005
commit 711ae36fb2
1 changed files with 93 additions and 46 deletions

View File

@ -1,71 +1,113 @@
package main package main
import ( import (
"gopkg.in/russross/blackfriday.v2"
"gopkg.in/yaml.v2"
"bufio" "bufio"
"bytes" "bytes"
"encoding/json"
"flag" "flag"
"fmt" "fmt"
"log" "gopkg.in/russross/blackfriday.v2"
"gopkg.in/yaml.v2"
"io" "io"
"os" "log"
"net/mail" "net/mail"
"os"
"strings" "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 { if err != nil {
return nil, err 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') msgBytes := append(input, '\n')
r := bytes.NewReader(msgBytes) r := bytes.NewReader(msgBytes)
m, err := mail.ReadMessage(r) m, err := mail.ReadMessage(r)
if err != nil { if err != nil {
return nil, err return nil, err
} }
header := new(Header) puzzle := new(Puzzle)
for key, val := range m.Header { for key, val := range m.Header {
key = strings.ToLower(key) key = strings.ToLower(key)
switch 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 := "" headerEnd := ""
headerBuf := new(bytes.Buffer) headerBuf := new(bytes.Buffer)
headerParser := Rfc822Parser headerParser := Rfc822Parser
@ -90,7 +132,7 @@ func parse(r io.Reader) (error) {
headerBuf.WriteString(line) headerBuf.WriteString(line)
headerBuf.WriteRune('\n') headerBuf.WriteRune('\n')
} }
bodyBuf := new(bytes.Buffer) bodyBuf := new(bytes.Buffer)
for scanner.Scan() { for scanner.Scan() {
line := scanner.Text() line := scanner.Text()
@ -98,37 +140,42 @@ func parse(r io.Reader) (error) {
bodyBuf.WriteString(line) bodyBuf.WriteString(line)
bodyBuf.WriteRune('\n') bodyBuf.WriteRune('\n')
} }
header, err := headerParser(headerBuf.Bytes()) puzzle, err := headerParser(headerBuf.Bytes())
if err != nil { if err != nil {
return err return err
} }
headerB, _ := yaml.Marshal(header)
bodyB := blackfriday.Run(bodyBuf.Bytes()) 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 return nil
} }
func main() { func main() {
flag.Parse() flag.Parse()
if flag.NArg() < 1 { if flag.NArg() < 1 {
fmt.Fprintf(flag.CommandLine.Output(), "Error: no files to parse\n\n") fmt.Fprintf(flag.CommandLine.Output(), "Error: no files to parse\n\n")
flag.PrintDefaults() flag.PrintDefaults()
os.Exit(1) os.Exit(1)
} }
for _,filename := range flag.Args() { for _, filename := range flag.Args() {
f, err := os.Open(filename) f, err := os.Open(filename)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
defer f.Close() defer f.Close()
if err := parse(f); err != nil { if err := parse(f); err != nil {
log.Fatal(err) log.Fatal(err)
} }