The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point in your pull request via creating an issue comment (i.e. comment on the pull request page) using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

cmd/internal/migrations/v3/csrfconfig.go (1)

16-16: Handle CRLF and end-of-file: make the trailing newline optional and robust

Your regex requires a trailing newline to match. This misses cases where SessionKey is the last item before a closing brace on the same line, or files with CRLF endings. Anchor to line start and accept either CRLF, LF, or EOF.

Apply this diff:

-	reSession := regexp.MustCompile(`(?m)\s*SessionKey:\s*[^,\n]+,?\s*(//[^\n]*)?\n`)
+	reSession := regexp.MustCompile(`(?m)^\s*SessionKey:\s*[^,\n]+,?\s*(//[^\n]*)?\s*(?:\r?\n|$)`)

cmd/internal/migrations/v3/basicauth_config.go (2)

17-18: Unify newline handling across platforms and EOF

Same concern as CSRF: both patterns require a trailing newline. Anchor to start-of-line and accept CRLF/LF/EOF to catch “last field on the same line as }” and Windows line endings. Functionality is unchanged otherwise.

-	reCtxUser := regexp.MustCompile(`(?m)\s*ContextUsername:\s*[^,\n]+,?\s*(//[^\n]*)?\n`)
-	reCtxPass := regexp.MustCompile(`(?m)\s*ContextPassword:\s*[^,\n]+,?\s*(//[^\n]*)?\n`)
+	reCtxUser := regexp.MustCompile(`(?m)^\s*ContextUsername:\s*[^,\n]+,?\s*(//[^\n]*)?\s*(?:\r?\n|$)`)
+	reCtxPass := regexp.MustCompile(`(?m)^\s*ContextPassword:\s*[^,\n]+,?\s*(//[^\n]*)?\s*(?:\r?\n|$)`)

---

22-25: Scope removal to basicauth.Config blocks (optional hardening)

Right now, user/pass lines are removed anywhere in the file. To reduce accidental matches inside comments or string literals unrelated to basicauth, consider restricting the replacements to the content inside basicauth.Config blocks (similar to CSRF).

I can draft a scoped variant that finds basicauth.Config{...} blocks first and applies the removals only inside them—say the word, and I’ll propose a patch.

cmd/internal/migrations/v3/csrfconfig_test.go (1)

42-65: Add edge cases: same-line closing brace and CRLF endings

Consider adding tests to prevent regressions where:

• SessionKey is followed immediately by the closing brace on the same line (no trailing newline).
• File uses Windows CRLF line endings.

Example additional tests (new functions to append to this file):

func Test_MigrateCSRFConfig_SessionKey_SameLineBrace(t *testing.T) {
	t.Parallel()
	dir, err := os.MkdirTemp("", "mcsrfslb")
	require.NoError(t, err)
	defer func() { require.NoError(t, os.RemoveAll(dir)) }()

	file := writeTempFile(t, dir, `package main
import "github.com/gofiber/fiber/v2/middleware/csrf"
var _ = csrf.New(csrf.Config{
    SessionKey: "csrf"})`) // note: no newline before }
	var buf bytes.Buffer
	cmd := newCmd(&buf)
	require.NoError(t, v3.MigrateCSRFConfig(cmd, dir, nil, nil))

	content := readFile(t, file)
	assert.NotContains(t, content, "SessionKey")
}

func Test_MigrateCSRFConfig_SessionKey_CRLF(t *testing.T) {
	t.Parallel()
	dir, err := os.MkdirTemp("", "mcsrfcrlf")
	require.NoError(t, err)
	defer func() { require.NoError(t, os.RemoveAll(dir)) }()

	src := "package main\r\n" +
		"import \"github.com/gofiber/fiber/v2/middleware/csrf\"\r\n" +
		"var _ = csrf.New(csrf.Config{\r\n" +
		"    SessionKey: \"csrf\", // comment\r\n" +
		"})\r\n"
	file := writeTempFile(t, dir, src)

	var buf bytes.Buffer
	cmd := newCmd(&buf)
	require.NoError(t, v3.MigrateCSRFConfig(cmd, dir, nil, nil))

	content := readFile(t, file)
	assert.NotContains(t, content, "SessionKey")
	assert.NotContains(t, content, "comment")
}

cmd/internal/migrations/v3/healthcheck_config.go (2)

37-47: Normalize endpoint regexes: anchor to line start and support CRLF/EOF

Great that you already made the trailing newline optional. For consistency and Windows support, also anchor to start-of-line and accept CRLF/EOF.

-				reLE := regexp.MustCompile(`(?m)\s*LivenessEndpoint:\s*([^,\n}]+),?\s*(//[^\n]*)?\n?`)
+				reLE := regexp.MustCompile(`(?m)^\s*LivenessEndpoint:\s*([^,\n}]+),?\s*(//[^\n]*)?\s*(?:\r?\n|$)`)
 				if m := reLE.FindStringSubmatch(body); len(m) > 1 {
 					lEndpoint = strings.TrimSpace(m[1])
 				}
 				body = reLE.ReplaceAllString(body, "")

-				reRE := regexp.MustCompile(`(?m)\s*ReadinessEndpoint:\s*([^,\n}]+),?\s*(//[^\n]*)?\n?`)
+				reRE := regexp.MustCompile(`(?m)^\s*ReadinessEndpoint:\s*([^,\n}]+),?\s*(//[^\n]*)?\s*(?:\r?\n|$)`)
 				if m := reRE.FindStringSubmatch(body); len(m) > 1 {
 					rEndpoint = strings.TrimSpace(m[1])
 				}
 				body = reRE.ReplaceAllString(body, "")

---

17-18: Make reUse non-greedy to avoid overmatching across blocks

(?s:(.*)) is greedy and can jump across multiple “)” matches if formatting is unusual. A non-greedy quantifier keeps the match tight around the healthcheck.New(...) call.

-		reUse := regexp.MustCompile(`(?m)^(\s*)(\w+)\.Use\(\s*healthcheck\.New\((?s:(.*))\)\s*\)`)
+		reUse := regexp.MustCompile(`(?m)^(\s*)(\w+)\.Use\(\s*healthcheck\.New\((?s:(.*?))\)\s*\)`)

cmd/internal/migrations/v3/config_listener_fields.go (1)

20-20: Anchor to line start and handle CRLF/EOF to remove the whole line including comments

The current pattern works but isn’t line-anchored and doesn’t explicitly handle CRLF or EOF. Anchoring reduces accidental mid-line matches and normalizes behavior across platforms. Consistent with other migrations.

-	reField := regexp.MustCompile(`\s*(Prefork|Network|DisableStartupMessage|EnablePrintRoutes):\s*([^,}]+),?\s*(//[^\n]*)?`)
+	reField := regexp.MustCompile(`(?m)^\s*(Prefork|Network|DisableStartupMessage|EnablePrintRoutes):\s*([^,}\r\n]+),?\s*(//[^\r\n]*)?\s*(?:\r?\n|$)`)

cmd/internal/migrations/v3/healthcheck_config_test.go (1)

185-214: Tighten assertions to catch endpoint fields lingering outside app.Use

Consider also asserting that LivenessEndpoint/ReadinessEndpoint are not present anywhere in the migrated file for this comment case too. It keeps parity with the non-comment test and protects against regressions when endpoints are configured elsewhere.

   content := readFile(t, file)
   assert.Contains(t, content, `app.Get("/live"`)
   assert.Contains(t, content, `app.Get("/ready"`)
   assert.NotContains(t, content, "live comment")
   assert.NotContains(t, content, "ready comment")
+  assert.NotContains(t, content, "LivenessEndpoint")
+  assert.NotContains(t, content, "ReadinessEndpoint")

cmd/internal/migrations/v3/config_listener_fields_test.go (1)

280-284: Add explicit “no Prefork” assertion for clarity

While fiber.Config{} indirectly implies it, asserting the string “Prefork” is not present makes the intent crystal clear and guards against formatting edge cases.

   content := readFile(t, file)
   assert.Contains(t, content, "fiber.New(fiber.Config{})")
   assert.NotContains(t, content, "// comment")
+  assert.NotContains(t, content, "Prefork")
   assert.Contains(t, content, `app.Listen(":3000", fiber.ListenConfig{EnablePrefork: prod})`)
   assert.Contains(t, buf.String(), "Migrating listener related config fields")

cmd/internal/migrations/v3/basicauth_config_test.go (1)

14-38: Optional: add a hashing smoke-check to prevent regressions

To ensure the Users hashing path remains unaffected by adjacent comment removal, add a minimal Users map and assert the “{SHA256}” prefix appears post-migration (no need to lock the exact digest).

 var _ = basicauth.New(basicauth.Config{
     ContextUsername: "user", // username comment
     ContextPassword: "pass", // password comment
+    Users: map[string]string{"alice": "plaintext"},
 })
@@
 content := readFile(t, file)
 assert.NotContains(t, content, "ContextUsername")
 assert.NotContains(t, content, "ContextPassword")
 assert.NotContains(t, content, "username comment")
 assert.NotContains(t, content, "password comment")
+assert.Contains(t, content, "{SHA256}")
 assert.Contains(t, buf.String(), "Migrating basicauth configs")

cmd/internal/migrations/v3/middleware_locals_test.go (1)

74-99: Optional: add a CSRF “with comment” variant

We already test keyauth with a trailing comment; adding the same for csrf would catch package-specific gaps.

 func Test_MigrateMiddlewareLocals_ContextKeyWithComment(t *testing.T) {
@@
-    "github.com/gofiber/fiber/v2/middleware/keyauth"
+    "github.com/gofiber/fiber/v2/middleware/keyauth"
+    "github.com/gofiber/fiber/v2/middleware/csrf"
@@
     _ = keyauth.New(keyauth.Config{ContextKey: "token", // key comment
     })
+    _ = csrf.New(csrf.Config{ContextKey: "csrf", // csrf comment
+    })
@@
     assert.NotContains(t, content, "ContextKey")
     assert.NotContains(t, content, "key comment")
+    assert.NotContains(t, content, "csrf comment")

cmd/internal/migrations/v3/middleware_locals.go (1)

45-61: Optional: reuse the shared removeConfigField helper for consistency

To avoid regex drift across migrators, consider delegating to removeConfigField for "ContextKey", "ContextUsername", and "ContextPassword". It already handles field cleanup and comma normalization elsewhere.

Example:

-        // (regex removal here)
-        reCtxKeyLine := ...
-        ...
-        content = reCtxKeyInline.ReplaceAllString(content, "$1")
+        for _, fld := range []string{"ContextKey", "ContextUsername", "ContextPassword"} {
+            content = removeConfigField(content, fld)
+        }

If removeConfigField currently isn’t comment-aware in all shapes, extending it once would harmonize all migrations.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: sixcolors
PR: gofiber/fiber#3051
File: middleware/session/session.go:215-216
Timestamp: 2024-06-30T00:38:06.580Z
Learning: Parallel tests for `Session.Save` already exist in the `middleware/session/session_test.go` file, specifically in the `Test_Session_Save` and `Test_Session_Save_Expiration` functions.

cmd/internal/migrations/v3/basicauth_config_test.go (1)

14-38: Add cases for block comments and mid-list fields to prevent regressions.

Current tests cover “tail field” and // comments. Add:

• /* block */ comment after value
• field not last (e.g., Foo, ContextUsername, Bar)

Extend with:

+func Test_MigrateBasicauthConfig_Inline_NotLast_AndBlockComment(t *testing.T) {
+  t.Parallel()
+  dir, err := os.MkdirTemp("", "mbasiccfg_notlast")
+  require.NoError(t, err)
+  t.Cleanup(func() { require.NoError(t, os.RemoveAll(dir)) })
+
+  file := writeTempFile(t, dir, `package main
+import "github.com/gofiber/fiber/v2/middleware/basicauth"
+var _ = basicauth.New(basicauth.Config{
+  Foo: 1,
+  ContextUsername: "user", /* user block comment */
+  Bar: 2,
+  ContextPassword: "pass", /* pass block comment */
+})`)
+
+  var buf bytes.Buffer
+  cmd := newCmd(&buf)
+  require.NoError(t, v3.MigrateBasicauthConfig(cmd, dir, nil, nil))
+
+  content := readFile(t, file)
+  assert.NotContains(t, content, "ContextUsername")
+  assert.NotContains(t, content, "ContextPassword")
+  assert.NotContains(t, content, "block comment")
+  assert.Contains(t, content, "basicauth.Config{")
+  assert.Contains(t, buf.String(), "Migrating basicauth configs")
+}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.