Refactor many if/else and switch for the session modules

session/command_handler.go

@@ -27,7 +27,6 @@ func (h *CommandHandler) Parse(line string) (bool, []string) {
 	result := h.Parser.FindStringSubmatch(line)
 	if len(result) == h.Parser.NumSubexp()+1 {
 		return true, result[1:]
-	} else {
-		return false, nil
 	}
+	return false, nil
 }

session/command_handler_test.go

@@ -46,11 +46,15 @@ func TestSessionCommandHandler(t *testing.T) {
 			shouldNotParse := "simple123"
 			shouldParse := "simple 123"
 
-			if parsed, _ := c.Parse(shouldNotParse); parsed {
+			parsed, _ := c.Parse(shouldNotParse)
+			if parsed {
 				t.Fatalf("should not parse '%s'", shouldNotParse)
-			} else if parsed, parts := c.Parse(shouldParse); !parsed {
+			}
+			parsed, parts := c.Parse(shouldParse)
+			if !parsed {
 				t.Fatalf("should parse '%s'", shouldParse)
-			} else if !sameStrings(parts, u.parsed) {
+			}
+			if !sameStrings(parts, u.parsed) {
 				t.Fatalf("expected '%v', got '%v'", u.parsed, parts)
 			}
 		}

session/environment.go

@@ -112,11 +112,11 @@ func (env *Environment) Get(name string) (bool, string) {
 
 func (env *Environment) GetInt(name string) (error, int) {
 	if found, value := env.Get(name); found {
-		if i, err := strconv.Atoi(value); err == nil {
-			return nil, i
-		} else {
+		i, err := strconv.Atoi(value)
+		if err != nil {
 			return err, 0
 		}
+		return nil, i
 	}
 
 	return fmt.Errorf("Not found."), 0

session/environment_test.go

@@ -22,17 +22,20 @@ func setup(t testing.TB, envFile bool, envFileData bool) {
 	teardown(t)
 
 	if envFile {
-		if fp, err := os.OpenFile(testEnvFile, os.O_RDONLY|os.O_CREATE, 0666); err == nil {
-			fp.Close()
-		} else {
+		fp, err := os.OpenFile(testEnvFile, os.O_RDONLY|os.O_CREATE, 0666);
+		if err != nil {
 			panic(err)
 		}
+		fp.Close()
 	}
 
 	if envFileData {
-		if raw, err := json.Marshal(testEnvData); err != nil {
+		raw, err := json.Marshal(testEnvData)
+		if err != nil {
 			panic(err)
-		} else if err = ioutil.WriteFile(testEnvFile, raw, 0755); err != nil {
+		}
+		err = ioutil.WriteFile(testEnvFile, raw, 0755);
+		if err != nil {
 			panic(err)
 		}
 	}
@@ -45,64 +48,71 @@ func teardown(t testing.TB) {
 }
 
 func TestSessionEnvironmentWithoutFile(t *testing.T) {
-	if env, err := NewEnvironment(""); env == nil {
-		t.Fatal("expected valid environment")
-	} else if err != nil {
+	env, err := NewEnvironment("")
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if len(env.Data) != 0 {
+	}
+	if len(env.Data) != 0 {
 		t.Fatalf("expected empty environment, found %d elements", len(env.Data))
 	}
+	t.Fatal("expected valid environment")
 }
 
 func TestSessionEnvironmentWithInvalidFile(t *testing.T) {
-	if env, err := NewEnvironment("/idontexist"); env == nil {
-		t.Fatal("expected valid environment")
-	} else if err != nil {
+	env, err := NewEnvironment("/idontexist")
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if len(env.Data) != 0 {
+	}
+	if len(env.Data) != 0 {
 		t.Fatalf("expected empty environment, found %d elements", len(env.Data))
 	}
+	t.Fatal("expected valid environment")
 }
 
 func TestSessionEnvironmentWithEmptyFile(t *testing.T) {
 	setup(t, true, false)
 	defer teardown(t)
 
-	if env, err := NewEnvironment(testEnvFile); env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	env, err := NewEnvironment(testEnvFile)
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if len(env.Data) != 0 {
+	}
+	if len(env.Data) != 0 {
 		t.Fatalf("expected empty environment, found %d elements", len(env.Data))
 	}
+
+	t.Fatal("expected environment")
 }
 
 func TestSessionEnvironmentWithDataFile(t *testing.T) {
 	setup(t, true, true)
 	defer teardown(t)
 
-	if env, err := NewEnvironment(testEnvFile); env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	env, err := NewEnvironment(testEnvFile)
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if len(env.Data) != len(testEnvData) {
+	}
+	if len(env.Data) != len(testEnvData) {
 		t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
-	} else if !reflect.DeepEqual(env.Data, testEnvData) {
+	} 
+	if !reflect.DeepEqual(env.Data, testEnvData) {
 		t.Fatalf("unexpected contents: %v", env.Data)
 	}
+	t.Fatal("expected environment")
 }
 
 func TestSessionEnvironmentSaveWithError(t *testing.T) {
 	setup(t, false, false)
 	defer teardown(t)
 
-	if env, err := NewEnvironment(testEnvFile); env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	env, err := NewEnvironment(testEnvFile)
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if err = env.Save("/lulz/nope"); err == nil {
+	}
+	if err = env.Save("/lulz/nope"); err == nil {
 		t.Fatal("expected error")
 	}
+	t.Fatal("expected environment")
 }
 
 func TestSessionEnvironmentSave(t *testing.T) {
@@ -110,24 +120,24 @@ func TestSessionEnvironmentSave(t *testing.T) {
 	defer teardown(t)
 
 	env, err := NewEnvironment(testEnvFile)
-	if env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
+	t.Log("expected environment")
 
 	env.Data["new"] = "value"
 	if err = env.Save(testEnvFile); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	if env, err := NewEnvironment(testEnvFile); env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	env, err = NewEnvironment(testEnvFile)
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if !reflect.DeepEqual(env.Data, map[string]string{"new": "value"}) {
+	}
+	if !reflect.DeepEqual(env.Data, map[string]string{"new": "value"}) {
 		t.Fatalf("unexpected contents: %v", env.Data)
 	}
+	t.Log("expected environment")
 }
 
 func TestSessionEnvironmentHas(t *testing.T) {
@@ -135,13 +145,13 @@ func TestSessionEnvironmentHas(t *testing.T) {
 	defer teardown(t)
 
 	env, err := NewEnvironment(testEnvFile)
-	if env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if len(env.Data) != len(testEnvData) {
+	} 
+	if len(env.Data) != len(testEnvData) {
 		t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
 	}
+	t.Log("expected environment")
 			
 	for k := range testEnvData {
 		if !env.Has(k) {
@@ -161,19 +171,24 @@ func TestSessionEnvironmentSet(t *testing.T) {
 	defer teardown(t)
 
 	env, err := NewEnvironment(testEnvFile)
-	if env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if old := env.Set("people", "ok"); old != "shit" {
+	}
+	old := env.Set("people", "ok")
+	if old != "shit" {
 		t.Fatalf("unexpected old value: %s", old)
-	} else if env.Data["people"] != "ok" {
+	}
+	if env.Data["people"] != "ok" {
 		t.Fatalf("unexpected new value: %s", env.Data["people"])
-	} else if old := env.Set("newkey", "nk"); old != "" {
+	}
+	old = env.Set("newkey", "nk")
+	if old != "" {
 		t.Fatalf("unexpected old value: %s", old)
-	} else if env.Data["newkey"] != "nk" {
+	}
+	if env.Data["newkey"] != "nk" {
 		t.Fatalf("unexpected new value: %s", env.Data["newkey"])
 	}
+	t.Log("expected environment")
 }
 
 func TestSessionEnvironmentSetWithCallback(t *testing.T) {
@@ -181,11 +196,10 @@ func TestSessionEnvironmentSetWithCallback(t *testing.T) {
 	defer teardown(t)
 
 	env, err := NewEnvironment(testEnvFile)
-	if env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
+	t.Log("expected environment")
 
 	cbCalled := false
 	old := env.WithCallback("people", "ok", func(newValue string) {
@@ -199,7 +213,8 @@ func TestSessionEnvironmentSetWithCallback(t *testing.T) {
 	old = env.Set("people", "shitagain")
 	if old != "ok" {
 		t.Fatalf("unexpected old value: %s", old)
-	} else if !cbCalled {
+	} 
+	if !cbCalled {
 		t.Fatal("callback has not been called")
 	}
 
@@ -215,24 +230,27 @@ func TestSessionEnvironmentGet(t *testing.T) {
 	defer teardown(t)
 
 	env, err := NewEnvironment(testEnvFile)
-	if env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if len(env.Data) != len(testEnvData) {
+	}
+	if len(env.Data) != len(testEnvData) {
 		t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
 	}
+	t.Log("expected environment")
 			
 	for k, v := range testEnvData {
-		if found, vv := env.Get(k); !found {
+		found, vv := env.Get(k)
+		if !found {
 			t.Fatalf("should have found %s", k)
-		} else if v != vv {
+		}
+		if v != vv {
 			t.Fatalf("unexpected value found: %s", vv)
 		}
 	}
 
 	for _, k := range []string{"these", "keys", "should", "not", "be", "found"} {
-		if found, _ := env.Get(k); found {
+		found, _ := env.Get(k)
+		if found {
 			t.Fatalf("should not have found %s", k)
 		}
 	}
@@ -243,13 +261,13 @@ func TestSessionEnvironmentGetInt(t *testing.T) {
 	defer teardown(t)
 
 	env, err := NewEnvironment(testEnvFile)
-	if env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if len(env.Data) != len(testEnvData) {
+	}
+	if len(env.Data) != len(testEnvData) {
 		t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
 	}
+	t.Log("expected environment")
 
 	for k := range testEnvData {
 		if err, _ := env.GetInt(k); err == nil {
@@ -258,9 +276,11 @@ func TestSessionEnvironmentGetInt(t *testing.T) {
 	}
 
 	env.Data["num"] = "1234"
-	if err, i := env.GetInt("num"); err != nil {
+	err, i := env.GetInt("num");
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if i != 1234 {
+	} 
+	if i != 1234 {
 		t.Fatalf("unexpected integer: %d", i)
 	}
 }
@@ -270,13 +290,14 @@ func TestSessionEnvironmentSorted(t *testing.T) {
 	defer teardown(t)
 
 	env, err := NewEnvironment(testEnvFile)
-	if env == nil {
-		t.Fatal("expected environment")
-	} else if err != nil {
+	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
-	} else if len(env.Data) != len(testEnvData) {
+	}
+	if len(env.Data) != len(testEnvData) {
 		t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
-	} else if sorted := env.Sorted(); !reflect.DeepEqual(sorted, testEnvSorted) {
+	}
+	if sorted := env.Sorted(); !reflect.DeepEqual(sorted, testEnvSorted) {
 		t.Fatalf("unexpected sorted keys: %v", sorted)
 	}
+	t.Log("expected environment")
 }

session/events.go

@@ -118,7 +118,8 @@ func (p *EventPool) Add(tag string, data interface{}) {
 func (p *EventPool) Log(level log.Verbosity, format string, args ...interface{}) {
 	if level == log.DEBUG && !p.debug {
 		return
-	} else if level < log.ERROR && p.silent {
+	}
+	if level < log.ERROR && p.silent {
 		return
 	}
 

session/module.go

@@ -61,60 +61,59 @@ func (m *SessionModule) Param(name string) *ModuleParam {
 
 func (m SessionModule) ListParam(name string) (err error, values []string) {
 	values = make([]string, 0)
-	list := ""
-	if err, list = m.StringParam(name); err != nil {
+	err, list := m.StringParam(name);
+	if err != nil {
 		return
-	} else {
-		parts := strings.Split(list, ",")
-		for _, part := range parts {
-			part = str.Trim(part)
-			if part != "" {
-				values = append(values, part)
-			}
+	}
+	
+	parts := strings.Split(list, ",")
+	for _, part := range parts {
+		part = str.Trim(part)
+		if part != "" {
+			values = append(values, part)
 		}
 	}
 	return
 }
 
 func (m SessionModule) StringParam(name string) (error, string) {
-	if p, found := m.params[name]; found {
-		if err, v := p.Get(m.Session); err != nil {
+	p, found := m.params[name];
+	if found {
+		err, v := p.Get(m.Session);
+		if err != nil {
 			return err, ""
-		} else {
-			return nil, v.(string)
 		}
-	} else {
-		return fmt.Errorf("Parameter %s does not exist.", name), ""
+		return nil, v.(string)
 	}
+	return fmt.Errorf("Parameter %s does not exist.", name), ""
 }
 
 func (m SessionModule) IPParam(name string) (error, net.IP) {
-	if err, v := m.StringParam(name); err != nil {
+	err, v := m.StringParam(name);
+	if err != nil {
 		return err, nil
-	} else {
-		return nil, net.ParseIP(v)
 	}
+	return nil, net.ParseIP(v)
 }
 
 func (m SessionModule) IntParam(name string) (error, int) {
-	if p, found := m.params[name]; found {
-		if err, v := p.Get(m.Session); err != nil {
+	p, found := m.params[name]; 
+	if found {
+		err, v := p.Get(m.Session); 
+		if err != nil {
 			return err, 0
-		} else {
-			return nil, v.(int)
 		}
-
-	} else {
-		return fmt.Errorf("Parameter %s does not exist.", name), 0
+		return nil, v.(int)
 	}
+	return fmt.Errorf("Parameter %s does not exist.", name), 0
 }
 
 func (m SessionModule) BoolParam(name string) (error, bool) {
-	if err, v := m.params[name].Get(m.Session); err != nil {
+	err, v := m.params[name].Get(m.Session);
+	if err != nil {
 		return err, false
-	} else {
-		return nil, v.(bool)
 	}
+	return nil, v.(bool)
 }
 
 func (m *SessionModule) AddHandler(h ModuleHandler) {
@@ -137,9 +136,8 @@ func (m *SessionModule) SetRunning(running bool, cb func()) error {
 	if running == m.Running() {
 		if m.Started {
 			return ErrAlreadyStarted
-		} else {
-			return ErrAlreadyStopped
 		}
+		return ErrAlreadyStopped
 	}
 
 	m.StatusLock.Lock()

session/module_param.go

@@ -64,18 +64,19 @@ func (p ModuleParam) Validate(value string) (error, interface{}) {
 		}
 	}
 
-	if p.Type == STRING {
+	switch p.Type {
+	case STRING:
 		return nil, value
-	} else if p.Type == BOOL {
+	case BOOL:
 		lvalue := strings.ToLower(value)
 		if lvalue == "true" {
 			return nil, true
-		} else if lvalue == "false" {
-			return nil, false
-		} else {
-			return fmt.Errorf("Can't typecast '%s' to boolean.", value), nil
 		}
-	} else if p.Type == INT {
+		if lvalue == "false" {
+			return nil, false
+		}
+		return fmt.Errorf("Can't typecast '%s' to boolean.", value), nil
+	case INT:
 		i, err := strconv.Atoi(value)
 		return err, i
 	}
@@ -90,13 +91,14 @@ const ParamRandomMAC = "<random mac>"
 
 func (p ModuleParam) Get(s *Session) (error, interface{}) {
 	_, v := s.Env.Get(p.Name)
-	if v == ParamIfaceName {
+	switch v {
+	case ParamIfaceName:
 		v = s.Interface.Name()
-	} else if v == ParamIfaceAddress {
+	case ParamIfaceAddress:
 		v = s.Interface.IpAddress
-	} else if v == ParamSubnet {
+	case ParamSubnet:
 		v = s.Interface.CIDR()
-	} else if v == ParamRandomMAC {
+	case ParamRandomMAC:
 		hw := make([]byte, 6)
 		rand.Read(hw)
 		v = net.HardwareAddr(hw).String()

session/session.go

@@ -119,9 +119,11 @@ func New() (*Session, error) {
 	}
 
 	if *s.Options.CpuProfile != "" {
-		if f, err := os.Create(*s.Options.CpuProfile); err != nil {
+		f, err := os.Create(*s.Options.CpuProfile);
+		if err != nil {
 			return nil, err
-		} else if err := pprof.StartCPUProfile(f); err != nil {
+		}
+		if err := pprof.StartCPUProfile(f); err != nil {
 			return nil, err
 		}
 	}
@@ -277,9 +279,11 @@ func (s *Session) Start() error {
 func (s *Session) Skip(ip net.IP) bool {
 	if ip.IsLoopback() {
 		return true
-	} else if ip.Equal(s.Interface.IP) {
+	}
+	if ip.Equal(s.Interface.IP) {
 		return true
-	} else if ip.Equal(s.Gateway.IP) {
+	}
+	if ip.Equal(s.Gateway.IP) {
 		return true
 	}
 	return false
@@ -324,9 +328,7 @@ func parseCapletCommand(line string) (is bool, caplet *caplets.Caplet, argv []st
 	// check for any arguments
 	if argc > 1 {
 		file = str.Trim(parts[0])
-		if argc >= 2 {
-			argv = parts[1:]
-		}
+		argv = parts[1:]
 	}
 
 	if err, cap := caplets.Load(file); err == nil {

session/session_core_handlers.go

@@ -46,11 +46,9 @@ func (s *Session) generalHelp() {
 	pad = "%" + strconv.Itoa(maxLen) + "s"
 
 	for _, m := range s.Modules {
-		status := ""
+		status := tui.Red("not running")
 		if m.Running() {
 			status = tui.Green("running")
-		} else {
-			status = tui.Red("not running")
 		}
 		fmt.Printf("  "+tui.Yellow(pad)+" > %s\n", m.Name(), status)
 	}
@@ -65,12 +63,11 @@ func (s *Session) moduleHelp(filter string) error {
 	}
 
 	fmt.Println()
-	status := ""
+	status := tui.Red("not running")
 	if m.Running() {
 		status = tui.Green("running")
-	} else {
-		status = tui.Red("not running")
 	}
+
 	fmt.Printf("%s (%s): %s\n\n", tui.Yellow(m.Name()), status, tui.Dim(m.Description()))
 
 	maxLen := 0
@@ -165,12 +162,11 @@ func (s *Session) exitHandler(args []string, sess *Session) error {
 }
 
 func (s *Session) sleepHandler(args []string, sess *Session) error {
-	if secs, err := strconv.Atoi(args[0]); err == nil {
+	secs, err := strconv.Atoi(args[0]);
+	if err == nil {
 		time.Sleep(time.Duration(secs) * time.Second)
-		return nil
-	} else {
-		return err
 	}
+	return err
 }
 
 func (s *Session) getHandler(args []string, sess *Session) error {
@@ -277,9 +273,8 @@ func (s *Session) aliasHandler(args []string, sess *Session) error {
 
 	if s.Lan.SetAliasFor(mac, alias) {
 		return nil
-	} else {
-		return fmt.Errorf("Could not find endpoint %s", mac)
 	}
+	return fmt.Errorf("Could not find endpoint %s", mac)
 }
 
 func (s *Session) addHandler(h CommandHandler, c *readline.PrefixCompleter) {

session/session_parse.go

@@ -74,11 +74,11 @@ func ParseCommands(line string) []string {
 func (s *Session) parseEnvTokens(str string) (string, error) {
 	for _, m := range reEnvVarCapture.FindAllString(str, -1) {
 		varName := strings.Trim(strings.Replace(m, "env.", "", -1), "{}")
-		if found, value := s.Env.Get(varName); found {
-			str = strings.Replace(str, m, value, -1)
-		} else {
+		found, value := s.Env.Get(varName);
+		if !found {
 			return "", fmt.Errorf("variable '%s' is not defined", varName)
 		}
+		str = strings.Replace(str, m, value, -1)
 	}
 	return str, nil
 }