fix: support filename other than ext.go and keep local vars on generation

Author: alexandre-daubois

internal/extgen/gofile.go

@@ -22,6 +22,7 @@ type goTemplateData struct {
 	BaseName          string
 	Imports           []string
 	Constants         []phpConstant
+	Variables         []string
 	InternalFunctions []string
 	Functions         []phpFunction
 	Classes           []phpClass
@@ -39,7 +40,7 @@ func (gg *GoFileGenerator) generate() error {
 
 func (gg *GoFileGenerator) buildContent() (string, error) {
 	sourceAnalyzer := SourceAnalyzer{}
-	imports, internalFunctions, err := sourceAnalyzer.analyze(gg.generator.SourceFile)
+	imports, variables, internalFunctions, err := sourceAnalyzer.analyze(gg.generator.SourceFile)
 	if err != nil {
 		return "", fmt.Errorf("analyzing source file: %w", err)
 	}
@@ -59,6 +60,7 @@ func (gg *GoFileGenerator) buildContent() (string, error) {
 		BaseName:          gg.generator.BaseName,
 		Imports:           filteredImports,
 		Constants:         gg.generator.Constants,
+		Variables:         variables,
 		InternalFunctions: internalFunctions,
 		Functions:         gg.generator.Functions,
 		Classes:           classes,

internal/extgen/hfile.go

@@ -17,6 +17,7 @@ type HeaderGenerator struct {
 }
 
 type TemplateData struct {
+	BaseName    string
 	HeaderGuard string
 	Constants   []phpConstant
 	Classes     []phpClass
@@ -50,6 +51,7 @@ func (hg *HeaderGenerator) buildContent() (string, error) {
 
 	var buf bytes.Buffer
 	err = tmpl.Execute(&buf, TemplateData{
+		BaseName:    hg.generator.BaseName,
 		HeaderGuard: headerGuard,
 		Constants:   hg.generator.Constants,
 		Classes:     hg.generator.Classes,

internal/extgen/hfile_test.go

@@ -1,11 +1,12 @@
 package extgen
 
 import (
-	"github.com/stretchr/testify/require"
 	"path/filepath"
 	"strings"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/stretchr/testify/assert"
 )
 
@@ -43,7 +44,7 @@ func TestHeaderGenerator_BuildContent(t *testing.T) {
 				"#ifndef _SIMPLE_H",
 				"#define _SIMPLE_H",
 				"#include <php.h>",
-				"extern zend_module_entry ext_module_entry;",
+				"extern zend_module_entry simple_module_entry;",
 				"#endif",
 			},
 		},
@@ -128,7 +129,7 @@ func TestHeaderGenerator_BasicStructure(t *testing.T) {
 
 	expectedElements := []string{
 		"#include <php.h>",
-		"extern zend_module_entry ext_module_entry;",
+		"extern zend_module_entry structtest_module_entry;",
 	}
 
 	for _, element := range expectedElements {
@@ -264,7 +265,7 @@ func TestHeaderGenerator_MinimalContent(t *testing.T) {
 		"#ifndef _MINIMAL_H",
 		"#define _MINIMAL_H",
 		"#include <php.h>",
-		"extern zend_module_entry ext_module_entry;",
+		"extern zend_module_entry minimal_module_entry;",
 		"#endif",
 	}
 
@@ -287,7 +288,7 @@ func testHeaderBasicStructure(t *testing.T, content, baseName string) {
 		"#ifndef _" + headerGuard,
 		"#define _" + headerGuard,
 		"#include <php.h>",
-		"extern zend_module_entry ext_module_entry;",
+		"extern zend_module_entry test_extension_module_entry;",
 		"#endif",
 	}
 

internal/extgen/srcanalyzer.go

@@ -10,11 +10,11 @@ import (
 
 type SourceAnalyzer struct{}
 
-func (sa *SourceAnalyzer) analyze(filename string) (imports []string, internalFunctions []string, err error) {
+func (sa *SourceAnalyzer) analyze(filename string) (imports []string, variables []string, internalFunctions []string, err error) {
 	fset := token.NewFileSet()
 	node, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
 	if err != nil {
-		return nil, nil, fmt.Errorf("parsing file: %w", err)
+		return nil, nil, nil, fmt.Errorf("parsing file: %w", err)
 	}
 
 	for _, imp := range node.Imports {
@@ -30,12 +30,58 @@ func (sa *SourceAnalyzer) analyze(filename string) (imports []string, internalFu
 
 	sourceContent, err := os.ReadFile(filename)
 	if err != nil {
-		return nil, nil, fmt.Errorf("reading source file: %w", err)
+		return nil, nil, nil, fmt.Errorf("reading source file: %w", err)
 	}
 
+	variables = sa.extractVariables(string(sourceContent))
 	internalFunctions = sa.extractInternalFunctions(string(sourceContent))
 
-	return imports, internalFunctions, nil
+	return imports, variables, internalFunctions, nil
+}
+
+func (sa *SourceAnalyzer) extractVariables(content string) []string {
+	lines := strings.Split(content, "\n")
+	var (
+		variables  []string
+		currentVar strings.Builder
+		inVarBlock bool
+		parenCount int
+	)
+
+	for _, line := range lines {
+		trimmedLine := strings.TrimSpace(line)
+
+		if strings.HasPrefix(trimmedLine, "var ") && !inVarBlock {
+			if strings.Contains(trimmedLine, "(") {
+				inVarBlock = true
+				parenCount = 1
+				currentVar.Reset()
+				currentVar.WriteString(line + "\n")
+			} else {
+				variables = append(variables, strings.TrimSpace(line))
+			}
+		} else if inVarBlock {
+			currentVar.WriteString(line + "\n")
+
+			for _, char := range line {
+				switch char {
+				case '(':
+					parenCount++
+				case ')':
+					parenCount--
+				}
+			}
+
+			if parenCount == 0 {
+				varContent := currentVar.String()
+				variables = append(variables, strings.TrimSpace(varContent))
+				inVarBlock = false
+				currentVar.Reset()
+			}
+		}
+	}
+
+	return variables
 }
 
 func (sa *SourceAnalyzer) extractInternalFunctions(content string) []string {

internal/extgen/srcanalyzer_test.go

@@ -14,6 +14,7 @@ func TestSourceAnalyzer_Analyze(t *testing.T) {
 		name              string
 		sourceContent     string
 		expectedImports   []string
+		expectedVariables []string
 		expectedFunctions []string
 		expectError       bool
 	}{
@@ -34,7 +35,8 @@ func regularFunction() {
 func exportedFunction() string {
 	return "exported"
 }`,
-			expectedImports: []string{`"fmt"`, `"strings"`},
+			expectedImports:   []string{`"fmt"`, `"strings"`},
+			expectedVariables: nil,
 			expectedFunctions: []string{
 				`func regularFunction() {
 	fmt.Println("hello")
@@ -53,7 +55,8 @@ import (
 )
 
 func test() {}`,
-			expectedImports: []string{`custom "fmt"`, `. "strings"`, `_ "os"`},
+			expectedImports:   []string{`custom "fmt"`, `. "strings"`, `_ "os"`},
+			expectedVariables: nil,
 			expectedFunctions: []string{
 				`func test() {}`,
 			},
@@ -82,7 +85,8 @@ func internalTwo() string {
 func exportedTwo() bool {
 	return true
 }`,
-			expectedImports: []string{},
+			expectedImports:   []string{},
+			expectedVariables: nil,
 			expectedFunctions: []string{
 				`func internalOne() {
 	// some code
@@ -116,7 +120,8 @@ func exportedComplex() {
 	}
 	fmt.Println(obj)
 }`,
-			expectedImports: []string{},
+			expectedImports:   []string{},
+			expectedVariables: nil,
 			expectedFunctions: []string{
 				`func complexFunction() {
 	if true {
@@ -163,10 +168,50 @@ func shouldNotBeExported() {}
 func normalFunction() {
 	//export_php:function inside function should not count
 }`,
-			expectedImports: []string{},
+			expectedImports:   []string{},
+			expectedVariables: nil,
 			expectedFunctions: []string{
 				`func normalFunction() {
 	//export_php:function inside function should not count
+}`,
+			},
+			expectError: false,
+		},
+		{
+			name: "file with variable blocks",
+			sourceContent: `package main
+
+import (
+	"sync"
+)
+
+var (
+	mu    sync.RWMutex
+	store = map[string]struct {
+		val     string
+		expires int64
+	}{}
+)
+
+var singleVar = "test"
+
+func testFunction() {
+	// test function
+}`,
+			expectedImports: []string{`"sync"`},
+			expectedVariables: []string{
+				`var (
+	mu    sync.RWMutex
+	store = map[string]struct {
+		val     string
+		expires int64
+	}{}
+)`,
+				`var singleVar = "test"`,
+			},
+			expectedFunctions: []string{
+				`func testFunction() {
+	// test function
 }`,
 			},
 			expectError: false,
@@ -181,7 +226,7 @@ func normalFunction() {
 			require.NoError(t, os.WriteFile(filename, []byte(tt.sourceContent), 0644))
 
 			analyzer := &SourceAnalyzer{}
-			imports, functions, err := analyzer.analyze(filename)
+			imports, variables, functions, err := analyzer.analyze(filename)
 
 			if tt.expectError {
 				assert.Error(t, err, "expected error")
@@ -194,6 +239,7 @@ func normalFunction() {
 				assert.Equal(t, tt.expectedImports, imports, "imports mismatch")
 			}
 
+			assert.Equal(t, tt.expectedVariables, variables, "variables mismatch")
 			assert.Len(t, functions, len(tt.expectedFunctions), "function count mismatch")
 
 			for i, expected := range tt.expectedFunctions {
@@ -207,7 +253,7 @@ func TestSourceAnalyzer_Analyze_InvalidFile(t *testing.T) {
 	analyzer := &SourceAnalyzer{}
 
 	t.Run("nonexistent file", func(t *testing.T) {
-		_, _, err := analyzer.analyze("/nonexistent/file.go")
+		_, _, _, err := analyzer.analyze("/nonexistent/file.go")
 		assert.Error(t, err, "expected error for nonexistent file")
 	})
 
@@ -222,7 +268,7 @@ func TestSourceAnalyzer_Analyze_InvalidFile(t *testing.T) {
 
 		require.NoError(t, os.WriteFile(filename, []byte(invalidContent), 0644))
 
-		_, _, err := analyzer.analyze(filename)
+		_, _, _, err := analyzer.analyze(filename)
 		assert.Error(t, err, "expected error for invalid syntax")
 	})
 }
@@ -372,7 +418,7 @@ func internalTwo() {
 	analyzer := &SourceAnalyzer{}
 
 	for b.Loop() {
-		_, _, err := analyzer.analyze(filename)
+		_, _, _, err := analyzer.analyze(filename)
 		require.NoError(b, err)
 	}
 }

internal/extgen/templates/extension.go.tpl

@@ -5,17 +5,21 @@ package {{.PackageName}}
 #include "{{.BaseName}}.h"
 */
 import "C"
-import "runtime/cgo"
 {{- range .Imports}}
 import {{.}}
 {{- end}}
 
 func init() {
-	frankenphp.RegisterExtension(unsafe.Pointer(&C.ext_module_entry))
+	frankenphp.RegisterExtension(unsafe.Pointer(&C.{{.BaseName}}_module_entry))
 }
-{{range .Constants}}
+{{- range .Constants}}
 const {{.Name}} = {{.Value}}
 {{- end}}
+
+{{ range .Variables}}
+{{.}}
+{{- end}}
+
 {{range .InternalFunctions}}
 {{.}}
 {{- end}}

internal/extgen/templates/extension.h.tpl

@@ -4,7 +4,7 @@
 #include <php.h>
 #include <stdint.h>
 
-extern zend_module_entry ext_module_entry;
+extern zend_module_entry {{.BaseName}}_module_entry;
 
 {{if .Constants}}
 /* User defined constants */{{end}}