github.com/covergates/covergates@v0.2.2-0.20201009050117-42ef8a19fb95/service/coverage/coverage.go (about)

     1  package coverage
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"io"
     7  	"regexp"
     8  	"strings"
     9  
    10  	"github.com/covergates/covergates/core"
    11  	"github.com/covergates/covergates/service/clover"
    12  	"github.com/covergates/covergates/service/golang"
    13  	"github.com/covergates/covergates/service/lcov"
    14  	"github.com/covergates/covergates/service/perl"
    15  	"github.com/covergates/covergates/service/python"
    16  	"github.com/covergates/covergates/service/ruby"
    17  )
    18  
    19  var errReportTypeNotSupport = errors.New("Report type not support")
    20  
    21  // Service of coverage report
    22  type Service struct{}
    23  
    24  //TypeCoverageService defines a coverage service for a language
    25  type TypeCoverageService interface {
    26  	Report(ctx context.Context, data io.Reader) (*core.CoverageReport, error)
    27  	Find(ctx context.Context, path string) (string, error)
    28  	Open(ctx context.Context, path string) (io.Reader, error)
    29  }
    30  
    31  // IsReportTypeNotSupportError check
    32  func IsReportTypeNotSupportError(err error) bool {
    33  	if err == errReportTypeNotSupport {
    34  		return true
    35  	}
    36  	return false
    37  }
    38  
    39  func (s *Service) service(t core.ReportType) (TypeCoverageService, error) {
    40  	switch t {
    41  	case core.ReportPerl:
    42  		return &perl.CoverageService{}, nil
    43  	case core.ReportGo:
    44  		return &golang.CoverageService{}, nil
    45  	case core.ReportPython:
    46  		return &python.CoverageService{}, nil
    47  	case core.ReportRuby:
    48  		return &ruby.CoverageService{}, nil
    49  	case core.ReportLCOV:
    50  		return &lcov.CoverageService{}, nil
    51  	case core.ReportClover:
    52  		return &clover.CoverageService{}, nil
    53  	default:
    54  		return nil, errReportTypeNotSupport
    55  	}
    56  }
    57  
    58  // Report coverage from reader data
    59  func (s *Service) Report(ctx context.Context, t core.ReportType, r io.Reader) (*core.CoverageReport, error) {
    60  	service, err := s.service(t)
    61  	if err != nil {
    62  		return nil, err
    63  	}
    64  	return service.Report(ctx, r)
    65  }
    66  
    67  // Find coverage report data from given path
    68  func (s *Service) Find(ctx context.Context, t core.ReportType, path string) (string, error) {
    69  	service, err := s.service(t)
    70  	if err != nil {
    71  		return "", err
    72  	}
    73  	return service.Find(ctx, path)
    74  }
    75  
    76  // Open coverage report with given path
    77  func (s *Service) Open(ctx context.Context, t core.ReportType, path string) (io.Reader, error) {
    78  	service, err := s.service(t)
    79  	if err != nil {
    80  		return nil, err
    81  	}
    82  	return service.Open(ctx, path)
    83  }
    84  
    85  // TrimFileNames for all files in coverage report
    86  func (s *Service) TrimFileNames(ctx context.Context, report *core.CoverageReport, filters core.FileNameFilters) error {
    87  	regexps := toRegexps(filters)
    88  	for _, file := range report.Files {
    89  		for _, regex := range regexps {
    90  			file.Name = regex.ReplaceAllString(file.Name, "")
    91  		}
    92  		file.Name = strings.Trim(file.Name, "/")
    93  	}
    94  	return nil
    95  }
    96  
    97  // TrimFileNamePrefix for all files in coverage report
    98  func (s *Service) TrimFileNamePrefix(ctx context.Context, report *core.CoverageReport, prefixes ...string) error {
    99  	for _, file := range report.Files {
   100  		for _, prefix := range prefixes {
   101  			file.Name = strings.TrimPrefix(file.Name, prefix)
   102  		}
   103  		file.Name = strings.Trim(file.Name, "/")
   104  	}
   105  	return nil
   106  }
   107  
   108  func toRegexps(slice []string) []*regexp.Regexp {
   109  	regex := make([]*regexp.Regexp, 0, len(slice))
   110  	for _, expr := range slice {
   111  		if r, err := regexp.Compile(expr); err == nil {
   112  			regex = append(regex, r)
   113  		}
   114  	}
   115  	return regex
   116  }