From f9cabc5255a5088823ece613c786c977c0567125 Mon Sep 17 00:00:00 2001 From: Neale Pickett Date: Thu, 3 Sep 2020 20:04:43 -0600 Subject: [PATCH] Start to support generated categories --- cmd/transpile/category.go | 78 +++++++++++++--- cmd/transpile/main.go | 64 +++++++++++-- cmd/transpile/puzzle.go | 162 ++++++++++++--------------------- cmd/transpile/puzzle_test.go | 26 +++--- cmd/transpile/puzzlehandler.go | 1 + 5 files changed, 194 insertions(+), 137 deletions(-) create mode 100644 cmd/transpile/puzzlehandler.go diff --git a/cmd/transpile/category.go b/cmd/transpile/category.go index d742eea..f2ab73a 100644 --- a/cmd/transpile/category.go +++ b/cmd/transpile/category.go @@ -1,27 +1,42 @@ package main import ( + "fmt" + "io" "log" "strconv" "github.com/spf13/afero" ) -// NewCategory returns a new category for the given path in the given fs. -func NewCategory(fs afero.Fs, cat string) Category { - return Category{ - Fs: NewBasePathFs(fs, cat), +type NopReadCloser struct { +} + +func (n NopReadCloser) Read(b []byte) (int, error) { + return 0, nil +} +func (n NopReadCloser) Close() error { + return nil +} + +// NewFsCategory returns a Category based on which files are present. +// If 'mkcategory' is present and executable, an FsCommandCategory is returned. +// Otherwise, FsCategory is returned. +func NewFsCategory(fs afero.Fs) Category { + if info, err := fs.Stat("mkcategory"); (err == nil) && (info.Mode()&0100 != 0) { + return FsCommandCategory{fs: fs} + } else { + return FsCategory{fs: fs} } } -// Category represents an on-disk category. -type Category struct { - afero.Fs +type FsCategory struct { + fs afero.Fs } -// Puzzles returns a list of puzzle values. -func (c Category) Puzzles() ([]int, error) { - puzzleEntries, err := afero.ReadDir(c, ".") +// Category returns a list of puzzle values. +func (c FsCategory) Inventory() ([]int, error) { + puzzleEntries, err := afero.ReadDir(c.fs, ".") if err != nil { return nil, err } @@ -41,7 +56,44 @@ func (c Category) Puzzles() ([]int, error) { return puzzles, nil } -// PuzzleDir returns the PuzzleDir associated with points. -func (c Category) PuzzleDir(points int) *PuzzleDir { - return NewPuzzleDir(c.Fs, points) +func (c FsCategory) Puzzle(points int) (Puzzle, error) { + return NewFsPuzzle(c.fs, points).Puzzle() +} + +func (c FsCategory) Open(points int, filename string) (io.ReadCloser, error) { + return NewFsPuzzle(c.fs, points).Open(filename) +} + +func (c FsCategory) Answer(points int, answer string) bool { + // BUG(neale): FsCategory.Answer should probably always return false, to prevent you from running uncompiled puzzles with participants. + p, err := c.Puzzle(points) + if err != nil { + return false + } + for _, a := range p.Answers { + if a == answer { + return true + } + } + return false +} + +type FsCommandCategory struct { + fs afero.Fs +} + +func (c FsCommandCategory) Inventory() ([]int, error) { + return nil, fmt.Errorf("Not implemented") +} + +func (c FsCommandCategory) Puzzle(points int) (Puzzle, error) { + return Puzzle{}, fmt.Errorf("Not implemented") +} + +func (c FsCommandCategory) Open(points int, filename string) (io.ReadCloser, error) { + return NopReadCloser{}, fmt.Errorf("Not implemented") +} + +func (c FsCommandCategory) Answer(points int, answer string) bool { + return false } diff --git a/cmd/transpile/main.go b/cmd/transpile/main.go index 4aeec1e..9562746 100644 --- a/cmd/transpile/main.go +++ b/cmd/transpile/main.go @@ -13,6 +13,54 @@ import ( "github.com/spf13/afero" ) +// Category defines the functionality required to be a puzzle category. +type Category interface { + // Inventory lists every puzzle in the category. + Inventory() ([]int, error) + + // Puzzle provides a Puzzle structure for the given point value. + Puzzle(points int) (Puzzle, error) + + // Open returns an io.ReadCloser for the given filename. + Open(points int, filename string) (io.ReadCloser, error) + + // Answer returns whether the given answer is correct. + Answer(points int, answer string) bool +} + +// PuzzleDef contains everything about a puzzle. +type Puzzle struct { + Pre struct { + Authors []string + Attachments []Attachment + Scripts []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 +} + +// Attachment carries information about an attached file. +type Attachment struct { + Filename string // Filename presented as part of puzzle + FilesystemPath string // Filename in backing FS (URL, mothball, or local FS) + Listed bool // Whether this file is listed as an attachment +} + // T contains everything required for a transpilation invocation (across the nation). type T struct { // What action to take @@ -24,11 +72,6 @@ type T struct { Fs afero.Fs } -// NewCategory returns a new Category as specified by cat. -func (t *T) NewCategory(cat string) Category { - return NewCategory(t.Fs, cat) -} - // ParseArgs parses command-line arguments into T, returning the action to take func (t *T) ParseArgs() string { action := flag.String("action", "inventory", "Action to take: must be 'inventory', 'open', 'answer', or 'mothball'") @@ -66,7 +109,7 @@ func (t *T) PrintInventory() error { for _, ent := range dirEnts { if ent.IsDir() { c := t.NewCategory(ent.Name()) - if puzzles, err := c.Puzzles(); err != nil { + if puzzles, err := c.Inventory(); err != nil { log.Print(err) continue } else { @@ -86,11 +129,10 @@ func (t *T) PrintInventory() error { // Open writes a file to the writer. func (t *T) Open() error { c := t.NewCategory(t.Cat) - pd := c.PuzzleDir(t.Points) switch t.Filename { case "puzzle.json", "": - p, err := pd.Export() + p, err := c.Puzzle(t.Points) if err != nil { return err } @@ -100,7 +142,7 @@ func (t *T) Open() error { } t.w.Write(jp) default: - f, err := pd.Open(t.Filename) + f, err := c.Open(t.Points, t.Filename) if err != nil { return err } @@ -113,6 +155,10 @@ func (t *T) Open() error { return nil } +func (t *T) NewCategory(name string) Category { + return NewFsCategory(NewBasePathFs(t.Fs, name)) +} + func main() { // XXX: Convert puzzle.py to standalone thingies diff --git a/cmd/transpile/puzzle.go b/cmd/transpile/puzzle.go index 2202e4c..cf6d5a9 100644 --- a/cmd/transpile/puzzle.go +++ b/cmd/transpile/puzzle.go @@ -9,7 +9,6 @@ import ( "io" "log" "net/mail" - "os" "os/exec" "strconv" "strings" @@ -20,56 +19,27 @@ import ( "gopkg.in/yaml.v2" ) -// NewPuzzleDir returns a new PuzzleDir for points. -func NewPuzzleDir(fs afero.Fs, points int) *PuzzleDir { - pd := &PuzzleDir{ +// NewFsPuzzle returns a new FsPuzzle for points. +func NewFsPuzzle(fs afero.Fs, points int) *FsPuzzle { + fp := &FsPuzzle{ fs: NewBasePathFs(fs, strconv.Itoa(points)), } - // BUG(neale): Doesn't yet handle "puzzle.py" or "mkpuzzle" - return pd + return fp } -// PuzzleDir is a single puzzle's directory. -type PuzzleDir struct { - fs afero.Fs +// FsPuzzle is a single puzzle's directory. +type FsPuzzle struct { + fs afero.Fs mkpuzzle bool } -// Open returns a newly-opened file. -func (pd *PuzzleDir) Open(name string) (io.ReadCloser, error) { - // BUG(neale): You cannot open generated files in puzzles, only files actually on the disk - if _, err := pd.fs.Stat("" - return pd.fs.Open(name) -} - -// Export returns a Puzzle struct for the current puzzle. -func (pd *PuzzleDir) Export() (Puzzle, error) { - p, staticErr := pd.exportStatic() - if staticErr == nil { - return p, nil - } - - // Only fall through if the static files don't exist. Otherwise, report the error. - if !os.IsNotExist(staticErr) { - return p, staticErr - } - - if p, cmdErr := pd.exportCommand(); cmdErr == nil { - return p, nil - } else if os.IsNotExist(cmdErr) { - // If the command doesn't exist either, report the non-existence of the static file instead. - return p, staticErr - } else { - return p, cmdErr - } -} - -func (pd *PuzzleDir) exportStatic() (Puzzle, error) { - r, err := pd.fs.Open("puzzle.md") +// Puzzle returns a Puzzle struct for the current puzzle. +func (fp FsPuzzle) Puzzle() (Puzzle, error) { + r, err := fp.fs.Open("puzzle.md") if err != nil { var err2 error - if r, err2 = pd.fs.Open("puzzle.moth"); err2 != nil { + if r, err2 = fp.fs.Open("puzzle.moth"); err2 != nil { return Puzzle{}, err } } @@ -124,34 +94,9 @@ func (pd *PuzzleDir) exportStatic() (Puzzle, error) { return puzzle, nil } -func (pd *PuzzleDir) exportCommand() (Puzzle, error) { - bfs, ok := pd.fs.(*BasePathFs) - if !ok { - return Puzzle{}, fmt.Errorf("Fs won't resolve real paths for %v", pd) - } - mkpuzzlePath, err := bfs.RealPath("mkpuzzle") - if err != nil { - return Puzzle{}, err - } - log.Print(mkpuzzlePath) - - ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) - defer cancel() - - cmd := exec.CommandContext(ctx, mkpuzzlePath) - stdout, err := cmd.Output() - if err != nil { - return Puzzle{}, err - } - - jsdec := json.NewDecoder(bytes.NewReader(stdout)) - jsdec.DisallowUnknownFields() - puzzle := Puzzle{} - if err := jsdec.Decode(&puzzle); err != nil { - return Puzzle{}, err - } - - return puzzle, nil +// Open returns a newly-opened file. +func (fp FsPuzzle) Open(name string) (io.ReadCloser, error) { + return fp.fs.Open(name) } func legacyAttachmentParser(val []string) []Attachment { @@ -175,39 +120,6 @@ func legacyAttachmentParser(val []string) []Attachment { return ret } -// Puzzle contains everything about a puzzle. -type Puzzle struct { - Pre struct { - Authors []string - Attachments []Attachment - Scripts []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 -} - -// Attachment carries information about an attached file. -type Attachment struct { - Filename string // Filename presented as part of puzzle - FilesystemPath string // Filename in backing FS (URL, mothball, or local FS) - Listed bool // Whether this file is listed as an attachment -} - func yamlHeaderParser(r io.Reader) (Puzzle, error) { p := Puzzle{} decoder := yaml.NewDecoder(r) @@ -249,3 +161,49 @@ func rfc822HeaderParser(r io.Reader) (Puzzle, error) { return p, nil } + +func (fp FsPuzzle) Answer(answer string) bool { + return false +} + +type FsCommandPuzzle struct { + fs afero.Fs +} + +func (fp FsCommandPuzzle) Puzzle() (Puzzle, error) { + bfs, ok := fp.fs.(*BasePathFs) + if !ok { + return Puzzle{}, fmt.Errorf("Fs won't resolve real paths for %v", fp) + } + mkpuzzlePath, err := bfs.RealPath("mkpuzzle") + if err != nil { + return Puzzle{}, err + } + log.Print(mkpuzzlePath) + + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + + cmd := exec.CommandContext(ctx, mkpuzzlePath) + stdout, err := cmd.Output() + if err != nil { + return Puzzle{}, err + } + + jsdec := json.NewDecoder(bytes.NewReader(stdout)) + jsdec.DisallowUnknownFields() + puzzle := Puzzle{} + if err := jsdec.Decode(&puzzle); err != nil { + return Puzzle{}, err + } + + return puzzle, nil +} + +func (fp FsCommandPuzzle) Open(filename string) (io.ReadCloser, error) { + return NopReadCloser{}, fmt.Errorf("Not implemented") +} + +func (fp FsCommandPuzzle) Answer(answer string) bool { + return false +} diff --git a/cmd/transpile/puzzle_test.go b/cmd/transpile/puzzle_test.go index 3f1788f..9b6a6d9 100644 --- a/cmd/transpile/puzzle_test.go +++ b/cmd/transpile/puzzle_test.go @@ -14,8 +14,8 @@ func TestPuzzle(t *testing.T) { catFs := afero.NewBasePathFs(puzzleFs, "cat0") { - pd := NewPuzzleDir(catFs, 1) - p, err := pd.Export() + pd := NewFsPuzzle(catFs, 1) + p, err := pd.Puzzle() if err != nil { t.Error(err) } @@ -32,7 +32,7 @@ func TestPuzzle(t *testing.T) { } { - p, err := NewPuzzleDir(catFs, 2).Export() + p, err := NewFsPuzzle(catFs, 2).Puzzle() if err != nil { t.Error(err) } @@ -47,24 +47,24 @@ func TestPuzzle(t *testing.T) { } } - if _, err := NewPuzzleDir(catFs, 3).Export(); err != nil { + if _, err := NewFsPuzzle(catFs, 3).Puzzle(); err != nil { t.Error("Legacy `puzzle.moth` file:", err) } - if _, err := NewPuzzleDir(catFs, 99).Export(); err == nil { + if _, err := NewFsPuzzle(catFs, 99).Puzzle(); err == nil { t.Error("Non-existent puzzle", err) } - if _, err := NewPuzzleDir(catFs, 10).Export(); err == nil { + if _, err := NewFsPuzzle(catFs, 10).Puzzle(); err == nil { t.Error("Broken YAML") } - if _, err := NewPuzzleDir(catFs, 20).Export(); err == nil { + if _, err := NewFsPuzzle(catFs, 20).Puzzle(); err == nil { t.Error("Bad RFC822 header") } - if _, err := NewPuzzleDir(catFs, 21).Export(); err == nil { + if _, err := NewFsPuzzle(catFs, 21).Puzzle(); err == nil { t.Error("Boken RFC822 header") } - if p, err := NewPuzzleDir(catFs, 22).Export(); err == nil { + if p, err := NewFsPuzzle(catFs, 22).Puzzle(); err == nil { t.Error("Duplicate bodies") } else if !strings.HasPrefix(err.Error(), "Puzzle body present") { t.Log(p) @@ -75,16 +75,16 @@ func TestPuzzle(t *testing.T) { func TestFsPuzzle(t *testing.T) { catFs := afero.NewBasePathFs(afero.NewOsFs(), "testdata") - if _, err := NewPuzzleDir(catFs, 1).Export(); err != nil { + if _, err := NewFsPuzzle(catFs, 1).Puzzle(); err != nil { t.Error(err) } - if _, err := NewPuzzleDir(catFs, 2).Export(); err != nil { + if _, err := NewFsPuzzle(catFs, 2).Puzzle(); err != nil { t.Error(err) } - mkpuzzleDir := NewPuzzleDir(catFs, 3) - if _, err := mkpuzzleDir.Export(); err != nil { + mkpuzzleDir := NewFsPuzzle(catFs, 3) + if _, err := mkpuzzleDir.Puzzle(); err != nil { t.Error(err) } diff --git a/cmd/transpile/puzzlehandler.go b/cmd/transpile/puzzlehandler.go new file mode 100644 index 0000000..06ab7d0 --- /dev/null +++ b/cmd/transpile/puzzlehandler.go @@ -0,0 +1 @@ +package main