generate-database: Reduce to single go:generate per package

Signed-off-by: Lucas Bremgartner <[email protected]>

Author: breml

cmd/generate-database/README.md

@@ -14,39 +14,55 @@ predictability.
 
 ### Initialization
 
-Generally the first thing we will want to do for any newly generated file is to
-establish the command, the target file, and ensure the file has been cleared of
-content:
+#### Package global
 
-```go
-//go:generate -command mapper generate-database db mapper -t instances.mapper.go
-//go:generate mapper generate -i -b "//go:build linux && cgo && !agent"
+Once per package, that uses `generate-database` for generation of database
+statements and associated `go` functions, `generate-database` needs to be invoked
+using the following `go:generate` instruction:
 
+```go
+//go:generate generate-database db mapper generate
 ```
 
-This will initiate a call to `generate-database db mapper -t instances.mapper.go mapper generate`,
+This will initiate a call to `generate-database db mapper generate`,
 which will then search for `//generate-database:mapper` directives in the same file
 and process those.
 
+#### File
+
+Generally the first thing we will want to do for any newly generated file is to
+ensure the file has been cleared of content:
+
+```go
+//generate-database:mapper target instances.mapper.go
+//generate-database:mapper reset -i -b "//go:build linux && cgo && !agent"
+```
+
 ### Generation Directive Arguments
 
 The generation directive aruments have the following form:
 
-`//generate-database:mapper <command> <entity> <kind> <config...>`
+`//generate-database:mapper <command> flags <kind> <args...>`
+
+The following flags are available:
+
+* `--build` / `-b`: build comment to include (commands: `reset`)
+* `--interface` / `-i`: create interface files (commands: `reset`, `method`)
+* `--entity` / `-e`: database entity to generate the method or statement for (commands: `stmt`, `method`)
 
 Example:
 
-* `//generate-database:mapper stmt instance objects table=table_name`
+* `//generate-database:mapper stmt -e instance objects table=table_name`
 
 The `table` key can be used to override the generated table name for a specified one.
 
-* `//generate-database:mapper stmt method instance Create references=Config,Device`
+* `//generate-database:mapper method -i -e instance Create references=Config,Device`
 
 For some tables (defined below under [Additional Information](#Additional-Information) as [EntityTable](#EntityTable), the `references=<ReferenceEntity>` key can be provided with the name of
 a [ReferenceTable](#ReferenceTable) or [MapTable](#MapTable) struct. This directive would produce `CreateInstance` in addition to `CreateInstanceConfig` and `CreateInstanceDevices`:
 
-* `//generate-database:mapper method instance_profile Create struct=Instance`
-* `//generate-database:mapper method instance_profile Create struct=Profile`
+* `//generate-database:mapper method -i -e instance_profile Create struct=Instance`
+* `//generate-database:mapper method -i -e instance_profile Create struct=Profile`
 
 For some tables (defined below under [Additional Information](#Additional-Information) as [AssociationTable](#AssociationTable), `method` declarations must
 include a `struct=<Entity>` to indicate the directionality of the function. An invocation can be called for each direction.
@@ -70,11 +86,11 @@ Type                                  | Description
 #### Examples
 
 ```go
-//generate-database:mapper stmt instance objects
-//generate-database:mapper stmt instance objects-by-Name-and-Project
-//generate-database:mapper stmt instance create
-//generate-database:mapper stmt instance update
-//generate-database:mapper stmt instance delete-by-Name-and-Project
+//generate-database:mapper stmt -e instance objects
+//generate-database:mapper stmt -e instance objects-by-Name-and-Project
+//generate-database:mapper stmt -e instance create
+//generate-database:mapper stmt -e instance update
+//generate-database:mapper stmt -e instance delete-by-Name-and-Project
 ```
 
 #### Statement Related Go Tags
@@ -112,14 +128,14 @@ Type                                | Description
 `DeleteMany`                        | Delete one or more rows from the table.
 
 ```go
-//generate-database:mapper method instance GetMany
-//generate-database:mapper method instance GetOne
-//generate-database:mapper method instance ID
-//generate-database:mapper method instance Exist
-//generate-database:mapper method instance Create
-//generate-database:mapper method instance Update
-//generate-database:mapper method instance DeleteOne-by-Project-and-Name
-//generate-database:mapper method instance DeleteMany-by-Name
+//generate-database:mapper method -i -e instance GetMany
+//generate-database:mapper method -i -e instance GetOne
+//generate-database:mapper method -i -e instance ID
+//generate-database:mapper method -i -e instance Exist
+//generate-database:mapper method -i -e instance Create
+//generate-database:mapper method -i -e instance Update
+//generate-database:mapper method -i -e instance DeleteOne-by-Project-and-Name
+//generate-database:mapper method -i -e instance DeleteMany-by-Name
 ```
 
 ### Additional Information
@@ -168,8 +184,8 @@ Real world invocation of these statements and functions should be done through a
 Example:
 
 ```go
-//generate-database:mapper stmt device create
-//generate-database:mapper method device Create
+//generate-database:mapper stmt -e device create
+//generate-database:mapper method -e device Create
 
 type Device struct {
   ID int
@@ -179,7 +195,7 @@ type Device struct {
 }
 
 //...
-//generate-database:mapper method instance Create references=Device
+//generate-database:mapper method -e instance Create references=Device
 // This will produce a function called `CreateInstanceDevices`.
 ```
 
@@ -191,8 +207,8 @@ On the SQL side, this is treated exactly like a `ReferenceTable`, but on the `go
 Example:
 
 ```go
-//generate-database:mapper stmt config create
-//generate-database:mapper method config Create
+//generate-database:mapper stmt -e config create
+//generate-database:mapper method -e config Create
 
 type Config struct {
   ID int
@@ -202,7 +218,7 @@ type Config struct {
 }
 
 //...
-//generate-database:mapper method instance Create references=Config
+//generate-database:mapper method -e instance Create references=Config
 // This will produce a function called `CreateInstanceConfig`, which will return a `map[string]string`.
 ```
 
@@ -217,8 +233,8 @@ An invocation can be called for each direction.
 Example:
 
 ```go
-//generate-database:mapper method instance_profile Create struct=Instance
-//generate-database:mapper method instance_profile Create struct=Profile
+//generate-database:mapper method -i -e instance_profile Create struct=Instance
+//generate-database:mapper method -i -e instance_profile Create struct=Profile
 
 type InstanceProfile struct {
   InstanceID int

cmd/generate-database/db.go

@@ -3,14 +3,15 @@
 package main
 
 import (
+	"encoding/csv"
 	"errors"
 	"fmt"
 	"go/build"
 	"os"
-	"path/filepath"
 	"strings"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 	"golang.org/x/tools/go/packages"
 
 	"github.com/lxc/incus/v6/cmd/generate-database/db"
@@ -64,9 +65,6 @@ func newDbMapper() *cobra.Command {
 }
 
 func newDbMapperGenerate() *cobra.Command {
-	var target string
-	var build string
-	var iface bool
 	var pkg string
 
 	cmd := &cobra.Command{
@@ -77,73 +75,74 @@ func newDbMapperGenerate() *cobra.Command {
 				return errors.New("GOPACKAGE environment variable is not set")
 			}
 
-			if os.Getenv("GOFILE") == "" {
-				return errors.New("GOFILE environment variable is not set")
-			}
-
-			return generate(target, build, iface, pkg)
+			return generate(pkg)
 		},
 	}
 
 	flags := cmd.Flags()
-	flags.BoolVarP(&iface, "interface", "i", false, "create interface files")
-	flags.StringVarP(&target, "target", "t", "-", "target source file to generate")
-	flags.StringVarP(&build, "build", "b", "", "build comment to include")
 	flags.StringVarP(&pkg, "package", "p", "", "Go package where the entity struct is declared")
 
 	return cmd
 }
 
 const prefix = "//generate-database:mapper "
 
-func generate(target string, build string, iface bool, pkg string) error {
-	err := file.Reset(target, db.Imports, build, iface)
-	if err != nil {
-		return err
-	}
-
+func generate(pkg string) error {
 	parsedPkg, err := packageLoad(pkg)
 	if err != nil {
 		return err
 	}
 
 	registeredSQLStmts := map[string]string{}
 	for _, goFile := range parsedPkg.CompiledGoFiles {
-		if filepath.Base(goFile) != os.Getenv("GOFILE") {
-			continue
-		}
-
 		body, err := os.ReadFile(goFile)
 		if err != nil {
 			return err
 		}
 
+		// Reset target to stdout
+		target := "-"
+
 		lines := strings.Split(string(body), "\n")
 		for _, line := range lines {
 			// Lazy matching for prefix, does not consider Go syntax and therefore
 			// lines starting with prefix, that are part of e.g. multiline strings
 			// match as well. This is highly unlikely to cause false positives.
 			if strings.HasPrefix(line, prefix) {
 				line = strings.TrimPrefix(line, prefix)
-				args := strings.Split(line, " ")
 
-				command := args[0]
-				entity := args[1]
-				kind := args[2]
-				config, err := parseParams(args[3:])
+				// Use csv parser to properly handle arguments surrounded by double quotes.
+				r := csv.NewReader(strings.NewReader(line))
+				r.Comma = ' ' // space
+				args, err := r.Read()
 				if err != nil {
 					return err
 				}
 
+				if len(args) == 0 {
+					return fmt.Errorf("command missing")
+				}
+
+				command := args[0]
+
 				switch command {
+				case "target":
+					if len(args) != 2 {
+						return fmt.Errorf("invalid arguments for command target, one argument for the target filename: %s", line)
+					}
+
+					target = args[1]
+				case "reset":
+					err = commandReset(args[1:], target)
+
 				case "stmt":
-					err = generateStmt(target, parsedPkg, entity, kind, config, registeredSQLStmts)
+					err = commandStmt(args[1:], target, parsedPkg, registeredSQLStmts)
 
 				case "method":
-					err = generateMethod(target, iface, parsedPkg, entity, kind, config, registeredSQLStmts)
+					err = commandMethod(args[1:], target, parsedPkg, registeredSQLStmts)
 
 				default:
-					err = fmt.Errorf("undefined command: %s", command)
+					err = fmt.Errorf("unknown command: %s", command)
 				}
 
 				if err != nil {
@@ -156,22 +155,83 @@ func generate(target string, build string, iface bool, pkg string) error {
 	return nil
 }
 
-func generateStmt(target string, parsedPkg *packages.Package, entity, kind string, config map[string]string, registeredSQLStmts map[string]string) error {
-	stmt, err := db.NewStmt(parsedPkg, entity, kind, config, registeredSQLStmts)
+func commandReset(commandLine []string, target string) error {
+	var err error
+
+	flags := pflag.NewFlagSet("", pflag.ContinueOnError)
+	iface := flags.BoolP("interface", "i", false, "create interface files")
+	buildComment := flags.StringP("build", "b", "", "build comment to include")
+
+	err = flags.Parse(commandLine)
 	if err != nil {
 		return err
 	}
 
-	return file.Append(entity, target, stmt, false)
+	err = file.Reset(target, db.Imports, *buildComment, *iface)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
-func generateMethod(target string, iface bool, parsedPkg *packages.Package, entity, kind string, config map[string]string, registeredSQLStmts map[string]string) error {
-	method, err := db.NewMethod(parsedPkg, entity, kind, config, registeredSQLStmts)
+func commandStmt(commandLine []string, target string, parsedPkg *packages.Package, registeredSQLStmts map[string]string) error {
+	var err error
+
+	flags := pflag.NewFlagSet("", pflag.ContinueOnError)
+	entity := flags.StringP("entity", "e", "", "database entity to generate the statement for")
+
+	err = flags.Parse(commandLine)
+	if err != nil {
+		return err
+	}
+
+	if len(flags.Args()) < 1 {
+		return fmt.Errorf("argument <kind> missing for stmt command")
+	}
+
+	kind := flags.Arg(0)
+	config, err := parseParams(flags.Args()[1:])
+	if err != nil {
+		return err
+	}
+
+	stmt, err := db.NewStmt(parsedPkg, *entity, kind, config, registeredSQLStmts)
+	if err != nil {
+		return err
+	}
+
+	return file.Append(*entity, target, stmt, false)
+}
+
+func commandMethod(commandLine []string, target string, parsedPkg *packages.Package, registeredSQLStmts map[string]string) error {
+	var err error
+
+	flags := pflag.NewFlagSet("", pflag.ContinueOnError)
+	iface := flags.BoolP("interface", "i", false, "create interface files")
+	entity := flags.StringP("entity", "e", "", "database entity to generate the method for")
+
+	err = flags.Parse(commandLine)
+	if err != nil {
+		return err
+	}
+
+	if len(flags.Args()) < 1 {
+		return fmt.Errorf("argument <kind> missing for method command")
+	}
+
+	kind := flags.Arg(0)
+	config, err := parseParams(flags.Args()[1:])
+	if err != nil {
+		return err
+	}
+
+	method, err := db.NewMethod(parsedPkg, *entity, kind, config, registeredSQLStmts)
 	if err != nil {
 		return err
 	}
 
-	return file.Append(entity, target, method, iface)
+	return file.Append(*entity, target, method, *iface)
 }
 
 func packageLoad(pkg string) (*packages.Package, error) {