add calculate and merge coverage files

internal/analyzer/coverage/coverage.go

@@ -0,0 +1,94 @@
+package coverage
+
+import (
+	"context"
+	"fmt"
+	"git.unistack.org/unistack-org/pkgdash/internal/models"
+	"golang.org/x/tools/cover"
+	"io"
+	"strings"
+)
+
+func Analyze(ctx context.Context, dataCoverage io.Reader, pack models.Package) (float64, error) {
+	calculcate, err := calculateFiles(dataCoverage)
+	if err != nil {
+		return 0, err
+	}
+
+	mapCover := make(map[string]float64)
+	{
+		tree, err := GetTreeFromGit(ctx, pack.URL)
+		if err != nil {
+			return 0, err
+		}
+		list, err := tree.GoFileList("")
+		if err != nil {
+			return 0, err
+		}
+
+		for _, f := range list {
+			mapCover[f] = 0.0
+		}
+	}
+
+	cur := len(mapCover)
+
+	for _, d := range calculcate.Files {
+		file := strings.TrimPrefix(d.Name, pack.Name+"/")
+		mapCover[file] = d.Coverage
+	}
+
+	// check)
+	if len(mapCover) != cur {
+		fmt.Printf("add new keys, was: %d, has: %d", cur, len(mapCover))
+	}
+
+	//TODO add calculate full
+
+	return 0, nil
+}
+
+type Data struct {
+	Files []*calculateFile
+	Set   bool
+}
+
+type calculateFile struct {
+	Name     string
+	Coverage float64
+}
+
+func calculateFiles(coverSrc io.Reader) (d *Data, err error) {
+	profiles, err := cover.ParseProfilesFromReader(coverSrc)
+	if err != nil {
+		return nil, err
+	}
+
+	d = new(Data)
+	for _, profile := range profiles {
+		fn := profile.FileName
+		if profile.Mode == "set" {
+			d.Set = true
+		}
+
+		d.Files = append(d.Files, &calculateFile{
+			Name:     fn,
+			Coverage: percentCovered(profile),
+		})
+	}
+	return d, err
+}
+
+func percentCovered(p *cover.Profile) float64 {
+	var total, covered int64
+	for _, b := range p.Blocks {
+		total += int64(b.NumStmt)
+		if b.Count > 0 {
+			covered += int64(b.NumStmt)
+		}
+	}
+	if total == 0 {
+		return 0
+	}
+	return float64(covered) / float64(total) * 100
+}

internal/analyzer/coverage/coverage_test.go

@@ -0,0 +1,36 @@
+package coverage
+
+import (
+	"context"
+	"git.unistack.org/unistack-org/pkgdash/internal/models"
+	"github.com/stretchr/testify/assert"
+	"os"
+	"testing"
+)
+
+func Test_Calculate(t *testing.T) {
+	file, err := os.Open("cover_test.out")
+	assert.Nil(t, err)
+	defer func() {
+		assert.Nil(t, file.Close())
+	}()
+
+	dataFiles, err := calculateFiles(file)
+	assert.Nil(t, err)
+	assert.NotNil(t, dataFiles)
+}
+
+func Test_Analyze(t *testing.T) {
+	file, err := os.Open("cover_test.out")
+	assert.Nil(t, err)
+	defer func() {
+		assert.Nil(t, file.Close())
+	}()
+
+	analyze, err := Analyze(context.Background(), file, models.Package{
+		Name: "go.unistack.org/micro/v4",
+		URL:  "https://git.unistack.org/unistack-org/micro.git",
+	})
+	assert.Nil(t, err)
+	assert.Equal(t, analyze, 0.0)
+}

internal/analyzer/coverage/git.go

@@ -0,0 +1,70 @@
+package coverage
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing/filemode"
+	"github.com/go-git/go-git/v5/plumbing/object"
+	"github.com/go-git/go-git/v5/storage/memory"
+	"os"
+	"regexp"
+	"strings"
+)
+
+var (
+	fileNil = errors.New("file pointer is nil")
+)
+
+func GetTreeFromGit(ctx context.Context, url string) (*Tree, error) {
+	cloneOpts := &git.CloneOptions{
+		URL:      url,
+		Progress: os.Stdout,
+	}
+
+	repo, err := git.CloneContext(ctx, memory.NewStorage(), nil, cloneOpts)
+	if err != nil {
+		return nil, err
+	}
+
+	ref, err := repo.Head()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get head: %v", err)
+	}
+
+	commit, err := repo.CommitObject(ref.Hash())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get commit: %v", err)
+	}
+
+	tree, err := commit.Tree()
+
+	return &Tree{tree}, err
+}
+
+type Tree struct {
+	*object.Tree
+}
+
+func (t Tree) GoFileList(pattern string) ([]string, error) {
+	matcher, err := regexp.Compile(pattern)
+	if err != nil {
+		return nil, err
+	}
+
+	var list []string
+	err = t.Files().ForEach(func(file *object.File) error {
+		if file == nil {
+			return fileNil
+		}
+		if file.Mode == filemode.Regular && strings.HasSuffix(file.Name, ".go") && !strings.HasSuffix(file.Name, "_test.go") && matcher.MatchString(file.Name) {
+			list = append(list, file.Name)
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return list, err
+}