Function FilterMap

utils/filter.go:41–71

FilterMap receives a map with string keys and arbitrary values (possibly other maps) and return a new map which is a subset of the original one containing only the keys matching any of the patterns in "include" and excluding keys matching any of the patterns in "exclude". The logic for determining i

(m map[string]interface{}, include, exclude []string)

//   resulting map, as long as it doesn't match a pattern in "exclude".
//
func FilterMap(m map[string]interface{}, include, exclude []string) map[string]interface{} {
	includeGlob := make([]glob.Glob, len(include))
	excludeGlob := make([]glob.Glob, len(exclude))
	for i, p := range include {
		cp := glob.MustCompile(p, '.')
		includeGlob[i] = cp
	}
	// For each include pattern that do not ends with **, add the same pattern
	// but ended in .**. This because when someone says that she wants to include
	// "foo.bar", where "foo.bar" is dictionary, what she actually expects is
	// getting the dictionary with all its keys, but the keys inside the
	// dictionary don't match the "foo.bar" pattern, so we add "foo.bar.**".
	for _, p := range include {
		if !strings.HasSuffix(p, "**") {
			includeGlob = append(includeGlob, glob.MustCompile(p+".**", '.'))
		}
	}
	for i, p := range exclude {
		cp := glob.MustCompile(p, '.')
		excludeGlob[i] = cp
	}
	// The same happens if you exclude "foo.bar", what you actually mean is
	// excluding "foo.bar" and "foo.bar.**".
	for _, p := range exclude {
		if !strings.HasSuffix(p, "**") {
			excludeGlob = append(excludeGlob, glob.MustCompile(p+".**", '.'))
		}
	}
	filtered := filterMap(reflect.ValueOf(m), includeGlob, excludeGlob, "")
	return filtered.Interface().(map[string]interface{})
}

// actualValue returns v if it's not an interface. If v is an interface it
// returns the value pointed to by the interface.