action.disabled = function()

in modules/actions/join.js [136:222]
58 lines of code
22 McCabe index (conditional complexity)

    action.disabled = function(graph) {
        var geometries = groupEntitiesByGeometry(graph);
        if (ids.length < 2 || ids.length !== geometries.line.length) {
            return 'not_eligible';
        }

        var joined = osmJoinWays(ids.map(graph.entity, graph), graph);
        if (joined.length > 1) {
            return 'not_adjacent';
        }

        var i;

        // All joined ways must belong to the same set of (non-restriction) relations.
        // Restriction relations have different logic, below, which allows some cases
        // this prohibits, and prohibits some cases this allows.
        var sortedParentRelations = function (id) {
            return graph.parentRelations(graph.entity(id))
                .filter((rel) => !rel.isRestriction() && !rel.isConnectivity())
                .sort((a, b) => a.id - b.id);
        };
        var relsA = sortedParentRelations(ids[0]);
        for (i = 1; i < ids.length; i++) {
            var relsB = sortedParentRelations(ids[i]);
            if (!utilArrayIdentical(relsA, relsB)) {
                return 'conflicting_relations';
            }
        }

        // Loop through all combinations of path-pairs
        // to check potential intersections between all pairs
        for (i = 0; i < ids.length - 1; i++) {
            for (var j = i + 1; j < ids.length; j++) {
                var path1 = graph.childNodes(graph.entity(ids[i]))
                    .map(function(e) { return e.loc; });
                var path2 = graph.childNodes(graph.entity(ids[j]))
                    .map(function(e) { return e.loc; });
                var intersections = geomPathIntersections(path1, path2);

                // Check if intersections are just nodes lying on top of
                // each other/the line, as opposed to crossing it
                var common = utilArrayIntersection(
                    joined[0].nodes.map(function(n) { return n.loc.toString(); }),
                    intersections.map(function(n) { return n.toString(); })
                );
                if (common.length !== intersections.length) {
                    return 'paths_intersect';
                }
            }
        }

        var nodeIds = joined[0].nodes.map(function(n) { return n.id; }).slice(1, -1);
        var relation;
        var tags = {};
        var conflicting = false;

        joined[0].forEach(function(way) {
            var parents = graph.parentRelations(way);
            parents.forEach(function(parent) {
                if ((parent.isRestriction() || parent.isConnectivity()) && parent.members.some(function(m) { return nodeIds.indexOf(m.id) >= 0; })) {
                    relation = parent;
                }
            });

            for (var k in way.tags) {
                if (!(k in tags)) {
                    tags[k] = way.tags[k];
                } else if (tags[k] && osmIsInterestingTag(k) && tags[k] !== way.tags[k]) {
                    conflicting = true;

                    // RapiD tagnosticRoadCombine
                    var tagnosticRoadCombine = prefs('rapid-internal-feature.tagnosticRoadCombine') === 'true';
                    if (k === 'highway' && tagnosticRoadCombine && !window.mocha) {
                        conflicting = false;
                    }
                }
            }
        });

        if (relation) {
            return relation.isRestriction() ? 'restriction' : 'connectivity';
        }

        if (conflicting) {
            return 'conflicting_tags';
        }
    };