From 79786009ced7c10d15ddc495f395965f1a4a7a94 Mon Sep 17 00:00:00 2001
From: Zeal Jagannatha <zealjagannatha@gmail.com>
Date: Mon, 23 Nov 2015 19:55:46 -0800
Subject: [PATCH 1/2] Added support for regexp flags

---
 flags_test.go | 11 +++++++++++
 parsers.go    | 13 +++++++++++++
 values.go     | 29 +++++++++++++++++++++++++++++
 3 files changed, 53 insertions(+)

diff --git a/flags_test.go b/flags_test.go
index 64a3be5..9528e64 100644
--- a/flags_test.go
+++ b/flags_test.go
@@ -107,3 +107,14 @@ func TestRequiredWithEnvar(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, 123, *flag)
 }
+
+func TestRegexp(t *testing.T) {
+	app := New("test", "")
+	flag := app.Flag("reg", "").Regexp()
+	_, err := app.Parse([]string{"--reg", "^abc$"})
+	assert.NoError(t, err)
+	assert.NotNil(t, *flag)
+	assert.Equal(t, "^abc$", (*flag).String())
+	assert.Regexp(t, *flag, "abc")
+	assert.NotRegexp(t, *flag, "abcd")
+}
diff --git a/parsers.go b/parsers.go
index d9ad57e..3144fc1 100644
--- a/parsers.go
+++ b/parsers.go
@@ -4,6 +4,7 @@ import (
 	"net"
 	"net/url"
 	"os"
+	"regexp"
 	"time"
 
 	"github.com/alecthomas/units"
@@ -210,3 +211,15 @@ func (p *parserMixin) Counter() (target *int) {
 func (p *parserMixin) CounterVar(target *int) {
 	p.SetValue(newCounterValue(target))
 }
+
+// Regexp
+func (p *parserMixin) Regexp() (target **regexp.Regexp) {
+	target = new(*regexp.Regexp)
+	p.RegexpVar(target)
+	return
+}
+
+// Regexp
+func (p *parserMixin) RegexpVar(target **regexp.Regexp) {
+	p.SetValue(newRegexpValue(target))
+}
diff --git a/values.go b/values.go
index dbbb0e0..23ee87b 100644
--- a/values.go
+++ b/values.go
@@ -445,3 +445,32 @@ func (c *counterValue) Set(s string) error {
 func (c *counterValue) Get() interface{} { return (int)(*c) }
 func (c *counterValue) IsBoolFlag() bool { return true }
 func (c *counterValue) String() string   { return fmt.Sprintf("%d", *c) }
+
+// -- regexp.Regexp value
+type regexpValue struct {
+	r **regexp.Regexp
+}
+
+func newRegexpValue(r **regexp.Regexp) *regexpValue {
+	return &regexpValue{r}
+}
+
+func (r *regexpValue) Set(value string) error {
+	if re, err := regexp.Compile(value); err != nil {
+		return err
+	} else {
+		*r.r = re
+		return nil
+	}
+}
+
+func (r *regexpValue) Get() interface{} {
+	return (*regexp.Regexp)(*r.r)
+}
+
+func (r *regexpValue) String() string {
+	if *r.r == nil {
+		return "<nil>"
+	}
+	return (*r.r).String()
+}

From d07c944e5b3f8274648f6c720df114c31042ee51 Mon Sep 17 00:00:00 2001
From: Zeal Jagannatha <zealjagannatha@gmail.com>
Date: Sun, 29 Nov 2015 01:37:50 -0800
Subject: [PATCH 2/2] Added RegexpList* functions

---
 values.json         |  3 ++-
 values_generated.go | 12 ++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/values.json b/values.json
index 6a9b57c..8654c09 100644
--- a/values.json
+++ b/values.json
@@ -18,5 +18,6 @@
   {"name": "TCPAddr", "Type": "*net.TCPAddr", "plural": "TCPList", "no_value_parser": true},
   {"name": "ExistingFile", "Type": "string", "plural": "ExistingFiles", "no_value_parser": true},
   {"name": "ExistingDir", "Type": "string", "plural": "ExistingDirs", "no_value_parser": true},
-  {"name": "ExistingFileOrDir", "Type": "string", "plural": "ExistingFilesOrDirs", "no_value_parser": true}
+  {"name": "ExistingFileOrDir", "Type": "string", "plural": "ExistingFilesOrDirs", "no_value_parser": true},
+  {"name": "Regexp", "Type": "*regexp.Regexp", "plural": "RegexpList", "no_value_parser": true}
 ]
diff --git a/values_generated.go b/values_generated.go
index 8920aab..132395c 100644
--- a/values_generated.go
+++ b/values_generated.go
@@ -3,6 +3,7 @@ package kingpin
 import (
 	"fmt"
 	"net"
+	"regexp"
 	"strconv"
 	"time"
 )
@@ -620,3 +621,14 @@ func (p *parserMixin) ExistingFilesOrDirs() (target *[]string) {
 func (p *parserMixin) ExistingFilesOrDirsVar(target *[]string) {
 	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newExistingFileOrDirValue(v.(*string)) }))
 }
+
+// RegexpList accumulates *regexp.Regexp values into a slice.
+func (p *parserMixin) RegexpList() (target *[]*regexp.Regexp) {
+	target = new([]*regexp.Regexp)
+	p.RegexpListVar(target)
+	return
+}
+
+func (p *parserMixin) RegexpListVar(target *[]*regexp.Regexp) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value { return newRegexpValue(v.(**regexp.Regexp)) }))
+}