Not sure how this one will be received ...

This is a more ambitious set of changes than #3517. It removes inheritable attributes from cs:names and cs:name nodes if they are the same in all calls originating from their cs:citation or cs:bibliography parent, and if they do not conflict across the two parents, and sets them on the parent instead.

The advantage of the reprocessed styles is a reduction in code replication. Also, since all inheritable attributes that remain on cs:names and cs:name nodes are consequential, it makes it easier to spot discrepancies, such as disparate application of initialize-with.

Here is the script used to apply the changes, with notes on the logic of the scan. (If this full pull request seems overly ambitious, the script can be applied to individual styles as well.)

(Code below is the working code, edited since the initial post here went up.)

// Safely migrate cs:names and cs:name attributes upward

// (1) Walk all macros in each of cs:citation and cs:bibliography
// (2) Check inheritable attributes on all cs:names and cs:name nodes found in the walk
// (3) Flag all attributes with identical values across all calls in the scope for migration
// (4) Forego migration of attribute if its migration values differ in cs:citation and cs:bibliography
//     cope, and there are cs:names-calling macros common to the two scopes
// (5) Forego migration of attribute if common value differs from an existing value set on parent
//     (cs:citation or cs:bibliography respectively)
//
// If run with no arguments as node ./migrateNamesAttributes.js, processes all independent styles.
// If run with style file name as sole argument, processes only that single file.
//
// The script currently touches only et-al-* attributes. See lines 78-88 below.

var fs = require('fs');
var xml = require('xmldom').DOMParser;
var xpath = require('xpath');
var enc = require('encode-decode');
var select = xpath.useNamespaces({"cs": "http://purl.org/net/xbiblio/csl"});

var singleFile = process.argv[2];

function EntityFixer() {
    this.dat = {};
    // Avoid chaos
    var lurkers = {
        "<": "{LESS-THAN}",
        ">": "{GREATER-THAN}",
        " ": "{NO-BREAK-SPACE}"
    }
    this.memo = function(txt) {
        for (var key in lurkers) {
            var rex = new RegExp(key, "g");
            txt = txt.replace(rex, lurkers[key]);
        }
        var m = txt.match(/(\&\#[0-9]+;)/g);
        if (m) {
            for (var memo of m) {
                // Avoid chaos again. Don't touch these!
                if (" " === memo) continue;
                if ("	" === memo) continue;
                this.dat[memo] = enc.htmlDecode(memo);
            }
        }
        return txt;
    }
    this.dememo = function(txt) {
        for (var key in this.dat) {
            var rex = new RegExp(this.dat[key], "g");
            txt = txt.replace(rex, key);
        }
        for (var key in lurkers) {
            var rex = new RegExp(lurkers[key], "g");
            txt = txt.replace(rex, key);
        }
        return txt;
    }
}

var AttributeCollector = function(doc) {
    this.doc = doc;
    this.parent_macro = [];
    this. acc = {
        citation: {
            names: {},
            name: {},
            seen_macros: {},
            macros: {}
        },
        bibliography: {
            names: {},
            name: {},
            seen_macros: {},
            macros: {}
        }
    };
//            "and": "and",
//            "delimiter-precedes-et-al": "delimiter-precedes-et-al",
//            "delimiter-precedes-last": "delimiter-precedes-last",
//            "initialize": "initialize",
//            "initialize-with": "initialize-with",
//            "name-as-sort-order": "name-as-sort-order",
//            "sort-separator": "sort-separator",
//            "form": "name-form",
//            "delimiter": "name-delimiter",

//            "delimiter": "names-delimiter"

    this.attrMap = {
        names: {
        },
        name: {
            "et-al-min": "et-al-min",
            "et-al-use-first": "et-al-use-first",
            "et-al-use-last": "et-al-use-last",
            "et-al-subsequent-min": "et-al-subsequent-min",
            "et-al-subsequent-use-first": "et-al-subsequent-use-first"
        }
    };
    this.processAttributes = function(seg, subseg, callback, node) {
        if (!node) {
            node = select("//cs:" + seg + "/cs:" + subseg, this.doc)[0];
            if (!node) return;
        }
        if (!this[seg + "Node"]) {
            this[seg + "Node"] = select("//cs:" + seg, this.doc)[0];
        }
        // Accumulate attributes on cs:names / cs:name
        var tags = ["names", "name"];
        for (var tag of tags) {
            var nxNodes = select(".//cs:" + tag, node);
            for (var nxNode of nxNodes) {
                callback.call(this, seg, subseg, tag, nxNode);
            }
        }
        // Drill down on either cs:key or cs:text macros
        // (the former will appear on cs:sort, and the latter never appear there)
        var macroNodes = select(".//cs:key[@macro]", node);
        if (macroNodes.length === 0) {
            macroNodes = select(".//cs:text[@macro]", node);
        }
        for (var macroNode of macroNodes) {
            var macroName = macroNode.getAttribute("macro");
            if (this.acc[seg].seen_macros[macroName]) continue;
            this.acc[seg].seen_macros[macroName] = true;
            var macroSourceNode = select(".//cs:macro[@name='" + macroName + "']", this.doc)[0];
            this.parent_macro.push(macroName);
            this.processAttributes(seg, subseg, callback, macroSourceNode);
            this.parent_macro.pop();
        }
    }
    this.cleanup = function() {
        // Strip no-migrate values
        for (var seg of ["citation", "bibliography"]) {
            for (var tag of ["names", "name"]) {
                var deletes = [];
                for (var key in this.acc[seg][tag]) {
                    if (!this.acc[seg][tag][key]) {
                        deletes.push(key);
                    }
                }
                for (var del of deletes) {
                    delete this.acc[seg][tag][del];
                    if (this.falsifyEtAl[del]) {
                        delete this.acc[seg][tag][this.falsifyEtAl[del]];
                    }
                }
            }
        }

        // Block migration if there is a conflict with existing parent values
        for (var seg of ["citation", "bibliography"]) {
            for (var tag of ["names", "name"]) {
                var deletes = [];
                for (var attr in this.acc[seg][tag]) {
                    var higherAttr = this.attrMap[tag][attr];
                    var higherVal = this[seg + "Node"].getAttribute(higherAttr);
                    if (higherVal && higherVal !== this.acc[seg][tag][attr]) {
                        deletes.push(attr);
                    }
                }
                for (var del of deletes) {
                    delete this.acc[seg][tag][del];
                    if (this.falsifyEtAl[del]) {
                        delete this.acc[seg][tag][this.falsifyEtAl[del]];
                    }
                }
            }
        }

        // Note that name-as-sort-order should be ignored
        // in sort context, since it is always forced to
        // "always".
        
        // In each segment, check each attribute marked for migration, to see if
        // (a) any macro is used in both segments, and (b) the migration value differs
        // from that in the other segment. If the answer to both is "yes," delete the
        // attribute migration marker from BOTH segments.

        var hasCommon = false;
        for (var key in this.acc.citation.macros) {
            if (this.acc.bibliography.macros[key]) {
                hasCommon = true;
                break;
            }
        }
        if (hasCommon) {
            var deletes = [];
            for (var key in this.acc.citation.names) {
                var cVal = this.acc.citation.names[key];
                if (this.acc.bibliography.names[key] !== cVal) {
                    deletes.push(key);
                }
            }
            for (var del of deletes) {
                delete this.acc.citation.names[del];
                delete this.acc.bibliography.names[del];
            }
            var deletes = [];
            for (var key in this.acc.citation.name) {
                var cVal = this.acc.citation.name[key];
                if (this.acc.bibliography.name[key] !== cVal) {
                    deletes.push(key);
                }
            }
            for (var del of deletes) {
                delete this.acc.citation.name[del];
                delete this.acc.bibliography.name[del];
                if (this.falsifyEtAl[del]) {
                    delete this.acc.citation.name[this.falsifyEtAl[del]];
                    delete this.acc.bibliography.name[this.falsifyEtAl[del]];
                }
            }
        }
        this.acc.citation.macros = {};
        this.acc.bibliography.macros = {};
        this.acc.citation.seen_macros = {};
        this.acc.bibliography.seen_macros = {};
    }
    this.finish = function(fn) {
        var writeFile = false;
        for (var seg of ["citation", "bibliography"]) {
            for (var tag of ["names", "name"]) {
                if (this[seg + "Node"]) {
                    for (var attr in this.acc[seg][tag]) {
                        writeFile = true;
                        var higherAttr = this.attrMap[tag][attr];
                        this[seg + "Node"].setAttribute(higherAttr, this.acc[seg][tag][attr])
                    }
                }
            }
        }
        if (writeFile) {
            var txt = entityFixer.dememo(this.doc.toString());
            //console.log(txt);
            fs.writeFileSync(fn, txt + "\n")
        }
    }
    
    this.falsifyEtAl = {
        "et-al-min": "et-al-use-first",
        "et-al-use-first": "et-al-min",
        "et-al-subsequent-min": "et-al-subsequent-use-first",
        "et-al-subsequent-use-first": "et-al-subsequent-min"
    }
}

function collector(seg, subseg, tag, nxNode) {
    var parent_macro = this.parent_macro.slice(-1)[0];
    if (parent_macro) {
        this.acc[seg].macros[parent_macro] = true;
    }
    if (tag === "names" && nxNode.parentNode.tagName === "substitute" && nxNode.attributes.length === 1) return;
    for (var attr in this.attrMap[tag]) {
        if (subseg === "sort" && attr === "name-as-sort-order") continue;
        var val = nxNode.getAttribute(attr);
        var accVal = this.acc[seg][tag][attr];
        if (accVal === undefined) {
            this.acc[seg][tag][attr] = val;
        } else if (accVal !== val) {
            this.acc[seg][tag][attr] = false;
        }
    }
}

function editor(seg, subseg, tag, nxNode) {
    if (tag === "names" && nxNode.parentNode.tagName === "substitute" && nxNode.attributes.length === 1) return;
    for (var attr in this.acc[seg][tag]) {
        nxNode.removeAttribute(attr);
    }
}

for (var fn of fs.readdirSync('.')) {
    var writeToFile = false;
    var entityFixer = new EntityFixer();
    if (fn.slice(-4) !== ".csl") continue;
    if (singleFile && fn !== singleFile) continue;
    
    console.log(fn);
    var txt = fs.readFileSync(fn).toString();
    txt = entityFixer.memo(txt);
    var doc = new xml().parseFromString(txt);
    var attributeCollector = new AttributeCollector(doc);

    // Collect common attributes
    attributeCollector.processAttributes("citation", "sort", collector);
    attributeCollector.processAttributes("citation", "layout", collector);
    attributeCollector.processAttributes("bibliography", "sort", collector);
    attributeCollector.processAttributes("bibliography", "layout", collector);

    //console.log(JSON.stringify(attributeCollector.acc, null, 2));
    
    // Reset for rerun of walk
    attributeCollector.cleanup();

    //console.log(JSON.stringify(attributeCollector.acc, null, 2));

    attributeCollector.processAttributes("citation", "sort", editor);
    attributeCollector.processAttributes("citation", "layout", editor);
    attributeCollector.processAttributes("bibliography", "sort", editor);
    attributeCollector.processAttributes("bibliography", "layout", editor);

    attributeCollector.finish(fn);
}