1 files changed, 134 insertions, 0 deletions
diff --git a/vendor/github.com/vbatts/git-validation/validate/rules.go b/vendor/github.com/vbatts/git-validation/validate/rules.go
new file mode 100644
index 000000000..38126a4f0
--- /dev/null
+++ b/vendor/github.com/vbatts/git-validation/validate/rules.go
@@ -0,0 +1,134 @@
+package validate
+
+import (
+	"sort"
+	"strings"
+	"sync"
+
+	"github.com/vbatts/git-validation/git"
+)
+
+var (
+	// RegisteredRules are the avaible validation to perform on git commits
+	RegisteredRules  = []Rule{}
+	registerRuleLock = sync.Mutex{}
+)
+
+// RegisterRule includes the Rule in the avaible set to use
+func RegisterRule(vr Rule) {
+	registerRuleLock.Lock()
+	defer registerRuleLock.Unlock()
+	RegisteredRules = append(RegisteredRules, vr)
+}
+
+// Rule will operate over a provided git.CommitEntry, and return a result.
+type Rule struct {
+	Name        string // short name for reference in in the `-run=...` flag
+	Value       string // value to configure for the rule (i.e. a regexp to check for in the commit message)
+	Description string // longer Description for readability
+	Run         func(Rule, git.CommitEntry) Result
+	Default     bool // whether the registered rule is run by default
+}
+
+// Commit processes the given rules on the provided commit, and returns the result set.
+func Commit(c git.CommitEntry, rules []Rule) Results {
+	results := Results{}
+	for _, r := range rules {
+		results = append(results, r.Run(r, c))
+	}
+	return results
+}
+
+// Result is the result for a single validation of a commit.
+type Result struct {
+	CommitEntry git.CommitEntry
+	Pass        bool
+	Msg         string
+}
+
+// Results is a set of results. This is type makes it easy for the following function.
+type Results []Result
+
+// PassFail gives a quick over/under of passes and failures of the results in this set
+func (vr Results) PassFail() (pass int, fail int) {
+	for _, res := range vr {
+		if res.Pass {
+			pass++
+		} else {
+			fail++
+		}
+	}
+	return pass, fail
+}
+
+// SanitizeFilters takes a comma delimited list and returns the trimmend and
+// split (on ",") items in the list
+func SanitizeFilters(filtStr string) (filters []string) {
+	for _, item := range strings.Split(filtStr, ",") {
+		filters = append(filters, strings.TrimSpace(item))
+	}
+	return
+}
+
+// FilterRules takes a set of rules and a list of short names to include, and
+// returns the reduced set.  The comparison is case insensitive.
+//
+// Some `includes` rules have values assigned to them.
+// i.e. -run "dco,message_regexp='^JIRA-[0-9]+ [A-Z].*$'"
+//
+func FilterRules(rules []Rule, includes []string) []Rule {
+	ret := []Rule{}
+
+	for _, r := range rules {
+		for i := range includes {
+			if strings.Contains(includes[i], "=") {
+				chunks := strings.SplitN(includes[i], "=", 2)
+				if strings.ToLower(r.Name) == strings.ToLower(chunks[0]) {
+					// for these rules, the Name won't be unique per se. There may be
+					// multiple "regexp=" with different values. We'll need to set the
+					// .Value = chunk[1] and ensure r is dup'ed so they don't clobber
+					// each other.
+					newR := Rule(r)
+					newR.Value = chunks[1]
+					ret = append(ret, newR)
+				}
+			} else {
+				if strings.ToLower(r.Name) == strings.ToLower(includes[i]) {
+					ret = append(ret, r)
+				}
+			}
+		}
+	}
+
+	return ret
+}
+
+// StringsSliceEqual compares two string arrays for equality
+func StringsSliceEqual(a, b []string) bool {
+	if !sort.StringsAreSorted(a) {
+		sort.Strings(a)
+	}
+	if !sort.StringsAreSorted(b) {
+		sort.Strings(b)
+	}
+	for i := range b {
+		if !StringsSliceContains(a, b[i]) {
+			return false
+		}
+	}
+	for i := range a {
+		if !StringsSliceContains(b, a[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// StringsSliceContains checks for the presence of a word in string array
+func StringsSliceContains(a []string, b string) bool {
+	if !sort.StringsAreSorted(a) {
+		sort.Strings(a)
+	}
+	i := sort.SearchStrings(a, b)
+	return i < len(a) && a[i] == b
+}