update template installer from solution

Author: jryannel

Taskfile.yml

@@ -4,6 +4,14 @@ env:
   GO111MODULE: on
   CGO_ENABLED: 0
 
+vars:
+  GIT_COMMIT:
+    sh: git rev-parse --short HEAD
+  GIT_TAG:
+    sh: git describe --tags --abbrev=0 --exact-match 2>/dev/null || echo "latest"
+  BUILD_DATA:
+    sh: date -u '+%Y-%m-%dT%H:%M:%SZ'
+
 tasks:
   setup:
     desc: Setup the project
@@ -12,13 +20,13 @@ tasks:
   build:
     desc: Build the project
     cmds:
-      - go build -o ./bin/apigear ./cmd/apigear
+      - go build -o ./bin/apigear -ldflags="-X main.version={{.GIT_TAG}} -X main.commit={{.GIT_COMMIT}} -X main.date={{.BUILD_DATA}}" ./cmd/apigear ./cmd/apigear
     sources:
       - "**/*.go"
   install:
     desc: Install the project
     cmds:
-      - go install ./cmd/apigear
+      - go install -ldflags="-X main.version={{.GIT_TAG}} -X main.commit={{.GIT_COMMIT}} -X main.date={{.BUILD_DATA}}" ./cmd/apigear
   lint:
     desc: Lint the project
     cmds:

pkg/cmd/registry/info.go

@@ -13,7 +13,7 @@ func NewInfoCommand() *cobra.Command {
 		Args:  cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
 			name := args[0]
-			info, err := repos.Registry.Info(name)
+			info, err := repos.Registry.Get(name)
 			if err != nil {
 				cmd.PrintErrln(err)
 				return

pkg/cmd/registry/install.go

@@ -17,8 +17,8 @@ func NewInstallCommand() *cobra.Command {
 		Args:    cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
 			repoID := args[0]
-			cmd.Printf("installing template from %s\n", repoID)
-			err := repos.InstallTemplateFromRepoID(repoID)
+			fixedRepoId, err := repos.GetOrInstallTemplateFromRepoID(repoID)
+			cmd.Printf("using template %s\n", fixedRepoId)
 			if err != nil {
 				cmd.PrintErrln(err)
 				return

pkg/gen/generator.go

@@ -43,14 +43,22 @@ func (s *GeneratorStats) TotalFiles() int {
 }
 
 type GeneratorOptions struct {
-	OutputDir    string
+	// OutputDir is the directory where files are written
+	OutputDir string
+	// TemplatesDir is the directory where templates are located
 	TemplatesDir string
-	System       *model.System
+	// System is the root system model
+	System *model.System
+	// UserFeatures is a list of features defined by user
 	UserFeatures []string
-	UserForce    bool
-	Output       Output
-	DryRun       bool
-	Meta         map[string]any
+	// UserForce forces overwrite of existing files
+	UserForce bool
+	// Output is the output writer
+	Output OutputWriter
+	// DryRun does not write files
+	DryRun bool
+	// Meta is a map of metadata
+	Meta map[string]any
 }
 
 // generator applies template transformation on a set of files define in rules
@@ -64,7 +72,7 @@ type generator struct {
 	OutputDir        string
 	DryRun           bool
 	Stats            GeneratorStats
-	Output           Output
+	Output           OutputWriter
 	Meta             map[string]any
 }
 

pkg/gen/out.go

@@ -7,7 +7,7 @@ import (
 	"github.com/apigear-io/cli/pkg/helper"
 )
 
-type Output interface {
+type OutputWriter interface {
 	Write(input []byte, target string, force bool) error
 	Copy(source, target string, force bool) error
 	Compare(input []byte, target string) (bool, error)

pkg/git/info.go

@@ -54,6 +54,11 @@ func SortRepoInfo(infos []*RepoInfo) {
 	sort.Slice(infos, func(i, j int) bool {
 		return infos[i].Name < infos[j].Name
 	})
+	for _, info := range infos {
+		sort.Slice(info.Versions, func(i, j int) bool {
+			return info.Versions[i].Name >= info.Versions[j].Name
+		})
+	}
 }
 
 func LocalRepoInfo(source string) (*RepoInfo, error) {

pkg/log/reporter.go renamed to pkg/log/eventwriter.go

@@ -19,14 +19,14 @@ type ReportEvent struct {
 	Error     string    `json:"error,omitempty"`
 }
 
-type ReportWriter struct {
+type EventLogWriter struct {
 }
 
-func NewReportWriter() io.Writer {
-	return &ReportWriter{}
+func NewEventLogWriter() io.Writer {
+	return &EventLogWriter{}
 }
 
-func (w *ReportWriter) Write(p []byte) (n int, err error) {
+func (w *EventLogWriter) Write(p []byte) (n int, err error) {
 	if bytesEmitter != nil {
 		bytesEmitter(string(p))
 	}

pkg/log/logger.go

@@ -26,7 +26,7 @@ func init() {
 	console := zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: "15:04:05"}
 	multi := zerolog.MultiLevelWriter(
 		console,
-		NewReportWriter(),
+		NewEventLogWriter(),
 		newRollingFile(logFile),
 	)
 	logger = zerolog.New(multi).With().Timestamp().Logger().Level(level)

pkg/repos/cache.go

@@ -208,3 +208,12 @@ func (c *cache) UpgradeAll() error {
 	}
 	return c.Upgrade(names)
 }
+
+func (c *cache) GetTemplateDir(repoId string) (string, error) {
+	repoId = EnsureRepoID(repoId)
+	target := helper.Join(c.cacheDir, repoId)
+	if !helper.IsDir(target) {
+		return "", fmt.Errorf("template %s not found", repoId)
+	}
+	return target, nil
+}

pkg/repos/install.go

@@ -1,34 +1,26 @@
 package repos
 
-import (
-	"fmt"
-)
-
 // InstallTemplateFromFQN tries to install a template
 // from a fully qualified name (e.g. name@version)
-func InstallTemplateFromRepoID(repoID string) error {
-	version := VersionFromRepoID(repoID)
-	info, err := Registry.Get(repoID)
+func GetOrInstallTemplateFromRepoID(repoID string) (string, error) {
+	fixedRepoId, err := Registry.FixRepoId(repoID)
 	if err != nil {
-		return err
+		return "", err
 	}
-	if version == "latest" {
-		version = info.Latest.Name
-		if version == "" {
-			return fmt.Errorf("no version found for template: %s", repoID)
-		}
-		repoID = MakeRepoID(info.Name, version)
-		log.Info().Msgf("use latest version %s ", repoID)
+	if Cache.Exists(fixedRepoId) {
+		log.Info().Msgf("template %s already installed", fixedRepoId)
+		return fixedRepoId, nil
 	}
-	if Cache.Exists(repoID) {
-		log.Info().Msgf("template %s already installed", repoID)
-		return nil
+	info, err := Registry.Get(fixedRepoId)
+	if err != nil {
+		return "", err
 	}
 	url := info.Git
-	log.Info().Msgf("installing template %s@%s from %s", repoID, version, url)
+	log.Info().Msgf("installing template %s from %s", fixedRepoId, url)
+	version := VersionFromRepoID(fixedRepoId)
 	_, err = Cache.Install(url, version)
 	if err != nil {
-		return err
+		return "", err
 	}
-	return nil
+	return fixedRepoId, nil
 }

pkg/repos/registry.go

@@ -85,21 +85,6 @@ func (r *registry) List() ([]*git.RepoInfo, error) {
 	return r.Registry.Entries, nil
 }
 
-// Info returns the template info
-func (r *registry) Info(repoID string) (*git.RepoInfo, error) {
-	repoID = NameFromRepoID(repoID)
-	err := r.ensureRegistry()
-	if err != nil {
-		return nil, err
-	}
-	for _, info := range r.Registry.Entries {
-		if info.Name == repoID {
-			return info, nil
-		}
-	}
-	return nil, fmt.Errorf("template not found: %s", repoID)
-}
-
 // Search searches for templates in the registry
 func (c *registry) Search(pattern string) ([]*git.RepoInfo, error) {
 	err := c.ensureRegistry()
@@ -177,3 +162,15 @@ func (r *registry) Reset() error {
 	}
 	return git.CloneOrPull(r.RegistryURL, r.RegistryDir)
 }
+
+func (r *registry) FixRepoId(repoID string) (string, error) {
+	version := VersionFromRepoID(repoID)
+	if !IsRepoID(repoID) || version == "latest" {
+		info, err := r.Get(repoID)
+		if err != nil {
+			return "", err
+		}
+		repoID = MakeRepoID(info.Name, info.Latest.Name)
+	}
+	return repoID, nil
+}

pkg/sol/runner.go

@@ -133,18 +133,35 @@ func runSolution(doc *spec.SolutionDoc) error {
 		if name == "" {
 			name = helper.BaseName(outDir)
 		}
-		err := repos.InstallTemplateFromRepoID(layer.Template)
-		if err != nil {
-			log.Info().Err(err).Msgf("not a registry template %s. Try local template", layer.Template)
+		// check for local template
+		tplDir := helper.Join(rootDir, layer.Template)
+		if helper.IsDir(tplDir) {
+			log.Info().Msgf("using local template %s", tplDir)
+		} else {
+			log.Info().Msgf("try to detect registered template %s", layer.Template)
+			repoId, err := repos.GetOrInstallTemplateFromRepoID(layer.Template)
+			if err != nil {
+				return err
+			}
+			tplDir, err = repos.Cache.GetTemplateDir(repoId)
+			if err != nil {
+				return fmt.Errorf("can't find template %s", layer.Template)
+			}
+			// update template id based on the resolved repo id
+			layer.Template = repoId
+			log.Info().Msgf("using registered template %s", tplDir)
 		}
-		tplDir := layer.GetTemplatesDir(rootDir)
 		if tplDir == "" {
-			return fmt.Errorf("template dir does not exist")
+			// we don't have a template
+			return fmt.Errorf("template is neither local nor registry template: %s", layer.Template)
 		}
-		rulesFile := layer.GetRulesFile(rootDir)
-		if rulesFile == "" {
-			return fmt.Errorf("no rules document or document is empty")
+		log.Info().Msgf("using template dir %s", tplDir)
+		rulesFile := helper.Join(tplDir, "rules.yaml")
+		if !helper.IsFile(rulesFile) {
+			return fmt.Errorf("rules document not found: %s", rulesFile)
 		}
+		log.Debug().Msgf("using rules document %s", rulesFile)
+		layer.UpdateTemplateDependencies(tplDir, rulesFile)
 		err = checkInputs(layer.ComputeExpandedInputs(rootDir))
 		if err != nil {
 			return err
@@ -160,7 +177,7 @@ func runSolution(doc *spec.SolutionDoc) error {
 		}
 		opts := gen.GeneratorOptions{
 			OutputDir:    outDir,
-			TemplatesDir: tplDir,
+			TemplatesDir: helper.Join(tplDir, "templates"),
 			System:       system,
 			UserFeatures: layer.Features,
 			UserForce:    layer.Force,

pkg/spec/sollayer.go

@@ -3,7 +3,6 @@ package spec
 import (
 	"fmt"
 
-	"github.com/apigear-io/cli/pkg/cfg"
 	"github.com/apigear-io/cli/pkg/helper"
 )
 
@@ -17,20 +16,8 @@ type SolutionLayer struct {
 	Force          bool     `json:"force" yaml:"force"`
 	expandedInputs []string `json:"-"` // expanded inputs
 	dependencies   []string `json:"-"` // dependencies of the layer
-}
-
-// ResolveTemplateDir resolves the template dir.
-// The template dir can be a relative path to the root dir of the solution.
-// If the template dir is not a relative path, it is considered as a template name.
-// The template name is used to find the template dir in the template cache dir.
-func (l *SolutionLayer) ResolveTemplateDir(rootDir string) string {
-	if helper.IsDir(helper.Join(rootDir, l.Template)) {
-		return helper.Join(rootDir, l.Template)
-	}
-	if helper.IsDir(helper.Join(cfg.CacheDir(), l.Template)) {
-		return helper.Join(cfg.CacheDir(), l.Template)
-	}
-	return ""
+	templateDir    string   `json:"-"` // template dir
+	rulesFile      string   `json:"-"` // rules file
 }
 
 // GetOutputDir returns the output dir.
@@ -39,26 +26,6 @@ func (l *SolutionLayer) GetOutputDir(rootDir string) string {
 	return helper.Join(rootDir, l.Output)
 }
 
-// GetTemplatesDir returns the templates dir.
-// The templates dir is a sub directory of the template dir.
-func (l *SolutionLayer) GetTemplatesDir(rootDir string) string {
-	tDir := l.ResolveTemplateDir(rootDir)
-	if tDir == "" {
-		return ""
-	}
-	return helper.Join(tDir, "templates")
-}
-
-// GetRulesFile returns the rules file.
-// The rules file is a file in the template dir.
-func (l *SolutionLayer) GetRulesFile(rootDir string) string {
-	tDir := l.ResolveTemplateDir(rootDir)
-	if tDir == "" {
-		return ""
-	}
-	return helper.Join(tDir, "rules.yaml")
-}
-
 func (l *SolutionLayer) Validate() error {
 	if l.Output == "" {
 		return fmt.Errorf("layer output is required")
@@ -76,25 +43,31 @@ func (l *SolutionLayer) Validate() error {
 	return nil
 }
 
+// ComputeDependencies computes the dependencies of a layer.
+// The dependencies are used for file system watchers.
+// The dependencies of a layer are the rules file, the templates dir and the expanded inputs.
+// The rules file is a file in the template dir.
+// The templates dir is a sub directory of the template dir.
+// The expanded inputs are the inputs with the variables expanded.
 func (l *SolutionLayer) ComputeDependencies(rootDir string) []string {
 	if l.dependencies == nil {
 		l.dependencies = make([]string, 0)
 	}
 	if len(l.dependencies) == 0 {
-		rulesFile := l.GetRulesFile(rootDir)
-		if rulesFile != "" {
-			l.dependencies = append(l.dependencies, rulesFile)
+		if l.templateDir != "" {
+			l.dependencies = append(l.dependencies, l.templateDir)
 		}
-		tplsDir := l.GetTemplatesDir(rootDir)
-		if tplsDir != "" {
-			l.dependencies = append(l.dependencies, tplsDir)
+		if l.rulesFile != "" {
+			l.dependencies = append(l.dependencies, l.rulesFile)
 		}
 		inputs := l.ComputeExpandedInputs(rootDir)
 		l.dependencies = append(l.dependencies, inputs...)
 	}
 	return l.dependencies
 }
 
+// ComputeExpandedInputs computes the expanded inputs of a layer.
+// The expanded inputs are the inputs with the variables expanded.
 func (l *SolutionLayer) ComputeExpandedInputs(rootDir string) []string {
 	if l.expandedInputs == nil {
 		l.expandedInputs = make([]string, 0)
@@ -115,3 +88,9 @@ func (l *SolutionLayer) Compute(rootDir string) error {
 	l.ComputeExpandedInputs(rootDir)
 	return nil
 }
+
+// UpdateTemplateDependencies updates the template dir and rules file of a layer.
+func (l *SolutionLayer) UpdateTemplateDependencies(templateDir, rulesFile string) {
+	l.templateDir = templateDir
+	l.rulesFile = rulesFile
+}