function analyzeMatch()

in javadocAggregate/search.js [160:226]

• 60 lines of code
• 27 McCabe index (conditional complexity)

function analyzeMatch(matcher, input, startOfName, category) {
    var from = startOfName;
    matcher.lastIndex = from;
    var match = matcher.exec(input);
    while (!match && from > 1) {
        from = input.lastIndexOf(".", from - 2) + 1;
        matcher.lastIndex = from;
        match = matcher.exec(input);
    }
    if (!match) {
        return NO_MATCH;
    }
    var boundaries = [];
    var matchEnd = match.index + match[0].length;
    var leftParen = input.indexOf("(");
    // exclude peripheral matches
    if (category !== "modules" && category !== "searchTags") {
        if (leftParen > -1 && leftParen < match.index) {
            return NO_MATCH;
        } else if (startOfName - 1 >= matchEnd) {
            return NO_MATCH;
        }
    }
    var endOfName = leftParen > -1 ? leftParen : input.length;
    var score = 5;
    var start = match.index;
    var prevEnd = -1;
    for (var i = 1; i < match.length; i += 2) {
        var isUpper = isUpperCase(input[start]);
        var isMatcherUpper = matcher.upperCase[i];
        // capturing groups come in pairs, match and non-match
        boundaries.push(start, start + match[i].length);
        // make sure groups are anchored on a left word boundary
        var prevChar = input[start - 1] || "";
        var nextChar = input[start + 1] || "";
        if (start !== 0 && !/[\W_]/.test(prevChar) && !/[\W_]/.test(input[start])) {
            if (isUpper && (isLowerCase(prevChar) || isLowerCase(nextChar))) {
                score -= 0.1;
            } else if (isMatcherUpper && start === prevEnd) {
                score -= isUpper ? 0.1 : 1.0;
            } else {
                return NO_MATCH;
            }
        }
        prevEnd = start + match[i].length;
        start += match[i].length + match[i + 1].length;

        // lower score for parts of the name that are missing
        if (match[i + 1] && prevEnd < endOfName) {
            score -= rateNoise(match[i + 1]);
        }
    }
    // lower score if a type name contains unmatched camel-case parts
    if (input[matchEnd - 1] !== "." && endOfName > matchEnd)
        score -= rateNoise(input.slice(matchEnd, endOfName));
    score -= rateNoise(input.slice(0, Math.max(startOfName, match.index)));

    if (score <= 0) {
        return NO_MATCH;
    }
    return {
        input: input,
        score: score,
        category: category,
        boundaries: boundaries
    };
}