fix: split extensions param respecting open/close brackets

field_parser.go

@@ -207,7 +207,9 @@ func (ps *tagBaseFieldParser) ComplementSchema(schema *spec.Schema) error {
 	extensionsTag := ps.tag.Get(extensionsTag)
 	if extensionsTag != "" {
 		structField.extensions = map[string]interface{}{}
+		extensionsTag := strings.ReplaceAll(extensionsTag, `,,`, `{{escape-comma}}`)
 		for _, val := range strings.Split(extensionsTag, ",") {
+			val = strings.ReplaceAll(val, `{{escape-comma}}`, ",")
 			parts := strings.SplitN(val, "=", 2)
 			if len(parts) == 2 {
 				structField.extensions[parts[0]] = parts[1]

field_parser_test.go

@@ -72,7 +72,22 @@ func TestDefaultFieldParser(t *testing.T) {
 	})
 
 	t.Run("Extensions tag", func(t *testing.T) {
+		t.Parallel()
 
+		schema := spec.Schema{}
+		schema.Type = []string{"int"}
+		schema.Extensions = map[string]interface{}{}
+		err := newTagBaseFieldParser(
+			&Parser{},
+			&ast.Field{Tag: &ast.BasicLit{
+				Value: `json:"test" extensions:"x-nullable,x-abc=def,!x-omitempty,x-example=[0,, 9]"`,
+			}},
+		).ComplementSchema(&schema)
+		assert.NoError(t, err)
+		assert.Equal(t, true, schema.Extensions["x-nullable"])
+		assert.Equal(t, "def", schema.Extensions["x-abc"])
+		assert.Equal(t, false, schema.Extensions["x-omitempty"])
+		assert.Equal(t, "[0, 9]", schema.Extensions["x-example"])
 	})
 
 	t.Run("Enums tag", func(t *testing.T) {

operation.go

@@ -495,8 +495,10 @@ func setEnumParam(param *spec.Parameter, attr, objectType, schemaType string) er
 }
 
 func setExtensionParam(param *spec.Parameter, attr string) error {
+	attr = strings.ReplaceAll(attr, `,,`, `{{escape-comma}}`)
 	param.Extensions = map[string]interface{}{}
 	for _, val := range strings.Split(attr, ",") {
+		val = strings.ReplaceAll(val, `{{escape-comma}}`, ",")
 		parts := strings.SplitN(val, "=", 2)
 		if len(parts) == 2 {
 			param.Extensions.Add(parts[0], parts[1])

parser_test.go

@@ -2951,6 +2951,63 @@ func Fun()  {
 	assert.Equal(t, expected, string(b))
 }
 
+func TestParseParamCommentExtension(t *testing.T) {
+	t.Parallel()
+
+	src := `
+package main
+
+// @Param request query string true "query params" extensions(x-example=[0,, 9],x-foo=bar)
+// @Success 200
+// @Router /test [get]
+func Fun()  {
+
+}
+`
+	expected := `{
+    "info": {
+        "contact": {}
+    },
+    "paths": {
+        "/test": {
+            "get": {
+                "parameters": [
+                    {
+                       "type": "string",
+                       "x-example": "[0, 9]",
+                       "x-foo": "bar",
+                       "description": "query params",
+                       "name": "request",
+                       "in": "query",
+                       "required": true
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": ""
+                    }
+                }
+            }
+        }
+    }
+}`
+
+	f, err := goparser.ParseFile(token.NewFileSet(), "", src, goparser.ParseComments)
+	assert.NoError(t, err)
+
+	p := New()
+	_ = p.packages.CollectAstFile("api", "api/api.go", f)
+
+	_, err = p.packages.ParseTypes()
+	assert.NoError(t, err)
+
+	err = p.ParseRouterAPIInfo("", f)
+	assert.NoError(t, err)
+
+	b, _ := json.MarshalIndent(p.swagger, "", "    ")
+	assert.JSONEq(t, expected, string(b))
+}
+
 func TestParseRenamedStructDefinition(t *testing.T) {
 	t.Parallel()