feat: [CI-18487]: Formatting

Author: DevanshMathur19

main.go

@@ -163,7 +163,6 @@ func run(c *cli.Context) error {
 		_ = godotenv.Load(c.String("env-file"))
 	}
 
-
 	plugin := Plugin{
 		Endpoint:              c.String("endpoint"),
 		Key:                   c.String("access-key"),
@@ -193,4 +192,3 @@ func run(c *cli.Context) error {
 
 	return plugin.Exec()
 }
-

plugin.go

@@ -143,7 +143,7 @@ func (p *Plugin) Exec() error {
 	if p.StripPrefix != "" {
 		if err := validateStripPrefix(p.StripPrefix); err != nil {
 			log.WithFields(log.Fields{
-				"error": err,
+				"error":   err,
 				"pattern": p.StripPrefix,
 			}).Error("Invalid strip_prefix pattern")
 			return err
@@ -322,13 +322,13 @@ func resolveKey(target, srcPath, stripPrefix string) string {
 	if err != nil {
 		// Log error but continue with original path
 		log.WithFields(log.Fields{
-			"error": err,
-			"path": srcPath,
+			"error":   err,
+			"path":    srcPath,
 			"pattern": stripPrefix,
 		}).Warning("Failed to strip prefix, using original path")
 		stripped = srcPath
 	}
-	
+
 	key := filepath.Join(target, stripped)
 	key = filepath.ToSlash(key)
 	if !strings.HasPrefix(key, "/") {
@@ -490,7 +490,6 @@ func (p *Plugin) createS3Client() *s3.S3 {
 		log.Warn("AWS Key and/or Secret not provided (falling back to ec2 instance profile)")
 	}
 
-
 	// Create session with primary credentials
 	sess, err = session.NewSession(conf)
 	if err != nil {
@@ -503,8 +502,8 @@ func (p *Plugin) createS3Client() *s3.S3 {
 	// Handle secondary role assumption if UserRoleArn is provided
 	if len(p.UserRoleArn) > 0 {
 		log.WithField("UserRoleArn", p.UserRoleArn).Info("Using user role ARN")
-		
-		// Create credentials using the existing session for role assumption 
+
+		// Create credentials using the existing session for role assumption
 		// by assuming the UserRoleArn (with ExternalID when provided)
 		creds := stscreds.NewCredentials(sess, p.UserRoleArn, func(provider *stscreds.AssumeRoleProvider) {
 			if p.UserRoleExternalID != "" {
@@ -539,48 +538,48 @@ func validateStripPrefix(pattern string) error {
 	if !strings.HasPrefix(pattern, "/") {
 		return fmt.Errorf("strip_prefix must start with '/'")
 	}
-	
+
 	// Check length limit
 	if len(pattern) > 256 {
 		return fmt.Errorf("strip_prefix pattern too long (max 256 characters)")
 	}
-	
+
 	// Count wildcards
 	wildcardCount := strings.Count(pattern, "*") + strings.Count(pattern, "?")
 	if wildcardCount > 20 {
 		return fmt.Errorf("strip_prefix pattern contains too many wildcards (max 20)")
 	}
-	
+
 	// Check for empty segments
 	if strings.Contains(pattern, "//") {
 		return fmt.Errorf("strip_prefix pattern contains empty segment '//'")
 	}
-	
+
 	// Check for invalid ** usage (must be standalone segment)
 	parts := strings.Split(pattern, "/")
 	for _, part := range parts {
 		if strings.Contains(part, "**") && part != "**" {
 			return fmt.Errorf("'**' must be a standalone directory segment")
 		}
 	}
-	
+
 	return nil
 }
 
 // patternToRegex converts shell-style wildcards to regex
 func patternToRegex(pattern string) (*regexp.Regexp, error) {
 	// Escape special regex characters except our wildcards
 	escaped := regexp.QuoteMeta(pattern)
-	
-	// Replace escaped wildcards with regex equivalents  
+
+	// Replace escaped wildcards with regex equivalents
 	// Order matters: ** must be replaced before *
-	escaped = strings.ReplaceAll(escaped, `\*\*`, "(.+)")      // ** -> (.+) any depth
-	escaped = strings.ReplaceAll(escaped, `\*`, "([^/]+)")      // * -> ([^/]+) one segment  
-	escaped = strings.ReplaceAll(escaped, `\?`, "([^/])")       // ? -> ([^/]) one character
-	
+	escaped = strings.ReplaceAll(escaped, `\*\*`, "(.+)")  // ** -> (.+) any depth
+	escaped = strings.ReplaceAll(escaped, `\*`, "([^/]+)") // * -> ([^/]+) one segment
+	escaped = strings.ReplaceAll(escaped, `\?`, "([^/])")  // ? -> ([^/]) one character
+
 	// Anchor at start
 	escaped = "^" + escaped
-	
+
 	return regexp.Compile(escaped)
 }
 
@@ -589,12 +588,12 @@ func stripWildcardPrefix(path, pattern string) (string, error) {
 	if pattern == "" {
 		return path, nil
 	}
-	
+
 	// Normalize paths
 	path = filepath.ToSlash(path)
 	pattern = filepath.ToSlash(pattern)
-	
-	// Handle literal prefix (no wildcards) 
+
+	// Handle literal prefix (no wildcards)
 	if !strings.ContainsAny(pattern, "*?") {
 		stripped := strings.TrimPrefix(path, pattern)
 		// Validate result for literal prefix
@@ -603,28 +602,28 @@ func stripWildcardPrefix(path, pattern string) (string, error) {
 		}
 		return stripped, nil
 	}
-	
+
 	// Convert pattern to regex
 	re, err := patternToRegex(pattern)
 	if err != nil {
 		return path, fmt.Errorf("invalid pattern: %v", err)
 	}
-	
+
 	// Find matches
 	matches := re.FindStringSubmatch(path)
 	if len(matches) == 0 {
 		// No match, return path unchanged
 		return path, nil
 	}
-	
+
 	// Calculate what to strip (the full match)
 	fullMatch := matches[0]
 	stripped := strings.TrimPrefix(path, fullMatch)
-	
+
 	// Validate result
 	if stripped == "" || stripped == "/" || strings.TrimPrefix(stripped, "/") == "" {
 		return path, fmt.Errorf("strip_prefix removes entire path for '%s'", filepath.Base(path))
 	}
-	
+
 	return stripped, nil
 }

wildcard_strip_test.go

@@ -111,7 +111,7 @@ func TestStripWildcardPrefix(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			result, err := stripWildcardPrefix(tt.path, tt.pattern)
-			
+
 			if tt.expectError {
 				if err == nil {
 					t.Errorf("stripWildcardPrefix(%q, %q) expected error, got nil", tt.path, tt.pattern)
@@ -174,7 +174,7 @@ func TestPatternToRegex(t *testing.T) {
 			if err != nil {
 				t.Fatalf("patternToRegex(%q) error: %v", tt.pattern, err)
 			}
-			
+
 			matches := re.MatchString(tt.testPath)
 			if matches != tt.matches {
 				t.Errorf("patternToRegex(%q).MatchString(%q) = %v, want %v", tt.pattern, tt.testPath, matches, tt.matches)
@@ -236,15 +236,15 @@ func TestResolveKeyWithWildcards(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			result := resolveKey(tt.target, tt.srcPath, tt.stripPrefix)
 			if result != tt.expected {
-				t.Errorf("resolveKey(%q, %q, %q) = %q, want %q", 
+				t.Errorf("resolveKey(%q, %q, %q) = %q, want %q",
 					tt.target, tt.srcPath, tt.stripPrefix, result, tt.expected)
 			}
 		})
 	}
 }
 
 // ===============================
-// ERROR HANDLING TESTS  
+// ERROR HANDLING TESTS
 // ===============================
 
 func TestWildcardErrorHandling(t *testing.T) {
@@ -311,13 +311,13 @@ func TestWildcardErrorHandling(t *testing.T) {
 func BenchmarkStripWildcardPrefix(b *testing.B) {
 	path := "/harness/artifacts/build-12345/services/auth/v1.2.3/auth-service.zip"
 	pattern := "/harness/artifacts/*/services/*/"
-	
+
 	// Pre-compile pattern (this would happen once in real usage)
 	_, err := patternToRegex(pattern)
 	if err != nil {
 		b.Fatalf("Failed to compile pattern: %v", err)
 	}
-	
+
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		_, _ = stripWildcardPrefix(path, pattern)