go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/sdk/copyright/copyright.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package copyright

import (
	"context"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"regexp"
	"strings"
	"unicode"

	"go.charczuk.com/sdk/diff"
	"go.charczuk.com/sdk/stringutil"
)

// Copyright is the main type that injects, removes and verifies copyright headers.
type Copyright struct {
	// Config holds the configuration opitons.
	Config
	// Stdout is the writer for Verbose and Debug output.
	// If it is unset, `os.Stdout` will be used.
	Stdout io.Writer
	// Stderr is the writer for Error output.
	// If it is unset, `os.Stderr` will be used.
	Stderr io.Writer
}

// Inject inserts the copyright header in any matching files that don't already
// have the copyright header.
func (c Copyright) Inject(ctx context.Context, root string) error {
	return c.Walk(ctx, c.inject, root)
}

// Remove removes the copyright header in any matching files that
// have the copyright header.
func (c Copyright) Remove(ctx context.Context, root string) error {
	return c.Walk(ctx, c.remove, root)
}

// Verify asserts that the files found during walk
// have the copyright header.
func (c Copyright) Verify(ctx context.Context, root string) error {
	if err := c.Walk(ctx, c.verify, root); err != nil {
		return err
	}
	c.Printf("copyright ok!")
	return nil
}

// Walk traverses the tree recursively from the root and applies the given action.
//
// If the root is a file, it is handled singly and then walk will return.
func (c Copyright) Walk(ctx context.Context, action Action, root string) error {
	if c.Config.CopyrightHolder == "" {
		return fmt.Errorf("copyright holder not configured; cannot continue")
	}

	noticeBody, err := c.compileNoticeTemplate(c.NoticeTemplateOrDefault())
	if err != nil {
		return err
	}

	c.Verbosef("using root: %s", root)
	c.Verbosef("using excludes: %s", strings.Join(c.Config.Excludes, ", "))
	c.Verbosef("using include files: %s", strings.Join(c.Config.Includes, ", "))
	c.Verbosef("using notice body:\n%s", noticeBody)

	// if the root is a file, just handle the file itself
	// otherwise walk the full tree
	if info, err := os.Stat(root); err != nil {
		return err
	} else if !info.IsDir() {
		c.Debugf("root is a file, processing and returning")
		return c.processFile(action, noticeBody, root, info)
	}

	var didFail bool
	err = filepath.Walk(root, func(path string, info os.FileInfo, fileErr error) error {
		if fileErr != nil {
			return fileErr
		}

		if skipErr := c.includeOrExclude(root, path, info); skipErr != nil {
			if skipErr == ErrWalkSkip {
				return nil
			}
			return skipErr
		}

		walkErr := c.processFile(action, noticeBody, path, info)
		if walkErr != nil {
			// if we don't exit on the first failure
			// check if the error is just a verification error
			// if so, mark that we've had a failure
			// and return nil so the walk continues
			if !c.Config.ExitFirst {
				// if it's a sentinel error
				// mark we've failed and return nil
				if walkErr == ErrFailure {
					didFail = true
					return nil
				}

				// this error might be an os issue / something else
				// return it
				return walkErr
			}

			// otherwise always return the error
			// this will abort the walk
			return walkErr
		}

		// no error no problem
		return nil
	})

	// if we had an error
	// return it
	if err != nil {
		return err
	}

	// if we failed at some point, ideally
	// because we're set to not exit first
	// return the sentinel error
	if didFail {
		return ErrFailure
	}
	return nil
}

// GetStdout returns standard out.
func (c Copyright) GetStdout() io.Writer {
	if c.Quiet {
		return io.Discard
	}
	if c.Stdout != nil {
		return c.Stdout
	}
	return os.Stdout
}

// GetStderr returns standard error.
func (c Copyright) GetStderr() io.Writer {
	if c.Quiet {
		return io.Discard
	}
	if c.Stderr != nil {
		return c.Stderr
	}
	return os.Stderr
}

// Printf writes to stdout.
func (c Copyright) Printf(format string, args ...interface{}) {
	fmt.Fprintf(c.GetStdout(), format+"\n", args...)
}

// Errorf writes to stderr.
func (c Copyright) Errorf(format string, args ...interface{}) {
	fmt.Fprintf(c.GetStderr(), format+"\n", args...)
}

// Verbosef writes to stdout if the `Verbose` flag is true.
func (c Copyright) Verbosef(format string, args ...interface{}) {
	if !c.Verbose {
		return
	}
	fmt.Fprintf(c.GetStdout(), format+"\n", args...)
}

// Debugf writes to stdout if the `Debug` flag is true.
func (c Copyright) Debugf(format string, args ...interface{}) {
	if !c.Debug {
		return
	}
	fmt.Fprintf(c.GetStdout(), format+"\n", args...)
}

//
// actions
//

func (c Copyright) inject(path string, info os.FileInfo, file, notice []byte) error {
	injectedContents := c.injectedContents(path, file, notice)
	if injectedContents == nil {
		return nil
	}
	if c.DryRun {
		c.Verbosef("[dry-run] skipping writing %s", path)
		return nil
	}
	return os.WriteFile(path, injectedContents, info.Mode().Perm())
}

func (c Copyright) remove(path string, info os.FileInfo, file, notice []byte) error {
	removedContents := c.removedContents(path, file, notice)
	if removedContents == nil {
		return nil
	}
	if c.DryRun {
		c.Verbosef("[dry-run] skipping writing %s", path)
		return nil
	}
	return os.WriteFile(path, removedContents, info.Mode().Perm())
}

func (c Copyright) verify(path string, _ os.FileInfo, file, notice []byte) error {
	fileExtension := Extension(filepath.Ext(path))
	var err error
	if c.hasShebang(file) {
		err = c.shebangVerifyNotice(path, file, notice)
	} else if fileExtension == ExtensionGo { // we have to treat go files specially because of build tags
		err = c.goVerifyNotice(path, file, notice)
	} else if fileExtension == ExtensionTS {
		err = c.tsVerifyNotice(path, file, notice)
	} else {
		err = c.verifyNotice(path, file, notice)
	}

	if err != nil {
		// verify prints the file that had the issue
		// as part of the normal action
		c.Errorf("%+v", err)
		if c.Config.ShowDiff {
			c.showDiff(path, file, notice)
		}
		return ErrFailure
	}
	return nil
}

//
// internal helpers
//

// includeOrExclude makes the determination if we should process a path (file or directory).
func (c Copyright) includeOrExclude(root, path string, info os.FileInfo) error {
	if info.IsDir() {
		if path == root {
			return ErrWalkSkip
		}
	}

	if c.Config.Excludes != nil {
		for _, exclude := range c.Config.Excludes {
			if stringutil.Glob(path, exclude) {
				c.Debugf("path %s matches exclude %s", path, exclude)
				if info.IsDir() {
					return filepath.SkipDir
				}
				return ErrWalkSkip
			}
		}
	}

	if c.Config.Includes != nil {
		var includePath bool
		for _, include := range c.Config.Includes {
			if stringutil.Glob(path, include) {
				includePath = true
				break
			}
		}
		if !includePath {
			c.Debugf("path %s does not match any includes", path)
			return ErrWalkSkip
		}
	}

	if info.IsDir() {
		return ErrWalkSkip
	}

	return nil
}

// processFile processes a single file with the action
func (c Copyright) processFile(action Action, noticeBody, path string, info os.FileInfo) error {
	fileExtension := Extension(filepath.Ext(path))
	injectionTemplate, ok := c.injectionTemplateByExtension(fileExtension)
	if !ok {
		return fmt.Errorf("copyright injection template for file not found, cannot continue; %s", filepath.Base(path))
	}

	injectedNotice, err := c.compileInjectionTemplate(injectionTemplate, noticeBody)
	if err != nil {
		return err
	}
	fileContents, err := os.ReadFile(path)
	if err != nil {
		return err
	}
	return action(path, info, fileContents, []byte(injectedNotice))
}

// injectionTemplateByExtension gets a notice template by extension or the default.
func (c Copyright) injectionTemplateByExtension(fileExtension Extension) (noticeTemplate string, ok bool) {
	if !strings.HasPrefix(string(fileExtension), ".") {
		fileExtension = "." + fileExtension
	}

	// check if there is a filetype specific notice template
	extensionNoticeTemplates := c.ExtensionInjectionTemplatesOrDefault()
	if noticeTemplate, ok = extensionNoticeTemplates[fileExtension]; ok {
		return
	}
	// fail
	return
}

func (c Copyright) injectedContents(path string, file, notice []byte) []byte {
	fileExtension := Extension(filepath.Ext(path))
	if c.hasShebang(file) {
		return c.shebangInjectNotice(path, file, notice)
	}

	switch fileExtension {
	case ExtensionGo:
		return c.goInjectNotice(path, file, notice)
	case ExtensionTS:
		return c.tsInjectNotice(path, file, notice)
	default:
		return c.injectNotice(path, file, notice)
	}
}

func (Copyright) hasShebang(file []byte) bool {
	return shebangMatch.Match(file)
}

func (c Copyright) removedContents(path string, file, notice []byte) []byte {
	fileExtension := Extension(filepath.Ext(path))
	if c.hasShebang(file) {
		return c.shebangRemoveNotice(path, file, notice)
	}

	switch fileExtension {
	case ExtensionGo:
		return c.goRemoveNotice(path, file, notice)
	case ExtensionTS:
		return c.tsRemoveNotice(path, file, notice)
	default:
		return c.removeNotice(path, file, notice)
	}
}

// shebangInjectNotice explicitly handles files that start with a shebang line.
//
// This assumes these are not `*.go` source files (which would be handled separately)
// so has more in common in implementation with `injectNotice()` than with `goInjectNotice()`.
func (c Copyright) shebangInjectNotice(path string, file, notice []byte) []byte {
	// Strip shebang lines from beginning of file
	shebangLines := shebangMatch.Find(file)
	file = shebangMatch.ReplaceAll(file, nil)

	if c.fileHasCopyrightHeader(file, notice) {
		return nil
	}
	c.Verbosef("injecting notice: %s", path)

	// remove any existing notice-ish looking text ...
	file = c.removeCopyrightHeader(file, notice)
	return c.mergeFileSections(shebangLines, notice, file)
}

// goInjectNotice handles go files differently because they may contain build tags.
func (c Copyright) goInjectNotice(path string, file, notice []byte) []byte {
	goBuildTag := goBuildTagMatch.Find(file)
	file = goBuildTagMatch.ReplaceAll(file, nil)
	if c.fileHasCopyrightHeader(file, notice) {
		return nil
	}

	c.Verbosef("injecting notice: %s", path)
	file = c.removeCopyrightHeader(file, notice)
	return c.mergeFileSections(goBuildTag, notice, file)
}

// tsInjectNotice handles ts files differently because they may have pragma comments.
func (c Copyright) tsInjectNotice(path string, file, notice []byte) []byte {
	tsReferenceTags := tsReferenceTagsMatch.Find(file)
	file = tsReferenceTagsMatch.ReplaceAll(file, nil)
	if c.fileHasCopyrightHeader(file, notice) {
		return nil
	}

	c.Verbosef("injecting notice: %s", path)
	file = c.removeCopyrightHeader(file, notice)
	return c.mergeFileSections(tsReferenceTags, notice, file)
}

// injectNotice is the default notice injector.
func (c Copyright) injectNotice(path string, file, notice []byte) []byte {
	if c.fileHasCopyrightHeader(file, notice) {
		return nil
	}

	c.Verbosef("injecting notice: %s", path)
	file = c.removeCopyrightHeader(file, notice)
	return c.mergeFileSections(notice, file)
}

// shebangRemoveNotice explicitly handles files that start with a shebang line.
//
// This assumes these are not `*.go` source files so has more in common with
// `removeNotice()` than with `goRemoveNotice()`.
func (c Copyright) shebangRemoveNotice(path string, file, notice []byte) []byte {
	// Strip shebang lines from beginning of file
	shebangLines := shebangMatch.Find(file)
	file = shebangMatch.ReplaceAll(file, nil)

	if !c.fileHasCopyrightHeader(file, notice) {
		return nil
	}
	c.Verbosef("removing notice: %s", path)
	removed := c.removeCopyrightHeader(file, notice)
	return c.mergeFileSections(shebangLines, removed)
}

func (c Copyright) goRemoveNotice(path string, file, notice []byte) []byte {
	goBuildTag := goBuildTagMatch.FindString(string(file))
	file = goBuildTagMatch.ReplaceAll(file, nil)
	if !c.fileHasCopyrightHeader(file, notice) {
		return nil
	}
	c.Verbosef("removing notice: %s", path)
	return c.mergeFileSections([]byte(goBuildTag), c.removeCopyrightHeader(file, notice))
}

func (c Copyright) tsRemoveNotice(path string, file, notice []byte) []byte {
	tsImportTags := tsReferenceTagsMatch.FindString(string(file))
	file = tsReferenceTagsMatch.ReplaceAll(file, nil)
	if !c.fileHasCopyrightHeader(file, notice) {
		return nil
	}
	c.Verbosef("removing notice: %s", path)
	return c.mergeFileSections([]byte(tsImportTags), c.removeCopyrightHeader(file, notice))
}

func (c Copyright) removeNotice(path string, file, notice []byte) []byte {
	if !c.fileHasCopyrightHeader(file, notice) {
		return nil
	}
	c.Verbosef("removing notice: %s", path)
	return c.removeCopyrightHeader(file, notice)
}

// shebangVerifyNotice explicitly handles files that start with a shebang line.
// This assumes these are not `*.go` source files so has more in common with
// `verifyNotice()` than with `goVerifyNotice()`.
func (c Copyright) shebangVerifyNotice(path string, file, notice []byte) error {
	// Strip and ignore shebang lines from beginning of file
	file = shebangMatch.ReplaceAll(file, nil)

	c.Debugf("verifying (shebang): %s", path)
	if !c.fileHasCopyrightHeader(file, notice) {
		return fmt.Errorf(ErrVerifyFormat, path)
	}
	return nil
}

func (c Copyright) goVerifyNotice(path string, file, notice []byte) error {
	c.Debugf("verifying (go): %s", path)
	fileLessTags := goBuildTagMatch.ReplaceAll(file, nil)
	if !c.fileHasCopyrightHeader(fileLessTags, notice) {
		return fmt.Errorf(ErrVerifyFormat, path)
	}
	return nil
}

func (c Copyright) tsVerifyNotice(path string, file, notice []byte) error {
	c.Debugf("verifying (ts): %s", path)
	fileLessTags := tsReferenceTagsMatch.ReplaceAll(file, nil)
	if !c.fileHasCopyrightHeader(fileLessTags, notice) {
		return fmt.Errorf(ErrVerifyFormat, path)
	}
	return nil
}

func (c Copyright) verifyNotice(path string, file, notice []byte) error {
	c.Debugf("verifying: %s", path)
	if !c.fileHasCopyrightHeader(file, notice) {
		return fmt.Errorf(ErrVerifyFormat, path)
	}
	return nil
}

func (c Copyright) createNoticeMatchExpression(notice []byte, trailingSpaceStrict bool) *regexp.Regexp {
	noticeString := string(notice)
	noticeExpr := yearMatch.ReplaceAllString(regexp.QuoteMeta(noticeString), yearExpr)
	noticeExpr = `^(\s*)` + noticeExpr
	if !trailingSpaceStrict {
		// remove trailing space
		noticeExpr = strings.TrimRightFunc(noticeExpr, unicode.IsSpace)
		// match trailing space
		noticeExpr = noticeExpr + `(\s*)`
	}
	return regexp.MustCompile(noticeExpr)
}

func (c Copyright) fileHasCopyrightHeader(fileContents, notice []byte) bool {
	return c.createNoticeMatchExpression(notice, true).Match(fileContents)
}

func (c Copyright) removeCopyrightHeader(fileContents []byte, notice []byte) []byte {
	return c.createNoticeMatchExpression(notice, false).ReplaceAll(fileContents, nil)
}

func (c Copyright) mergeFileSections(sections ...[]byte) []byte {
	var fullLength int
	for _, section := range sections {
		fullLength += len(section)
	}

	combined := make([]byte, fullLength)

	var written int
	for _, section := range sections {
		copy(combined[written:], section)
		written += len(section)
	}
	return combined
}

func (c Copyright) compileInjectionTemplate(noticeTemplate, noticeBody string) (string, error) {
	return renderTemplate(noticeTemplate, c.templateViewModel(map[string]interface{}{
		"Notice": noticeBody,
	}))
}

func (c Copyright) templateViewModel(extra ...map[string]interface{}) map[string]interface{} {
	base := map[string]interface{}{
		TemplateFieldYear:            c.YearOrDefault(),
		TemplateFieldCopyrightHolder: c.CopyrightHolderOrDefault(),
		TemplateFieldLicense:         c.LicenseOrDefault(),
	}
	for _, m := range extra {
		for key, value := range m {
			base[key] = value
		}
	}
	return base
}

func (c Copyright) compileRestrictionsTemplate(restrictionsTemplate string) (string, error) {
	return renderTemplate(restrictionsTemplate, c.templateViewModel())
}

func (c Copyright) compileNoticeTemplate(noticeBodyTemplate string) (string, error) {
	restrictions, err := c.compileRestrictionsTemplate(c.RestrictionsOrDefault())
	if err != nil {
		return "", err
	}
	viewModel := c.templateViewModel(map[string]interface{}{
		"Restrictions": restrictions,
	})
	output, err := renderTemplate(noticeBodyTemplate, viewModel)
	if err != nil {
		return "", err
	}
	return output, nil
}

func (c Copyright) showDiff(path string, file, notice []byte) {
	noticeLineCount := len(stringutil.SplitLines(string(notice)))
	fileLines := stringutil.SplitLines(string(file))
	if len(fileLines) < noticeLineCount {
		noticeLineCount = len(fileLines)
	}
	fileTruncated := strings.Join(fileLines[:noticeLineCount], "")
	fileDiff := diff.New().Diff(string(notice), fileTruncated, true /*checklines*/)
	prettyDiff := diff.PrettyText(fileDiff)
	if strings.TrimSpace(prettyDiff) != "" {
		fmt.Fprintf(c.GetStderr(), "%s: diff\n", path)
		fmt.Fprintln(c.GetStderr(), prettyDiff)
	}
}