Can an extended 'conditional' style rule use the first pattern multiple times ?

[Jc-L]

I would like to extend a conditional rule so that a term can be defined in two ways:

1. World Health Organization (WHO)
2. WHO: World Health Organization

A working regex for the second case is ([A-Z]{3,5})\s*\:\s*(?:\b[A-Z][a-z]+ )+. This regex works when used alone, but when grouping both regex only the first part (before the |) matches, never the second part. Is there a way to make this work ?

first: \b([A-Z]{3,5})\b
second: (?:\b[A-Z][a-z]+ )+\(([A-Z]{3,5})\)|([A-Z]{3,5})\s*\:\s*(?:\b[A-Z][a-z]+ )+

I assume that this have to to with capture groups and having both using the same identifier, but unclear if this is possible at all ?

[jdkato]

Could you share a real example of what you're trying to match against?

One thing to keep in mind, though, is that the definition must appear before any single usages.

[Jc-L]

I want definitions of Acronyms like WHO to be done in two different ways:

Either by specifying the Acronym in brackets after the words: "World Health Organization (WHO)"
Or with a colon: "WHO: World Health Organization"

The pattern matching works individually in both cases, but using a regex with a | does not take into account the part after the |. I think this is due to the presence of two capture groups in the regex, with only the first one being used (from what I understood from the source).

[Jc-L]

See conditional.go

	alerts := []core.Alert{}

	txt := blk.Text
	// We first look for the consequent of the conditional statement.
	// For example, if we're ensuring that abbreviations have been defined
	// parenthetically, we'd have something like:
	//
	//     "WHO" [antecedent], "World Health Organization (WHO)" [consequent]
	//
	// In other words: if "WHO" exists, it must also have a definition -- which
	// we're currently looking for.
	matches := c.patterns[0].FindAllStringSubmatch(txt, -1)
	for _, mat := range matches {
		if len(mat) > 1 {
			// If we find one, we store it in a slice associated with this
			// particular file.
			f.Sequences = append(f.Sequences, mat[1])
		}
	}

	// Now we look for the antecedent.
	locs := c.patterns[1].FindAllStringIndex(txt, -1)
	for _, loc := range locs {
		s := txt[loc[0]:loc[1]]
		if !core.StringInSlice(s, f.Sequences) && !isMatch(c.exceptRe, s) {
			// If we've found one (e.g., "WHO") and we haven't marked it as
			// being defined previously, send an Alert.
			alerts = append(alerts, makeAlert(c.Definition, loc, txt))
		}
	}

	return alerts, nil

[jdkato]

This is now supported thanks to #393.