[gentoo-dev] [PATCH 1/2] esed.eclass: new eclass

[Ionen Wolkens]

Signed-off-by: Ionen Wolkens <ionen@g.o>
---
 eclass/esed.eclass | 199 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 199 insertions(+)
 create mode 100644 eclass/esed.eclass

diff --git a/eclass/esed.eclass b/eclass/esed.eclass
new file mode 100644
index 00000000000..69f546804c4
--- /dev/null
+++ b/eclass/esed.eclass
@@ -0,0 +1,199 @@
+# Copyright 2022 Gentoo Authors
+# Distributed under the terms of the GNU General Public License v2
+
+# @ECLASS: esed.eclass
+# @MAINTAINER:
+# Ionen Wolkens <ionen@g.o>
+# @AUTHOR:
+# Ionen Wolkens <ionen@g.o>
+# @SUPPORTED_EAPIS: 8
+# @BLURB: sed(1) wrappers that die if expressions did not modify any files
+# @EXAMPLE:
+#
+# @CODE
+# esed 's/a/b/' src/file.c # -i is default, dies if 'a' does not become 'b'
+#
+# enewsed 's/a/b/' project.pc.in "${T}"/project.pc # stdin/out not supported
+#
+# esedfind . -type f -name '*.c' -esed 's/a/b/' # dies if zero files changed
+#
+# local esedexps=(
+#     # dies if /any/ of these did nothing, -e 's/a/b/' -e 's/c/d/' would not
+#     's/a/b/'
+#     's/c/d/' # bug 000000
+#     # use quotes around "$(use..)" to avoid word splitting/globs, won't run
+#     # sed(1) for empty elements (i.e. if USE is disabled)
+#     "$(usev fnord "s/foo bar/${baz}/")"
+# )
+# esed Makefile lib/Makefile # unsets esedexps so it's not re-used
+#
+# use prefix && esed "s|^prefix=|&${EPREFIX}|" project.pc # deterministic
+# @CODE
+#
+# Migration note: be wary of non-deterministic esed() involving variables,
+# e.g. s|lib|$(get_libdir)|, s|-O3|${CFLAGS}|, and the above ${EPREFIX} one.
+# esed() dies if these do nothing, like libdir being 'lib' on x86.  Either
+# verify, keep sed(1), or ensure a change (extra space, @placeholders@).
+
+case ${EAPI} in
+	8) ;;
+	*) die "${ECLASS}: EAPI ${EAPI:-0} not supported" ;;
+esac
+
+if [[ ! -v _ESED_ECLASS ]]; then
+_ESED_ECLASS=1
+
+# @ECLASS_VARIABLE: ESED_VERBOSE
+# @DEFAULT_UNSET
+# @USER_VARIABLE
+# @DESCRIPTION:
+# If set to a non-empty value, esed() and its wrappers will use diff(1)
+# if available to display file differences.
+
+# @VARIABLE: esedexps
+# @DEFAULT_UNSET
+# @DESCRIPTION:
+# Bash array that can optionally contain sed expressions to use sequencially
+# on separate sed calls when using esed() and its wrappers.  Allows inspection
+# of modifications per-expressions.  Unset after use so it's not used in
+# subsequent calls.  Will not run sed(1) for empty array elements.
+
+# @FUNCTION: esed
+# @USAGE: <sed-argument>...
+# @DESCRIPTION:
+# sed(1) wrapper that dies if the expression(s) did not modify any files.
+# sed's -i/--in-place is forced, and so stdin/out cannot be used.
+esed() {
+	local -i i
+
+	if [[ ${esedexps@a} =~ a ]]; then
+		# expression must be before -- but after the rest for e.g. -E to work
+		local -i pos
+		for ((pos=1; pos<=${#}; pos++)); do
+			[[ ${!pos} == -- ]] && break
+		done
+
+		for ((i=0; i<${#esedexps[@]}; i++)); do
+			[[ ${esedexps[i]} ]] &&
+				esedexps= esed "${@:1:pos-1}" -e "${esedexps[i]}" "${@:pos}"
+		done
+
+		unset esedexps
+		return 0
+	fi
+
+	# Roughly attempt to find files in arguments by checking if it's a
+	# readable file (aka s/// is not a file) and does not start with -
+	# (unless after --), then store contents for comparing after sed.
+	local contents=() endopts files=()
+	for ((i=1; i<=${#}; i++)); do
+		if [[ ${!i} == -- && ! -v endopts ]]; then
+			endopts=1
+		elif [[ ${!i} =~ ^(-i|--in-place)$ && ! -v endopts ]]; then
+			# detect rushed sed -i -> esed -i, -i also silently breaks enewsed
+			die "passing ${!i} to ${FUNCNAME[0]} is invalid"
+		elif [[ ${!i} =~ ^(-f|--file)$ && ! -v endopts ]]; then
+			i+=1 # ignore script files
+		elif [[ ( ${!i} != -* || -v endopts ) && -f ${!i} && -r ${!i} ]]; then
+			files+=( "${!i}" )
+
+			# eval 2>/dev/null to silence \0 warnings if sed binary files
+			eval 'contents+=( "$(<"${!i}")" )' 2>/dev/null \
+				|| die "failed to read: ${!i}"
+		fi
+	done
+	(( ${#files[@]} )) || die "no readable files found from '${*}' arguments"
+
+	local verbose
+	[[ ${ESED_VERBOSE} ]] && type diff &>/dev/null && verbose=1
+
+	local changed newcontents
+	if [[ -v _esed_output ]]; then
+		[[ -v verbose ]] &&
+			einfo "${FUNCNAME[0]}: sed ${*} > ${_esed_output} ..."
+
+		sed "${@}" > "${_esed_output}" \
+			|| die "failed to run: sed ${*} > ${_esed_output}"
+
+		eval 'newcontents=$(<${_esed_output})' 2>/dev/null \
+			|| die "failed to read: ${_esed_output}"
+
+		local IFS=$'\n' # sed concats with newline even if none at EOF
+		contents=${contents[*]}
+		unset IFS
+
+		[[ ${contents} != "${newcontents}" ]] && changed=1
+
+		[[ -v verbose ]] &&
+			diff -u --color --label="${files[*]}" --label="${_esed_output}" \
+				<(echo "${contents}") <(echo "${newcontents}")
+	else
+		[[ -v verbose ]] && einfo "${FUNCNAME[0]}: sed -i ${*} ..."
+
+		sed -i "${@}" || die "failed to run: sed -i ${*}"
+
+		for ((i=0; i<${#files[@]}; i++)); do
+			eval 'newcontents=$(<"${files[i]}")' 2>/dev/null \
+				|| die "failed to read: ${files[i]}"
+
+			if [[ ${contents[i]} != "${newcontents}" ]]; then
+				changed=1
+				[[ -v verbose ]] || break
+			fi
+
+			[[ -v verbose ]] &&
+				diff -u --color --label="${files[i]}"{,} \
+					<(echo "${contents[i]}") <(echo "${newcontents}")
+		done
+	fi
+
+	[[ -v changed ]] \
+		|| die "no-op: ${FUNCNAME[0]} ${*}${_esed_command:+ (from: ${_esed_command})}"
+}
+
+# @FUNCTION: enewsed
+# @USAGE: <esed-argument>... <output-file>
+# @DESCRIPTION:
+# esed() wrapper to save the result to <output-file>.  Same as using
+# `sed ... input > output` given esed() does not support stdin/out.
+enewsed() {
+	local _esed_command="${FUNCNAME[0]} ${*}"
+	local _esed_output=${*: -1:1}
+	esed "${@:1:${#}-1}"
+}
+
+# @FUNCTION: esedfind
+# @USAGE: <find-argument>... [-esed [<esed-argument>...]]
+# @DESCRIPTION:
+# esed() wrapper to ease use with find(1) given -exec wouldn't see a shell
+# function.  Will die if find(1) found no files, or if not a single file
+# was changed.  -esed is optional with the esedexps=( .. ) array.  -print0
+# will be appended to <find-arguments>.
+#
+# Requires that the found list not exceed args limit for file changes to be
+# evaluated together in a single esed() call.  Use is discouraged if modifying
+# files with a large total size (50+MB), as they will be loaded in memory
+# and compared ineffectively by the shell.
+esedfind() {
+	local _esed_command="${FUNCNAME[0]} ${*}"
+
+	local find=( find )
+	while (( ${#} )); do
+		if [[ ${1} == -esed ]]; then
+			shift
+			break
+		fi
+		find+=( "${1}" )
+		shift
+	done
+	find+=( -print0 )
+
+	local files
+	mapfile -d '' -t files < <("${find[@]}" || die "failed to run: ${find[*]}")
+
+	(( ${#files[@]} )) || die "no files found from: ${find[*]}"
+
+	esed "${@}" -- "${files[@]}"
+}
+
+fi
-- 
2.35.1