From a713753d70ace5ea73c0bf35a11689f32f7c9e51 Mon Sep 17 00:00:00 2001 From: Kenia Date: Sun, 1 Nov 2020 02:32:42 -0800 Subject: [PATCH 1/5] Support returning multiple errors on parse and compile --- main.go | 21 ++++++++++++--------- pkg/lang/compile.go | 13 +++++++++++-- pkg/lang/errors.go | 31 ++++++++++++++++++++++++++++++- pkg/lang/parse.go | 36 ++++++++++++++++++++++++++++++------ 4 files changed, 83 insertions(+), 18 deletions(-) diff --git a/main.go b/main.go index fa79a8d..be5e0d9 100644 --- a/main.go +++ b/main.go @@ -3,16 +3,17 @@ package main import ( "flag" "fmt" + "os" + "strings" + "github.com/mbStavola/slydes/pkg/lang" "github.com/mbStavola/slydes/render/html" "github.com/mbStavola/slydes/render/native" - "os" - "strings" ) func main() { filename := flag.String("file", "", "slide to open") - output := flag.String("out", "html", "method of display (html, native)") + output := flag.String("out", "html", "method of display (html, noop, native)") debug := flag.Bool("debug", false, "print debug info") flag.Parse() @@ -23,8 +24,8 @@ func main() { } else if !strings.HasSuffix(*filename, ".sly") { fmt.Print("Only .sly files are supported") return - } else if *output != "native" && *output != "html" { - fmt.Print("Output must be either native or html") + } else if *output != "native" && *output != "html" && *output != "noop" { + fmt.Print("Output must be either html, native, or noop") return } @@ -47,14 +48,16 @@ func main() { } switch *output { - case "native": - if err := native.Render(show); err != nil { + case "html": + if err := html.Render(show); err != nil { fmt.Print(err) } break - case "html": - if err := html.Render(show); err != nil { + case "noop": + break + case "native": + if err := native.Render(show); err != nil { fmt.Print(err) } diff --git a/pkg/lang/compile.go b/pkg/lang/compile.go index 85286a5..d55ea51 100644 --- a/pkg/lang/compile.go +++ b/pkg/lang/compile.go @@ -1,9 +1,11 @@ package lang import ( + "errors" "fmt" - "github.com/mbStavola/slydes/pkg/types" "image/color" + + "github.com/mbStavola/slydes/pkg/types" ) type Compiler interface { @@ -18,13 +20,20 @@ func NewDefaultCompiler() DefaultCompiler { func (comp DefaultCompiler) Compile(statements []Statement) (types.Show, error) { state := newCompilationState() + errBundle := newErrorInfoBundle() for _, statement := range statements { - if err := state.processStatement(statement); err != nil { + if err := state.processStatement(statement); err != nil && errors.As(err, &ErrorInfo{}) { + errBundle.Add(err.(ErrorInfo)) + } else if err != nil { return types.Show{}, err } } + if errBundle.HasErrors() { + return types.Show{}, errBundle + } + return state.finalizeCompilation(), nil } diff --git a/pkg/lang/errors.go b/pkg/lang/errors.go index 1c19144..76b3b12 100644 --- a/pkg/lang/errors.go +++ b/pkg/lang/errors.go @@ -1,6 +1,35 @@ package lang -import "fmt" +import ( + "fmt" + "strings" +) + +type ErrorInfoBundle struct { + errors []ErrorInfo +} + +func newErrorInfoBundle() ErrorInfoBundle { + return ErrorInfoBundle{errors: make([]ErrorInfo, 0)} +} + +func (b *ErrorInfoBundle) Add(err ErrorInfo) { + b.errors = append(b.errors, err) +} + +func (b ErrorInfoBundle) HasErrors() bool { + return len(b.errors) > 0 +} + +func (b ErrorInfoBundle) Error() string { + builder := strings.Builder{} + for _, err := range b.errors { + builder.WriteString(err.Error()) + builder.WriteByte('\n') + } + + return builder.String() +} type ErrorInfo struct { line uint diff --git a/pkg/lang/parse.go b/pkg/lang/parse.go index a23cc78..9d16b88 100644 --- a/pkg/lang/parse.go +++ b/pkg/lang/parse.go @@ -1,6 +1,9 @@ package lang -import "fmt" +import ( + "errors" + "fmt" +) type StatementType int @@ -84,16 +87,24 @@ func NewDefaultParser() DefaultParser { func (pars DefaultParser) Parse(tokens []Token) ([]Statement, error) { statements := make([]Statement, 0, 1024) muncher := tokenMuncher{tokens: tokens} + errBundle := newErrorInfoBundle() for !muncher.atEnd() { statement, err := declaration(&muncher) - if err != nil { + if err != nil && errors.As(err, &ErrorInfo{}) { + errBundle.Add(err.(ErrorInfo)) + synchronizeFromErrorState(&muncher) + } else if err != nil { return statements, err } statements = append(statements, statement) } + if errBundle.HasErrors() { + return statements, errBundle + } + return statements, nil } @@ -234,11 +245,12 @@ func colorLiteral(muncher *tokenMuncher) (interface{}, error) { } // TODO(Matt): We should be able to use variables here - if value, err := muncher.tryEat(Integer); err != nil { + value, err := muncher.tryEat(Integer) + if err != nil { return nil, err - } else { - values[i] = value.data.(uint8) } + + values[i] = value.data.(uint8) } // Allow trailing comma @@ -284,6 +296,18 @@ func value(muncher *tokenMuncher) (interface{}, error) { return nil, tokenErrorInfo(token, "Expected value") } +func synchronizeFromErrorState(muncher *tokenMuncher) { + muncher.eat() + + for !muncher.atEnd() { + if muncher.previous().Type == Semicolon { + return + } + + muncher.eat() + } +} + type tokenMuncher struct { tokens []Token current int @@ -344,7 +368,7 @@ func (tm *tokenMuncher) check(expected TokenType) bool { func (tm *tokenMuncher) eat() Token { if !tm.atEnd() { - tm.current += 1 + tm.current++ } return tm.previous() From 6db1199e698c2224a1e19d11cc3e232929a85412 Mon Sep 17 00:00:00 2001 From: Kenia Date: Sun, 1 Nov 2020 02:45:25 -0800 Subject: [PATCH 2/5] Go lint fixes --- pkg/lang/lex.go | 6 +++--- pkg/lang/sly.go | 3 ++- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/pkg/lang/lex.go b/pkg/lang/lex.go index c557f01..016f323 100644 --- a/pkg/lang/lex.go +++ b/pkg/lang/lex.go @@ -94,7 +94,7 @@ func (lex DefaultLexer) Lex(reader io.Reader) ([]Token, error) { switch char { case '#': _, _, _ = bufReader.ReadLine() - line += 1 + line++ break case '[': @@ -226,7 +226,7 @@ func (lex DefaultLexer) Lex(reader io.Reader) ([]Token, error) { if char == '-' && dashCounter == 2 { break } else if char == '-' { - dashCounter += 1 + dashCounter++ continue } else if dashCounter > 0 { // If we've seen some number of dashes that is less than @@ -303,7 +303,7 @@ func (lex DefaultLexer) Lex(reader io.Reader) ([]Token, error) { break case '\n': - line += 1 + line++ break default: diff --git a/pkg/lang/sly.go b/pkg/lang/sly.go index c1ee31f..be557f2 100644 --- a/pkg/lang/sly.go +++ b/pkg/lang/sly.go @@ -1,9 +1,10 @@ package lang import ( - "github.com/mbStavola/slydes/pkg/types" "io" "strings" + + "github.com/mbStavola/slydes/pkg/types" ) // This type represents a three phase "compiler" for From 74945ae234d10f7e470bc97b7e08618dd2fb2d2b Mon Sep 17 00:00:00 2001 From: Kenia Date: Sun, 1 Nov 2020 03:23:34 -0800 Subject: [PATCH 3/5] Return multiple lex errors --- pkg/lang/lex.go | 467 ++++++++++++++++++++++++++---------------------- 1 file changed, 251 insertions(+), 216 deletions(-) diff --git a/pkg/lang/lex.go b/pkg/lang/lex.go index 016f323..70912d1 100644 --- a/pkg/lang/lex.go +++ b/pkg/lang/lex.go @@ -3,6 +3,7 @@ package lang import ( "bufio" "bytes" + "errors" "io" "strconv" "strings" @@ -14,6 +15,7 @@ type TokenType int const ( InvalidToken TokenType = iota EOF + Skip // Single Character LeftParen @@ -42,6 +44,7 @@ func (t TokenType) String() string { return []string{ "InvalidToken", "EOF", + "Skip", "LeftParen", "RightParen", @@ -82,282 +85,314 @@ func NewDefaultLexer() DefaultLexer { } func (lex DefaultLexer) Lex(reader io.Reader) ([]Token, error) { - bufReader := bufio.NewReader(reader) + muncher := newRuneMuncher(reader) + errBundle := newErrorInfoBundle() + tokens := make([]Token, 0, 1024) - var line uint = 1 - for char, _, err := bufReader.ReadRune(); err != io.EOF; char, _, err = bufReader.ReadRune() { - if err != nil { + for !muncher.atEnd() { + token, err := processRune(muncher) + if err != nil && errors.As(err, &ErrorInfo{}) { + errBundle.Add(err.(ErrorInfo)) + } else if err != nil { return tokens, err } - switch char { - case '#': - _, _, _ = bufReader.ReadLine() - line++ - - break - case '[': - ty := SlideScope - if shouldEat, err := eatIf(bufReader, '['); err == io.EOF { - return tokens, lexemeErrorInfo(line, char, "Unexpected end of file") - } else if err != nil { - return tokens, err - } else if shouldEat { - ty = SubScope - } + if token.Type == Skip { + continue + } - title, err := bufReader.ReadString(']') - if err == io.EOF { - return tokens, lexemeErrorInfo(line, char, "Unterminated scope") - } else if err != nil { - return tokens, err - } + tokens = append(tokens, token) + } - if shouldEat, err := eatIf(bufReader, ']'); err == io.EOF { - return tokens, lexemeErrorInfo(line, char, "Unexpected end of file") - } else if err != nil { - return tokens, err - } else if ty == SubScope && !shouldEat { - return tokens, lexemeErrorInfo(line, ']', "Subscope expected closing ']'") - } else if ty == SlideScope && shouldEat { - return tokens, lexemeErrorInfo(line, ']', "Dangling scope end") - } + if errBundle.HasErrors() { + return tokens, errBundle + } - tokens = append(tokens, Token{ - Type: ty, - line: line, - lexeme: char, - // Cut off the dangling ] in the scope title - data: title[:len(title)-1], - }) - - break - case '(': - tokens = append(tokens, Token{ - Type: LeftParen, - line: line, - lexeme: char, - }) + return tokens, nil +} - break - case ')': - tokens = append(tokens, Token{ - Type: RightParen, - line: line, - lexeme: char, - }) +func processRune(muncher *runeMuncher) (Token, error) { + char, _, err := muncher.ReadRune() + if err != nil { + return Token{}, err + } - break - case '{': - tokens = append(tokens, Token{ - Type: LeftBrace, - line: line, - lexeme: char, - }) + switch char { + case '#': + _, _, _ = muncher.ReadLine() + muncher.newLine() + return Token{Type: Skip}, nil + + case '[': + ty := SlideScope + if shouldEat, err := muncher.eatIf('['); err == io.EOF { + return Token{}, lexemeErrorInfo(muncher.line, char, "Unexpected end of file") + } else if err != nil { + return Token{}, err + } else if shouldEat { + ty = SubScope + } - break - case '}': - tokens = append(tokens, Token{ - Type: RightBrace, - line: line, - lexeme: char, - }) + title, err := muncher.ReadString(']') + if err == io.EOF { + return Token{}, lexemeErrorInfo(muncher.line, char, "Unterminated scope") + } else if err != nil { + return Token{}, err + } - break - case '@': - tokens = append(tokens, Token{ - Type: AtSign, - line: line, - lexeme: char, - }) + if shouldEat, err := muncher.eatIf(']'); err == io.EOF { + return Token{}, lexemeErrorInfo(muncher.line, char, "Unexpected end of file") + } else if err != nil { + return Token{}, err + } else if ty == SubScope && !shouldEat { + return Token{}, lexemeErrorInfo(muncher.line, ']', "Subscope expected closing ']'") + } else if ty == SlideScope && shouldEat { + return Token{}, lexemeErrorInfo(muncher.line, ']', "Dangling scope end") + } - break - case '$': - tokens = append(tokens, Token{ - Type: DollarSign, - line: line, - lexeme: char, - }) + return Token{ + Type: ty, + line: muncher.line, + lexeme: char, + // Cut off the dangling ] in the scope title + data: title[:len(title)-1], + }, nil + + case '(': + return Token{ + Type: LeftParen, + line: muncher.line, + lexeme: char, + }, nil + + case ')': + return Token{ + Type: RightParen, + line: muncher.line, + lexeme: char, + }, nil + + case '{': + return Token{ + Type: LeftBrace, + line: muncher.line, + lexeme: char, + }, nil + + case '}': + return Token{ + Type: RightBrace, + line: muncher.line, + lexeme: char, + }, nil + + case '@': + return Token{ + Type: AtSign, + line: muncher.line, + lexeme: char, + }, nil + + case '$': + return Token{ + Type: DollarSign, + line: muncher.line, + lexeme: char, + }, nil + + case '=': + return Token{ + Type: EqualSign, + line: muncher.line, + lexeme: char, + }, nil + + case ';': + return Token{ + Type: Semicolon, + line: muncher.line, + lexeme: char, + }, nil + + case ',': + return Token{ + Type: Comma, + line: muncher.line, + lexeme: char, + }, nil + + case '-': + if chars, err := muncher.Peek(2); err == io.EOF { + return Token{}, lexemeErrorInfo(muncher.line, char, "Unexpected end of file") + } else if err != nil { + return Token{}, err + } else if string(chars[:]) != "--" { + return Token{}, lexemeErrorInfo(muncher.line, char, "Malformed text block") + } - break - case '=': - tokens = append(tokens, Token{ - Type: EqualSign, - line: line, - lexeme: char, - }) + // Eat the starting dashes + if err = muncher.eatN(2); err != nil { + return Token{}, err + } - break - case ';': - tokens = append(tokens, Token{ - Type: Semicolon, - line: line, - lexeme: char, - }) + text := strings.Builder{} + dashCounter := 0 - case ',': - tokens = append(tokens, Token{ - Type: Comma, - line: line, - lexeme: char, - }) - - break - case '-': - if chars, err := bufReader.Peek(2); err == io.EOF { - return tokens, lexemeErrorInfo(line, char, "Unexpected end of file") - } else if err != nil { - return tokens, err - } else if string(chars[:]) != "--" { - return tokens, lexemeErrorInfo(line, char, "Malformed text block") + // Read runes until we encounter three dashes in a row + for char, _, err := muncher.ReadRune(); ; char, _, err = muncher.ReadRune() { + if char == '-' && dashCounter == 2 { + break + } else if char == '-' { + dashCounter++ + continue + } else if dashCounter > 0 { + // If we've seen some number of dashes that is less than + // three, write them to the text buffer and reset the count + dashes := bytes.Repeat([]byte("-"), dashCounter) + text.Write(dashes) + dashCounter = 0 } - // Eat the starting dashes - if err = eatN(bufReader, 2); err != nil { - return tokens, err + if err != nil { + return Token{}, err } - text := strings.Builder{} - dashCounter := 0 + text.WriteRune(char) + } - // Read runes until we encounter three dashes in a row - for char, _, err := bufReader.ReadRune(); ; char, _, err = bufReader.ReadRune() { - if char == '-' && dashCounter == 2 { - break - } else if char == '-' { - dashCounter++ - continue - } else if dashCounter > 0 { - // If we've seen some number of dashes that is less than - // three, write them to the text buffer and reset the count - dashes := bytes.Repeat([]byte("-"), dashCounter) - text.Write(dashes) - dashCounter = 0 - } + return Token{ + Type: Text, + line: muncher.line, + lexeme: char, + data: text.String(), + }, nil + + case '"': + str, err := muncher.ReadString('"') + if err == io.EOF { + return Token{}, simpleErrorInfo(muncher.line, "Unterminated String") + } else if err != nil { + return Token{}, err + } - if err != nil { - return tokens, err - } + return Token{ + Type: String, + line: muncher.line, + lexeme: char, + // Cut off the dangling " in the string + data: str[:len(str)-1], + }, nil + + case '0': + case '1', '2', '3', '4', '5', '6', '7', '8', '9': + num := strings.Builder{} + num.WriteRune(char) - text.WriteRune(char) + for char, _, err := muncher.ReadRune(); ; char, _, err = muncher.ReadRune() { + if err != nil { + return Token{}, err } - tokens = append(tokens, Token{ - Type: Text, - line: line, - lexeme: char, - data: text.String(), - }) - - break - case '"': - str, err := bufReader.ReadString('"') - if err == io.EOF { - return tokens, simpleErrorInfo(line, "Unterminated String") - } else if err != nil { - return tokens, err + if !unicode.IsNumber(char) { + muncher.UnreadRune() + break } - tokens = append(tokens, Token{ - Type: String, - line: line, - lexeme: char, - // Cut off the dangling " in the string - data: str[:len(str)-1], - }) - - break - case '0': - case '1', '2', '3', '4', '5', '6', '7', '8', '9': - num := strings.Builder{} num.WriteRune(char) + } - for char, _, err := bufReader.ReadRune(); ; char, _, err = bufReader.ReadRune() { + data, err := strconv.ParseUint(num.String(), 10, 8) + if err != nil { + return Token{}, err + } + + return Token{ + Type: Integer, + line: muncher.line, + lexeme: char, + data: uint8(data), + }, nil + + case ' ', '\t', '\r': + return Token{Type: Skip}, nil + + case '\n': + muncher.newLine() + return Token{Type: Skip}, nil + + default: + if unicode.IsLetter(char) { + ident := strings.Builder{} + ident.WriteRune(char) + + for char, _, err := muncher.ReadRune(); ; char, _, err = muncher.ReadRune() { if err != nil { - return tokens, err + return Token{}, err } - if !unicode.IsNumber(char) { - bufReader.UnreadRune() + if !unicode.IsLetter(char) && !unicode.IsNumber(char) { + muncher.UnreadRune() break } - num.WriteRune(char) - } - - data, err := strconv.ParseUint(num.String(), 10, 8) - if err != nil { - return tokens, err + ident.WriteRune(char) } - tokens = append(tokens, Token{ - Type: Integer, - line: line, + return Token{ + Type: Identifier, + line: muncher.line, lexeme: char, - data: uint8(data), - }) - - break - case ' ', '\t', '\r': - - break - case '\n': - line++ + data: ident.String(), + }, nil + } - break - default: - if unicode.IsLetter(char) { - ident := strings.Builder{} - ident.WriteRune(char) + return Token{}, lexemeErrorInfo(muncher.line, char, "Unexpected character") + } - for char, _, err := bufReader.ReadRune(); ; char, _, err = bufReader.ReadRune() { - if err != nil { - return tokens, err - } + panic("unreachable") +} - if !unicode.IsLetter(char) && !unicode.IsNumber(char) { - bufReader.UnreadRune() - break - } +type runeMuncher struct { + line uint + *bufio.Reader +} - ident.WriteRune(char) - } +func newRuneMuncher(reader io.Reader) *runeMuncher { + r := new(runeMuncher) - tokens = append(tokens, Token{ - Type: Identifier, - line: line, - lexeme: char, - data: ident.String(), - }) + r.line = 1 + r.Reader = bufio.NewReader(reader) - break - } + return r +} - return tokens, lexemeErrorInfo(line, char, "Unexpected character") - } - } +func (r *runeMuncher) atEnd() bool { + _, err := r.Peek(1) + return err == io.EOF +} - return tokens, nil +func (r *runeMuncher) newLine() { + r.line++ } // Helper function to conditionally eat a lexeme if it matches // the expected rune -func eatIf(reader *bufio.Reader, expected rune) (bool, error) { - if actual, _, err := reader.ReadRune(); err != nil { +func (r *runeMuncher) eatIf(expected rune) (bool, error) { + if actual, _, err := r.ReadRune(); err != nil { // TODO(Matt): Would it be more correct to unread the rune here? return false, err } else if actual == expected { return true, nil } - return false, reader.UnreadRune() + return false, r.UnreadRune() } // Helper function to discard a specified number of runes -func eatN(reader *bufio.Reader, n int) error { +func (r *runeMuncher) eatN(n int) error { for i := 0; i < n; i++ { - if _, _, err := reader.ReadRune(); err != nil { + if _, _, err := r.ReadRune(); err != nil { return err } } From 068cfa3fb1c43172edade17d87d83d541271eb49 Mon Sep 17 00:00:00 2001 From: Kenia Date: Sun, 1 Nov 2020 03:48:56 -0800 Subject: [PATCH 4/5] Slightly refactor lexing multicharacter tokens --- pkg/lang/lex.go | 58 +++++++++++++++++++++++++++++++++---------------- 1 file changed, 39 insertions(+), 19 deletions(-) diff --git a/pkg/lang/lex.go b/pkg/lang/lex.go index 70912d1..9064329 100644 --- a/pkg/lang/lex.go +++ b/pkg/lang/lex.go @@ -240,12 +240,12 @@ func processRune(muncher *runeMuncher) (Token, error) { dashCounter := 0 // Read runes until we encounter three dashes in a row - for char, _, err := muncher.ReadRune(); ; char, _, err = muncher.ReadRune() { + err := muncher.eatWhile(func(char rune) bool { if char == '-' && dashCounter == 2 { - break + return false } else if char == '-' { dashCounter++ - continue + return true } else if dashCounter > 0 { // If we've seen some number of dashes that is less than // three, write them to the text buffer and reset the count @@ -254,11 +254,13 @@ func processRune(muncher *runeMuncher) (Token, error) { dashCounter = 0 } - if err != nil { - return Token{}, err - } - text.WriteRune(char) + + return true + }) + + if err != nil { + return Token{}, err } return Token{ @@ -289,17 +291,19 @@ func processRune(muncher *runeMuncher) (Token, error) { num := strings.Builder{} num.WriteRune(char) - for char, _, err := muncher.ReadRune(); ; char, _, err = muncher.ReadRune() { - if err != nil { - return Token{}, err - } - + err := muncher.eatWhile(func(char rune) bool { if !unicode.IsNumber(char) { muncher.UnreadRune() - break + return false } num.WriteRune(char) + + return true + }) + + if err != nil { + return Token{}, err } data, err := strconv.ParseUint(num.String(), 10, 8) @@ -326,17 +330,19 @@ func processRune(muncher *runeMuncher) (Token, error) { ident := strings.Builder{} ident.WriteRune(char) - for char, _, err := muncher.ReadRune(); ; char, _, err = muncher.ReadRune() { - if err != nil { - return Token{}, err - } - + err := muncher.eatWhile(func(char rune) bool { if !unicode.IsLetter(char) && !unicode.IsNumber(char) { muncher.UnreadRune() - break + return false } ident.WriteRune(char) + + return true + }) + + if err != nil { + return Token{}, err } return Token{ @@ -399,3 +405,17 @@ func (r *runeMuncher) eatN(n int) error { return nil } + +func (r *runeMuncher) eatWhile(callback func(rune) bool) error { + for char, _, err := r.ReadRune(); ; char, _, err = r.ReadRune() { + if err != nil { + return err + } + + if shouldContinue := callback(char); !shouldContinue { + break + } + } + + return nil +} From a22e90f99f1315e41a04fb6b515c0b1b8133ae06 Mon Sep 17 00:00:00 2001 From: Kenia Date: Sun, 1 Nov 2020 03:53:25 -0800 Subject: [PATCH 5/5] Remove native and make noop the default --- main.go | 15 ++++----------- render/native/render.go | 9 --------- 2 files changed, 4 insertions(+), 20 deletions(-) delete mode 100644 render/native/render.go diff --git a/main.go b/main.go index be5e0d9..150ab56 100644 --- a/main.go +++ b/main.go @@ -8,12 +8,11 @@ import ( "github.com/mbStavola/slydes/pkg/lang" "github.com/mbStavola/slydes/render/html" - "github.com/mbStavola/slydes/render/native" ) func main() { filename := flag.String("file", "", "slide to open") - output := flag.String("out", "html", "method of display (html, noop, native)") + output := flag.String("out", "noop", "method of display (noop, html)") debug := flag.Bool("debug", false, "print debug info") flag.Parse() @@ -25,7 +24,7 @@ func main() { fmt.Print("Only .sly files are supported") return } else if *output != "native" && *output != "html" && *output != "noop" { - fmt.Print("Output must be either html, native, or noop") + fmt.Print("Output must be either noop or html") return } @@ -48,16 +47,10 @@ func main() { } switch *output { - case "html": - if err := html.Render(show); err != nil { - fmt.Print(err) - } - - break case "noop": break - case "native": - if err := native.Render(show); err != nil { + case "html": + if err := html.Render(show); err != nil { fmt.Print(err) } diff --git a/render/native/render.go b/render/native/render.go deleted file mode 100644 index dc14ad4..0000000 --- a/render/native/render.go +++ /dev/null @@ -1,9 +0,0 @@ -package native - -import ( - "github.com/mbStavola/slydes/pkg/types" -) - -func Render(show types.Show) error { - return nil -}