go-generator-git

A golang library for generating files from templates, capable of obtaining the templates from one git repository and committing and pushing the result to another git repository. Can be used to scaffold application code.

See go-generator-lib for details regarding the templates and the generation process. This library just clones the git repositories to two directories, creates or checks out the necessary branches, and handles the final commit and push in the target repository. It relies on go-generator-lib to generate output files between the two directories.

Usage

Globals (not thread safe)

For easy use in one-off situations or command line tools, we have added global accessor functions.

important: these operate on a global singleton instance, and thus are not thread safe

Leaving out any error handling, this is the minimal code to perform a full clone, render, commit cycle:

parameters := map[string]string{} // assuming all parameters have defaults, otherwise specify here

aulogging.SetupNoLoggerForTesting()

generatorgit.CreateTemporaryWorkdir(context.TODO(), "../output")
defer generatorgit.Cleanup(context.TODO())

generatorgit.CloneSourceRepo(context.TODO(), "https://github.com/StephanHCB/tpl-go-rest-chi", "master")
generatorgit.CloneTargetRepo(context.TODO(), "https://github.com/StephanHCB/scratch", "feature/target", "main")
generatorgit.WriteRenderSpecFile(context.TODO(), "main", "generated-main.yaml", parameters)
generatorgit.Generate(context.TODO())
generatorgit.CommitAndPush(context.TODO(), "somebody", "somebody@mailinator.com", "initial generation", nil)

Note that CommitAndPush will only push the commit it creates in the target repo if you provide it with authentication information in the last parameter. AuthMethod has a number of implementations provided by go-git/go-git, for example a BasicAuth structure that lets you specify a username and password.

Work with an instance (thread safe)

This is the thread safe interface.

Remember that you must pick one of the go-autumn-logging choices (see below), or call SetupNoLoggerForTesting() (not recommended) before calling into this library.

import (
	"context"
	generatorgit "github.com/StephanHCB/go-generator-git"
	generatorgitapi "github.com/StephanHCB/go-generator-git/api"
)

func demoCloneRenderCommit(ctx context.Context, gen generatorgitapi.GitApi) error {
	sourceUrl := "https://github.com/StephanHCB/tpl-go-rest-chi"
	sourceBranch := "master"
	targetUrl := "https://github.com/StephanHCB/scratch"
	targetBranch := "demo"
	targetBranchFrom := "main"
	generatorName := "main"
	renderSpecFile := "generated-main.yaml"
	parameters := map[string]string{} // all parameters have defaults for this generator

	if err := gen.CloneSourceRepo(ctx, sourceUrl, sourceBranch); err != nil {
		return err
	}

	if err := gen.CloneTargetRepo(ctx, targetUrl, targetBranch, targetBranchFrom); err != nil {
		return err
	}

	if _, err := gen.WriteRenderSpecFile(ctx, generatorName, renderSpecFile, parameters); err != nil {
		// find details for individual errors in first return value
		return err
	}

	if _, err := gen.Generate(ctx); err != nil {
		// find details for individual errors and the list of files that were rendered in first return value
		return err
	}

	// if auth is nil, commit won't be pushed
	if err := gen.CommitAndPush(ctx, "John Smith", "example@mailinator.com", "commit message", nil); err != nil {
		return err
	}

	return nil
}

func demoToplevel() error {
	ctx := context.TODO() // or provided from elsewhere
	basePath := "/tmp"

	gen := generatorgit.ThreadsafeInstance()

	if err := gen.CreateTemporaryWorkdir(ctx, basePath); err != nil {
		return err
	}

	if err := demoCloneRenderCommit(ctx, gen); err != nil {
		// always call Cleanup even if an error occurred to clean up after yourself
		_ = gen.Cleanup(ctx)
		return err
	}

	return gen.Cleanup(ctx)
}

Implementation Prerequisites

Choose a Logging Framework Plugin

This library uses go-autumn-logging to allow you to plug in the logging framework of your choice. You will need to include one of the available specific wrappers among your dependencies.

The simplest one, just using golang's standard logger, is go-autumn-logging-log. We also have go-autumn-logging-zerolog.

If you do not want any logging, just call aulogging.SetupNoLoggerForTesting before calling any of the library functions. This will disable all logging, which is not really recommended:

import "github.com/StephanHCB/go-autumn-logging"

func init() {
    aulogging.SetupNoLoggerForTesting()
}

Or you can provide your own implementation of auloggingapi.LoggingImplementation and assign it to aulogging.Logger.

Acceptance Tests (give you examples)

We have BDD-style acceptance tests.

Running the tests and reading their code will give you lots of easy to understand examples, including most common error situations.

StephanHCB / go-generator-git