Add scrap push to upload scraps to a configurable server

Author: Victorystick

cmd/scrap/main.go

@@ -11,26 +11,46 @@ import (
 	"github.com/Victorystick/scrapscript/yards"
 )
 
-type Command func(args []string)
+type Command struct {
+	name string
+	desc string
+	fn   func(args []string)
+}
 
-var commands = map[string]Command{
-	"eval": evaluate,
-	"type": inferType,
+var commands = []Command{
+	{name: "eval", desc: "evaluates it", fn: evaluate},
+	{name: "type", desc: "infers its type", fn: inferType},
+	{name: "push", desc: "pushes it to the server", fn: pushScrap},
 }
 
+var (
+	server = flag.String("server", "https://scraps.oseg.dev/", "The scrapyard server to use")
+)
+
 func main() {
 	flag.Parse()
 
-	cmd, ok := commands[flag.Arg(0)]
-	if !ok {
-		flag.Usage()
-		for name := range commands {
-			fmt.Fprintln(os.Stderr, name)
+	name := flag.Arg(0)
+	var cmd *Command
+	for i := range commands {
+		if commands[i].name == name {
+			cmd = &commands[i]
+			break
+		}
+	}
+
+	if cmd == nil {
+		fmt.Fprintln(os.Stderr, os.Args[0], "reads a script from stdin, parses it and does one of", len(commands), "things:")
+		fmt.Fprintln(os.Stderr)
+		for _, cmd := range commands {
+			fmt.Fprintf(os.Stderr, "%s %s - %s\n", os.Args[0], cmd.name, cmd.desc)
 		}
+		fmt.Fprintln(os.Stderr, "\nFlags:")
+		flag.PrintDefaults()
 		os.Exit(2)
 	}
 
-	cmd(flag.Args()[1:])
+	cmd.fn(flag.Args()[1:])
 }
 
 func must[T any](val T, err error) T {
@@ -43,12 +63,13 @@ func must[T any](val T, err error) T {
 
 func makeEnv() *eval.Environment {
 	env := eval.NewEnvironment()
+
+	pusher := yards.ByHttp(*server)
+	env.UsePusher(pusher)
 	env.UseFetcher(must(yards.NewDefaultCacheFetcher(
 		// Don't cache invalid scraps, but trust the local cache for now.
-		yards.Validate(
-			// TODO: make configurable
-			yards.ByHttp("https://scraps.oseg.dev/")),
-	)))
+		yards.Validate(pusher)),
+	))
 	return env
 }
 
@@ -73,3 +94,11 @@ func inferType(args []string) {
 	scrap := must(env.Read(input))
 	fmt.Println(must(env.Infer(scrap)))
 }
+
+func pushScrap(args []string) {
+	input := must(io.ReadAll(os.Stdin))
+	env := makeEnv()
+	scrap := must(env.Read(input))
+	key := must(env.Push(scrap))
+	fmt.Println(key)
+}

eval/env.go

@@ -20,6 +20,7 @@ type Scrap struct {
 type Sha256Hash = [32]byte
 
 type Environment struct {
+	pusher  yards.Pusher
 	fetcher yards.Fetcher
 	reg     types.Registry
 	// The TypeScope and Variables match each other's contents.
@@ -54,6 +55,10 @@ func NewEnvironment() *Environment {
 	return env
 }
 
+func (e *Environment) UsePusher(pusher yards.Pusher) {
+	e.pusher = pusher
+}
+
 func (e *Environment) UseFetcher(fetcher yards.Fetcher) {
 	e.fetcher = fetcher
 }
@@ -132,3 +137,11 @@ func (e *Environment) Scrap(value Value) string {
 	}
 	return value.String()
 }
+
+func (e *Environment) Push(scrap *Scrap) (string, error) {
+	if e.pusher == nil {
+		return "", fmt.Errorf("cannot push without a pusher")
+	}
+
+	return e.pusher.PushScrap(scrap.expr.Source.Bytes())
+}

yards/http.go

@@ -1,6 +1,7 @@
 package yards
 
 import (
+	"bytes"
 	"fmt"
 	"io"
 	"net/http"
@@ -11,11 +12,11 @@ type httpFetcher struct {
 	hostname string
 }
 
-func ByHttp(hostname string) Fetcher {
+func ByHttp(hostname string) FetchPusher {
 	return ByHttpWithClient(hostname, http.DefaultClient)
 }
 
-func ByHttpWithClient(hostname string, client *http.Client) Fetcher {
+func ByHttpWithClient(hostname string, client *http.Client) FetchPusher {
 	return httpFetcher{client, hostname}
 }
 
@@ -24,6 +25,7 @@ func (h httpFetcher) FetchSha256(key string) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
+	req.Header.Add("Accept", "application/scrap")
 
 	resp, err := h.client.Do(req)
 	if err != nil {
@@ -36,3 +38,20 @@ func (h httpFetcher) FetchSha256(key string) ([]byte, error) {
 
 	return io.ReadAll(resp.Body)
 }
+
+func (h httpFetcher) PushScrap(data []byte) (key string, err error) {
+	req, err := http.NewRequest("POST", string(h.hostname), bytes.NewReader(data))
+	if err != nil {
+		return
+	}
+	req.Header.Add("Content-Type", "application/scrap")
+
+	resp, err := h.client.Do(req)
+	if err != nil {
+		return
+	}
+
+	bytes, err := io.ReadAll(resp.Body)
+	key = string(bytes)
+	return
+}

yards/yard.go

@@ -12,6 +12,17 @@ type Fetcher interface {
 	FetchSha256(key string) ([]byte, error)
 }
 
+// Pusher is the interface for storing scraps, returning their SHA hashes.
+type Pusher interface {
+	PushScrap(data []byte) (key string, err error)
+}
+
+// A FetchPusher is both a Fetcher and a Pusher.
+type FetchPusher interface {
+	Fetcher
+	Pusher
+}
+
 // ByDirectory returns a Fetcher that looks in the given directory.
 func ByDirectory(fs fs.FS) Fetcher {
 	return &directoryFetcher{fs}