archive

var AllGzipStabilizers = []Stabilizer{
	StableGzipCompression,
	StableGzipName,
	StableGzipTime,
	StableGzipMisc,
}

var AllJarStabilizers = []Stabilizer{
	StableJARBuildMetadata,
	StableJAROrderOfAttributeValues,
	StableGitProperties,
}

var AllStabilizers = slices.Concat(AllZipStabilizers, AllTarStabilizers, AllGzipStabilizers, AllJarStabilizers)

var AllTarStabilizers = []Stabilizer{
	StableTarFileOrder,
	StableTarTime,
	StableTarFileMode,
	StableTarOwners,
	StableTarXattrs,
	StableTarDeviceNumber,
}

var AllZipStabilizers = []Stabilizer{
	StableZipFileOrder,
	StableZipModifiedTime,
	StableZipCompression,
	StableZipDataDescriptor,
	StableZipFileEncoding,
	StableZipFileMode,
	StableZipMisc,
}

var StableGitProperties = ZipEntryStabilizer{
	Name: "jar-git-properties",
	Func: func(zf *MutableZipFile) {

		if path.Base(zf.Name) == "git.json" {
			zf.SetContent([]byte("{}"))
		}

		if path.Base(zf.Name) == "git.properties" {
			zf.SetContent([]byte{})
		}
	},
}

var StableGzipCompression = GzipStabilizer{
	Name: "gzip-compression",
	Func: func(h *MutableGzipHeader) {
		h.Compression = gzip.NoCompression
	},
}

var StableGzipMisc = GzipStabilizer{
	Name: "gzip-misc",
	Func: func(h *MutableGzipHeader) {
		h.Comment = ""
		h.Extra = nil
		h.OS = 255
	},
}

var StableGzipName = GzipStabilizer{
	Name: "gzip-name",
	Func: func(h *MutableGzipHeader) {
		h.Name = ""
	},
}

var StableGzipTime = GzipStabilizer{
	Name: "gzip-time",
	Func: func(h *MutableGzipHeader) {

		h.ModTime = time.Time{}
	},
}

var StableJARBuildMetadata = ZipEntryStabilizer{
	Name: "jar-build-metadata",
	Func: func(zf *MutableZipFile) {

		if !strings.HasSuffix(zf.Name, "META-INF/MANIFEST.MF") {
			return
		}
		r, err := zf.Open()
		if err != nil {
			return
		}
		manifest, err := ParseManifest(r)
		if err != nil {
			return
		}
		for _, attr := range []string{
			"Archiver-Version",
			"Bnd-LastModified",
			"Build-Date",
			"Build-Date-UTC",
			"Build-Host",
			"Build-Id",
			"Build-Java-Version",
			"Build-Jdk",
			"Build-Jdk-Spec",
			"Build-Job",
			"Build-Number",
			"Build-OS",
			"Build-Status",
			"Build-Time",
			"Build-Timestamp",
			"Build-Tool",
			"Build-Url",
			"Built-By",
			"Built-Date",
			"Built-Host",
			"Built-JDK",
			"Built-On",
			"Built-OS",
			"Built-Status",
			"Created-By",
			"DSTAMP",
			"Eclipse-SourceReferences",
			"Git-Commit-Id-Describe",
			"Git-Remote-Origin-Url",
			"Git-SHA",
			"Git-Descriptor",
			"git-describe",
			"git-tags",
			"hash",
			"Hudson-Build-Number",
			"Implementation-Build-Date",
			"Implementation-Build-Java-Vendor",
			"Implementation-Build-Java-Version",
			"Implementation-Build",
			"Ion-Java-Build-Time",
			"Java-Vendor",
			"Java-Version",
			"JCabi-Date",
			"Jenkins-Build-Number",
			"Maven-Version",
			"Module-Origin",
			"Originally-Created-By",
			"Os-Arch",
			"Os-Name",
			"Os-Version",
			"SCM-Git-Branch",
			"SCM-Git-Commit-Dirty",
			"SCM-Git-Commit-ID",
			"SCM-Git-Commit-Abbrev",
			"SCM-Git-Commit-Description",
			"SCM-Git-Commit-Timestamp",
			"SCM-Revision",
			"SHA-256-Digest",
			"Source-Date-Epoch",
			"Sunset-BuiltOn",
			"TODAY",
			"Tool",
			"TSTAMP",
			"url",
		} {
			manifest.MainSection.Delete(attr)
		}
		buf := bytes.NewBuffer(nil)
		if err := WriteManifest(buf, manifest); err != nil {
			return
		}
		zf.SetContent(buf.Bytes())
	},
}

var StableJAROrderOfAttributeValues = ZipEntryStabilizer{
	Name: "jar-attribute-value-order",
	Func: func(zf *MutableZipFile) {
		if !strings.HasSuffix(zf.Name, "META-INF/MANIFEST.MF") {
			return
		}
		r, err := zf.Open()
		if err != nil {
			return
		}
		manifest, err := ParseManifest(r)
		if err != nil {
			return
		}

		for _, attr := range []string{
			"Export-Package",
			"Include-Resource",
			"Provide-Capability",
			"Private-Package",
		} {
			value, _ := manifest.MainSection.Get(attr)

			if value == "" {
				continue
			}
			subvalues := splitPreservingQuotes(value, ',')

			sort.Strings(subvalues)
			for i, subvalue := range subvalues {
				subvalueArray := splitPreservingQuotes(subvalue, ';')
				sort.Strings(subvalueArray)
				subvalues[i] = strings.Join(subvalueArray, ";")
			}
			manifest.MainSection.Set(attr, strings.Join(subvalues, ","))
		}
		buf := bytes.NewBuffer(nil)
		if err := WriteManifest(buf, manifest); err != nil {
			return
		}
		zf.SetContent(buf.Bytes())
	},
}

var StableTarDeviceNumber = TarEntryStabilizer{
	Name: "tar-device-number",
	Func: func(e *TarEntry) {

		e.Devmajor = 0
		e.Devminor = 0
	},
}

var StableTarFileMode = TarEntryStabilizer{
	Name: "tar-file-mode",
	Func: func(e *TarEntry) {
		e.Mode = int64(fs.ModePerm)
	},
}

var StableTarFileOrder = TarArchiveStabilizer{
	Name: "tar-file-order",
	Func: func(f *TarArchive) {
		slices.SortFunc(f.Files, func(a, b *TarEntry) int {
			return strings.Compare(a.Name, b.Name)
		})
	},
}

var StableTarOwners = TarEntryStabilizer{
	Name: "tar-owners",
	Func: func(e *TarEntry) {
		e.Uid = 0
		e.Gid = 0
		e.Uname = ""
		e.Gname = ""
	},
}

var StableTarTime = TarEntryStabilizer{
	Name: "tar-time",
	Func: func(e *TarEntry) {
		e.ModTime = time.UnixMilli(0)
		e.AccessTime = time.UnixMilli(0)
		e.ChangeTime = time.Time{}

		e.Format = tar.FormatPAX
	},
}

var StableTarXattrs = TarEntryStabilizer{
	Name: "tar-xattrs",
	Func: func(e *TarEntry) {
		clear(e.Xattrs)
		clear(e.PAXRecords)
	},
}

var StableZipCompression = ZipEntryStabilizer{
	Name: "zip-compression",
	Func: func(zf *MutableZipFile) {
		zf.Method = zip.Store
	},
}

var StableZipDataDescriptor = ZipEntryStabilizer{
	Name: "zip-data-descriptor",
	Func: func(zf *MutableZipFile) {
		zf.Flags = zf.Flags & ^dataDescriptorFlag
		zf.CRC32 = 0
		zf.CompressedSize = 0
		zf.CompressedSize64 = 0
		zf.UncompressedSize = 0
		zf.UncompressedSize64 = 0
	},
}

var StableZipFileEncoding = ZipEntryStabilizer{
	Name: "zip-file-encoding",
	Func: func(zf *MutableZipFile) {
		zf.NonUTF8 = false
	},
}

var StableZipFileMode = ZipEntryStabilizer{
	Name: "zip-file-mode",
	Func: func(zf *MutableZipFile) {
		zf.CreatorVersion = 0
		zf.ExternalAttrs = 0
	},
}

var StableZipFileOrder = ZipArchiveStabilizer{
	Name: "zip-file-order",
	Func: func(zr *MutableZipReader) {
		slices.SortFunc(zr.File, func(i, j *MutableZipFile) int {
			return strings.Compare(i.Name, j.Name)
		})
	},
}

var StableZipMisc = ZipEntryStabilizer{
	Name: "zip-misc",
	Func: func(zf *MutableZipFile) {
		zf.Comment = ""
		zf.ReaderVersion = 0
		zf.Extra = []byte{}

		zf.Flags = zf.Flags & dataDescriptorFlag
	},
}

var StableZipModifiedTime = ZipEntryStabilizer{
	Name: "zip-modified-time",
	Func: func(zf *MutableZipFile) {
		zf.Modified = time.UnixMilli(0)
		zf.ModifiedDate = 0
		zf.ModifiedTime = 0
	},
}