Been doing some LDAP stuff lately, and I came across the
“migrationtools” package
<https://gitlab.com/future-ad-laboratory/migrationtools> for
converting the contents of /etc/passwd and family to LDAP records.
This is a bunch of Perl code, full of lines like these:

if ($shell) {
print $HANDLE "loginShell: $shell\n";
}

if ($uid ne "") {
print $HANDLE "uidNumber: $uid\n";
} else {
print $HANDLE "uidNumber:\n";
}

if ($gid ne "") {
print $HANDLE "gidNumber: $gid\n";
} else {
print $HANDLE "gidNumber:\n";
}

if ($homedir) {
print $HANDLE "homeDirectory: $homedir\n";
} else {
print $HANDLE "homeDirectory:\n";
}

Perl is supposed to be famous, even notorious, for the conciseness of
its code, but I think whoever created this originally didn’t get that
memo.

I created an alternative tool
<https://bitbucket.org/ldo17/passwd_to_ldap>, focusing just on the
passwd, shadow and group files, and leaving out the macOS
compatibility. My code for writing out a single LDIF record is
basically this:

write_attr \
(
out,
"dn",
"%s=%s,%s" % (table.dn_field, escape_dn(entry[table.keyfield]), tabledn)
)
for objclass in table.object_classes :
write_attr(out, "objectClass", objclass)
#end for
write_attr(out, "objectClass", "top")
for field, key in table.ldap_mapping :
if key in entry :
value = entry[key]
if isinstance(value, (list, tuple)) :
for item in value :
write_attr(out, field, item)
#end for
else :
write_attr(out, field, value)
#end if
#end if
#end for
out.write("\n")

If you total the sizes of migrate_passwd.pl and migrate_group.pl, you
get 496 lines (not including migrate_common.ph). My entire script
is just 341 lines.

Of course, what I didn’t show you above is the table of rules that
drives that common LDIF-writing code, to steer the different
processing of the different files and their fields. But that complete
table is just 63 lines.

This is quite common with table-driven aka data-driven programming:
you might think that factoring out common code into a more generic
form, with the different cases defined in a data structure, just moves
the complexity from one place to another, but in fact it is usually
the case that you end up with less code overall.