adventofcode/main.go at main · microhod/adventofcode · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package main

import (
	"errors"
	"fmt"
	"os"
	"strconv"
	"strings"

	"github.com/microhod/adventofcode/internal/puzzle"
)

const (
	tokenFile    = ".token"
	readmeFile   = "README.md"
	inputFile    = "input.txt"
	testFile     = "test.txt"
	solutionFile = "main.go"
)

// get the puzzle files for the year & day specified
func main() {
	// parse arguments
	if len(os.Args) < 3 {
		fail(fmt.Errorf("need year and day arguments"))
	}
	year, err := strconv.Atoi(os.Args[1])
	if err != nil {
		fail(err)
	}
	day, err := strconv.Atoi(os.Args[2])
	if err != nil {
		fail(err)
	}

	// create client with token
	bytes, err := os.ReadFile(tokenFile)
	if err != nil {
		fail(err)
	}
	token := strings.TrimSpace(string(bytes))

	client := puzzle.NewClient(token)
	p, err := client.Get(year, day)
	if err != nil {
		fail(err)
	}

	// make folders
	err = os.MkdirAll(folder(year, day), os.ModePerm)
	if err != nil {
		fail(err)
	}

	// README.md
	readme, err := os.Create(fmt.Sprintf("%s/%s", folder(year, day), readmeFile))
	if err != nil {
		fail(err)
	}
	fmt.Fprintln(readme, p.Readme)

	// input.txt
	input, err := os.Create(fmt.Sprintf("%s/%s", folder(year, day), inputFile))
	if err != nil {
		fail(err)
	}
	fmt.Fprint(input, p.Input)

	// test.txt
	testFilePath := fmt.Sprintf("%s/%s", folder(year, day), testFile)
	// only create test.txt if it doesn't already exist
	if !exists(testFilePath) {
		test, err := os.Create(testFilePath)
		if err != nil {
			fail(err)
		}
		fmt.Fprintln(test, p.TestInput)
	}

	// main.go
	solutionPath := fmt.Sprintf("%s/%s", folder(year, day), solutionFile)
	// only create main.go if it doesn't already exist
	if !exists(solutionPath) {
		main, err := os.Create(solutionPath)
		if err != nil {
			fail(err)
		}
		solution, err := puzzle.InitialSolutionFile(p)
		if err != nil {
			fail(err)
		}
		fmt.Fprint(main, solution)
	}
}

func exists(path string) bool {
	_, err := os.Stat(path)
	return !errors.Is(err, os.ErrNotExist)
}

func fail(err error) {
	fmt.Printf("ERROR: %s\n", err)
	os.Exit(1)
}

func folder(year, day int) string {
	if day < 10 {
		return fmt.Sprintf("%d/0%d", year, day)
	}
	return fmt.Sprintf("%d/%d", year, day)
}