go fmt

1 files changed, 190 insertions, 196 deletions

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
 }