go fmt

4 files changed, 355 insertions, 365 deletions

diff --git a/cli/context.go b/cli/context.go
index ce82b17..cafb03f 100644
--- a/cli/context.go
+++ b/cli/context.go
@@ -1,33 +1,32 @@
 package cli
 
-
 type Context struct {
-    args Arguments
-    handlers []*Handler
+	args     Arguments
+	handlers []*Handler
 }
 
 func (self Context) Args() Arguments {
-    return self.args
+	return self.args
 }
 
 func (self Context) Handlers() []*Handler {
-    return self.handlers
+	return self.handlers
 }
 
 type Arguments map[string]interface{}
 
 func (self Arguments) String(key string) string {
-    return self[key].(string)
+	return self[key].(string)
 }
 
 func (self Arguments) Int64(key string) int64 {
-    return self[key].(int64)
+	return self[key].(int64)
 }
 
 func (self Arguments) Bool(key string) bool {
-    return self[key].(bool)
+	return self[key].(bool)
 }
 
 func (self Arguments) StringSlice(key string) []string {
-    return self[key].([]string)
+	return self[key].([]string)
 }
diff --git a/cli/flags.go b/cli/flags.go
index 6c82ed7..61ecfb4 100644
--- a/cli/flags.go
+++ b/cli/flags.go
@@ -1,162 +1,160 @@
 package cli
 
 type Flag interface {
-    GetPatterns() []string
-    GetName() string
-    GetDescription() string
-    GetParser() Parser
+	GetPatterns() []string
+	GetName() string
+	GetDescription() string
+	GetParser() Parser
 }
 
 func getFlagParser(flags []Flag) Parser {
-    var parsers []Parser
+	var parsers []Parser
 
-    for _, flag := range flags {
-        parsers = append(parsers, flag.GetParser())
-    }
+	for _, flag := range flags {
+		parsers = append(parsers, flag.GetParser())
+	}
 
-    return FlagParser{parsers}
+	return FlagParser{parsers}
 }
 
-
 type BoolFlag struct {
-    Patterns []string
-    Name string
-    Description string
-    DefaultValue bool
-    OmitValue bool
+	Patterns     []string
+	Name         string
+	Description  string
+	DefaultValue bool
+	OmitValue    bool
 }
 
 func (self BoolFlag) GetName() string {
-    return self.Name
+	return self.Name
 }
 
 func (self BoolFlag) GetPatterns() []string {
-    return self.Patterns
+	return self.Patterns
 }
 
 func (self BoolFlag) GetDescription() string {
-    return self.Description
+	return self.Description
 }
 
 func (self BoolFlag) GetParser() Parser {
-    var parsers []Parser
-    for _, p := range self.Patterns {
-        parsers = append(parsers, BoolFlagParser{
-            pattern: p,
-            key: self.Name,
-            omitValue: self.OmitValue,
-            defaultValue: self.DefaultValue,
-        })
-    }
-
-    if len(parsers) == 1 {
-        return parsers[0]
-    }
-    return ShortCircuitParser{parsers}
+	var parsers []Parser
+	for _, p := range self.Patterns {
+		parsers = append(parsers, BoolFlagParser{
+			pattern:      p,
+			key:          self.Name,
+			omitValue:    self.OmitValue,
+			defaultValue: self.DefaultValue,
+		})
+	}
+
+	if len(parsers) == 1 {
+		return parsers[0]
+	}
+	return ShortCircuitParser{parsers}
 }
 
-
 type StringFlag struct {
-    Patterns []string
-    Name string
-    Description string
-    DefaultValue string
+	Patterns     []string
+	Name         string
+	Description  string
+	DefaultValue string
 }
 
 func (self StringFlag) GetName() string {
-    return self.Name
+	return self.Name
 }
 
 func (self StringFlag) GetPatterns() []string {
-    return self.Patterns
+	return self.Patterns
 }
 
 func (self StringFlag) GetDescription() string {
-    return self.Description
+	return self.Description
 }
 
 func (self StringFlag) GetParser() Parser {
-    var parsers []Parser
-    for _, p := range self.Patterns {
-        parsers = append(parsers, StringFlagParser{
-            pattern: p,
-            key: self.Name,
-            defaultValue: self.DefaultValue,
-        })
-    }
+	var parsers []Parser
+	for _, p := range self.Patterns {
+		parsers = append(parsers, StringFlagParser{
+			pattern:      p,
+			key:          self.Name,
+			defaultValue: self.DefaultValue,
+		})
+	}
 
-    if len(parsers) == 1 {
-        return parsers[0]
-    }
-    return ShortCircuitParser{parsers}
+	if len(parsers) == 1 {
+		return parsers[0]
+	}
+	return ShortCircuitParser{parsers}
 }
 
 type IntFlag struct {
-    Patterns []string
-    Name string
-    Description string
-    DefaultValue int64
+	Patterns     []string
+	Name         string
+	Description  string
+	DefaultValue int64
 }
 
 func (self IntFlag) GetName() string {
-    return self.Name
+	return self.Name
 }
 
 func (self IntFlag) GetPatterns() []string {
-    return self.Patterns
+	return self.Patterns
 }
 
 func (self IntFlag) GetDescription() string {
-    return self.Description
+	return self.Description
 }
 
 func (self IntFlag) GetParser() Parser {
-    var parsers []Parser
-    for _, p := range self.Patterns {
-        parsers = append(parsers, IntFlagParser{
-            pattern: p,
-            key: self.Name,
-            defaultValue: self.DefaultValue,
-        })
-    }
+	var parsers []Parser
+	for _, p := range self.Patterns {
+		parsers = append(parsers, IntFlagParser{
+			pattern:      p,
+			key:          self.Name,
+			defaultValue: self.DefaultValue,
+		})
+	}
 
-    if len(parsers) == 1 {
-        return parsers[0]
-    }
-    return ShortCircuitParser{parsers}
+	if len(parsers) == 1 {
+		return parsers[0]
+	}
+	return ShortCircuitParser{parsers}
 }
 
 type StringSliceFlag struct {
-    Patterns []string
-    Name string
-    Description string
-    DefaultValue []string
+	Patterns     []string
+	Name         string
+	Description  string
+	DefaultValue []string
 }
 
 func (self StringSliceFlag) GetName() string {
-    return self.Name
+	return self.Name
 }
 
 func (self StringSliceFlag) GetPatterns() []string {
-    return self.Patterns
+	return self.Patterns
 }
 
 func (self StringSliceFlag) GetDescription() string {
-    return self.Description
+	return self.Description
 }
 
 func (self StringSliceFlag) GetParser() Parser {
-    var parsers []Parser
-    for _, p := range self.Patterns {
-        parsers = append(parsers, StringSliceFlagParser{
-            pattern: p,
-            key: self.Name,
-            defaultValue: self.DefaultValue,
-        })
-    }
-
-    if len(parsers) == 1 {
-        return parsers[0]
-    }
-    return ShortCircuitParser{parsers}
+	var parsers []Parser
+	for _, p := range self.Patterns {
+		parsers = append(parsers, StringSliceFlagParser{
+			pattern:      p,
+			key:          self.Name,
+			defaultValue: self.DefaultValue,
+		})
+	}
+
+	if len(parsers) == 1 {
+		return parsers[0]
+	}
+	return ShortCircuitParser{parsers}
 }
diff --git a/cli/handler.go b/cli/handler.go
index a1a7257..3c53e7e 100644
--- a/cli/handler.go
+++ b/cli/handler.go
@@ -1,119 +1,118 @@
 package cli
 
 import (
-    "regexp"
-    "strings"
+	"regexp"
+	"strings"
 )
 
-func NewFlagGroup(name string, flags...Flag) FlagGroup {
-    return FlagGroup{
-        Name: name,
-        Flags: flags,
-    }
+func NewFlagGroup(name string, flags ...Flag) FlagGroup {
+	return FlagGroup{
+		Name:  name,
+		Flags: flags,
+	}
 }
 
 type FlagGroup struct {
-    Name string
-    Flags []Flag
+	Name  string
+	Flags []Flag
 }
 
 type FlagGroups []FlagGroup
 
 func (groups FlagGroups) getFlags(name string) []Flag {
-    for _, group := range groups {
-        if group.Name == name {
-            return group.Flags
-        }
-    }
+	for _, group := range groups {
+		if group.Name == name {
+			return group.Flags
+		}
+	}
 
-    return nil
+	return nil
 }
 
 var handlers []*Handler
 
 type Handler struct {
-    Pattern string
-    FlagGroups FlagGroups
-    Callback func(Context)
-    Description string
+	Pattern     string
+	FlagGroups  FlagGroups
+	Callback    func(Context)
+	Description string
 }
 
 func (self *Handler) getParser() Parser {
-    var parsers []Parser
-
-    for _, pattern := range self.SplitPattern() {
-        if isFlagGroup(pattern) {
-            groupName := flagGroupName(pattern)
-            flags := self.FlagGroups.getFlags(groupName)
-            parsers = append(parsers, getFlagParser(flags))
-        } else if isCaptureGroup(pattern) {
-            parsers = append(parsers, CaptureGroupParser{pattern})
-        } else {
-            parsers = append(parsers, EqualParser{pattern})
-        }
-    }
-
-    return CompleteParser{parsers}
+	var parsers []Parser
+
+	for _, pattern := range self.SplitPattern() {
+		if isFlagGroup(pattern) {
+			groupName := flagGroupName(pattern)
+			flags := self.FlagGroups.getFlags(groupName)
+			parsers = append(parsers, getFlagParser(flags))
+		} else if isCaptureGroup(pattern) {
+			parsers = append(parsers, CaptureGroupParser{pattern})
+		} else {
+			parsers = append(parsers, EqualParser{pattern})
+		}
+	}
+
+	return CompleteParser{parsers}
 }
 
 // Split on spaces but ignore spaces inside <...> and [...]
 func (self *Handler) SplitPattern() []string {
-    re := regexp.MustCompile(`(<[^>]+>|\[[^\]]+]|\S+)`)
-    matches := []string{}
+	re := regexp.MustCompile(`(<[^>]+>|\[[^\]]+]|\S+)`)
+	matches := []string{}
 
-    for _, value := range re.FindAllStringSubmatch(self.Pattern, -1) {
-        matches = append(matches, value[1])
-    }
+	for _, value := range re.FindAllStringSubmatch(self.Pattern, -1) {
+		matches = append(matches, value[1])
+	}
 
-    return matches
+	return matches
 }
 
 func SetHandlers(h []*Handler) {
-    handlers = h
+	handlers = h
 }
 
 func AddHandler(pattern string, groups FlagGroups, callback func(Context), desc string) {
-    handlers = append(handlers, &Handler{
-        Pattern: pattern,
-        FlagGroups: groups,
-        Callback: callback,
-        Description: desc,
-    })
+	handlers = append(handlers, &Handler{
+		Pattern:     pattern,
+		FlagGroups:  groups,
+		Callback:    callback,
+		Description: desc,
+	})
 }
 
 func findHandler(args []string) *Handler {
-    for _, h := range handlers {
-        if _, ok := h.getParser().Match(args); ok {
-            return h
-        }
-    }
-    return nil
+	for _, h := range handlers {
+		if _, ok := h.getParser().Match(args); ok {
+			return h
+		}
+	}
+	return nil
 }
 
-
 func Handle(args []string) bool {
-    h := findHandler(args)
-    if h == nil {
-        return false
-    }
-
-    _, data := h.getParser().Capture(args)
-    ctx := Context{
-        args: data,
-        handlers: handlers,
-    }
-    h.Callback(ctx)
-    return true
+	h := findHandler(args)
+	if h == nil {
+		return false
+	}
+
+	_, data := h.getParser().Capture(args)
+	ctx := Context{
+		args:     data,
+		handlers: handlers,
+	}
+	h.Callback(ctx)
+	return true
 }
 
 func isCaptureGroup(arg string) bool {
-    return strings.HasPrefix(arg, "<") && strings.HasSuffix(arg, ">")
+	return strings.HasPrefix(arg, "<") && strings.HasSuffix(arg, ">")
 }
 
 func isFlagGroup(arg string) bool {
-    return strings.HasPrefix(arg, "[") && strings.HasSuffix(arg, "]")
+	return strings.HasPrefix(arg, "[") && strings.HasSuffix(arg, "]")
 }
 
 func flagGroupName(s string) string {
-    return s[1:len(s) - 1]
+	return s[1 : len(s)-1]
 }
diff --git a/cli/parser.go b/cli/parser.go
index 5fbbe3f..e1b5bc1 100644
--- a/cli/parser.go
+++ b/cli/parser.go
@@ -1,357 +1,351 @@
 package cli
 
 import (
-    "fmt"
-    "strconv"
+	"fmt"
+	"strconv"
 )
 
 type Parser interface {
-    Match([]string) ([]string, bool)
-    Capture([]string) ([]string, map[string]interface{})
+	Match([]string) ([]string, bool)
+	Capture([]string) ([]string, map[string]interface{})
 }
 
 type EqualParser struct {
-    value string
+	value string
 }
 
 func (self EqualParser) Match(values []string) ([]string, bool) {
-    if len(values) == 0 {
-        return values, false
-    }
+	if len(values) == 0 {
+		return values, false
+	}
 
-    if self.value == values[0] {
-        return values[1:], true
-    }
+	if self.value == values[0] {
+		return values[1:], true
+	}
 
-    return values, false
+	return values, false
 }
 
 func (self EqualParser) Capture(values []string) ([]string, map[string]interface{}) {
-    remainingValues, _ := self.Match(values)
-    return remainingValues, nil
+	remainingValues, _ := self.Match(values)
+	return remainingValues, nil
 }
 
 func (self EqualParser) String() string {
-    return fmt.Sprintf("EqualParser '%s'", self.value)
+	return fmt.Sprintf("EqualParser '%s'", self.value)
 }
 
-
 type CaptureGroupParser struct {
-    value string
+	value string
 }
 
 func (self CaptureGroupParser) Match(values []string) ([]string, bool) {
-    if len(values) == 0 {
-        return values, false
-    }
+	if len(values) == 0 {
+		return values, false
+	}
 
-    return values[1:], true
+	return values[1:], true
 }
 
 func (self CaptureGroupParser) key() string {
-    return self.value[1:len(self.value) - 1]
+	return self.value[1 : len(self.value)-1]
 }
 
 func (self CaptureGroupParser) Capture(values []string) ([]string, map[string]interface{}) {
-    if remainingValues, ok := self.Match(values); ok {
-        return remainingValues, map[string]interface{}{self.key(): values[0]}
-    }
+	if remainingValues, ok := self.Match(values); ok {
+		return remainingValues, map[string]interface{}{self.key(): values[0]}
+	}
 
-    return values, nil
+	return values, nil
 }
 
 func (self CaptureGroupParser) String() string {
-    return fmt.Sprintf("CaptureGroupParser '%s'", self.value)
+	return fmt.Sprintf("CaptureGroupParser '%s'", self.value)
 }
 
-
-
 type BoolFlagParser struct {
-    pattern string
-    key string
-    omitValue bool
-    defaultValue bool
+	pattern      string
+	key          string
+	omitValue    bool
+	defaultValue bool
 }
 
 func (self BoolFlagParser) Match(values []string) ([]string, bool) {
-    if self.omitValue {
-        return flagKeyMatch(self.pattern, values, 0)
-    }
+	if self.omitValue {
+		return flagKeyMatch(self.pattern, values, 0)
+	}
 
-    remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
-    if !ok {
-        return remaining, false
-    }
+	remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
+	if !ok {
+		return remaining, false
+	}
 
-    // Check that value is a valid boolean
-    if _, err := strconv.ParseBool(value); err != nil {
-        return remaining, false
-    }
+	// Check that value is a valid boolean
+	if _, err := strconv.ParseBool(value); err != nil {
+		return remaining, false
+	}
 
-    return remaining, true
+	return remaining, true
 }
 
 func (self BoolFlagParser) Capture(values []string) ([]string, map[string]interface{}) {
-    if self.omitValue {
-        remaining, ok := flagKeyMatch(self.pattern, values, 0)
-        return remaining, map[string]interface{}{self.key: ok}
-    }
+	if self.omitValue {
+		remaining, ok := flagKeyMatch(self.pattern, values, 0)
+		return remaining, map[string]interface{}{self.key: ok}
+	}
 
-    remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
-    if !ok {
-        return remaining, map[string]interface{}{self.key: self.defaultValue}
-    }
+	remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
+	if !ok {
+		return remaining, map[string]interface{}{self.key: self.defaultValue}
+	}
 
-    b, _ := strconv.ParseBool(value)
-    return remaining, map[string]interface{}{self.key: b}
+	b, _ := strconv.ParseBool(value)
+	return remaining, map[string]interface{}{self.key: b}
 }
 
 func (self BoolFlagParser) String() string {
-    return fmt.Sprintf("BoolFlagParser '%s'", self.pattern)
+	return fmt.Sprintf("BoolFlagParser '%s'", self.pattern)
 }
 
 type StringFlagParser struct {
-    pattern string
-    key string
-    defaultValue string
+	pattern      string
+	key          string
+	defaultValue string
 }
 
 func (self StringFlagParser) Match(values []string) ([]string, bool) {
-    remaining, _, ok := flagKeyValueMatch(self.pattern, values, 0)
-    return remaining, ok
+	remaining, _, ok := flagKeyValueMatch(self.pattern, values, 0)
+	return remaining, ok
 }
 
 func (self StringFlagParser) Capture(values []string) ([]string, map[string]interface{}) {
-    remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
-    if !ok {
-        return remaining, map[string]interface{}{self.key: self.defaultValue}
-    }
+	remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
+	if !ok {
+		return remaining, map[string]interface{}{self.key: self.defaultValue}
+	}
 
-    return remaining, map[string]interface{}{self.key: value}
+	return remaining, map[string]interface{}{self.key: value}
 }
 
 func (self StringFlagParser) String() string {
-    return fmt.Sprintf("StringFlagParser '%s'", self.pattern)
+	return fmt.Sprintf("StringFlagParser '%s'", self.pattern)
 }
 
 type IntFlagParser struct {
-    pattern string
-    key string
-    defaultValue int64
+	pattern      string
+	key          string
+	defaultValue int64
 }
 
 func (self IntFlagParser) Match(values []string) ([]string, bool) {
-    remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
-    if !ok {
-        return remaining, false
-    }
+	remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
+	if !ok {
+		return remaining, false
+	}
 
-    // Check that value is a valid integer
-    if _, err := strconv.ParseInt(value, 10, 64); err != nil {
-        return remaining, false
-    }
+	// Check that value is a valid integer
+	if _, err := strconv.ParseInt(value, 10, 64); err != nil {
+		return remaining, false
+	}
 
-    return remaining, true
+	return remaining, true
 }
 
 func (self IntFlagParser) Capture(values []string) ([]string, map[string]interface{}) {
-    remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
-    if !ok {
-        return remaining, map[string]interface{}{self.key: self.defaultValue}
-    }
+	remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
+	if !ok {
+		return remaining, map[string]interface{}{self.key: self.defaultValue}
+	}
 
-    n, _ := strconv.ParseInt(value, 10, 64)
-    return remaining, map[string]interface{}{self.key: n}
+	n, _ := strconv.ParseInt(value, 10, 64)
+	return remaining, map[string]interface{}{self.key: n}
 }
 
 func (self IntFlagParser) String() string {
-    return fmt.Sprintf("IntFlagParser '%s'", self.pattern)
+	return fmt.Sprintf("IntFlagParser '%s'", self.pattern)
 }
 
-
 type StringSliceFlagParser struct {
-    pattern string
-    key string
-    defaultValue []string
+	pattern      string
+	key          string
+	defaultValue []string
 }
 
 func (self StringSliceFlagParser) Match(values []string) ([]string, bool) {
-    if len(values) < 2 {
-        return values, false
-    }
+	if len(values) < 2 {
+		return values, false
+	}
 
-    var remainingValues []string
+	var remainingValues []string
 
-    for i := 0; i < len(values); i++ {
-        if values[i] == self.pattern && i + 1 < len(values) {
-            i++
-            continue
-        }
-        remainingValues = append(remainingValues, values[i])
-    }
+	for i := 0; i < len(values); i++ {
+		if values[i] == self.pattern && i+1 < len(values) {
+			i++
+			continue
+		}
+		remainingValues = append(remainingValues, values[i])
+	}
 
-    return remainingValues, len(values) != len(remainingValues)
+	return remainingValues, len(values) != len(remainingValues)
 }
 
 func (self StringSliceFlagParser) Capture(values []string) ([]string, map[string]interface{}) {
-    remainingValues, ok := self.Match(values)
-    if !ok {
-        return values, map[string]interface{}{self.key: self.defaultValue}
-    }
+	remainingValues, ok := self.Match(values)
+	if !ok {
+		return values, map[string]interface{}{self.key: self.defaultValue}
+	}
 
-    var captured []string
+	var captured []string
 
-    for i := 0; i < len(values); i++ {
-        if values[i] == self.pattern && i + 1 < len(values) {
-            captured = append(captured, values[i + 1])
-        }
-    }
+	for i := 0; i < len(values); i++ {
+		if values[i] == self.pattern && i+1 < len(values) {
+			captured = append(captured, values[i+1])
+		}
+	}
 
-    return remainingValues, map[string]interface{}{self.key: captured}
+	return remainingValues, map[string]interface{}{self.key: captured}
 }
 
 func (self StringSliceFlagParser) String() string {
-    return fmt.Sprintf("StringSliceFlagParser '%s'", self.pattern)
+	return fmt.Sprintf("StringSliceFlagParser '%s'", self.pattern)
 }
 
-
 type FlagParser struct {
-    parsers []Parser
+	parsers []Parser
 }
 
 func (self FlagParser) Match(values []string) ([]string, bool) {
-    remainingValues := values
+	remainingValues := values
 
-    for _, parser := range self.parsers {
-        remainingValues, _ = parser.Match(remainingValues)
-    }
-    return remainingValues, true
+	for _, parser := range self.parsers {
+		remainingValues, _ = parser.Match(remainingValues)
+	}
+	return remainingValues, true
 }
 
 func (self FlagParser) Capture(values []string) ([]string, map[string]interface{}) {
-    captured := map[string]interface{}{}
-    remainingValues := values
+	captured := map[string]interface{}{}
+	remainingValues := values
 
-    for _, parser := range self.parsers {
-        var data map[string]interface{}
-        remainingValues, data = parser.Capture(remainingValues)
-        for key, value := range data {
-            captured[key] = value
-        }
-    }
+	for _, parser := range self.parsers {
+		var data map[string]interface{}
+		remainingValues, data = parser.Capture(remainingValues)
+		for key, value := range data {
+			captured[key] = value
+		}
+	}
 
-    return remainingValues, captured
+	return remainingValues, captured
 }
 
 func (self FlagParser) String() string {
-    return fmt.Sprintf("FlagParser %v", self.parsers)
+	return fmt.Sprintf("FlagParser %v", self.parsers)
 }
 
-
 type ShortCircuitParser struct {
-    parsers []Parser
+	parsers []Parser
 }
 
 func (self ShortCircuitParser) Match(values []string) ([]string, bool) {
-    remainingValues := values
+	remainingValues := values
 
-    for _, parser := range self.parsers {
-        var ok bool
-        remainingValues, ok = parser.Match(remainingValues)
-        if ok {
-            return remainingValues, true
-        }
-    }
+	for _, parser := range self.parsers {
+		var ok bool
+		remainingValues, ok = parser.Match(remainingValues)
+		if ok {
+			return remainingValues, true
+		}
+	}
 
-    return remainingValues, false
+	return remainingValues, false
 }
 
 func (self ShortCircuitParser) Capture(values []string) ([]string, map[string]interface{}) {
-    if len(self.parsers) == 0 {
-        return values, nil
-    }
+	if len(self.parsers) == 0 {
+		return values, nil
+	}
 
-    for _, parser := range self.parsers {
-        if _, ok := parser.Match(values); ok {
-            return parser.Capture(values)
-        }
-    }
+	for _, parser := range self.parsers {
+		if _, ok := parser.Match(values); ok {
+			return parser.Capture(values)
+		}
+	}
 
-    // No parsers matched at this point,
-    // just return the capture value of the first one
-    return self.parsers[0].Capture(values)
+	// No parsers matched at this point,
+	// just return the capture value of the first one
+	return self.parsers[0].Capture(values)
 }
 
 func (self ShortCircuitParser) String() string {
-    return fmt.Sprintf("ShortCircuitParser %v", self.parsers)
+	return fmt.Sprintf("ShortCircuitParser %v", self.parsers)
 }
 
 type CompleteParser struct {
-    parsers []Parser
+	parsers []Parser
 }
 
 func (self CompleteParser) Match(values []string) ([]string, bool) {
-    remainingValues := copySlice(values)
+	remainingValues := copySlice(values)
 
-    for _, parser := range self.parsers {
-        var ok bool
-        remainingValues, ok = parser.Match(remainingValues)
-        if !ok {
-            return remainingValues, false
-        }
-    }
+	for _, parser := range self.parsers {
+		var ok bool
+		remainingValues, ok = parser.Match(remainingValues)
+		if !ok {
+			return remainingValues, false
+		}
+	}
 
-    return remainingValues, len(remainingValues) == 0
+	return remainingValues, len(remainingValues) == 0
 }
 
 func (self CompleteParser) Capture(values []string) ([]string, map[string]interface{}) {
-    remainingValues := copySlice(values)
-    data := map[string]interface{}{}
+	remainingValues := copySlice(values)
+	data := map[string]interface{}{}
 
-    for _, parser := range self.parsers {
-        var captured map[string]interface{}
-        remainingValues, captured = parser.Capture(remainingValues)
-        for key, value := range captured {
-            data[key] = value
-        }
-    }
+	for _, parser := range self.parsers {
+		var captured map[string]interface{}
+		remainingValues, captured = parser.Capture(remainingValues)
+		for key, value := range captured {
+			data[key] = value
+		}
+	}
 
-    return remainingValues, data
+	return remainingValues, data
 }
 
 func (self CompleteParser) String() string {
-    return fmt.Sprintf("CompleteParser %v", self.parsers)
+	return fmt.Sprintf("CompleteParser %v", self.parsers)
 }
 
 func flagKeyValueMatch(key string, values []string, index int) ([]string, string, bool) {
-    if index > len(values) - 2 {
-        return values, "", false
-    }
+	if index > len(values)-2 {
+		return values, "", false
+	}
 
-    if values[index] == key {
-        value := values[index + 1]
-        remaining := append(copySlice(values[:index]), values[index + 2:]...)
-        return remaining, value, true
-    }
+	if values[index] == key {
+		value := values[index+1]
+		remaining := append(copySlice(values[:index]), values[index+2:]...)
+		return remaining, value, true
+	}
 
-    return flagKeyValueMatch(key, values, index + 1)
+	return flagKeyValueMatch(key, values, index+1)
 }
 
 func flagKeyMatch(key string, values []string, index int) ([]string, bool) {
-    if index > len(values) - 1 {
-        return values, false
-    }
+	if index > len(values)-1 {
+		return values, false
+	}
 
-    if values[index] == key {
-        remaining := append(copySlice(values[:index]), values[index + 1:]...)
-        return remaining, true
-    }
+	if values[index] == key {
+		remaining := append(copySlice(values[:index]), values[index+1:]...)
+		return remaining, true
+	}
 
-    return flagKeyMatch(key, values, index + 1)
+	return flagKeyMatch(key, values, index+1)
 }
 
 func copySlice(a []string) []string {
-    b := make([]string, len(a))
-    copy(b, a)
-    return b
+	b := make([]string, len(a))
+	copy(b, a)
+	return b
 }