Rename blob transforms to match HTTP encoding names.

src/collect.go

···
 
 	appendFile := func(header *tar.Header, data []byte, transform Transform) (err error) {
 		switch transform {
-		case Transform_None:
-		case Transform_Zstandard:
+		case Transform_Identity:
+		case Transform_Zstd:
 			data, err = zstdDecoder.DecodeAll(data, []byte{})
 			if err != nil {
 				return err
···
 			header.Typeflag = tar.TypeDir
 			header.Mode = 0755
 			header.ModTime = manifestMtime
-			err = appendFile(&header, nil, Transform_None)
+			err = appendFile(&header, nil, Transform_Identity)
 
 		case Type_InlineFile:
 			header.Typeflag = tar.TypeReg
···
 			header.Typeflag = tar.TypeSymlink
 			header.Mode = 0644
 			header.ModTime = manifestMtime
-			err = appendFile(&header, entry.GetData(), Transform_None)
+			err = appendFile(&header, entry.GetData(), Transform_Identity)
 
 		default:
 			return fmt.Errorf("unexpected entry type")
···
 			Typeflag: tar.TypeReg,
 			Mode:     0644,
 			ModTime:  manifestMtime,
-		}, []byte(redirects), Transform_None)
+		}, []byte(redirects), Transform_Identity)
 		if err != nil {
 			return err
 		}
···
 			Typeflag: tar.TypeReg,
 			Mode:     0644,
 			ModTime:  manifestMtime,
-		}, []byte(headers), Transform_None)
+		}, []byte(headers), Transform_Identity)
 		if err != nil {
 			return err
 		}

src/manifest.go

···
 	for path, entry := range manifest.Contents {
 		if entry.GetType() == Type_Directory || entry.GetType() == Type_Symlink {
 			// no Content-Type
-		} else if entry.GetType() == Type_InlineFile && entry.GetTransform() == Transform_None {
+		} else if entry.GetType() == Type_InlineFile && entry.GetTransform() == Transform_Identity {
 			contentType := mime.TypeByExtension(filepath.Ext(path))
 			if contentType == "" {
 				contentType = http.DetectContentType(entry.Data[:min(512, len(entry.Data))])
···
 
 	var originalSize, compressedSize int64
 	for _, entry := range manifest.Contents {
-		if entry.GetType() == Type_InlineFile && entry.GetTransform() == Transform_None {
+		if entry.GetType() == Type_InlineFile && entry.GetTransform() == Transform_Identity {
 			mtype := getMediaType(entry.GetContentType())
 			if strings.HasPrefix(mtype, "video/") || strings.HasPrefix(mtype, "audio/") {
 				continue
···
 			if len(compressedData) < int(*entry.Size) {
 				entry.Data = compressedData
 				entry.Size = proto.Int64(int64(len(entry.Data)))
-				entry.Transform = Transform_Zstandard.Enum()
+				entry.Transform = Transform_Zstd.Enum()
 			}
 			compressedSize += entry.GetSize()
 		}

src/pages.go

···
 	acceptedEncodings := parseHTTPEncodings(r.Header.Get("Accept-Encoding"))
 	negotiatedEncoding := true
 	switch entry.GetTransform() {
-	case Transform_None:
-		if acceptedEncodings.Negotiate("identity") != "identity" {
+	case Transform_Identity:
+		switch acceptedEncodings.Negotiate("identity") {
+		case "identity":
+		default:
 			negotiatedEncoding = false
 		}
-	case Transform_Zstandard:
+	case Transform_Zstd:
 		supported := []string{"zstd", "identity"}
 		if entry.ContentType == nil {
 			// If Content-Type is unset, `http.ServeContent` will try to sniff

src/schema.pb.go

···
 	return file_schema_proto_rawDescGZIP(), []int{0}
 }
 
+// Transformation names should match HTTP `Accept-Encoding:` header.
 type Transform int32
 
 const (
 	// No transformation.
-	Transform_None Transform = 0
+	Transform_Identity Transform = 0
 	// Zstandard compression.
-	Transform_Zstandard Transform = 1
+	Transform_Zstd Transform = 1
 )
 
 // Enum value maps for Transform.
 var (
 	Transform_name = map[int32]string{
-		0: "None",
-		1: "Zstandard",
+		0: "Identity",
+		1: "Zstd",
 	}
 	Transform_value = map[string]int32{
-		"None":      0,
-		"Zstandard": 1,
+		"Identity": 0,
+		"Zstd":     1,
 	}
 )
 
···
 	if x != nil && x.Transform != nil {
 		return *x.Transform
 	}
-	return Transform_None
+	return Transform_Identity
 }
 
 func (x *Entry) GetContentType() string {
···
 	"\n" +
 	"InlineFile\x10\x02\x12\x10\n" +
 	"\fExternalFile\x10\x03\x12\v\n" +
-	"\aSymlink\x10\x04*$\n" +
-	"\tTransform\x12\b\n" +
-	"\x04None\x10\x00\x12\r\n" +
-	"\tZstandard\x10\x01B,Z*codeberg.org/git-pages/git-pages/git_pagesb\beditionsp\xe8\a"
+	"\aSymlink\x10\x04*#\n" +
+	"\tTransform\x12\f\n" +
+	"\bIdentity\x10\x00\x12\b\n" +
+	"\x04Zstd\x10\x01B,Z*codeberg.org/git-pages/git-pages/git_pagesb\beditionsp\xe8\a"
 
 var (
 	file_schema_proto_rawDescOnce sync.Once

src/schema.proto

···
 	Symlink = 4;
 }
 
+// Transformation names should match HTTP `Accept-Encoding:` header.
 enum Transform {
 	// No transformation.
-	None = 0;
+	Identity = 0;
 	// Zstandard compression.
-	Zstandard = 1;
+	Zstd = 1;
 }
 
 message Entry {