cranky-reduce-debdiff

#!/bin/bash -eu
#
# Reduce a derivative debdiff by filtering out master changes
#

function out()
{
    local rc=${?}

    trap - EXIT INT TERM HUP

    if [ "${rc}" -ne 0 ] ; then
        echo "Script failed" >&2
    fi

    exit "${rc}"
}

function find_master_commit()
{
	local changelog=${1} version=${2}
	local src tag found mversion

	src=$(dpkg-parsechangelog -l "${changelog}" -S Source)
	if [ "${src}" = "linux" ] ; then
		tag=Ubuntu-${version//\~/_}
	else
		tag=Ubuntu${src#linux}-${version//\~/_}
	fi

	found=0
	while IFS= read -r line ; do
		case "${line}" in
			"linux"*"(${version})"*)
				found=1
				;;
			"  [ Ubuntu: "*)
				if [ ${found} -eq 1 ] ; then
					mversion=${line##* Ubuntu: }
					mversion=${mversion%% *}
					git log --oneline "${tag}" | \
						grep -m1 -P "^[0-9a-f]+ UBUNTU: Ubuntu.*-${mversion}$"
					return
				fi
				;;
		esac
	done < <(cat "${changelog}")
}

function calc_patch_id()
{
	local name=${1}
	local patch_id

	# File modes can be different in a debdiff due to 'reconstruct' and that
	# screws up patch-id, so filter them out
	patch_id=$(sed 's/file mode [0-9]*/file mode XXXXXX/' "${name}" | \
				   git patch-id)

	echo "${patch_id% *}"
}

function usage()
{
	cat <<EOF
Usage: $(basename "${0}") [-h] [-p PREV_VERSION]

Reduce a derivative debdiff by filtering out master changes.

Optional arguments:
  -h, --help                       Show this help text and exit.
  -p, --prev_version PREV_VERSION  Use the previous version PREV_VERSION. If
                                   not provided, determines it from the
                                   debdiff.
EOF
}

prev_version=

while [ ${#} -ne 0 ] ; do
	case "${1}" in
		-h|--help)
			usage
			exit
			;;
		-p|--prev_version)
			shift
			prev_version=${1}
			;;
		*)
			echo "Invalid argument: ${1}" >&2
			exit 2
			;;
	esac
	shift
done

if ! [ -e debian/debian.env ] ; then
	echo "The current repo is not an Ubuntu kernel repo" >&2
	exit 1
fi


# shellcheck disable=SC1091
. debian/debian.env
if [ "${DEBIAN}" = "debian.master" ] ; then
	echo "The current repo is not a derivative kernel repo"
	exit
fi

trap out EXIT INT TERM HUP

source=$(dpkg-parsechangelog -l "${DEBIAN}"/changelog -S Source)
version=$(dpkg-parsechangelog -l "${DEBIAN}"/changelog -S Version)
debdiff=../${source}_${version}.debdiff
reduced_debdiff=../${source}_${version}.reduced.debdiff

if ! [ -e "${debdiff}" ] ; then
	echo "No such debdiff: ${debdiff}" >&2
	exit 1
fi

echo "Reducing debdiff ${debdiff}"

if [ -z "${prev_version}" ] ; then
	# Pull the previous version from the debdiff
	prev_version=$(grep -m1 '^# HEADER Previous: ' "${debdiff}")
	prev_version=${prev_version%.dsc}
	prev_version=${prev_version%_source.changes}
	prev_version=${prev_version#*_}

	if [ -z "${prev_version}" ] ; then
		echo "Failed to determine previous version from debdiff" >&2
		exit 1
	fi
fi

# Find the current master commit
master=$(find_master_commit "${DEBIAN}"/changelog "${version}")
if [ -z "${master}" ] ; then
	echo "Unable to find master commit for version ${version}" >&2
	exit 1
fi

# Find the previous master commit
master_prev=$(find_master_commit "${DEBIAN}"/changelog "${prev_version}")
if [ -z "${master_prev}" ] ; then
	echo "Unable to find master commit for previous version ${prev_version}" >&2
	exit 1
fi

# Create master diff hunks
echo "Creating master diff hunks for ${master_prev%% *}..${master%% *}" \
	 "(${master_prev##* }..${master##* })"
rm -rf .master.d
git diff --src-prefix=___AAA___/ --dst-prefix=___BBB___/ \
	"${master_prev%% *}" "${master%% *}" | split-git-diff .master.d

# Fix the source and destination prefixes
prefix=${source}_${version}
prev_prefix=${source}_${prev_version}
for f in .master.d/* ; do
	if grep -m1 -q '^--- /dev/null' "${f}" ; then
		# Added
		aaa=${prefix}
		bbb=${prefix}
	else
		# Modified
		aaa=${prev_prefix}
		bbb=${prefix}
	fi
	sed -i -e "s/___AAA___/${aaa}/g" -e "s/___BBB___/${bbb}/g" "${f}"
done

# Create debdiff diff hunks
echo "Creating debdiff diff hunks"
rm -rf .debdiff.d
split-git-diff .debdiff.d < "${debdiff}"

# Collect patch IDs from master hunks
master_patch_ids=()
for name in .master.d/* ; do
	patch_id=$(calc_patch_id "${name}")
	if [ -z "${patch_id}" ] ; then
		continue
	fi
	master_patch_ids+=("${patch_id}")
done

# Collect patch IDs from debdiff hunks
declare -A debdiffs=()
for name in .debdiff.d/* ; do
	patch_id=$(calc_patch_id "${name}")
	debdiffs[${name}]=${patch_id}
done

# Remove matching debdiff hunks
count=0
for master_patch_id in "${master_patch_ids[@]}" ; do
	for name in .debdiff.d/* ; do
		patch_id=${debdiffs[${name}]}
		if [ "${patch_id}" = "${master_patch_id}" ] ; then
			rm "${name}"
			count=$((count + 1))
			break
		fi
	done
done
echo "Removed ${count} matching master hunks"

# Assemble the reduced debdiff
cat .debdiff.d/*.diff > "${reduced_debdiff}"
echo "Wrote reduced debdiff ${reduced_debdiff}"