check configuration to build the build tool

EXPERIMENTAL/typicmd/prebuilder/checker.go

@@ -0,0 +1,19 @@
+package prebuilder
+
+type checker struct {
+ mockTarget bool
+ constructor bool
+ configuration bool
+ testTarget bool
+ buildToolBinary bool
+ contextChecksum bool
+}
+
+func (r *checker) checkBuildTool() bool {
+ return r.mockTarget ||
+ r.constructor ||
+ r.configuration ||
+ r.testTarget ||
+ r.buildToolBinary ||
+ r.contextChecksum
+}

EXPERIMENTAL/typicmd/prebuilder/checker_test.go

@@ -0,0 +1,24 @@
+package prebuilder
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestChecker_CheckBuildTool(t *testing.T) {
+ testcases := []struct {
+ checker checker
+ checkBuildTool bool
+ }{
+ {checker{mockTarget: true}, true},
+ {checker{constructor: true}, true},
+ {checker{configuration: true}, true},
+ {checker{testTarget: true}, true},
+ {checker{buildToolBinary: true}, true},
+ {checker{contextChecksum: true}, true},
+ }
+ for _, tt := range testcases {
+ require.Equal(t, tt.checkBuildTool, tt.checker.checkBuildTool())
+ }
+}

EXPERIMENTAL/typicmd/prebuilder/prebuilder.go

@@ -1,14 +1,12 @@
 package prebuilder
 
 import (
- "reflect"
- "strings"
+ "github.com/typical-go/typical-rest-server/EXPERIMENTAL/typiobj"
 
  "github.com/typical-go/typical-rest-server/EXPERIMENTAL/typicmd/prebuilder/golang"
 
  "github.com/typical-go/typical-rest-server/EXPERIMENTAL/slice"
 
- "github.com/iancoleman/strcase"
  log "github.com/sirupsen/logrus"
 
  "github.com/typical-go/typical-rest-server/EXPERIMENTAL/typicmd/prebuilder/walker"
@@ -19,66 +17,25 @@ import (
 type prebuilder struct {
  ProjectFiles *walker.ProjectFiles
  Dirs slice.Strings
- ConfigImports golang.Imports
  ApplicationImports golang.Imports
  ContextImport string
- // Configs  []config
+ ConfigFields  []typiobj.ConfigField
 }
 
 func (p *prebuilder) Initiate(ctx *typictx.Context) (err error) {
- var contextFile *walker.ContextFile
  var files slice.Strings
- log.Debug("Scan project to get package and filenames")
  if p.Dirs, files, err = scanProject(typienv.AppName); err != nil {
  return
  }
- log.Debug("Walk the project to get annotated or metadata")
  if p.ProjectFiles, err = walker.WalkProject(files); err != nil {
  return
  }
- log.Debug("Walk the context file")
- if contextFile, err = walker.WalkContext(ctxPath); err != nil {
- return
- }
- log.Debug("Create context import")
  p.ContextImport = ctx.Root + "/typical"
- log.Debug("Create imports for Config")
- p.ConfigImports = contextFile.Imports
- p.ConfigImports.AddImport("", "github.com/kelseyhightower/envconfig")
  log.Debug("Create imports for Application")
  for _, dir := range p.Dirs {
  p.ApplicationImports.AddImport("", ctx.Root+"/"+dir)
  }
  p.ApplicationImports.AddImport("", p.ContextImport)
+ p.ConfigFields = typictx.ConfigFields(ctx)
  return
 }
-
-func (p *prebuilder) Prebuild() (r report, err error) {
- if r.TestTargetUpdated, err = Generate("test_target", testTarget{
- ContextImport: p.ContextImport,
- Packages: p.Dirs,
- }); err != nil {
- return
- }
- if r.MockTargetUpdated, err = Generate("mock_target", mockTarget{
- ApplicationImports: p.ApplicationImports,
- MockTargets: p.ProjectFiles.Automocks(),
- }); err != nil {
- return
- }
- if r.ConstructorUpdated, err = Generate("constructor", constructor{
- ApplicationImports: p.ApplicationImports,
- Constructors: p.ProjectFiles.Autowires(),
- }); err != nil {
- return
- }
- return
-}
-
-func fmtConfigKey(s string) string {
- return strcase.ToCamel(strings.ToLower(s))
-}
-
-func fmtConfigTyp(v interface{}) string {
- return reflect.TypeOf(v).String()
-}

EXPERIMENTAL/typicmd/prebuilder/run.go

@@ -8,6 +8,7 @@ import (
  log "github.com/sirupsen/logrus"
 
  "github.com/typical-go/typical-rest-server/EXPERIMENTAL/bash"
+ "github.com/typical-go/typical-rest-server/EXPERIMENTAL/typicmd/prebuilder/metadata"
  "github.com/typical-go/typical-rest-server/EXPERIMENTAL/typictx"
  "github.com/typical-go/typical-rest-server/EXPERIMENTAL/typienv"
 )
@@ -25,9 +26,12 @@ const (
 
 // Run the prebuilder
 func Run(ctx *typictx.Context) {
- var prebuilder prebuilder
- var report report
  var err error
+ var preb prebuilder
+ checker := checker{
+ contextChecksum: contextChecksum(),
+ buildToolBinary: !filekit.IsExist(typienv.BuildTool.BinPath),
+ }
  if os.Getenv(debugEnv) != "" {
  log.SetLevel(log.DebugLevel)
  }
@@ -37,26 +41,40 @@ func Run(ctx *typictx.Context) {
  if err = typictx.GenerateEnvfile(ctx); err != nil {
  log.Fatal(err.Error())
  }
- if err := prebuilder.Initiate(ctx); err != nil {
+ if err := preb.Initiate(ctx); err != nil {
+ log.Fatal(err.Error())
+ }
+ if checker.configuration, err = metadata.Update("config_fields", preb.ConfigFields); err != nil {
  log.Fatal(err.Error())
  }
- if report, err = prebuilder.Prebuild(); err != nil {
+ if checker.testTarget, err = Generate("test_target", testTarget{
+ ContextImport: preb.ContextImport,
+ Packages: preb.Dirs,
+ }); err != nil {
  log.Fatal(err.Error())
  }
- checker := buildToolChecker{
- BinaryNotExist: !filekit.IsExist(typienv.BuildTool.BinPath),
- PrebuildUpdated: report.Updated(),
- HaveBuildArgs: haveBuildArg(),
+ if checker.mockTarget, err = Generate("mock_target", mockTarget{
+ ApplicationImports: preb.ApplicationImports,
+ MockTargets: preb.ProjectFiles.Automocks(),
+ }); err != nil {
+ log.Fatal(err.Error())
+ }
+ if checker.constructor, err = Generate("constructor", constructor{
+ ApplicationImports: preb.ApplicationImports,
+ Constructors: preb.ProjectFiles.Autowires(),
+ }); err != nil {
+ log.Fatal(err.Error())
  }
- if checker.Check() {
+ if checker.checkBuildTool() {
  log.Info("Build the build-tool")
  if err := bash.GoBuild(typienv.BuildTool.BinPath, typienv.BuildTool.SrcPath); err != nil {
  log.Fatal(err.Error())
  }
  }
 }
 
-func haveBuildArg() bool {
+func contextChecksum() bool {
+ // NOTE: context checksum is passed by typicalw
  if len(os.Args) > 1 {
  return os.Args[1] == "1"
  }

EXPERIMENTAL/typictx/config.go

@@ -0,0 +1,44 @@
+package typictx
+
+import (
+ "fmt"
+ "os"
+
+ log "github.com/sirupsen/logrus"
+ "github.com/typical-go/typical-rest-server/EXPERIMENTAL/typiobj"
+)
+
+const (
+ defaultDotEnv = ".env"
+)
+
+// ConfigFields return config list
+func ConfigFields(ctx *Context) (fields []typiobj.ConfigField) {
+ if configurer, ok := ctx.Application.(typiobj.Configurer); ok {
+ fields = append(fields, configurer.Configure().ConfigFields()...)
+ }
+ for _, module := range ctx.Modules {
+ if configurer, ok := module.(typiobj.Configurer); ok {
+ fields = append(fields, configurer.Configure().ConfigFields()...)
+ }
+ }
+ return
+}
+
+// GenerateEnvfile to generate .env file if not exist
+func GenerateEnvfile(ctx *Context) (err error) {
+ if _, err = os.Stat(defaultDotEnv); !os.IsNotExist(err) {
+ return
+ }
+ log.Infof("Generate new project environment at '%s'", defaultDotEnv)
+ var file *os.File
+ if file, err = os.Create(defaultDotEnv); err != nil {
+ return
+ }
+ defer file.Close()
+ for _, field := range ConfigFields(ctx) {
+ s := fmt.Sprintf("%s=%s\n", field.Name, field.Default)
+ file.WriteString(s)
+ }
+ return
+}

EXPERIMENTAL/typiobj/modules.go

@@ -8,16 +8,6 @@ import (
 // Modules is list of module
 type Modules slice.Interfaces
 
-// Configurations return list of config
-func (m Modules) Configurations() (cfgs []Configuration) {
- for _, module := range m {
- if configurer, ok := module.(Configurer); ok {
- cfgs = append(cfgs, configurer.Configure())
- }
- }
- return
-}
-
 // Commands return list of command
 func (m Modules) Commands() (cmds []cli.Command) {
  for _, module := range m {