diff --git a/main.go b/main.go index 9658560..5d3764d 100644 --- a/main.go +++ b/main.go @@ -53,22 +53,48 @@ func main() { luaExpr := args[1] files := args[2:] + // Generate the Lua script + luaScript := buildLuaScript(luaExpr) + log.Printf("Final expression: %s", luaExpr) + + // Make sure the regex can match across multiple lines by adding (?s) flag + if !strings.HasPrefix(regexPattern, "(?s)") { + regexPattern = "(?s)" + regexPattern + } + log.Printf("Regex pattern: %s", regexPattern) + log.Printf("Lua script: %s", luaScript) + log.Printf("Processing files: %v", files) + + // Compile the pattern for file processing + pattern, err := regexp.Compile(regexPattern) + if err != nil { + Error.Printf("Invalid regex pattern: %v", err) + return + } + + // Process each file + for _, file := range files { + err := processFile(file, pattern, luaScript) + if err != nil { + Error.Printf("Error processing file %s: %v", file, err) + } + } +} + +// buildLuaScript creates a complete Lua script from the expression +func buildLuaScript(luaExpr string) string { // Check if the expression needs v1 to be prepended if strings.HasPrefix(luaExpr, "*") || strings.HasPrefix(luaExpr, "/") || strings.HasPrefix(luaExpr, "+") || strings.HasPrefix(luaExpr, "-") || strings.HasPrefix(luaExpr, "^") || strings.HasPrefix(luaExpr, "%") { luaExpr = "v[1]" + luaExpr - log.Printf("Expression modified to: %s", luaExpr) } // Replace shorthand v1, v2, etc. with v[1], v[2] shorthandRegex := regexp.MustCompile(`\bv(\d+)\b`) luaExpr = shorthandRegex.ReplaceAllString(luaExpr, "v[$1]") - log.Printf("Final expression: %s", luaExpr) - // Check if the expression is a simple expression or explicitly manipulates v table - var fullScript string - // Add custom script header + // Add custom script header with helper functions scriptHeader := ` -- Custom Lua helpers for math operations function min(a, b) return math.min(a, b) end @@ -78,6 +104,8 @@ function floor(x) return math.floor(x) end function ceil(x) return math.ceil(x) end ` + // Check if the expression already has assignments or a return statement + var fullScript string if strings.Contains(luaExpr, "v[1] =") || strings.Contains(luaExpr, "v[2] =") || strings.Contains(luaExpr, "return") { // Already has assignments, use as is @@ -98,39 +126,31 @@ end `, scriptHeader, luaExpr) } - log.Printf("Regex pattern: %s", regexPattern) - log.Printf("Lua script: %s", fullScript) - log.Printf("Processing files: %v", files) + return fullScript +} - // Compile the pattern for file processing - pattern, err := regexp.Compile(regexPattern) +func processFile(filename string, pattern *regexp.Regexp, luaScript string) error { + log.Printf("Processing file: %s", filename) + fullPath := filepath.Join(".", filename) + + content, err := os.ReadFile(fullPath) if err != nil { - Error.Printf("Invalid regex pattern: %v", err) - return + return fmt.Errorf("error reading file: %v", err) } - // Process each file - for _, file := range files { - log.Printf("Processing file: %s", file) - fullPath := filepath.Join(".", file) - - content, err := os.ReadFile(fullPath) - if err != nil { - Error.Printf("error reading file: %v", err) - continue - } - - fileContent := string(content) - result, err := process(fileContent, pattern, fullScript) - if err != nil { - Error.Printf("Error processing file %s: %v", file, err) - } - - err = os.WriteFile(fullPath, []byte(result), 0644) - if err != nil { - Error.Printf("error writing file: %v", err) - } + fileContent := string(content) + result, err := process(fileContent, pattern, luaScript) + if err != nil { + return err } + + err = os.WriteFile(fullPath, []byte(result), 0644) + if err != nil { + return fmt.Errorf("error writing file: %v", err) + } + + log.Printf("File %s updated successfully", filename) + return nil } func process(data string, pattern *regexp.Regexp, luaScript string) (string, error) { @@ -149,6 +169,7 @@ func process(data string, pattern *regexp.Regexp, luaScript string) (string, err return data, fmt.Errorf("error in Lua script: %v", err) } + modified := false // Process all regex matches result := pattern.ReplaceAllStringFunc(data, func(match string) string { captures := pattern.FindStringSubmatch(match) @@ -203,6 +224,7 @@ func process(data string, pattern *regexp.Regexp, luaScript string) (string, err // Replace old value with new value result = strings.Replace(result, oldVal, newVal, 1) } + modified = true return result } @@ -210,5 +232,9 @@ func process(data string, pattern *regexp.Regexp, luaScript string) (string, err return match }) + if !modified { + log.Printf("No changes made to the content") + } + return result, nil } diff --git a/main_test.go b/main_test.go index b1b4342..4117b46 100644 --- a/main_test.go +++ b/main_test.go @@ -2,10 +2,18 @@ package main import ( "regexp" + "strings" "testing" ) -func TestSimpleFileSimpleExpression(t *testing.T) { +// Helper function to normalize whitespace for comparison +func normalizeWhitespace(s string) string { + // Replace all whitespace with a single space + re := regexp.MustCompile(`\s+`) + return re.ReplaceAllString(strings.TrimSpace(s), " ") +} + +func TestSimpleValueMultiplication(t *testing.T) { fileContents := ` @@ -21,20 +29,25 @@ func TestSimpleFileSimpleExpression(t *testing.T) { ` - regex := regexp.MustCompile(`(\d+)`) + // Create a regex pattern with the (?s) flag for multiline matching + regex := regexp.MustCompile(`(?s)(\d+)`) luaExpr := `*1.5` + luaScript := buildLuaScript(luaExpr) - modifiedContent, err := process(fileContents, regex, luaExpr) + modifiedContent, err := process(fileContents, regex, luaScript) if err != nil { t.Fatalf("Error processing file: %v", err) } - if modifiedContent != expected { - t.Fatalf("Expected modified content to be %v, but got %v", expected, modifiedContent) + // Compare normalized content + normalizedModified := normalizeWhitespace(modifiedContent) + normalizedExpected := normalizeWhitespace(expected) + if normalizedModified != normalizedExpected { + t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified) } } -func TestSimpleFileVExpression(t *testing.T) { +func TestShorthandNotation(t *testing.T) { fileContents := ` @@ -50,20 +63,23 @@ func TestSimpleFileVExpression(t *testing.T) { ` - regex := regexp.MustCompile(`(\d+)`) + regex := regexp.MustCompile(`(?s)(\d+)`) luaExpr := `v1 * 1.5` + luaScript := buildLuaScript(luaExpr) - modifiedContent, err := process(fileContents, regex, luaExpr) + modifiedContent, err := process(fileContents, regex, luaScript) if err != nil { t.Fatalf("Error processing file: %v", err) } - if modifiedContent != expected { - t.Fatalf("Expected modified content to be %v, but got %v", expected, modifiedContent) + normalizedModified := normalizeWhitespace(modifiedContent) + normalizedExpected := normalizeWhitespace(expected) + if normalizedModified != normalizedExpected { + t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified) } } -func TestSimpleFileTableVExpression(t *testing.T) { +func TestArrayNotation(t *testing.T) { fileContents := ` @@ -79,20 +95,23 @@ func TestSimpleFileTableVExpression(t *testing.T) { ` - regex := regexp.MustCompile(`(\d+)`) + regex := regexp.MustCompile(`(?s)(\d+)`) luaExpr := `v[1] * 1.5` + luaScript := buildLuaScript(luaExpr) - modifiedContent, err := process(fileContents, regex, luaExpr) + modifiedContent, err := process(fileContents, regex, luaScript) if err != nil { t.Fatalf("Error processing file: %v", err) } - if modifiedContent != expected { - t.Fatalf("Expected modified content to be %v, but got %v", expected, modifiedContent) + normalizedModified := normalizeWhitespace(modifiedContent) + normalizedExpected := normalizeWhitespace(expected) + if normalizedModified != normalizedExpected { + t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified) } } -func TestComplexFileSimpleExpression(t *testing.T) { +func TestMultipleMatches(t *testing.T) { fileContents := ` @@ -116,89 +135,169 @@ func TestComplexFileSimpleExpression(t *testing.T) { ` - regex := regexp.MustCompile(`(\d+)`) + regex := regexp.MustCompile(`(?s)(\d+)`) luaExpr := `*1.5` + luaScript := buildLuaScript(luaExpr) - modifiedContent, err := process(fileContents, regex, luaExpr) + modifiedContent, err := process(fileContents, regex, luaScript) if err != nil { t.Fatalf("Error processing file: %v", err) } - if modifiedContent != expected { - t.Fatalf("Expected modified content to be %v, but got %v", expected, modifiedContent) + normalizedModified := normalizeWhitespace(modifiedContent) + normalizedExpected := normalizeWhitespace(expected) + if normalizedModified != normalizedExpected { + t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified) } } -func TestComplexFileVExpression(t *testing.T) { +func TestMultipleCaptureGroups(t *testing.T) { fileContents := ` - 100 + 10 + 5 - - 200 - - 300 ` expected := ` - 150 + 50 + 5 - - 300 - - 450 ` - regex := regexp.MustCompile(`(\d+)`) - luaExpr := `v1 * 1.5` + // Use (?s) flag to match across multiple lines + regex := regexp.MustCompile(`(?s)(\d+).*?(\d+)`) + luaExpr := `v1 * v2` + luaScript := buildLuaScript(luaExpr) - modifiedContent, err := process(fileContents, regex, luaExpr) + // Verify the regex matches before processing + matches := regex.FindStringSubmatch(fileContents) + if len(matches) <= 1 { + t.Fatalf("Regex didn't match any capture groups in test input: %v", fileContents) + } + t.Logf("Matches: %v", matches) + + modifiedContent, err := process(fileContents, regex, luaScript) if err != nil { t.Fatalf("Error processing file: %v", err) } - if modifiedContent != expected { - t.Fatalf("Expected modified content to be %v, but got %v", expected, modifiedContent) + normalizedModified := normalizeWhitespace(modifiedContent) + normalizedExpected := normalizeWhitespace(expected) + if normalizedModified != normalizedExpected { + t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified) } } -func TestComplexFileTableVExpression(t *testing.T) { +func TestModifyingMultipleValues(t *testing.T) { fileContents := ` - 100 + 50 + 3 + 2 - - 200 - - 300 ` expected := ` - 150 + 75 + 5 + 1 - - 300 - - 450 ` - regex := regexp.MustCompile(`(\d+)`) - luaExpr := `v[1] * 1.5` + regex := regexp.MustCompile(`(?s)(\d+).*?(\d+).*?(\d+)`) + luaExpr := `v[1] = v[1] * v[2] / v[3]; v[2] = min(v[2] * 2, 5); v[3] = max(1, v[3] / 2)` + luaScript := buildLuaScript(luaExpr) - modifiedContent, err := process(fileContents, regex, luaExpr) + // Verify the regex matches before processing + matches := regex.FindStringSubmatch(fileContents) + if len(matches) <= 1 { + t.Fatalf("Regex didn't match any capture groups in test input: %v", fileContents) + } + t.Logf("Matches: %v", matches) + + modifiedContent, err := process(fileContents, regex, luaScript) if err != nil { t.Fatalf("Error processing file: %v", err) } - if modifiedContent != expected { - t.Fatalf("Expected modified content to be %v, but got %v", expected, modifiedContent) + normalizedModified := normalizeWhitespace(modifiedContent) + normalizedExpected := normalizeWhitespace(expected) + if normalizedModified != normalizedExpected { + t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified) } -} \ No newline at end of file +} + +func TestDecimalValues(t *testing.T) { + fileContents := ` + + + 10.5 + 2.5 + + + ` + expected := ` + + + 26.25 + 2.5 + + + ` + + regex := regexp.MustCompile(`(?s)([0-9.]+).*?([0-9.]+)`) + luaExpr := `v1 * v2` + luaScript := buildLuaScript(luaExpr) + + modifiedContent, err := process(fileContents, regex, luaScript) + if err != nil { + t.Fatalf("Error processing file: %v", err) + } + + normalizedModified := normalizeWhitespace(modifiedContent) + normalizedExpected := normalizeWhitespace(expected) + if normalizedModified != normalizedExpected { + t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified) + } +} + +func TestLuaMathFunctions(t *testing.T) { + fileContents := ` + + + 16 + + + ` + expected := ` + + + 4 + + + ` + + regex := regexp.MustCompile(`(?s)(\d+)`) + luaExpr := `math.sqrt(v1)` + luaScript := buildLuaScript(luaExpr) + + modifiedContent, err := process(fileContents, regex, luaScript) + if err != nil { + t.Fatalf("Error processing file: %v", err) + } + + normalizedModified := normalizeWhitespace(modifiedContent) + normalizedExpected := normalizeWhitespace(expected) + if normalizedModified != normalizedExpected { + t.Fatalf("Expected modified content to be %q, but got %q", normalizedExpected, normalizedModified) + } +}