github.com/yoheimuta/protolint@v0.49.8-0.20240515023657-4ecaebb7575d/internal/linter/report/reporters/ciReporter.go

package reporters

import (
	"bytes"
	"io"
	"log"
	"os"
	"strconv"
	"strings"
	"text/template"

	"github.com/yoheimuta/protolint/linter/report"
)

type CiPipelineLogTemplate string

const (
	// problemMatcher provides a generic issue line that can be parsed in a problem matcher or jenkins pipeline
	problemMatcher CiPipelineLogTemplate = "Protolint {{ .Rule }} ({{ .Severity }}): {{ .File }}[{{ .Line }},{{ .Column }}]: {{ .Message }}"
	// azureDevOps provides a log message according to https://learn.microsoft.com/en-us/azure/devops/pipelines/scripts/logging-commands?view=azure-devops&tabs=bash#task-commands
	azureDevOps CiPipelineLogTemplate = "{{ if ne \"info\" .Severity }}##vso[task.logissue type={{ .Severity }};sourcepath={{ .File }};linenumber={{ .Line }};columnnumber={{ .Column }};code={{ .Rule }};]{{ .Message }}{{end}}"
	// gitlabCiCd provides an issue template where the severity is written in upper case. This is matched by the pipeline
	gitlabCiCd CiPipelineLogTemplate = "{{ .Severity | ToUpper }}: {{ .Rule }}  {{ .File }}({{ .Line }},{{ .Column }}) : {{ .Message }}"
	// githubActions provides an issue template according to https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#setting-a-notice-message
	githubActions CiPipelineLogTemplate = "::{{ if ne \"info\" .Severity }}{{ .Severity }}{{ else }}notice{{ end }} file={{ .File }},line={{ .Line }},col={{ .Column }},title={{ .Rule }}::{{ .Message }}"
	// empty provides default value for invalid returns
	empty CiPipelineLogTemplate = ""
	// env provides a marker for processing CI Templates from environment
	env CiPipelineLogTemplate = "[ENV]"
)

type CiReporter struct {
	pattern CiPipelineLogTemplate
}

func NewCiReporterForAzureDevOps() CiReporter {
	return CiReporter{pattern: azureDevOps}
}

func NewCiReporterForGitlab() CiReporter {
	return CiReporter{pattern: gitlabCiCd}
}

func NewCiReporterForGithubActions() CiReporter {
	return CiReporter{pattern: githubActions}
}

func NewCiReporterWithGenericFormat() CiReporter {
	return CiReporter{pattern: problemMatcher}
}

func NewCiReporterFromEnv() CiReporter {
	return CiReporter{pattern: env}
}

type ciReportedFailure struct {
	Severity string
	File     string
	Line     int
	Column   int
	Rule     string
	Message  string
}

func (c CiReporter) Report(w io.Writer, fs []report.Failure) error {
	template, err := c.getTemplate()
	if err != nil {
		return err
	}

	for _, failure := range fs {
		reportedFailure := ciReportedFailure{
			Severity: getSeverity(failure.Severity()),
			File:     failure.Pos().Filename,
			Line:     failure.Pos().Line,
			Column:   failure.Pos().Column,
			Rule:     failure.RuleID(),
			Message:  strings.Trim(strconv.Quote(failure.Message()), `"`), // Ensure message is on a single line without quotes
		}

		var buffer bytes.Buffer
		err = template.Execute(&buffer, reportedFailure)
		if err != nil {
			return err
		}

		written, err := w.Write(buffer.Bytes())
		if err != nil {
			return err
		}

		if written > 0 {
			_, err = w.Write([]byte("\n"))
			if err != nil {
				return err
			}
		}
	}

	return nil
}

func getSeverity(s string) string {
	if s == "note" {
		return "info"
	}

	return s
}

func (c CiReporter) getTemplateString() CiPipelineLogTemplate {
	if c.pattern == env {
		template, err := getPatternFromEnv()
		if err != nil {
			log.Printf("[ERROR] Failed to process template from Environment: %s\n", err.Error())
			return problemMatcher
		}

		if template == empty {
			return problemMatcher
		}

		return template
	}
	if c.pattern != empty {
		return c.pattern
	}
	return problemMatcher
}

func (c CiReporter) getTemplate() (*template.Template, error) {
	toParse := c.getTemplateString()

	toUpper := template.FuncMap{"ToUpper": strings.ToUpper}

	template := template.New("Failure").Funcs(toUpper)
	evaluate, err := template.Parse(string(toParse))
	if err != nil {
		return nil, err
	}
	return evaluate, nil
}

func getPatternFromEnv() (CiPipelineLogTemplate, error) {
	templateString := os.Getenv("PROTOLINT_CIREPORTER_TEMPLATE_STRING")
	if templateString != "" {
		return CiPipelineLogTemplate(templateString), nil
	}

	templateFile := os.Getenv("PROTOLINT_CIREPORTER_TEMPLATE_FILE")
	if templateFile != "" {
		content, err := os.ReadFile(templateFile)

		if err != nil {
			if os.IsNotExist(err) {
				log.Printf("[ERROR] Failed to open file %s from 'PROTOLINT_CIREPORTER_TEMPLATE_FILE'. File does not exist.\n", templateFile)
				log.Println("[WARN] Starting output with default processor.")
				return empty, nil
			}
			if os.IsPermission(err) {
				log.Printf("[ERROR] Failed to open file %s from 'PROTOLINT_CIREPORTER_TEMPLATE_FILE'. Insufficient permissions.\n", templateFile)
				log.Println("[WARN] Starting output with default processor.")
				return empty, nil
			}

			return empty, err
		}

		content_string := string(content)

		return CiPipelineLogTemplate(content_string), nil
	}

	return empty, nil
}