Merge pull request #181 from applejag/feature/infer-package-name

Infer output:package from output:file

Author: jmattheis

config/config.go

@@ -35,8 +35,8 @@ type Raw struct {
 }
 
 type context struct {
-	Loader *pkgload.PackageLoader
-
+	Loader           *pkgload.PackageLoader
+	WorkDir          string
 	EnumTransformers map[string]enum.Transformer
 }
 
@@ -46,7 +46,7 @@ func Parse(raw *Raw) ([]*Converter, error) {
 		return nil, err
 	}
 
-	ctx := &context{Loader: loader, EnumTransformers: raw.EnumTransformers}
+	ctx := &context{Loader: loader, EnumTransformers: raw.EnumTransformers, WorkDir: raw.WorkDir}
 
 	converters := []*Converter{}
 	for _, rawConverter := range raw.Converters {

config/converter.go

@@ -13,7 +13,8 @@ import (
 )
 
 const (
-	configExtend = "extend"
+	configExtend     = "extend"
+	configOutputFile = "output:file"
 )
 
 type Format string
@@ -29,10 +30,9 @@ var DefaultCommon = Common{
 }
 
 var DefaultConfigInterface = ConverterConfig{
-	OutputFile:        "./generated/generated.go",
-	OutputPackageName: "generated",
-	Common:            DefaultCommon,
-	OutputFormat:      FormatStruct,
+	OutputFile:   "./generated/generated.go",
+	Common:       DefaultCommon,
+	OutputFormat: FormatStruct,
 }
 
 var DefaultConfigVariables = ConverterConfig{
@@ -109,10 +109,33 @@ func parseConverter(ctx *context, rawConverter *RawConverter, global RawLines) (
 		return nil, err
 	}
 
+	resolveOutputPackage(ctx, c)
+
 	err = parseMethods(ctx, rawConverter, c)
 	return c, err
 }
 
+func resolveOutputPackage(ctx *context, c *Converter) {
+	targetPackage, err := resolvePackage(c.FileName, c.Package, c.OutputFile)
+	if err != nil {
+		return
+	}
+
+	if c.OutputPackagePath == "" {
+		c.OutputPackagePath = targetPackage
+	}
+
+	pkg := ctx.Loader.GetUncheckedPkg(targetPackage)
+
+	if pkg == nil {
+		return
+	}
+
+	if c.OutputPackageName == "" {
+		c.OutputPackageName = pkg.Types.Name()
+	}
+}
+
 func initConverter(loader *pkgload.PackageLoader, rawConverter *RawConverter) (*Converter, error) {
 	c := &Converter{
 		FileName: rawConverter.FileName,
@@ -161,8 +184,8 @@ func parseConverterLine(ctx *context, c *Converter, value string) (err error) {
 		c.Name, err = parse.String(rest)
 	case "output:raw":
 		c.OutputRaw = append(c.OutputRaw, rest)
-	case "output:file":
-		c.OutputFile, err = parse.String(rest)
+	case configOutputFile:
+		c.OutputFile, err = parse.File(ctx.WorkDir, rest)
 	case "output:format":
 		if len(c.Extend) != 0 {
 			return fmt.Errorf("Cannot change output:format after extend functions have been added.\nMove the extend below the output:format setting.")

config/package.go

@@ -1,18 +1,37 @@
 package config
 
 import (
+	"path/filepath"
 	"strings"
 
 	"github.com/jmattheis/goverter/config/parse"
 	"github.com/jmattheis/goverter/pkgload"
 )
 
+func resolvePackage(sourceFileName, sourcePackage, targetFile string) (string, error) {
+	relativeFile := targetFile
+	if filepath.IsAbs(targetFile) {
+		var err error
+		relativeFile, err = filepath.Rel(filepath.Dir(sourceFileName), targetFile)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return filepath.Dir(filepath.Join(sourcePackage, relativeFile)), nil
+}
+
 func getPackages(raw *Raw) []string {
 	lookup := map[string]struct{}{}
 	for _, c := range raw.Converters {
 		lookup[c.PackagePath] = struct{}{}
-		registerConverterLines(lookup, c.PackagePath, c.Converter)
-		registerConverterLines(lookup, c.PackagePath, raw.Global)
+
+		// the default output:file is in ./generated and is not configured in Raw.
+		// This preemptively loads this package, in case it already exists.
+		lookup[filepath.Join(c.PackagePath, "generated")] = struct{}{}
+
+		registerConverterLines(lookup, raw.WorkDir, c.FileName, c.PackagePath, c.Converter)
+		registerConverterLines(lookup, raw.WorkDir, c.FileName, c.PackagePath, raw.Global)
 		for _, m := range c.Methods {
 			registerMethodLines(lookup, c.PackagePath, m)
 		}
@@ -26,33 +45,44 @@ func getPackages(raw *Raw) []string {
 	return pkgs
 }
 
-func registerConverterLines(lookup map[string]struct{}, cwd string, lines RawLines) {
+func registerConverterLines(lookup map[string]struct{}, cwd, filename, sourcePackage string, lines RawLines) {
 	for _, line := range lines.Lines {
 		cmd, rest := parse.Command(line)
-		if cmd == configExtend {
+		switch cmd {
+		case configExtend:
 			for _, fullMethod := range strings.Fields(rest) {
-				registerFullMethod(lookup, cwd, fullMethod)
+				registerFullMethod(lookup, sourcePackage, fullMethod)
+			}
+		case configOutputFile:
+			file, err := parse.File(cwd, rest)
+			if err != nil {
+				continue
+			}
+			targetPackage, err := resolvePackage(filename, sourcePackage, file)
+			if err != nil {
+				continue
 			}
+			lookup[targetPackage] = struct{}{}
 		}
 	}
 }
 
-func registerMethodLines(lookup map[string]struct{}, cwd string, lines RawLines) {
+func registerMethodLines(lookup map[string]struct{}, sourcePackage string, lines RawLines) {
 	for _, line := range lines.Lines {
 		cmd, rest := parse.Command(line)
 		switch cmd {
 		case configMap:
 			if _, _, custom, err := parseMethodMap(rest); err == nil && custom != "" {
-				registerFullMethod(lookup, cwd, custom)
+				registerFullMethod(lookup, sourcePackage, custom)
 			}
 		case configDefault:
-			registerFullMethod(lookup, cwd, rest)
+			registerFullMethod(lookup, sourcePackage, rest)
 		}
 	}
 }
 
-func registerFullMethod(lookup map[string]struct{}, cwd, fullMethod string) {
-	pkg, _, err := pkgload.ParseMethodString(cwd, fullMethod)
+func registerFullMethod(lookup map[string]struct{}, sourcePackage, fullMethod string) {
+	pkg, _, err := pkgload.ParseMethodString(sourcePackage, fullMethod)
 	if err == nil {
 		lookup[pkg] = struct{}{}
 	}

config/parse/file.go

@@ -0,0 +1,18 @@
+package parse
+
+import (
+	"path/filepath"
+	"strings"
+)
+
+func File(cwd, rest string) (string, error) {
+	field, err := String(rest)
+	if err != nil {
+		return field, err
+	}
+
+	if strings.HasPrefix(field, "@cwd/") {
+		return filepath.Abs(filepath.Join(cwd, strings.TrimPrefix(field, "@cwd/")))
+	}
+	return field, nil
+}

docs/changelog.md

@@ -9,6 +9,8 @@ import GH from './GH.vue';
 - Fix go1.24 support. <GH issue="186" pr="187"/>
 - Increase minimal go version to go1.22 due to breaking changes in x/tools for
   go1.24 <GH pr="187"/>
+- Infer [`output:package`](./reference/output.md) from file location
+  <GH issue="180" pr="181"/>
 
 ## v1.7.0
 

docs/guide/output-same-package.md

@@ -6,8 +6,7 @@ interface you can follow these steps:
 ## Configure generation
 
 Configure [`output`](../reference/output.md) to output the file into the same
-directory, define the full package path, and then run [`goverter
-gen`](../reference/cli.md).
+directory, and then run [`goverter gen`](../reference/cli.md).
 
 ::: code-group
 <<< @../../example/samepackage/input.go

docs/reference/output.md

@@ -78,10 +78,11 @@ Default is `:generated`.
 
 ### output:package PACKAGE
 
-This is the recommended way to define this setting. If you define the full
-package path, goverter is able to prevent edge-cases in the converter
-generation. The package name used in the generated `.go` file will be inferred
-from the normalized full package path. E.g.
+Goverter will infer the package path from `output:file` if it's outputted in
+the same go module, but you can override it with this setting. The full package
+path is needed is able to prevent edge-cases in the converter generation. If
+there is already a package name defined in the package, then it's used
+otherwise it will be infered from the full normalized package path. E.g.
 
 ```go
 // goverter:converter

example/samepackage/input.go

@@ -2,7 +2,6 @@ package samepackage
 
 // goverter:converter
 // goverter:output:file ./generated.go
-// goverter:output:package github.com/jmattheis/goverter/example/samepackage
 type Converter interface {
 	Convert(source *Input) *Output
 }

generator/filemanager.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"fmt"
 	"path/filepath"
-	"strings"
 
 	"github.com/dave/jennifer/jen"
 	"github.com/jmattheis/goverter/config"
@@ -23,7 +22,7 @@ type managedFile struct {
 }
 
 func (m *fileManager) Get(conv *config.Converter, cfg Config) (*jen.File, *namer.Namer, error) {
-	output := getOutputDir(conv, cfg.WorkingDir)
+	output := getOutputDir(conv)
 
 	f, ok := m.Files[output]
 	if !ok {
@@ -66,11 +65,7 @@ func (m *fileManager) renderFiles() (map[string][]byte, error) {
 	return result, nil
 }
 
-func getOutputDir(c *config.Converter, cwd string) string {
-	if strings.HasPrefix(c.OutputFile, "@cwd/") {
-		return filepath.Join(cwd, strings.TrimPrefix(c.OutputFile, "@cwd/"))
-	}
-
+func getOutputDir(c *config.Converter) string {
 	if filepath.IsAbs(c.OutputFile) {
 		return c.OutputFile
 	}

generator/generate.go

@@ -9,7 +9,6 @@ import (
 
 // Config the generate config.
 type Config struct {
-	WorkingDir      string
 	BuildConstraint string
 }