Add client from yitsushi/aoc

Author: yitsushi

client/README.md

@@ -0,0 +1,70 @@
+# Advent of Code helper
+
+> You can also get the [JSON] for this private leaderboard. Please
+> don't make frequent automated requests to this service - avoid
+> sending requests more often than once every 15 minutes (900 seconds).
+> If you do this from a script, you'll have to provide your session
+> cookie in the request; a fresh session cookie lasts for about a month.
+> Timestamps use Unix time.
+>
+> Source: adventofcode.com
+
+```go
+targetDir := fmt.Sprintf("input/day%02d", dayNumber)
+targetFile := fmt.Sprintf("%s/input", targetDir)
+
+ensurePath(targetDir)
+
+client := aoc.NewClient(os.Getenv("AOC_SESSION"))
+
+err := client.DownloadAndSaveInput(currentYear, dayNumber, targetFile)
+if err != nil {
+    logrus.Fatal(err.Error())
+
+    return
+}
+```
+
+## Submit a solution
+
+```go
+client := aoc.NewClient(os.Getenv("AOC_SESSION"))
+
+valid, err := client.SubmitSolution(currentYear, dayNumber, partNumber, solution)
+if err != nil {
+    fmt.Printf("%s\n", err.Error())
+
+    return
+}
+
+if valid {
+    fmt.Println("Done \\o/")
+} else {
+    fmt.Println("Something is wrong :(")
+}
+```
+
+## Generate file/directory structure from template
+
+Note: All file will be rendered with `.tmpl` extension
+      and all directory will be created where there is at least
+      one `.tmpl` file.
+
+```go
+type templateVariables struct {
+    Day  int
+    Root string
+}
+
+err := aoc.Scaffold(
+    templateDir,
+    fmt.Sprintf("days/day%02d", dayNumber),
+    templateVariables{
+        Day:  dayNumber,
+        Root: packageRoot,
+    },
+)
+if err != nil {
+    logrus.Errorln(err)
+}
+```

client/client.go

@@ -0,0 +1,44 @@
+package client
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/sirupsen/logrus"
+)
+
+// HTTPClient is a simple interface for http.Client.
+// Reason: mock client in tests.
+type HTTPClient interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+// Client for Advent of Code.
+type Client struct {
+	SessionToken string
+	HTTPClient   HTTPClient
+
+	logger *logrus.Logger
+}
+
+// RequestTimout is the timeout of a request in seconds.
+const RequestTimout = 10
+
+// NewClient creates a new client.
+func NewClient(token string) Client {
+	return Client{
+		SessionToken: token,
+		HTTPClient: &http.Client{
+			Transport:     nil,
+			CheckRedirect: nil,
+			Jar:           nil,
+			Timeout:       time.Second * RequestTimout,
+		},
+		logger: logrus.New(),
+	}
+}
+
+// LogLevel sets logger level.
+func (c *Client) LogLevel(level logrus.Level) {
+	c.logger.SetLevel(level)
+}

client/client_test.go

@@ -0,0 +1,3 @@
+package client_test
+
+// It's something... for later.

client/download.go

@@ -0,0 +1,67 @@
+package client
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"time"
+)
+
+// DownloadInput downloads the requested input file.
+func (c *Client) DownloadInput(year, day int) (io.ReadCloser, error) {
+	url := fmt.Sprintf("https://adventofcode.com/%d/day/%d/input", year, day)
+
+	req, err := http.NewRequestWithContext(context.Background(), "GET", url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("unable to create request from context: %w", err)
+	}
+
+	req.AddCookie(&http.Cookie{
+		Name:       "session",
+		Value:      c.SessionToken,
+		Path:       "",
+		Domain:     "",
+		Expires:    time.Time{},
+		RawExpires: "",
+		MaxAge:     0,
+		Secure:     false,
+		HttpOnly:   false,
+		SameSite:   0,
+		Raw:        "",
+		Unparsed:   []string{},
+	})
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, DownloadError{StatusCode: resp.StatusCode}
+	}
+
+	return resp.Body, nil
+}
+
+// DownloadAndSaveInput downloads and saves the requested input file.
+func (c *Client) DownloadAndSaveInput(year, day int, targetFile string) error {
+	file, err := c.DownloadInput(year, day)
+	if err != nil {
+		return err
+	}
+
+	defer file.Close()
+
+	outputFile, err := os.Create(targetFile)
+	if err != nil {
+		return fmt.Errorf("unable to create output file: %w", err)
+	}
+
+	defer outputFile.Close()
+
+	_, err = io.Copy(outputFile, file)
+
+	return fmt.Errorf("unable to copy response into the output file: %w", err)
+}

client/error.go

@@ -0,0 +1,42 @@
+package client
+
+import "fmt"
+
+// NetworkError occurs when something went wrong with the HTTP request.
+type NetworkError struct {
+	Original error
+}
+
+func (e NetworkError) Error() string {
+	return fmt.Sprintf("Network error: %s", e.Original.Error())
+}
+
+// DownloadError occurs when the AoC server returns with a status code
+// other than 200.
+type DownloadError struct {
+	StatusCode int
+}
+
+func (e DownloadError) Error() string {
+	return fmt.Sprintf("Download error: %d", e.StatusCode)
+}
+
+// SubmitError occurs when the AoC server returns with a status code
+// other than 200.
+type SubmitError struct {
+	StatusCode int
+}
+
+func (e SubmitError) Error() string {
+	return fmt.Sprintf("Submit error: %d", e.StatusCode)
+}
+
+// IncorrectAnswerError occurs when the provided answer is not correct.
+type IncorrectAnswerError struct {
+	Hint string
+	Wait string
+}
+
+func (e IncorrectAnswerError) Error() string {
+	return fmt.Sprintf("Error: %s\n%s", e.Hint, e.Wait)
+}

client/io.go

@@ -0,0 +1,11 @@
+package client
+
+import (
+	"os"
+)
+
+func ensureDirectory(path string) {
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		_ = os.Mkdir(path, os.ModePerm)
+	}
+}

client/scaffold.go

@@ -0,0 +1,65 @@
+package client
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"text/template"
+)
+
+// Scaffold generates a Solution directory structure for a day.
+func Scaffold(templateDir string, outputDir string, variables interface{}) error {
+	ensureDirectory(outputDir)
+
+	walkErr := filepath.Walk(
+		templateDir,
+		func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+
+			if info.IsDir() {
+				ensureDirectory(path)
+
+				return nil
+			}
+
+			dir := filepath.Join(
+				outputDir,
+				strings.TrimPrefix(
+					strings.TrimSuffix(path, filepath.Base(path)),
+					templateDir,
+				),
+			)
+			ensureDirectory(dir)
+
+			targetFile := strings.TrimSuffix(filepath.Join(dir, filepath.Base(path)), ".tmpl")
+
+			outputFile, err := os.Create(targetFile)
+			if err != nil {
+				return fmt.Errorf("unable to create output file: %w", err)
+			}
+
+			defer outputFile.Close()
+
+			tmpl, err := template.ParseFiles(path)
+			if err != nil {
+				return fmt.Errorf("unable to parse template file: %w", err)
+			}
+
+			tmplErr := tmpl.Execute(outputFile, variables)
+			if tmplErr != nil {
+				return fmt.Errorf("template execution failed: %w", tmplErr)
+			}
+
+			return nil
+		},
+	)
+
+	if walkErr != nil {
+		return fmt.Errorf("something went wrong with scaffolding: %w", walkErr)
+	}
+
+	return nil
+}