refactor(envparser): simplify trimExportPrefix function

Refactored trimExportPrefix for clarity by eliminating unnecessary condition checks.

refactor(resolve-address-middleware): add splitHostPort function

Added a new function splitHostPort to handle splitting of host and port in DetectLocalNetwork.

refactor(uris): streamline CleanPath and CommonPath functions

Improved CleanPath by refactoring trailing slash handling. Simplified logic in CommonPath by optimizing segment handling.

test(logfx): streamline assertion logic

Adjusted test cases to streamline error and nil checks in handler_test, mod_test, replacer_test, and define_test.

pkg/bliss/configfx/envparser/mod.go

@@ -108,32 +108,26 @@ func extractKeyName(src []byte) (string, int, error) {
 }
 
 func trimExportPrefix(src []byte) []byte {
-	var newSrc []byte
+	trimmedSrc := bytes.TrimPrefix(src, []byte(exportPrefix))
 
-	if bytes.HasPrefix(src, []byte(exportPrefix)) {
-		newSrc = bytes.TrimPrefix(src, []byte(exportPrefix))
-	} else {
-		newSrc = src
-	}
-
-	return lib.StringsTrimLeadingSpaceFromBytes(newSrc)
+	return lib.StringsTrimLeadingSpaceFromBytes(trimmedSrc)
 }
 
 // locateKeyName locates and parses key name and returns rest of slice.
 func locateKeyName(src []byte) (string, []byte, error) {
-	src = trimExportPrefix(src)
+	newSrc := trimExportPrefix(src)
 
-	key, offset, err := extractKeyName(src)
+	key, offset, err := extractKeyName(newSrc)
 	if err != nil {
 		return "", nil, err
 	}
 
-	if len(src) == 0 {
+	if len(newSrc) == 0 {
 		return "", nil, ErrZeroLengthString.New()
 	}
 
 	key = lib.StringsTrimTrailingSpace(key)
-	cutset := lib.StringsTrimLeadingSpaceFromBytes(src[offset:])
+	cutset := lib.StringsTrimLeadingSpaceFromBytes(newSrc[offset:])
 
 	return key, cutset, nil
 }

pkg/bliss/httpfx/middlewares/resolve-address-middleware.go

@@ -63,20 +63,27 @@ func ResolveAddressMiddleware() httpfx.Handler {
 	}
 }
 
+func splitHostPort(addr string) (string, string, error) {
+	if !strings.ContainsRune(addr, ':') {
+		return addr, "", nil
+	}
+
+	host, port, err := net.SplitHostPort(addr)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to split host and port: %w", err)
+	}
+
+	return host, port, nil
+}
+
 func DetectLocalNetwork(requestAddr string) (bool, error) {
 	var requestIp string
 
 	requestAddrs := strings.SplitN(requestAddr, ",", 2) //nolint:mnd
 
-	if strings.ContainsRune(requestAddrs[0], ':') {
-		host, _, err := net.SplitHostPort(requestAddrs[0])
-		if err != nil {
-			return false, fmt.Errorf("failed to split host and port: %w", err)
-		}
-
-		requestIp = host
-	} else {
-		requestIp = requestAddrs[0]
+	requestIp, _, err := splitHostPort(requestAddrs[0])
+	if err != nil {
+		return false, err
 	}
 
 	addrs, err := net.InterfaceAddrs()

pkg/bliss/httpfx/uris/clean-path.go

@@ -29,10 +29,10 @@ func CleanPath(p string) string {
 	if p[len(p)-1] == '/' && np != "/" {
 		// Fast path for common case of p being the string we want:
 		if len(p) == len(np)+1 && strings.HasPrefix(p, np) {
-			np = p
-		} else {
-			np += "/"
+			return p
 		}
+
+		return np + "/"
 	}
 
 	return np

pkg/bliss/httpfx/uris/common-path.go

@@ -22,11 +22,15 @@ func CommonPath(p1, p2 *Pattern) string {
 	)
 
 	for segs1, segs2 = p1.Segments, p2.Segments; len(segs1) > 0 && len(segs2) > 0; segs1, segs2 = segs1[1:], segs2[1:] {
-		if s1 := segs1[0]; s1.Wild {
+		s1 := segs1[0]
+
+		if s1.Wild {
 			writeSegment(&b, segs2[0])
-		} else {
-			writeSegment(&b, s1)
+
+			continue
 		}
+
+		writeSegment(&b, s1)
 	}
 
 	if len(segs1) > 0 {

pkg/bliss/httpfx/uris/difference-path_test.go

@@ -111,9 +111,11 @@ func TestDifferencePath(t *testing.T) {
 
 				if tt.want == "" {
 					assert.NotNil(t, r, "DifferencePath() did not panic")
-				} else {
-					assert.Nil(t, r, "DifferencePath() panicked: %v", r)
+
+					return
 				}
+
+				assert.Nil(t, r, "DifferencePath() panicked: %v", r)
 			}()
 
 			got := uris.DifferencePath(tt.p1, tt.p2)

pkg/bliss/logfx/handler_test.go

@@ -59,10 +59,12 @@ func TestNewHandler(t *testing.T) {
 			if tt.expectedErr != "" {
 				require.EqualError(t, err, tt.expectedErr)
 				assert.Nil(t, handler)
-			} else {
-				require.NoError(t, err)
-				assert.NotNil(t, handler)
+
+				return
 			}
+
+			require.NoError(t, err)
+			assert.NotNil(t, handler)
 		})
 	}
 }

pkg/bliss/logfx/mod_test.go

@@ -49,10 +49,12 @@ func TestRegisterLogger(t *testing.T) {
 				require.Error(t, err)
 				assert.Nil(t, logger)
 				assert.Equal(t, tt.expectedErr, err.Error())
-			} else {
-				require.NoError(t, err)
-				assert.NotNil(t, logger)
+
+				return
 			}
+
+			require.NoError(t, err)
+			assert.NotNil(t, logger)
 		})
 	}
 }

pkg/bliss/logfx/replacer_test.go

@@ -178,12 +178,14 @@ func TestTraceLines(t *testing.T) {
 
 			if len(tt.expected) == 0 {
 				assert.Equal(t, tt.expected, result)
-			} else {
-				for i := range tt.expected {
-					ext := strings.Split(tt.expected[i], " ")
 
-					assert.Contains(t, result[i], ext[0])
-				}
+				return
+			}
+
+			for i := range tt.expected {
+				ext := strings.Split(tt.expected[i], " ")
+
+				assert.Contains(t, result[i], ext[0])
 			}
 		})
 	}

pkg/bliss/results/define_test.go

@@ -92,9 +92,11 @@ func TestDefineNew(t *testing.T) {
 
 			if tt.expectedOk {
 				assert.False(t, tt.occurrence.IsError())
-			} else {
-				assert.True(t, tt.occurrence.IsError())
+
+				return
 			}
+
+			assert.True(t, tt.occurrence.IsError())
 		})
 	}
 }