Improve tag parsing (regex support added)

Author: kpeu3i

README.md

@@ -16,15 +16,15 @@ The library provides the following features:
 
   * Struct fields representation with ENUM.
   * Different functions and methods to work with ENUM (validation, listing, conversion to string, etc).
-  * Tag-based field names extraction.
+  * Tag-based field names extraction (regex can be used to extract a value from a tag).
   * Embedded fields extraction.
   * Fields excluding.
   * Different formatting (camel, pascal, snake).
   * Template overriding.
 
 ## Installation
 
-    $ go install github.com/kpeu3i/fielder@v1.4.0
+    go install github.com/kpeu3i/fielder@v1.5.0
 
 ## Usage
 
@@ -48,7 +48,7 @@ Then, run command bellow to generate the code:
 
     $ go generate ./...
 
-The following formatting strategies can be applied for the extracted field names (see `format` flag):
+The following formatting strategies can be applied for the extracted field names (see `format` and `tag_format` flag):
  * `snake_case` (e.g `first_name`)
  * `camel_case` (e.g `firstName`)
  * `pascal_case` (e.g `FirstName`)
@@ -60,23 +60,29 @@ The following CLI flags are allowed:
 ```
 Usage of fielder:
   -embedded
-        Extract embedded fields (default false)
+    	Extract embedded fields (default false)
   -excluded string
-        Comma separated list of excluded fields (default "")
+    	Comma separated list of excluded fields (default "")
   -format string
-        Format of the generated type values (default "as_is")
+    	Format of the generated type values extracted from the struct field (default "as_is")
   -output string
-        Set output filename (default "<src_dir>/<type>_fielder.go")
+    	Set output filename (default "<src_dir>/<type>_fielder.go")
   -pkg string
-        Package name to extract type from (default ".")
+    	Package name to extract type from (default ".")
   -suffix string
-        Suffix for the generated struct (default "Field")
+    	Suffix for the generated struct (default "Field")
   -tag string
-        Use tag to extract field values from (default "")
+    	Tag to extract field values from (default "")
+  -tag_format string
+    	Format of the generated type values extracted from the tag (default "as_is")
+  -tag_regexp string
+    	Regular expression to parse field value from a tag (default "")
+  -tag_strict
+    	Strict mode for tag parsing (returns error if tag is not found)
   -tpl string
-        Set template filename (default "")
+    	Set template filename (default "")
   -type string
-        Type to extract fields from
+    	Type to extract fields from
 ```
 
 ## Generated types, functions and methods

config.go

@@ -21,8 +21,11 @@ type config struct {
 	Pkg              string
 	Type             string
 	Suffix           string
-	Tag              string
 	Format           string
+	Tag              string
+	TagRegex         string
+	TagFormat        string
+	TagStrict        bool
 	Embedded         bool
 	Excluded         []string
 	TemplateFilename string
@@ -33,8 +36,11 @@ func initConfig() (config, error) {
 	pkg := flag.String("pkg", ".", "Package name to extract type from")
 	typ := flag.String("type", "", "Type to extract fields from")
 	suffix := flag.String("suffix", "Field", "Suffix for the generated struct")
-	tag := flag.String("tag", "", `Use tag to extract field values from (default "")`)
-	format := flag.String("format", formatAsIs, "Format of the generated type values")
+	format := flag.String("format", formatAsIs, "Format of the generated type values extracted from the struct field")
+	tag := flag.String("tag", "", `Tag to extract field values from (default "")`)
+	tagRegex := flag.String("tag_regex", "", `Regular expression to parse field value from a tag (default "")`)
+	tagFormat := flag.String("tag_format", formatAsIs, "Format of the generated type values extracted from the tag")
+	tagStrict := flag.Bool("tag_strict", false, "Strict mode for tag parsing (returns error if tag is not found)")
 	embedded := flag.Bool("embedded", false, "Extract embedded fields (default false)")
 	excluded := flag.String("excluded", "", `Comma separated list of excluded fields (default "")`)
 	templateFilename := flag.String("tpl", "", `Set template filename (default "")`)
@@ -46,18 +52,45 @@ func initConfig() (config, error) {
 		return config{}, errors.New("type is required")
 	}
 
+	if *tag == "" {
+		if *tagRegex != "" {
+			return config{}, errors.New("tag is required when tag_regex is set")
+		}
+
+		if *tagFormat != formatAsIs {
+			return config{}, errors.New("tag is required when tag_format is set")
+		}
+
+		if *tagStrict != false {
+			return config{}, errors.New("tag is required when tag_strict is set")
+		}
+	}
+
+	if *tagStrict && *format != formatAsIs {
+		return config{}, errors.New("format is not supported when tag_strict is set")
+	}
+
 	switch *format {
 	case formatAsIs, formatSnakeCase, formatCamelCase, formatPascalCase:
 	default:
 		return config{}, fmt.Errorf("invalid format %s", *format)
 	}
 
+	switch *tagFormat {
+	case formatAsIs, formatSnakeCase, formatCamelCase, formatPascalCase:
+	default:
+		return config{}, fmt.Errorf("invalid tag_format %s", *format)
+	}
+
 	conf := config{}
 	conf.Pkg = *pkg
 	conf.Type = *typ
 	conf.Suffix = *suffix
-	conf.Tag = *tag
 	conf.Format = *format
+	conf.Tag = *tag
+	conf.TagRegex = *tagRegex
+	conf.TagFormat = *tagFormat
+	conf.TagStrict = *tagStrict
 	conf.Embedded = *embedded
 	conf.TemplateFilename = *templateFilename
 

examples/simple/models/user_account.go

@@ -1,4 +1,4 @@
-//go:generate fielder -type=UserAccount -suffix=Column -embedded=true -tag=db -excluded=FullName
+//go:generate fielder -type=UserAccount -suffix=Column -embedded=true -tag=db -tag_strict=true -excluded=FullName
 
 package models
 

examples/simple/models/user_account_fielder.go

@@ -6,14 +6,14 @@ import (
 	"os"
 )
 
-func writeToFile(filename string, output []byte) error {
+func writeToFile(data []byte, filename string) error {
 	f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, fs.ModePerm)
 	if err != nil {
 		return fmt.Errorf("could not open file %q: %v", filename, err)
 	}
 	defer f.Close()
 
-	_, err = f.Write(output)
+	_, err = f.Write(data)
 	if err != nil {
 		return fmt.Errorf("could not write to file: %v", err)
 	}

fileutil.go

@@ -13,9 +13,10 @@ type EntityDeletedAt struct {
 }
 
 type Entity struct {
-	ID        string    `db:"uuid"`
-	CreatedAt time.Time `db:"created_at"`
-	UpdatedAt time.Time `db:"updated_at"`
+	ID             string    `db:"uuid"`
+	CreatedAt      time.Time `db:"created_at,type:timestamp"`
+	UpdatedAt      time.Time `db:"updated_at,type:timestamp"`
+	FirstUpdatedAt time.Time
 
 	EntityID
 	EntityDeletedAt

internal/testdata/user.go

@@ -15,7 +15,17 @@ func main() {
 		log.Fatalf("cannot parse type %s: %v", conf.Type, err)
 	}
 
-	fields, err := parseFields(typ, conf.Tag, conf.Embedded, conf.Excluded, conf.Format, 0)
+	parseParams := parseFieldsParams{
+		format:    conf.Format,
+		tag:       conf.Tag,
+		tagRegex:  conf.TagRegex,
+		tagFormat: conf.TagFormat,
+		tagStrict: conf.TagStrict,
+		embedded:  conf.Embedded,
+		excluded:  conf.Excluded,
+	}
+
+	fields, err := parseFields(typ, parseParams, 0)
 	if err != nil {
 		log.Fatalf("cannot parse fields for type %s: %v", conf.Type, err)
 	}
@@ -33,7 +43,7 @@ func main() {
 		log.Fatalf("no output generated")
 	}
 
-	err = writeToFile(conf.OutputFilename, output)
+	err = writeToFile(output, conf.OutputFilename)
 	if err != nil {
 		log.Fatalf("cannot write to file %s: %v", conf.OutputFilename, err)
 	}

main.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"go/types"
+	"regexp"
 
 	"github.com/fatih/structtag"
 	"github.com/iancoleman/strcase"
@@ -17,6 +18,16 @@ type field struct {
 	Depth int
 }
 
+type parseFieldsParams struct {
+	format    string
+	tag       string
+	tagRegex  string
+	tagFormat string
+	tagStrict bool
+	embedded  bool
+	excluded  []string
+}
+
 func parseType(path, name string) (string, types.Type, error) {
 	cfg := &packages.Config{
 		Mode: packages.NeedTypes | packages.NeedImports | packages.NeedModule,
@@ -40,14 +51,7 @@ func parseType(path, name string) (string, types.Type, error) {
 	return obj.Pkg().Name(), obj.Type(), nil
 }
 
-func parseFields(
-	typ types.Type,
-	useTag string,
-	useEmbedded bool,
-	excluded []string,
-	format string,
-	depth int,
-) ([]field, error) {
+func parseFields(typ types.Type, params parseFieldsParams, depth int) ([]field, error) {
 	strct, ok := typ.Underlying().(*types.Struct)
 	if !ok {
 		return nil, fmt.Errorf("type %s is not a struct", typ)
@@ -62,42 +66,70 @@ func parseFields(
 			continue
 		}
 
-		isExcluded := lo.Contains(excluded, strct.Field(i).Name())
+		isExcluded := lo.Contains(params.excluded, strct.Field(i).Name())
 		if isExcluded {
 			continue
 		}
 
 		if strct.Field(i).Embedded() {
-			if !useEmbedded {
+			if !params.embedded {
 				continue
 			}
 
-			embeddedFields, err := parseFields(strct.Field(i).Type(), useTag, useEmbedded, excluded, format, depth)
+			embeddedFields, err := parseFields(strct.Field(i).Type(), params, depth)
 			if err != nil {
 				return nil, err
 			}
 
 			fields = append(fields, embeddedFields...)
 		} else {
 			alias := strct.Field(i).Name()
-			if useTag != "" {
+			format := params.format
+
+			if params.tag != "" {
 				tags, err := structtag.Parse(strct.Tag(i))
 				if err != nil {
 					return nil, err
 				}
 
-				found := false
+				var matchedTag *structtag.Tag
 				for _, t := range tags.Tags() {
-					if t.Key == useTag {
-						alias = t.Name
-						found = true
+					if t.Key == params.tag {
+						matchedTag = t
 
 						break
 					}
 				}
 
-				if !found {
-					return nil, fmt.Errorf("tag %s not found for field %s", useTag, strct.Field(i).Name())
+				if matchedTag != nil {
+					if params.tagRegex == "" {
+						alias = matchedTag.Name
+						format = params.tagFormat
+					} else {
+						regex, err := regexp.Compile(params.tagRegex)
+						if err != nil {
+							return nil, err
+						}
+
+						matches := regex.FindStringSubmatch(matchedTag.Value())
+						if len(matches) < 2 {
+							if params.tagStrict {
+								return nil, fmt.Errorf(
+									"tag %s of field %s does not match regex %s",
+									matchedTag.Value(),
+									strct.Field(i).Name(),
+									params.tagRegex,
+								)
+							}
+						} else {
+							format = params.tagFormat
+							alias = matches[1]
+						}
+					}
+				} else {
+					if params.tagStrict {
+						return nil, fmt.Errorf("tag %s not found for field %s", params.tag, strct.Field(i).Name())
+					}
 				}
 			}
 
@@ -110,7 +142,7 @@ func parseFields(
 			case formatPascalCase:
 				alias = strcase.ToCamel(alias)
 			default:
-				return nil, fmt.Errorf("invalid format %s", format)
+				return nil, fmt.Errorf("invalid format %s", params.format)
 			}
 
 			fields = append(fields, field{