mirror of
https://github.com/lukaszraczylo/filepuff-mcp.git
synced 2026-06-08 22:49:14 +00:00
feat(docs, ci, config): add comprehensive documentation and tooling
- [x] Add API reference documentation with tool descriptions and examples - [x] Add ERROR_CODES reference with error descriptions and remediation steps - [x] Add PERFORMANCE tuning guide with caching and optimization details - [x] Add GitHub Actions workflows for linting and security scanning - [x] Add golangci-lint configuration with comprehensive linter settings - [x] Add pre-commit hooks configuration for local development - [x] Add API documentation generator tool (cmd/docgen) - [x] Update Go version from 1.24 to 1.25 across workflows - [x] Add static build configuration to goreleaser - [x] Add metrics package with Prometheus-style metric types - [x] Add parser benchmarks for performance testing - [x] Add LSP manager integration tests - [x] Add server integration tests with MCP protocol flow testing - [x] Extract regex cache to shared utility package - [x] Add context cancellation handling in AST queries - [x] Add graceful shutdown with timeout to server - [x] Add configurable max parse size (MaxParseSize) - [x] Add Config.Validate() method with comprehensive checks - [x] Add parser cache statistics tracking - [x] Add file permission preservation in edit operations - [x] Improve line splitting for large files with bufio.Scanner - [x] Add comprehensive config tests for edge cases - [x] Update Makefile with new targets and documentation
This commit is contained in:
@@ -0,0 +1,459 @@
|
||||
package parser
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// BenchmarkParse benchmarks parsing files of various sizes.
|
||||
func BenchmarkParse(b *testing.B) {
|
||||
registry := NewRegistry()
|
||||
defer registry.Close()
|
||||
ctx := context.Background()
|
||||
|
||||
benchmarks := []struct {
|
||||
name string
|
||||
content string
|
||||
}{
|
||||
{
|
||||
name: "small_file_100_lines",
|
||||
content: generateGoCode(100),
|
||||
},
|
||||
{
|
||||
name: "medium_file_1000_lines",
|
||||
content: generateGoCode(1000),
|
||||
},
|
||||
{
|
||||
name: "large_file_5000_lines",
|
||||
content: generateGoCode(5000),
|
||||
},
|
||||
{
|
||||
name: "very_large_file_10000_lines",
|
||||
content: generateGoCode(10000),
|
||||
},
|
||||
}
|
||||
|
||||
for _, bm := range benchmarks {
|
||||
b.Run(bm.name, func(b *testing.B) {
|
||||
content := []byte(bm.content)
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, err := registry.Parse(ctx, "test.go", content)
|
||||
if err != nil {
|
||||
b.Fatalf("Parse failed: %v", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkParseCacheHit benchmarks cache hit performance.
|
||||
func BenchmarkParseCacheHit(b *testing.B) {
|
||||
registry := NewRegistry()
|
||||
defer registry.Close()
|
||||
ctx := context.Background()
|
||||
|
||||
content := []byte(generateGoCode(1000))
|
||||
|
||||
// Warm up the cache
|
||||
_, err := registry.Parse(ctx, "test.go", content)
|
||||
if err != nil {
|
||||
b.Fatalf("initial parse failed: %v", err)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, err := registry.Parse(ctx, "test.go", content)
|
||||
if err != nil {
|
||||
b.Fatalf("Parse failed: %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkParseCacheMiss benchmarks cache miss performance.
|
||||
func BenchmarkParseCacheMiss(b *testing.B) {
|
||||
registry := NewRegistry()
|
||||
defer registry.Close()
|
||||
ctx := context.Background()
|
||||
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
// Use different content each time to force cache miss
|
||||
content := []byte(generateGoCodeWithSuffix(1000, i))
|
||||
_, err := registry.Parse(ctx, "test.go", content)
|
||||
if err != nil {
|
||||
b.Fatalf("Parse failed: %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkParseLanguages benchmarks parsing different language files.
|
||||
func BenchmarkParseLanguages(b *testing.B) {
|
||||
registry := NewRegistry()
|
||||
defer registry.Close()
|
||||
ctx := context.Background()
|
||||
|
||||
languages := []struct {
|
||||
name string
|
||||
filename string
|
||||
content string
|
||||
}{
|
||||
{
|
||||
name: "go",
|
||||
filename: "test.go",
|
||||
content: generateGoCode(500),
|
||||
},
|
||||
{
|
||||
name: "typescript",
|
||||
filename: "test.ts",
|
||||
content: generateTypeScriptCode(500),
|
||||
},
|
||||
{
|
||||
name: "python",
|
||||
filename: "test.py",
|
||||
content: generatePythonCode(500),
|
||||
},
|
||||
{
|
||||
name: "javascript",
|
||||
filename: "test.js",
|
||||
content: generateJavaScriptCode(500),
|
||||
},
|
||||
}
|
||||
|
||||
for _, lang := range languages {
|
||||
b.Run(lang.name, func(b *testing.B) {
|
||||
content := []byte(lang.content)
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, err := registry.Parse(ctx, lang.filename, content)
|
||||
if err != nil {
|
||||
b.Fatalf("Parse failed: %v", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkParseComplexity benchmarks parsing files with varying complexity.
|
||||
func BenchmarkParseComplexity(b *testing.B) {
|
||||
registry := NewRegistry()
|
||||
defer registry.Close()
|
||||
ctx := context.Background()
|
||||
|
||||
benchmarks := []struct {
|
||||
name string
|
||||
content string
|
||||
}{
|
||||
{
|
||||
name: "simple_functions",
|
||||
content: generateSimpleFunctions(100),
|
||||
},
|
||||
{
|
||||
name: "nested_structures",
|
||||
content: generateNestedStructures(50),
|
||||
},
|
||||
{
|
||||
name: "complex_types",
|
||||
content: generateComplexTypes(50),
|
||||
},
|
||||
}
|
||||
|
||||
for _, bm := range benchmarks {
|
||||
b.Run(bm.name, func(b *testing.B) {
|
||||
content := []byte(bm.content)
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, err := registry.Parse(ctx, "test.go", content)
|
||||
if err != nil {
|
||||
b.Fatalf("Parse failed: %v", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkContentHash benchmarks the content hashing function.
|
||||
func BenchmarkContentHash(b *testing.B) {
|
||||
sizes := []int{100, 1000, 10000, 100000}
|
||||
|
||||
for _, size := range sizes {
|
||||
b.Run(formatSize(size), func(b *testing.B) {
|
||||
content := []byte(strings.Repeat("a", size))
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = contentHash(content)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkIsBinary benchmarks the binary detection function.
|
||||
func BenchmarkIsBinary(b *testing.B) {
|
||||
sizes := []int{100, 1000, 8000, 10000}
|
||||
|
||||
for _, size := range sizes {
|
||||
b.Run(formatSize(size)+"_text", func(b *testing.B) {
|
||||
content := []byte(strings.Repeat("Hello, World!\n", size/14))
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = isBinary(content)
|
||||
}
|
||||
})
|
||||
|
||||
b.Run(formatSize(size)+"_binary", func(b *testing.B) {
|
||||
content := make([]byte, size)
|
||||
for j := 0; j < size; j++ {
|
||||
content[j] = byte(j % 256)
|
||||
}
|
||||
content[size/2] = 0 // Add null byte
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = isBinary(content)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkParseWithMaxSize benchmarks parsing with different max size limits.
|
||||
func BenchmarkParseWithMaxSize(b *testing.B) {
|
||||
ctx := context.Background()
|
||||
|
||||
limits := []int64{
|
||||
10 * 1024, // 10KB
|
||||
100 * 1024, // 100KB
|
||||
1024 * 1024, // 1MB
|
||||
10 * 1024 * 1024, // 10MB
|
||||
}
|
||||
|
||||
content := []byte(generateGoCode(500))
|
||||
|
||||
for _, limit := range limits {
|
||||
b.Run(formatBytes(limit), func(b *testing.B) {
|
||||
// Skip if content is larger than limit
|
||||
if int64(len(content)) > limit {
|
||||
b.Skipf("content size %d exceeds limit %d", len(content), limit)
|
||||
}
|
||||
|
||||
registry := NewRegistryWithSize(limit)
|
||||
defer registry.Close()
|
||||
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, err := registry.Parse(ctx, "test.go", content)
|
||||
if err != nil {
|
||||
b.Fatalf("Parse failed: %v", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkConcurrentParse benchmarks concurrent parsing operations.
|
||||
func BenchmarkConcurrentParse(b *testing.B) {
|
||||
registry := NewRegistry()
|
||||
defer registry.Close()
|
||||
ctx := context.Background()
|
||||
|
||||
content := []byte(generateGoCode(500))
|
||||
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
b.RunParallel(func(pb *testing.PB) {
|
||||
for pb.Next() {
|
||||
_, err := registry.Parse(ctx, "test.go", content)
|
||||
if err != nil {
|
||||
b.Fatalf("Parse failed: %v", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Helper functions to generate test code
|
||||
|
||||
func generateGoCode(lines int) string {
|
||||
var sb strings.Builder
|
||||
sb.WriteString("package main\n\n")
|
||||
|
||||
for i := 0; i < lines/10; i++ {
|
||||
sb.WriteString("func Function")
|
||||
sb.WriteString(itoa(i))
|
||||
sb.WriteString("(a, b int) int {\n")
|
||||
sb.WriteString("\tif a > b {\n")
|
||||
sb.WriteString("\t\treturn a + b\n")
|
||||
sb.WriteString("\t}\n")
|
||||
sb.WriteString("\treturn a - b\n")
|
||||
sb.WriteString("}\n\n")
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func generateGoCodeWithSuffix(lines int, suffix int) string {
|
||||
code := generateGoCode(lines)
|
||||
return code + "// Suffix: " + itoa(suffix) + "\n"
|
||||
}
|
||||
|
||||
func generateTypeScriptCode(lines int) string {
|
||||
var sb strings.Builder
|
||||
|
||||
for i := 0; i < lines/8; i++ {
|
||||
sb.WriteString("function function")
|
||||
sb.WriteString(itoa(i))
|
||||
sb.WriteString("(a: number, b: number): number {\n")
|
||||
sb.WriteString(" if (a > b) {\n")
|
||||
sb.WriteString(" return a + b;\n")
|
||||
sb.WriteString(" }\n")
|
||||
sb.WriteString(" return a - b;\n")
|
||||
sb.WriteString("}\n\n")
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func generatePythonCode(lines int) string {
|
||||
var sb strings.Builder
|
||||
|
||||
for i := 0; i < lines/6; i++ {
|
||||
sb.WriteString("def function")
|
||||
sb.WriteString(itoa(i))
|
||||
sb.WriteString("(a, b):\n")
|
||||
sb.WriteString(" if a > b:\n")
|
||||
sb.WriteString(" return a + b\n")
|
||||
sb.WriteString(" return a - b\n\n")
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func generateJavaScriptCode(lines int) string {
|
||||
var sb strings.Builder
|
||||
|
||||
for i := 0; i < lines/8; i++ {
|
||||
sb.WriteString("function function")
|
||||
sb.WriteString(itoa(i))
|
||||
sb.WriteString("(a, b) {\n")
|
||||
sb.WriteString(" if (a > b) {\n")
|
||||
sb.WriteString(" return a + b;\n")
|
||||
sb.WriteString(" }\n")
|
||||
sb.WriteString(" return a - b;\n")
|
||||
sb.WriteString("}\n\n")
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func generateSimpleFunctions(count int) string {
|
||||
var sb strings.Builder
|
||||
sb.WriteString("package main\n\n")
|
||||
|
||||
for i := 0; i < count; i++ {
|
||||
sb.WriteString("func Func")
|
||||
sb.WriteString(itoa(i))
|
||||
sb.WriteString("() { }\n\n")
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func generateNestedStructures(depth int) string {
|
||||
var sb strings.Builder
|
||||
sb.WriteString("package main\n\n")
|
||||
|
||||
for i := 0; i < depth; i++ {
|
||||
sb.WriteString("type Struct")
|
||||
sb.WriteString(itoa(i))
|
||||
sb.WriteString(" struct {\n")
|
||||
sb.WriteString("\tField1 int\n")
|
||||
sb.WriteString("\tField2 string\n")
|
||||
if i > 0 {
|
||||
sb.WriteString("\tNested Struct")
|
||||
sb.WriteString(itoa(i - 1))
|
||||
sb.WriteString("\n")
|
||||
}
|
||||
sb.WriteString("}\n\n")
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func generateComplexTypes(count int) string {
|
||||
var sb strings.Builder
|
||||
sb.WriteString("package main\n\n")
|
||||
|
||||
for i := 0; i < count; i++ {
|
||||
sb.WriteString("type Type")
|
||||
sb.WriteString(itoa(i))
|
||||
sb.WriteString(" interface {\n")
|
||||
sb.WriteString("\tMethod1() error\n")
|
||||
sb.WriteString("\tMethod2(a int, b string) (int, error)\n")
|
||||
sb.WriteString("\tMethod3() chan interface{}\n")
|
||||
sb.WriteString("}\n\n")
|
||||
}
|
||||
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func formatSize(size int) string {
|
||||
if size < 1000 {
|
||||
return itoa(size) + "B"
|
||||
}
|
||||
return itoa(size/1000) + "KB"
|
||||
}
|
||||
|
||||
func formatBytes(bytes int64) string {
|
||||
if bytes < 1024 {
|
||||
return itoa(int(bytes)) + "B"
|
||||
}
|
||||
if bytes < 1024*1024 {
|
||||
return itoa(int(bytes/1024)) + "KB"
|
||||
}
|
||||
return itoa(int(bytes/(1024*1024))) + "MB"
|
||||
}
|
||||
|
||||
// Simple integer to string conversion without importing strconv
|
||||
func itoa(n int) string {
|
||||
if n == 0 {
|
||||
return "0"
|
||||
}
|
||||
|
||||
negative := n < 0
|
||||
if negative {
|
||||
n = -n
|
||||
}
|
||||
|
||||
var buf [20]byte
|
||||
i := len(buf) - 1
|
||||
|
||||
for n > 0 {
|
||||
buf[i] = byte('0' + n%10)
|
||||
n /= 10
|
||||
i--
|
||||
}
|
||||
|
||||
if negative {
|
||||
buf[i] = '-'
|
||||
i--
|
||||
}
|
||||
|
||||
return string(buf[i+1:])
|
||||
}
|
||||
Reference in New Issue
Block a user