go fmt

1 files changed, 68 insertions, 69 deletions

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]
 }