489 lines
13 KiB
Go
489 lines
13 KiB
Go
package remap
|
|
|
|
/*
|
|
Map returns a map[string][]<match bytes> for regexes with named capture groups matched in bytes b.
|
|
Note that this supports non-unique group names; [regexp.Regexp] allows for patterns with multiple groups
|
|
using the same group name (though your IDE might complain; I know GoLand does).
|
|
|
|
Each match for each group is in a slice keyed under that group name, with that slice
|
|
ordered by the indexing done by the regex match itself.
|
|
|
|
In summary, the parameters are as follows:
|
|
|
|
# inclNoMatch
|
|
|
|
If true, then attempt to return a non-nil matches (as long as b isn't nil).
|
|
Group keys will be populated and explicitly defined as nil.
|
|
|
|
For example, if a pattern
|
|
|
|
^(?P<g1>foo)(?P<g1>bar)(?P<g2>baz)$
|
|
|
|
is provided but b does not match then matches will be:
|
|
|
|
map[string][][]byte{
|
|
"g1": nil,
|
|
"g2": nil,
|
|
}
|
|
|
|
# inclNoMatchStrict
|
|
|
|
If true (and inclNoMatch is true), instead of a single nil the group's values will be
|
|
a slice of nil values explicitly matching the number of times the group name is specified
|
|
in the pattern.
|
|
|
|
For example, if a pattern:
|
|
|
|
^(?P<g1>foo)(?P<g1>bar)(?P<g2>baz)$
|
|
|
|
is provided but b does not match then matches will be:
|
|
|
|
map[string][][]byte{
|
|
"g1": [][]byte{
|
|
nil,
|
|
nil,
|
|
},
|
|
"g2": [][]byte{
|
|
nil,
|
|
},
|
|
}
|
|
|
|
# mustMatch
|
|
|
|
If true, matches will be nil if the entirety of b does not match the pattern (and thus
|
|
no capture groups matched) (overrides inclNoMatch) -- explicitly:
|
|
|
|
matches == nil
|
|
|
|
Otherwise if false (and assuming inclNoMatch is false), matches will be:
|
|
|
|
map[string][][]byte{}{}
|
|
|
|
# Condition Tree
|
|
|
|
In detail, matches and/or its values may be nil or empty under the following condition tree:
|
|
|
|
IF b is nil:
|
|
THEN matches will always be nil
|
|
ELSE:
|
|
IF all of b does not match pattern
|
|
IF mustMuch is true
|
|
THEN matches == nil
|
|
ELSE
|
|
THEN matches == map[string][][]byte{} (non-nil but empty)
|
|
ELSE IF pattern has no named capture groups
|
|
IF inclNoMatch is true
|
|
THEN matches == map[string][][]byte{} (non-nil but empty)
|
|
ELSE
|
|
THEN matches == nil
|
|
ELSE
|
|
IF there are no named group matches
|
|
IF inclNoMatch is true
|
|
THEN matches is non-nil; matches[<group name>, ...] is/are defined but nil (_, ok = matches[<group name>]; ok == true)
|
|
ELSE
|
|
THEN matches == nil
|
|
ELSE
|
|
IF <group name> does not have a match
|
|
IF inclNoMatch is true
|
|
IF inclNoMatchStrict is true
|
|
THEN matches[<group name>] is defined and non-nil, but populated with placeholder nils
|
|
(matches[<group name>] == [][]byte{nil[, nil...]})
|
|
ELSE
|
|
THEN matches[<group name>] is guaranteed defined but may be nil (_, ok = matches[<group name>]; ok == true)
|
|
ELSE
|
|
THEN matches[<group name>] is not defined (_, ok = matches[<group name>]; ok == false)
|
|
ELSE
|
|
matches[<group name>] == []{<match>[, <match>...]}
|
|
*/
|
|
func (r *ReMap) Map(b []byte, inclNoMatch, inclNoMatchStrict, mustMatch bool) (matches map[string][][]byte) {
|
|
|
|
var ok bool
|
|
var mIdx int
|
|
var match []byte
|
|
var grpNm string
|
|
var names []string
|
|
var matchBytes [][]byte
|
|
var tmpMap map[string][][]byte = make(map[string][][]byte)
|
|
|
|
if b == nil {
|
|
return
|
|
}
|
|
|
|
names = r.Regexp.SubexpNames()
|
|
matchBytes = r.Regexp.FindSubmatch(b)
|
|
|
|
if matchBytes == nil {
|
|
// b does not match pattern
|
|
if !mustMatch {
|
|
matches = make(map[string][][]byte)
|
|
}
|
|
return
|
|
}
|
|
|
|
if names == nil || len(names) == 0 || len(names) == 1 {
|
|
/*
|
|
no named capture groups;
|
|
technically only the last condition would be the case.
|
|
*/
|
|
if inclNoMatch {
|
|
matches = make(map[string][][]byte)
|
|
}
|
|
return
|
|
}
|
|
names = names[1:]
|
|
|
|
if len(matchBytes) == 0 || len(matchBytes) == 1 {
|
|
/*
|
|
no submatches whatsoever.
|
|
*Technically* I don't think this condition can actually be reached.
|
|
This is more of a safe-return before we re-slice.
|
|
*/
|
|
matches = make(map[string][][]byte)
|
|
if inclNoMatch {
|
|
if len(names) >= 1 {
|
|
for _, grpNm = range names {
|
|
matches[grpNm] = nil
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
matchBytes = matchBytes[1:]
|
|
|
|
for mIdx, match = range matchBytes {
|
|
grpNm = names[mIdx]
|
|
/*
|
|
Thankfully, it's actually a build error if a pattern specifies a named
|
|
capture group with an empty name.
|
|
So we don't need to worry about accounting for that,
|
|
and can just skip over grpNm == "" (which is an *unnamed* capture group).
|
|
*/
|
|
if grpNm == "" {
|
|
continue
|
|
}
|
|
|
|
if match == nil {
|
|
// group did not match
|
|
if !inclNoMatch {
|
|
continue
|
|
}
|
|
if _, ok = tmpMap[grpNm]; !ok {
|
|
if !inclNoMatchStrict {
|
|
tmpMap[grpNm] = nil
|
|
} else {
|
|
tmpMap[grpNm] = [][]byte{nil}
|
|
}
|
|
} else {
|
|
if inclNoMatchStrict {
|
|
tmpMap[grpNm] = append(tmpMap[grpNm], nil)
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
|
|
if _, ok = tmpMap[grpNm]; !ok {
|
|
tmpMap[grpNm] = make([][]byte, 0)
|
|
}
|
|
tmpMap[grpNm] = append(tmpMap[grpNm], match)
|
|
}
|
|
|
|
// This *technically* should be completely handled above.
|
|
if inclNoMatch {
|
|
for _, grpNm = range names {
|
|
if _, ok = tmpMap[grpNm]; !ok {
|
|
tmpMap[grpNm] = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(tmpMap) > 0 {
|
|
matches = tmpMap
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
/*
|
|
MapString is exactly like ReMap.Map(), but operates on (and returns) strings instead.
|
|
(matches will always be nil if s == “.)
|
|
|
|
A small deviation, though; empty strings instead of nils (because duh) will occupy slice placeholders (if `inclNoMatchStrict` is specified).
|
|
This unfortunately *does not provide any indication* if an empty string positively matched the pattern (a "hit") or if it was simply
|
|
not matched at all (a "miss"). If you need definitive determination between the two conditions, it is instead recommended to either
|
|
*not* use inclNoMatchStrict or to use ReMap.Map() instead and convert any non-nil values to strings after.
|
|
|
|
Particularly:
|
|
|
|
# inclNoMatch
|
|
|
|
If true, then attempt to return a non-nil matches (as long as s isn't empty).
|
|
Group keys will be populated and explicitly defined as nil.
|
|
|
|
For example, if a pattern
|
|
|
|
^(?P<g1>foo)(?P<g1>bar)(?P<g2>baz)$
|
|
|
|
is provided but s does not match then matches will be:
|
|
|
|
map[string][]string{
|
|
"g1": nil,
|
|
"g2": nil,
|
|
}
|
|
|
|
# inclNoMatchStrict
|
|
|
|
If true (and inclNoMatch is true), instead of a single nil the group's values will be
|
|
a slice of eempty string values explicitly matching the number of times the group name is specified
|
|
in the pattern.
|
|
|
|
For example, if a pattern:
|
|
|
|
^(?P<g1>foo)(?P<g1>bar)(?P<g2>baz)$
|
|
|
|
is provided but s does not match then matches will be:
|
|
|
|
map[string][]string{
|
|
"g1": []string{
|
|
"",
|
|
"",
|
|
},
|
|
"g2": []string{
|
|
"",
|
|
},
|
|
}
|
|
|
|
# mustMatch
|
|
|
|
If true, matches will be nil if the entirety of s does not match the pattern (and thus
|
|
no capture groups matched) (overrides inclNoMatch) -- explicitly:
|
|
|
|
matches == nil
|
|
|
|
Otherwise if false (and assuming inclNoMatch is false), matches will be:
|
|
|
|
map[string][]string{}{}
|
|
|
|
# Condition Tree
|
|
|
|
In detail, matches and/or its values may be nil or empty under the following condition tree:
|
|
|
|
IF s is empty:
|
|
THEN matches will always be nil
|
|
ELSE:
|
|
IF all of s does not match pattern
|
|
IF mustMuch is true
|
|
THEN matches == nil
|
|
ELSE
|
|
THEN matches == map[string][]string{} (non-nil but empty)
|
|
ELSE IF pattern has no named capture groups
|
|
IF inclNoMatch is true
|
|
THEN matches == map[string][]string{} (non-nil but empty)
|
|
ELSE
|
|
THEN matches == nil
|
|
ELSE
|
|
IF there are no named group matches
|
|
IF inclNoMatch is true
|
|
THEN matches is non-nil; matches[<group name>, ...] is/are defined but nil (_, ok = matches[<group name>]; ok == true)
|
|
ELSE
|
|
THEN matches == nil
|
|
ELSE
|
|
IF <group name> does not have a match
|
|
IF inclNoMatch is true
|
|
IF inclNoMatchStrict is true
|
|
THEN matches[<group name>] is defined and non-nil, but populated with placeholder nils
|
|
(matches[<group name>] == []string{""[, ""...]})
|
|
ELSE
|
|
THEN matches[<group name>] is guaranteed defined but may be nil (_, ok = matches[<group name>]; ok == true)
|
|
ELSE
|
|
THEN matches[<group name>] is not defined (_, ok = matches[<group name>]; ok == false)
|
|
ELSE
|
|
matches[<group name>] == []{<match>[, <match>...]}
|
|
*/
|
|
func (r *ReMap) MapString(s string, inclNoMatch, inclNoMatchStrict, mustMatch bool) (matches map[string][]string) {
|
|
|
|
var ok bool
|
|
var endIdx int
|
|
var startIdx int
|
|
var chunkIdx int
|
|
var grpNm string
|
|
var names []string
|
|
var matchStr string
|
|
/*
|
|
A slice of indices or index pairs.
|
|
For each element `e` in idxChunks,
|
|
* if `e` is nil, no group match.
|
|
* if len(e) == 1, only a single character was matched.
|
|
* otherwise len(e) == 2, the start and end of the match.
|
|
*/
|
|
var idxChunks [][]int
|
|
var matchIndices []int
|
|
var chunkIndices []int // always 2 elements; start pos and end pos
|
|
var tmpMap map[string][]string = make(map[string][]string)
|
|
|
|
/*
|
|
OK so this is a bit of a deviation.
|
|
|
|
It's not as straightforward as above, because there isn't an explicit way
|
|
like above to determine if a pattern was *matched as an empty string* vs.
|
|
*not matched*.
|
|
|
|
So instead do roundabout index-y things.
|
|
*/
|
|
|
|
if s == "" {
|
|
return
|
|
}
|
|
/*
|
|
I'm not entirely sure how serious they are about "the slice should not be modified"...
|
|
|
|
DO NOT sort or dedupe `names`! If the same name for groups is duplicated,
|
|
it will be duplicated here in proper order and the ordering is tied to
|
|
the ordering of matchIndices.
|
|
*/
|
|
names = r.Regexp.SubexpNames()[:]
|
|
matchIndices = r.Regexp.FindStringSubmatchIndex(s)
|
|
|
|
if matchIndices == nil {
|
|
// s does not match pattern at all.
|
|
if !mustMatch {
|
|
matches = make(map[string][]string)
|
|
}
|
|
return
|
|
}
|
|
|
|
if names == nil || len(names) <= 1 {
|
|
/*
|
|
No named capture groups;
|
|
technically only the last condition would be the case,
|
|
as (regexp.Regexp).SubexpNames() will ALWAYS at the LEAST
|
|
return a `[]string{""}`.
|
|
*/
|
|
if inclNoMatch {
|
|
matches = make(map[string][]string)
|
|
}
|
|
return
|
|
}
|
|
|
|
if len(matchIndices) == 0 || len(matchIndices) == 1 {
|
|
/*
|
|
No (sub)matches whatsoever.
|
|
*technically* I don't think this condition can actually be reached;
|
|
matchIndices should ALWAYS either be `nil` or len will be at LEAST 2,
|
|
and modulo 2 thereafter since they're PAIRS of indices...
|
|
Why they didn't just return a [][]int or [][2]int or something
|
|
instead of an []int, who knows.
|
|
But we're correcting that poor design.
|
|
This is more of a safe-return before we chunk the indices.
|
|
*/
|
|
matches = make(map[string][]string)
|
|
if inclNoMatch {
|
|
for _, grpNm = range names {
|
|
if grpNm != "" {
|
|
matches[grpNm] = nil
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
/*
|
|
A reslice of `matchIndices` could technically start at 2 (as long as `names` is sliced [1:])
|
|
because they're in pairs: []int{<start>, <end>, <start>, <end>, ...}
|
|
and the first pair is the entire pattern match (un-resliced names[0]).
|
|
Thus the len(matchIndices) == 2*len(names), *even* if you
|
|
Keep in mind that since the first element of names is removed,
|
|
the first pair here is skipped.
|
|
This provides a bit more consistent readability, though.
|
|
*/
|
|
idxChunks = make([][]int, len(names))
|
|
chunkIdx = 0
|
|
endIdx = 0
|
|
for startIdx = 0; endIdx < len(matchIndices); startIdx += 2 {
|
|
endIdx = startIdx + 2
|
|
// This technically should never happen.
|
|
if endIdx > len(matchIndices) {
|
|
endIdx = len(matchIndices)
|
|
}
|
|
|
|
chunkIndices = matchIndices[startIdx:endIdx]
|
|
|
|
if chunkIndices[0] == -1 || chunkIndices[1] == -1 {
|
|
// group did not match
|
|
chunkIndices = nil
|
|
} else {
|
|
if chunkIndices[0] == chunkIndices[1] {
|
|
chunkIndices = []int{chunkIndices[0]}
|
|
} else {
|
|
chunkIndices = matchIndices[startIdx:endIdx]
|
|
}
|
|
}
|
|
idxChunks[chunkIdx] = chunkIndices
|
|
chunkIdx++
|
|
}
|
|
|
|
// Now associate with names and pull the string sequence.
|
|
for chunkIdx, chunkIndices = range idxChunks {
|
|
grpNm = names[chunkIdx]
|
|
/*
|
|
Thankfully, it's actually a build error if a pattern specifies a named
|
|
capture group with an empty name.
|
|
So we don't need to worry about accounting for that,
|
|
and can just skip over grpNm == ""
|
|
(which is either an *unnamed* capture group
|
|
OR the first element in `names`, which is always
|
|
the entire match).
|
|
*/
|
|
if grpNm == "" {
|
|
continue
|
|
}
|
|
|
|
if chunkIndices == nil || len(chunkIndices) == 0 {
|
|
// group did not match
|
|
if !inclNoMatch {
|
|
continue
|
|
}
|
|
if _, ok = tmpMap[grpNm]; !ok {
|
|
if !inclNoMatchStrict {
|
|
tmpMap[grpNm] = nil
|
|
} else {
|
|
tmpMap[grpNm] = []string{""}
|
|
}
|
|
} else {
|
|
if inclNoMatchStrict {
|
|
tmpMap[grpNm] = append(tmpMap[grpNm], "")
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
|
|
switch len(chunkIndices) {
|
|
case 1:
|
|
// Single character
|
|
matchStr = string(s[chunkIndices[0]])
|
|
case 2:
|
|
// Multiple characters
|
|
matchStr = s[chunkIndices[0]:chunkIndices[1]]
|
|
}
|
|
|
|
if _, ok = tmpMap[grpNm]; !ok {
|
|
tmpMap[grpNm] = make([]string, 0)
|
|
}
|
|
tmpMap[grpNm] = append(tmpMap[grpNm], matchStr)
|
|
}
|
|
|
|
// This *technically* should be completely handled above.
|
|
if inclNoMatch {
|
|
for _, grpNm = range names {
|
|
if _, ok = tmpMap[grpNm]; !ok {
|
|
tmpMap[grpNm] = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(tmpMap) > 0 {
|
|
matches = tmpMap
|
|
}
|
|
|
|
return
|
|
}
|