yaml数组解析

[zachhu2024-cpu]

获取的yaml数组字段解析后格式是字符串"[test111 test222]"，有官方解析、获取值的方式吗？
或直接返回yaml的原始文本的方法也可以

[coderabbitai]

📝 CodeRabbit Plan Mode

Generate an implementation plan and prompts that you can use with your favorite coding agent.

✅ Successfully generated implementation plan.

💡 Use @coderabbitai <feedback> to replan

Examples

• Example 1
• Example 2

---

---

🧪 Issue enrichment is currently in open beta.

You can configure auto-planning by selecting labels in the issue_enrichment configuration.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord or schedule a call!

[coderabbitai]

Coding Plan

Approach

Users are experiencing an issue where YAML array fields are being stringified during parsing (e.g., "[test111 test222]" instead of proper arrays). The ticket requests either: (1) a proper way to retrieve YAML arrays as slices, or (2) a method to retrieve raw YAML content. The root cause is in the YAML parser's flattening logic, and the solution should fix the parsing to preserve array types.

Observations

The Apollo Go client uses a layered architecture for configuration management. Configuration flows from Apollo servers as raw bytes, gets parsed by format-specific parsers (using Viper for YAML), stored in a type-preserving cache layer, and exposed to users via typed accessor methods like GetStringSliceValue() and GetIntSliceValue(). The YAML parser in utils/parse/yaml/ uses Viper to parse content and then flattens it into a map[string]interface{} structure. The cache layer (agcache/) properly preserves Go types including slices. The issue occurs during the YAML parsing phase where Viper's flattened structure conversion may not properly preserve array types.

Assumptions

Assumption 1: How should nested YAML arrays be handled?

Options Considered:

• Flatten all structures with dot-notation and preserve array values at leaf nodes
• Preserve full nested structure as nested maps with arrays

Chosen Option: Flatten structures with dot-notation but preserve array types at leaf nodes

Rationale: This aligns with the existing flattening pattern used by Viper and the dot-notation key access pattern already in the codebase. Developers can access values like config.GetStringSliceValue("parent.child", ",", defaultValue).

Assumption 2: Should both YAML parser files be updated identically?

Options Considered:

• Update both files identically to maintain consistency
• Refactor to share common implementation

Chosen Option: Update both files identically to maintain consistency

Rationale: While refactoring would be cleaner, the ticket scope is limited to fixing array parsing. Maintaining the existing pattern of duplicate implementations is simpler and avoids unnecessary refactoring risk.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Fix YAML Array Type Preservation

Enhance the YAML parser to properly detect and preserve array/slice types during the conversion from Viper's parsed structure to the flat map[string]interface{} format.

Task 1: Update YAML Parser Array Handling

Modify the convertToMap() function in utils/parse/yaml/parser.go and utils/parse/yml/parser.go to detect and preserve slice types.

• Update the convertToMap() function to check if values returned by vp.Get(key) are slices or arrays
• Use Go's reflection or type assertion to detect slice types ([]interface{}, []string, []int, etc.)
• When a slice is detected, preserve it as-is in the resulting map[string]interface{}
• When a value is not a slice, continue with existing behavior (store as-is)
• Handle both simple arrays (e.g., items: [a, b, c]) and nested arrays within structures (e.g., parent.items: [a, b, c])

Task 2: Verify Cache and Retrieval Flow

Ensure the enhanced parser output flows correctly through the existing cache and retrieval layers.

• Confirm that when convertToMap() returns slices, they are stored properly in the cache via cache.Set() (no changes needed here based on exploration - cache already preserves types)
• Verify that existing GetStringSliceValue(), GetIntSliceValue(), and GetSliceValue() methods can retrieve the preserved array types (no changes needed - these methods already handle type assertions)
• Ensure the parsing change doesn't break existing non-array configuration retrieval (other types should continue working as before)

🤖 Prompt for AI agents

Fix the YAML parser to preserve array types during parsing instead of
stringifying them.

Modify `convertToMap()` in both `utils/parse/yaml/parser.go` and
`utils/parse/yml/parser.go`:
- Add slice/array type detection for values returned by `vp.Get(key)` using
reflection or type assertion
- Preserve detected slices as-is in the result map (handle `[]interface{}`,
`[]string`, `[]int`, etc.)
- Keep existing behavior for non-slice values
- Support both root-level and nested arrays with dot-notation keys

Verify integration:
- Confirm slices flow correctly through cache storage
- Test that `GetStringSliceValue()`, `GetIntSliceValue()`, `GetSliceValue()`
retrieve arrays properly
- Ensure non-array configs continue working

Phase 2: Add Test Coverage for YAML Arrays

Add comprehensive test cases to verify YAML array parsing and retrieval works correctly.

Task 1: Create YAML Array Parsing Tests

Add test cases in utils/parse/yaml/parser_test.go and utils/parse/yml/parser_test.go to verify array parsing.

• Create test YAML content with various array formats: string arrays, integer arrays, mixed-type arrays, and nested structures containing arrays
• Verify that Parse() returns map[string]interface{} with proper slice types (not stringified)
• Test both root-level arrays (e.g., items: [a, b]) and nested arrays (e.g., config.items: [a, b])
• Include edge cases: empty arrays, single-item arrays, arrays with special characters

Task 2: Add Integration Tests for Array Retrieval

Create end-to-end tests in storage/repository_test.go that demonstrate proper YAML array retrieval.

• Test the full flow: YAML content → parsing → cache storage → retrieval via GetStringSliceValue(), GetIntSliceValue(), and GetSliceValue()
• Verify that users can retrieve array values using the existing accessor methods
• Include test cases that match the reported issue pattern (arrays that were previously stringified should now be properly retrieved as slices)
• Document the expected usage pattern for developers retrieving YAML arrays

🤖 Prompt for AI agents

Add comprehensive test coverage for YAML array parsing and retrieval.

Create parser unit tests in `utils/parse/yaml/parser_test.go` and
`utils/parse/yml/parser_test.go`:
- Test various array formats: string arrays, integer arrays, mixed-type arrays
- Test nested structures with arrays using dot-notation keys
- Verify `Parse()` returns proper slice types, not stringified values
- Include edge cases: empty arrays, single items, special characters

Add integration tests in `storage/repository_test.go`:
- Test end-to-end flow from YAML content through parsing, caching, to retrieval
- Verify `GetStringSliceValue()`, `GetIntSliceValue()`, `GetSliceValue()` work
correctly
- Include test cases matching the reported issue (previously stringified arrays)
- Document expected usage patterns for developers

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Fix the YAML parser to preserve array types during parsing instead of
stringifying them.

Modify `convertToMap()` in both `utils/parse/yaml/parser.go` and
`utils/parse/yml/parser.go`:
- Add slice/array type detection for values returned by `vp.Get(key)` using
reflection or type assertion
- Preserve detected slices as-is in the result map (handle `[]interface{}`,
`[]string`, `[]int`, etc.)
- Keep existing behavior for non-slice values
- Support both root-level and nested arrays with dot-notation keys

Verify integration:
- Confirm slices flow correctly through cache storage
- Test that `GetStringSliceValue()`, `GetIntSliceValue()`, `GetSliceValue()`
retrieve arrays properly
- Ensure non-array configs continue working
===============================================================================

Task: 2

Add comprehensive test coverage for YAML array parsing and retrieval.

Create parser unit tests in `utils/parse/yaml/parser_test.go` and
`utils/parse/yml/parser_test.go`:
- Test various array formats: string arrays, integer arrays, mixed-type arrays
- Test nested structures with arrays using dot-notation keys
- Verify `Parse()` returns proper slice types, not stringified values
- Include edge cases: empty arrays, single items, special characters

Add integration tests in `storage/repository_test.go`:
- Test end-to-end flow from YAML content through parsing, caching, to retrieval
- Verify `GetStringSliceValue()`, `GetIntSliceValue()`, `GetSliceValue()` work
correctly
- Include test cases matching the reported issue (previously stringified arrays)
- Document expected usage patterns for developers

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- @coderabbitai You can skip phase 3. Add a simple unit test case for phase 2.
- @coderabbitai For assumption 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!