diff --git a/info.go b/info.go index 24a12df..fb1e3b8 100644 --- a/info.go +++ b/info.go @@ -28,28 +28,28 @@ func PrintPluginInfo(manifest *model.Manifest) error { // printBasicInfo prints basic plugin information. func printBasicInfo(manifest *model.Manifest) { - Logger.Info("Plugin Information:") - Logger.Info("==================") + fmt.Println("Plugin Information:") + fmt.Println("==================") - Logger.Info("ID:", "value", manifest.Id) - Logger.Info("Name:", "value", manifest.Name) - Logger.Info("Version:", "value", manifest.Version) + fmt.Printf("ID: %s\n", manifest.Id) + fmt.Printf("Name: %s\n", manifest.Name) + fmt.Printf("Version: %s\n", manifest.Version) minVersion := manifest.MinServerVersion if minVersion == "" { minVersion = "Not specified" } - Logger.Info("Min MM Version:", "value", minVersion) + fmt.Printf("Min MM Version: %s\n", minVersion) if manifest.Description != "" { - Logger.Info("Description:", "value", manifest.Description) + fmt.Printf("Description: %s\n", manifest.Description) } } // printCodeComponents prints information about server and webapp code. func printCodeComponents(manifest *model.Manifest) { - Logger.Info("Code Components:") - Logger.Info("================") + fmt.Println("Code Components:") + fmt.Println("================") printServerCodeInfo(manifest) printWebappCodeInfo(manifest) @@ -58,28 +58,33 @@ func printCodeComponents(manifest *model.Manifest) { // printServerCodeInfo prints server code information. func printServerCodeInfo(manifest *model.Manifest) { if HasServerCode(manifest) { - Logger.Info("Server Code:", "value", "Yes") + fmt.Println("Server Code: Yes") if manifest.Server != nil && len(manifest.Server.Executables) > 0 { - var executables []string + fmt.Print("Executables: ") + first := true for platform := range manifest.Server.Executables { - executables = append(executables, platform) + if !first { + fmt.Print(", ") + } + fmt.Print(platform) + first = false } - Logger.Info("Executables:", "platforms", executables) + fmt.Println() } } else { - Logger.Info("Server Code:", "value", "No") + fmt.Println("Server Code: No") } } // printWebappCodeInfo prints webapp code information. func printWebappCodeInfo(manifest *model.Manifest) { if HasWebappCode(manifest) { - Logger.Info("Webapp Code:", "value", "Yes") + fmt.Println("Webapp Code: Yes") if manifest.Webapp != nil && manifest.Webapp.BundlePath != "" { - Logger.Info("Bundle Path:", "value", manifest.Webapp.BundlePath) + fmt.Printf("Bundle Path: %s\n", manifest.Webapp.BundlePath) } } else { - Logger.Info("Webapp Code:", "value", "No") + fmt.Println("Webapp Code: No") } } @@ -89,7 +94,7 @@ func printSettingsSchema(manifest *model.Manifest) { if manifest.SettingsSchema != nil { value = "Yes" } - Logger.Info("Settings Schema:", "value", value) + fmt.Printf("Settings Schema: %s\n", value) } // InfoCommandWithPath implements the 'info' command with a custom path. diff --git a/updateassets.go b/updateassets.go index 60196cd..69ff444 100644 --- a/updateassets.go +++ b/updateassets.go @@ -8,6 +8,9 @@ import ( "os" "path/filepath" "strings" + "text/template" + + "github.com/mattermost/mattermost/server/public/model" ) //go:embed assets/* @@ -45,6 +48,7 @@ func RunUpdateAssetsCommand(args []string, pluginPath string) error { hasWebapp: hasWebapp, updatedCount: &updatedCount, pluginCtlConfig: pluginCtlConfig, + manifest: manifest, } err = fs.WalkDir(assetsFS, "assets", func(path string, d fs.DirEntry, err error) error { @@ -121,6 +125,12 @@ type AssetProcessorConfig struct { hasWebapp bool updatedCount *int pluginCtlConfig *PluginCtlConfig + manifest *model.Manifest +} + +// TemplateContext holds the data available to templates. +type TemplateContext struct { + Manifest *model.Manifest } func processAssetEntry(path string, d fs.DirEntry, err error, config AssetProcessorConfig) error { @@ -151,21 +161,21 @@ func processAssetEntry(path string, d fs.DirEntry, err error, config AssetProces return createDirectory(targetPath) } - return processAssetFile(path, targetPath, relativePath, config.updatedCount) + return processAssetFile(path, targetPath, relativePath, config) } -func processAssetFile(embeddedPath, targetPath, relativePath string, updatedCount *int) error { - shouldUpdate, err := shouldUpdateFile(embeddedPath, targetPath) +func processAssetFile(embeddedPath, targetPath, relativePath string, config AssetProcessorConfig) error { + shouldUpdate, err := shouldUpdateFile(embeddedPath, targetPath, config.manifest) if err != nil { return err } if shouldUpdate { - err = updateFile(embeddedPath, targetPath, relativePath) + err = updateFile(embeddedPath, targetPath, relativePath, config.manifest) if err != nil { return err } - (*updatedCount)++ + (*config.updatedCount)++ } return nil @@ -179,10 +189,11 @@ func createDirectory(targetPath string) error { return nil } -func shouldUpdateFile(embeddedPath, targetPath string) (bool, error) { - content, err := assetsFS.ReadFile(embeddedPath) +func shouldUpdateFile(embeddedPath, targetPath string, manifest *model.Manifest) (bool, error) { + // Process the template to get the final content + processedContent, err := processTemplate(embeddedPath, manifest) if err != nil { - return false, fmt.Errorf("failed to read embedded file %s: %w", embeddedPath, err) + return false, fmt.Errorf("failed to process template %s: %w", embeddedPath, err) } existingContent, err := os.ReadFile(targetPath) @@ -191,13 +202,14 @@ func shouldUpdateFile(embeddedPath, targetPath string) (bool, error) { return true, nil //nolint:nilerr } - return !bytes.Equal(existingContent, content), nil + return !bytes.Equal(existingContent, processedContent), nil } -func updateFile(embeddedPath, targetPath, relativePath string) error { - content, err := assetsFS.ReadFile(embeddedPath) +func updateFile(embeddedPath, targetPath, relativePath string, manifest *model.Manifest) error { + // Process the template to get the final content + processedContent, err := processTemplate(embeddedPath, manifest) if err != nil { - return fmt.Errorf("failed to read embedded file %s: %w", embeddedPath, err) + return fmt.Errorf("failed to process template %s: %w", embeddedPath, err) } parentDir := filepath.Dir(targetPath) @@ -205,7 +217,7 @@ func updateFile(embeddedPath, targetPath, relativePath string) error { return fmt.Errorf("failed to create parent directory %s: %w", parentDir, err) } - if err := os.WriteFile(targetPath, content, filePermissions); err != nil { + if err := os.WriteFile(targetPath, processedContent, filePermissions); err != nil { return fmt.Errorf("failed to write file %s: %w", targetPath, err) } @@ -213,3 +225,32 @@ func updateFile(embeddedPath, targetPath, relativePath string) error { return nil } + +// processTemplate processes a template file with the manifest context. +func processTemplate(embeddedPath string, manifest *model.Manifest) ([]byte, error) { + // Read the template content + templateContent, err := assetsFS.ReadFile(embeddedPath) + if err != nil { + return nil, fmt.Errorf("failed to read embedded file %s: %w", embeddedPath, err) + } + + // Create template context + context := TemplateContext{ + Manifest: manifest, + } + + // Create and parse the template + tmpl, err := template.New(embeddedPath).Parse(string(templateContent)) + if err != nil { + return nil, fmt.Errorf("failed to parse template %s: %w", embeddedPath, err) + } + + // Execute the template + var buf bytes.Buffer + err = tmpl.Execute(&buf, context) + if err != nil { + return nil, fmt.Errorf("failed to execute template %s: %w", embeddedPath, err) + } + + return buf.Bytes(), nil +}