Merge pull request #1370 from jlongtine/engine-scratch-not-a-task

Make engine.#Scratch a specialization of #FS, rather than a task

europa-universe/yarn/tests/simple/simple.cue

@@ -5,7 +5,7 @@ import (
 )
 
 b: #Build & {
-	source: engine.#Scratch.output
+	source: engine.#Scratch
 }
 
 out: b.output

plan/task/build.go

@@ -115,14 +115,17 @@ func (t *buildTask) dockerfile(ctx context.Context, pctx *plancontext.Context, s
 		return nil, err
 	}
 
-	st, err := ref.ToState()
-	if err != nil {
-		return nil, err
-	}
+	solvedRef := ref
+	if ref != nil {
+		st, err := ref.ToState()
+		if err != nil {
+			return nil, err
+		}
 
-	solvedRef, err := s.Solve(ctx, st, pctx.Platform.Get())
-	if err != nil {
-		return nil, err
+		solvedRef, err = s.Solve(ctx, st, pctx.Platform.Get())
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	// Image metadata

plan/task/scratch.go

@@ -1,24 +0,0 @@
-package task
-
-import (
-	"context"
-
-	"go.dagger.io/dagger/compiler"
-	"go.dagger.io/dagger/plancontext"
-	"go.dagger.io/dagger/solver"
-)
-
-func init() {
-	Register("Scratch", func() Task { return &scratchTask{} })
-}
-
-type scratchTask struct {
-}
-
-func (t *scratchTask) Run(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value) (*compiler.Value, error) {
-	fs := pctx.FS.New(nil)
-
-	return compiler.NewValue().FillFields(map[string]interface{}{
-		"output": fs.MarshalCUE(),
-	})
-}

plancontext/fs.go

@@ -42,8 +42,14 @@ func (fs *FS) State() (llb.State, error) {
 
 func (fs *FS) MarshalCUE() *compiler.Value {
 	v := compiler.NewValue()
-	if err := v.FillPath(fsIDPath, fs.id); err != nil {
-		panic(err)
+	if fs.result == nil {
+		if err := v.FillPath(fsIDPath, nil); err != nil {
+			panic(err)
+		}
+	} else {
+		if err := v.FillPath(fsIDPath, fs.id); err != nil {
+			panic(err)
+		}
 	}
 	return v
 }
@@ -71,6 +77,11 @@ func (c *fsContext) FromValue(v *compiler.Value) (*FS, error) {
 	c.l.RLock()
 	defer c.l.RUnlock()
 
+	// This is #Scratch, so we'll return an empty FS
+	if v.LookupPath(fsIDPath).Kind() == cue.NullKind {
+		return &FS{}, nil
+	}
+
 	id, err := v.LookupPath(fsIDPath).String()
 	if err != nil {
 		return nil, fmt.Errorf("invalid FS %q: %w", v.Path(), err)

stdlib/europa/dagger/engine/fs.cue

@@ -49,11 +49,7 @@ package engine
 }
 
 // Produce an empty directory
-#Scratch: {
-	$dagger: task: _name: "Scratch"
-
-	output: #FS
-}
+#Scratch: #FS & {$dagger: fs: _id: null}
 
 // Copy files from one FS tree to another
 #Copy: {

stdlib/europa/dagger/engine/types.cue

@@ -7,7 +7,7 @@ package engine
 //  - A directory containing binary artifacts
 // Rule of thumb: if it fits in a tar archive, it fits in a #FS.
 #FS: {
-	$dagger: fs: _id: string
+	$dagger: fs: _id: string | null
 }
 
 // A reference to an external secret, for example:

stdlib/europa/dagger/utils.cue

@@ -16,12 +16,9 @@ import (
 	// Subdirectory tree
 	output: #FS & copy.output
 
-	// Base image
-	scratch: engine.#Scratch
-
 	// Copy action
 	copy: engine.#Copy & {
-		"input": scratch.output
+		"input": engine.#Scratch
 		source: {
 			root:   input
 			"path": path

tests/plan/outputs/outputs.cue

@@ -3,15 +3,11 @@ package main
 import "alpha.dagger.io/europa/dagger/engine"
 
 engine.#Plan & {
-	actions: {
-		scratch: engine.#Scratch
-
-		data: engine.#WriteFile & {
-			input:       scratch.output
-			path:        "/test"
-			permissions: 0o600
-			contents:    "foobar"
-		}
+	actions: data: engine.#WriteFile & {
+		input:       engine.#Scratch
+		path:        "/test"
+		permissions: 0o600
+		contents:    "foobar"
 	}
 
 	outputs: directories: test: {

tests/tasks.bats

@@ -92,6 +92,8 @@ setup() {
 @test "task: #Scratch" {
     cd "$TESTDIR"/tasks/scratch
     "$DAGGER" --europa up ./scratch.cue -l debug
+    "$DAGGER" --europa up ./scratch_build_scratch.cue -l debug
+    "$DAGGER" --europa up ./scratch_writefile.cue -l debug
 }
 
 @test "task: #Subdir" {

tests/tasks/scratch/scratch.cue

@@ -10,13 +10,11 @@ engine.#Plan & {
 			source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
 		}
 
-		scratch: engine.#Scratch
-
 		exec: engine.#Exec & {
 			input: image.output
 			mounts: fs: {
 				dest:     "/scratch"
-				contents: scratch.output
+				contents: engine.#Scratch
 			}
 			workdir: "/"
 			args: [

tests/tasks/scratch/scratch_build_scratch.cue

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"alpha.dagger.io/europa/dagger/engine"
+)
+
+engine.#Plan & {
+	actions: build: engine.#Build & {
+		source: engine.#Scratch
+		dockerfile: contents: "FROM scratch"
+		// Assert that output is engine.#Scratch
+		output: engine.#Scratch
+	}
+}

tests/tasks/scratch/scratch_writefile.cue

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"alpha.dagger.io/europa/dagger/engine"
+)
+
+engine.#Plan & {
+	actions: {
+		write: engine.#WriteFile & {
+			input:       engine.#Scratch
+			path:        "/testing"
+			contents:    "1,2,3"
+			permissions: 700
+		}
+		readfile: engine.#ReadFile & {
+			input: write.output
+			path:  "/testing"
+		} & {
+			// assert result
+			contents: "1,2,3"
+		}
+	}
+}