format-coverage.go

package cmd

import (
	"fmt"
	"io"
	"os"
	"strings"

	"github.com/Sirupsen/logrus"
	"github.com/codeclimate/test-reporter/formatters"
	"github.com/codeclimate/test-reporter/formatters/clover"
	"github.com/codeclimate/test-reporter/formatters/cobertura"
	"github.com/codeclimate/test-reporter/formatters/coveragepy"
	"github.com/codeclimate/test-reporter/formatters/dotcover"
	"github.com/codeclimate/test-reporter/formatters/excoveralls"
	"github.com/codeclimate/test-reporter/formatters/gcov"
	"github.com/codeclimate/test-reporter/formatters/gocov"
	"github.com/codeclimate/test-reporter/formatters/jacoco"
	"github.com/codeclimate/test-reporter/formatters/lcov"
	"github.com/codeclimate/test-reporter/formatters/lcovjson"
	"github.com/codeclimate/test-reporter/formatters/simplecov"
	"github.com/codeclimate/test-reporter/formatters/xccov"
	"github.com/gobuffalo/envy"
	"github.com/pkg/errors"
	"github.com/spf13/cobra"
)

type CoverageFormatter struct {
	CoveragePath string
	In           formatters.Formatter
	InputType    string
	Output       string
	Prefix       string
	AddPrefix    string
	writer       io.Writer
}

var formatOptions = CoverageFormatter{}

// a prioritized list of the formatters to use
var formatterList = []string{"clover", "cobertura", "coverage.py", "excoveralls", "gcov", "gocov", "jacoco", "lcov", "lcov-json", "simplecov", "xccov", "dotcover"}

// a map of the formatters to use
var formatterMap = map[string]formatters.Formatter{
	"clover":      &clover.Formatter{},
	"cobertura":   &cobertura.Formatter{},
	"coverage.py": &coveragepy.Formatter{},
	"excoveralls": &excoveralls.Formatter{},
	"gcov":        &gcov.Formatter{},
	"gocov":       &gocov.Formatter{},
	"jacoco":      &jacoco.Formatter{},
	"lcov":        &lcov.Formatter{},
	"lcov-json":   &lcovjson.Formatter{},
	"simplecov":   &simplecov.Formatter{},
	"xccov":       &xccov.Formatter{},
	"dotcover":    &dotcover.Formatter{},
}

// formatCoverageCmd represents the format command
var formatCoverageCmd = &cobra.Command{
	Use:   "format-coverage [coverage file]",
	Short: "Locate, parse, and re-format supported coverage sources.",
	RunE: func(cmd *cobra.Command, args []string) error {
		if len(args) != 0 {
			logrus.Debugf("coverage path %s", args[0])
			formatOptions.CoveragePath = args[0]
			if formatOptions.InputType == "" {
				return errors.WithStack(errors.Errorf("please specify the format of the coverage file \"%s\" using the --input-type flag", formatOptions.CoveragePath))
			}
		}
		return runFormatter(formatOptions)
	},
}

func runFormatter(formatOptions CoverageFormatter) error {
	envy.Set("PREFIX", formatOptions.Prefix)
	envy.Set("ADD_PREFIX", formatOptions.AddPrefix)

	// if a type is specified use that
	if formatOptions.InputType != "" {
		if f, ok := formatterMap[formatOptions.InputType]; ok {
			logrus.Debugf("using formatter %s", formatOptions.InputType)
			_, err := f.Search(formatOptions.CoveragePath)
			if err != nil {
				logrus.Errorf("could not find coverage file %s\n%s", formatOptions.CoveragePath, err)
				return errors.WithStack(err)
			}
			formatOptions.In = f
		} else {
			return errors.WithStack(errors.Errorf("could not find a formatter of type %s", formatOptions.InputType))
		}
	} else {
		logrus.Debug("searching for a formatter to use")
		// else start searching for files:
		for n, f := range formatterMap {
			logrus.Debugf("checking %s formatter", n)
			if p, err := f.Search(); err == nil {
				logrus.Debugf("found file %s for %s formatter", p, n)
				formatOptions.In = f
				break
			}
		}
	}

	if formatOptions.In == nil {
		return errors.WithStack(errors.Errorf("could not find any viable formatter. available formatters: %s", strings.Join(formatterList, ", ")))
	}

	return formatOptions.Save()
}

func (f CoverageFormatter) Save() error {
	rep, err := f.In.Format()
	if err != nil {
		return errors.WithStack(err)
	}

	if len(rep.SourceFiles) == 0 {
		return errors.WithStack(errors.New("could not find coverage info for source files"))
	}

	if f.writer == nil {
		f.writer, err = writer(formatOptions.Output)
		if err != nil {
			return errors.WithStack(err)
		}
	}

	err = rep.Save(f.writer)
	if err != nil {
		return errors.WithStack(err)
	}
	return nil
}

func init() {
	pwd, _ := os.Getwd()
	formatCoverageCmd.Flags().StringVarP(&formatOptions.Prefix, "prefix", "p", pwd, "the root directory where the coverage analysis was performed")
	formatCoverageCmd.Flags().StringVar(&formatOptions.AddPrefix, "add-prefix", "", "add this prefix to file paths")
	formatCoverageCmd.Flags().StringVarP(&formatOptions.Output, "output", "o", ccDefaultCoveragePath, "output path")
	formatCoverageCmd.Flags().StringVarP(&formatOptions.InputType, "input-type", "t", "", fmt.Sprintf("type of input source to use [%s]", strings.Join(formatterList, ", ")))
	RootCmd.AddCommand(formatCoverageCmd)
}