go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/cmd/copyright/main.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 main

import (
	"bufio"
	"errors"
	"fmt"
	"os"
	"strings"
	"time"

	"github.com/urfave/cli/v2"
	"go.charczuk.com/sdk/copyright"
)

func main() {
	app := &cli.App{
		Name: "copyright",
		UsageText: `code copyright management cli

> copyright [inject|verify|remove] [ROOT(s)...]

Verify, inject or remove copyright notices from files in a given tree roots.

By default without other flags provided, this tool verifies that copyright notices are present.

To verify headers:

> copyright
- OR -
> copyright verify
- OR -
> copyright verify ./critical
- OR -
> copyright verify ./critical/foo.py

To inject headers:

> copyright inject
- OR -
> copyright inject ./critical/foo.py

- NOTE: you can run "--inject" multiple times; it will only add the header if it is not present.
- NOTE: Headers are treated exactly; do not edit the headers once they've been injected 
			  otherwise the next 'inject' pass will duplicate the headers.

To remove headers:

> copyright remove

If you have an old version of the header in your files, and you want to migrate to an updated version:

1. Save the existing header to a file, "notice.txt", including any newlines between the notice and code
2. Remove existing notices:
	> copyright remove --ext=py=notice.txt
3. Then inject the new notice:
	> copyright inject --use-include-defaults=false --include="*.py"
4. You should now have the new notice in your files, and "copyright inject" will honor it`,

		Flags: persistentFlags,
		Commands: []*cli.Command{
			verify,
			inject,
			remove,
		},
	}

	if err := app.Run(os.Args); err != nil {
		if !errors.Is(err, copyright.ErrFailure) {
			fmt.Fprintf(os.Stderr, "%+v\n", err)
		}
		os.Exit(1)
	}
}

var persistentFlags = []cli.Flag{
	&cli.BoolFlag{Name: "quiet", Usage: "If all output should be suppressed"},
	&cli.BoolFlag{Name: "verbose", Usage: "If verbose output should be shown"},
	&cli.BoolFlag{Name: "debug", Usage: "If debug output should be shown"},

	&cli.StringFlag{Name: "notice-path", Usage: "The {{ .Notice }} template value read from a given path"},
	&cli.StringFlag{Name: "notice", Value: copyright.DefaultNoticeTemplate, Usage: "The notice template value as a literal string"},

	&cli.StringFlag{Name: "restrictions-path", Usage: "The {{ .Restrictions }} template variable value read from a given path"},
	&cli.StringFlag{Name: "restrictions", Value: "open-source", Usage: "The {{ .Restrictions }} template variable value as a literal (use `internal` for the default internal template, and `open-source` for the default open source template)"},

	&cli.StringFlag{Name: "holder", Value: copyright.DefaultCopyrightHolder, Usage: "The {{ .CopyrightHolder }} template variable value, or the entity that holds the copyright"},
	&cli.IntFlag{Name: "year", Value: time.Now().UTC().Year(), Usage: "The {{ .Year }} template variable value"},
	&cli.StringFlag{Name: "license", Value: copyright.DefaultOpenSourceLicense, Usage: "The {{ .License }} template variable value, or the license type"},

	&cli.StringSliceFlag{Name: "ext", Usage: "Injection template paths for extensions; should be in the form -ext=js=js_template.txt, you can provide be multiple"},

	&cli.BoolFlag{Name: "use-exclude-defaults", Value: true, Usage: "If we should consider the default exclude glob list"},
	&cli.StringSliceFlag{Name: "exclude", Usage: "Path globs to exclude from processing"},
	&cli.StringFlag{Name: "excludes-path", Usage: "Path globs to exclude from processing read from a given path"},
	&cli.BoolFlag{Name: "use-include-defaults", Value: true, Usage: "If we should consider the default include glob list"},
	&cli.StringSliceFlag{Name: "include", Usage: "Path globs to include in processing"},
	&cli.StringFlag{Name: "includes-path", Usage: "Path globs to include in processing read a given path"},
}

var verify = &cli.Command{
	Name:  "verify",
	Usage: "Verify that files contain proper copyright headers",
	Flags: append(persistentFlags,
		&cli.BoolFlag{Name: "show-diff", Usage: "If we should show the difference between the template and the header found in files"},
		&cli.BoolFlag{Name: "exit-first", Usage: "If we should exit after the first failure"},
	),
	Action: wrapCommand(func(ctx *cli.Context, engine *copyright.Copyright, roots ...string) (err error) {
		engine.ShowDiff = ctx.Bool("show-diff")
		engine.ExitFirst = ctx.Bool("exit-first")
		for _, root := range roots {
			if err = engine.Verify(ctx.Context, root); err != nil {
				return
			}
		}
		return
	}),
}

var inject = &cli.Command{
	Name:  "inject",
	Usage: "Inject copyright headers into files",
	Flags: append(persistentFlags,
		&cli.BoolFlag{Name: "dry-run", Usage: "If we should print the actions taken but not modify files"},
	),
	Action: wrapCommand(func(ctx *cli.Context, engine *copyright.Copyright, roots ...string) (err error) {
		engine.DryRun = ctx.Bool("dry-run")
		for _, root := range roots {
			if err = engine.Inject(ctx.Context, root); err != nil {
				return
			}
		}
		return
	}),
}
var remove = &cli.Command{
	Name:  "remove",
	Usage: "Remove copyright headers from files",
	Flags: append(persistentFlags,
		&cli.BoolFlag{Name: "dry-run", Value: false, Usage: "If we should print the actions taken but not modify files"},
	),
	Action: wrapCommand(func(ctx *cli.Context, engine *copyright.Copyright, roots ...string) (err error) {
		engine.DryRun = ctx.Bool("dry-run")
		for _, root := range roots {
			if err = engine.Remove(ctx.Context, root); err != nil {
				return
			}
		}
		return
	}),
}

func wrapCommand(commandAction func(*cli.Context, *copyright.Copyright, ...string) error) func(*cli.Context) error {
	return func(ctx *cli.Context) error {
		flagNoticeTemplate := strings.TrimSpace(readPathOrLiteral(ctx.String("notice-path"), ctx.String("notice")))
		if flagNoticeTemplate == "" {
			return fmt.Errorf("--notice provided is an empty string; cannot continue")
		}

		var roots []string
		if args := ctx.Args().Slice(); len(args) > 0 {
			roots = args[:]
		} else {
			roots = []string{"."}
		}

		flagExcludes := ctx.StringSlice("exclude")
		if ctx.Bool("use-exclude-defaults") {
			flagExcludes = append(flagExcludes, flagStrings(copyright.DefaultExcludes)...)
		}
		if excludesPath := ctx.String("excludes-path"); excludesPath != "" {
			excludes, err := readGlobFile(excludesPath)
			if err != nil {
				return err
			}
			flagExcludes = append(flagExcludes, excludes...)
		}

		flagIncludes := ctx.StringSlice("include")
		if ctx.Bool("use-include-defaults") {
			flagIncludes = append(flagIncludes, flagStrings(copyright.DefaultIncludes)...)
		}
		if includesPath := ctx.String("includes-path"); includesPath != "" {
			includes, err := readGlobFile(includesPath)
			if err != nil {
				return err
			}
			flagIncludes = append(flagIncludes, includes...)
		}

		var restrictions string
		var err error
		if restrictionsPath := ctx.String("restrictions-path"); restrictionsPath != "" {
			restrictions, err = tryReadFile(restrictionsPath)
			if err != nil {
				return fmt.Errorf("cannot read restrictions by path; %w", err)
			}
		} else {
			restrictions = ctx.String("restrictions")
			switch restrictions {
			case "open-source":
				restrictions = copyright.DefaultRestrictionsTemplate
			case "internal":
				restrictions = copyright.DefaultRestrictionsTemplateInternal
			default:
			}
		}

		extensionInjectionTemplates := copyright.DefaultExtensionInjectionTemplates
		for _, extValue := range ctx.StringSlice("ext") {
			ext, noticeTemplate, err := parseExtensionNoticeBodyTemplate(extValue)
			if err != nil {
				return err
			}
			extensionInjectionTemplates[ext] = noticeTemplate
		}

		engine := &copyright.Copyright{
			Config: copyright.Config{
				NoticeTemplate:              flagNoticeTemplate,
				CopyrightHolder:             ctx.String("holder"),
				RestrictionsTemplate:        restrictions,
				Year:                        ctx.Int("year"),
				License:                     ctx.String("license"),
				ExtensionInjectionTemplates: extensionInjectionTemplates,
				Excludes:                    flagExcludes,
				Includes:                    flagIncludes,
				Quiet:                       ctx.Bool("quiet"),
				Verbose:                     ctx.Bool("verbose"),
				Debug:                       ctx.Bool("debug"),
			},
		}
		return commandAction(ctx, engine, roots...)
	}
}

type flagStrings []string

func (fs flagStrings) String() string {
	return strings.Join(fs, ", ")
}

func (fs *flagStrings) Set(flagValue string) error {
	if flagValue == "" {
		return fmt.Errorf("invalid flag value; is empty")
	}
	*fs = append(*fs, flagValue)
	return nil
}

func tryReadFile(path string) (string, error) {
	contents, err := os.ReadFile(path)
	return string(contents), err
}

func readPathOrLiteral(path, literal string) string {
	if path != "" {
		contents, _ := os.ReadFile(path)
		return string(contents)
	}
	return literal
}

func readGlobFile(path string) ([]string, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	var output []string
	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		output = append(output, strings.TrimSpace(scanner.Text()))
	}
	return output, nil
}

func parseExtensionNoticeBodyTemplate(extensionNoticeBodyTemplate string) (extension copyright.Extension, noticeBodyTemplate string, err error) {
	parts := strings.SplitN(extensionNoticeBodyTemplate, "=", 2)
	if len(parts) < 2 {
		err = fmt.Errorf("invalid `-ext` value; %s", extensionNoticeBodyTemplate)
		return
	}
	extension = copyright.Extension(parts[0])
	if !strings.HasPrefix(string(extension), ".") {
		extension = "." + extension
	}
	noticeBodyTemplate = readPathOrLiteral(parts[1], parts[1])
	return
}