This is an automated email from the ASF dual-hosted git repository. warren pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/incubator-devlake.git
commit 2b15cefc6b94212cf8ea3337eb1b467a2a1b0286 Author: Nddtfjiang <[email protected]> AuthorDate: Wed Jun 8 13:52:04 2022 +0000 feat: add order type semver Add tagOrder rule semver Add tagOrder rule reverse semver CaculateTagPattern now only run once in PrepareTaskData. Nddtfjiang <[email protected]> --- plugins/refdiff/README.md | 4 +- plugins/refdiff/refdiff.go | 10 +++ .../refdiff/tasks/ref_commit_diff_calculator.go | 14 +--- plugins/refdiff/tasks/ref_issue_diff_calculator.go | 14 +--- plugins/refdiff/tasks/refdiff_task_data.go | 77 ++++++++++++++++++---- 5 files changed, 84 insertions(+), 35 deletions(-) diff --git a/plugins/refdiff/README.md b/plugins/refdiff/README.md index 3c065aea..1db6a4d2 100644 --- a/plugins/refdiff/README.md +++ b/plugins/refdiff/README.md @@ -85,7 +85,7 @@ and if you want to perform certain subtasks. ] ``` Or you can use tagsPattern to match the tags you want -And you can use tagOrder (support `alphabetically` and `reverse alphabetically`) to set the order rule with tagLimit to limit the count of matching. +And you can use tagOrder (support `alphabetically`,`reverse alphabetically`,`semver`,`reverse semver`) to set the order rule with tagLimit to limit the count of matching. This is support to calculateCommitsDiff and calculateIssuesDiff ```json [ @@ -100,7 +100,7 @@ This is support to calculateCommitsDiff and calculateIssuesDiff "repoId": "github:GithubRepo:384111310", "tagsPattern":".*\\.11\\..*", "tagLimit":3, - "tagOrder":"reverse alphabetically", + "tagOrder":"reverse semver", } } ] diff --git a/plugins/refdiff/refdiff.go b/plugins/refdiff/refdiff.go index c9c3b9d0..8fb502e1 100644 --- a/plugins/refdiff/refdiff.go +++ b/plugins/refdiff/refdiff.go @@ -64,6 +64,16 @@ func (plugin RefDiff) PrepareTaskData(taskCtx core.TaskContext, options map[stri return nil, err } + db := taskCtx.GetDb() + tagsPattern := op.TagsPattern + tagsLimit := op.TagsLimit + tagsOrder := op.TagsOrder + + op.TagsRefs, err = tasks.CaculateTagPattern(db, tagsPattern, tagsLimit, tagsOrder) + if err != nil { + return nil, err + } + return &tasks.RefdiffTaskData{ Options: &op, }, nil diff --git a/plugins/refdiff/tasks/ref_commit_diff_calculator.go b/plugins/refdiff/tasks/ref_commit_diff_calculator.go index 606d1462..7e2b3504 100644 --- a/plugins/refdiff/tasks/ref_commit_diff_calculator.go +++ b/plugins/refdiff/tasks/ref_commit_diff_calculator.go @@ -32,19 +32,11 @@ func CalculateCommitsPairs(taskCtx core.SubTaskContext) (RefCommitPairs, error) data := taskCtx.GetData().(*RefdiffTaskData) repoId := data.Options.RepoId pairs := data.Options.Pairs - tagsLimit := data.Options.TagsLimit + rs := data.Options.TagsRefs db := taskCtx.GetDb() - rs, err := CaculateTagPattern(taskCtx) - if err != nil { - return RefCommitPairs{}, err - } - if tagsLimit > rs.Len() { - tagsLimit = rs.Len() - } - - commitPairs := make(RefCommitPairs, 0, tagsLimit+len(pairs)) - for i := 1; i < tagsLimit; i++ { + commitPairs := make(RefCommitPairs, 0, len(rs)+len(pairs)) + for i := 1; i < len(rs); i++ { commitPairs = append(commitPairs, [4]string{rs[i-1].CommitSha, rs[i].CommitSha, rs[i-1].Name, rs[i].Name}) } diff --git a/plugins/refdiff/tasks/ref_issue_diff_calculator.go b/plugins/refdiff/tasks/ref_issue_diff_calculator.go index aed0f4e8..3f6809f5 100644 --- a/plugins/refdiff/tasks/ref_issue_diff_calculator.go +++ b/plugins/refdiff/tasks/ref_issue_diff_calculator.go @@ -31,18 +31,10 @@ func CaculatePairList(taskCtx core.SubTaskContext) (RefPairLists, error) { data := taskCtx.GetData().(*RefdiffTaskData) repoId := data.Options.RepoId pairs := data.Options.Pairs - tagsLimit := data.Options.TagsLimit + rs := data.Options.TagsRefs - rs, err := CaculateTagPattern(taskCtx) - if err != nil { - return RefPairLists{}, err - } - if tagsLimit > rs.Len() { - tagsLimit = rs.Len() - } - - pairList := make(RefPairLists, 0, tagsLimit+len(pairs)) - for i := 1; i < tagsLimit; i++ { + pairList := make(RefPairLists, 0, len(rs)+len(pairs)) + for i := 1; i < len(rs); i++ { pairList = append(pairList, RefPairList{fmt.Sprintf("%s:%s", repoId, rs[i-1].Id), fmt.Sprintf("%s:%s", repoId, rs[i].Id)}) } diff --git a/plugins/refdiff/tasks/refdiff_task_data.go b/plugins/refdiff/tasks/refdiff_task_data.go index ad36b2c1..37781308 100644 --- a/plugins/refdiff/tasks/refdiff_task_data.go +++ b/plugins/refdiff/tasks/refdiff_task_data.go @@ -21,10 +21,11 @@ import ( "fmt" "regexp" "sort" + "strings" "time" "github.com/apache/incubator-devlake/models/domainlayer/code" - "github.com/apache/incubator-devlake/plugins/core" + "gorm.io/gorm" ) type RefdiffOptions struct { @@ -32,9 +33,10 @@ type RefdiffOptions struct { Tasks []string `json:"tasks,omitempty"` Pairs []RefPair - TagsPattern string // The Pattern to match from all tags - TagsLimit int // How many tags be matched should be used. - TagsOrder string // The Rule to Order the tag list + TagsPattern string // The Pattern to match from all tags + TagsLimit int // How many tags be matched should be used. + TagsOrder string // The Rule to Order the tag list + TagsRefs []code.Ref // Caculate out by TagsPattern TagsLimit TagsOrder from db } type RefdiffTaskData struct { @@ -54,6 +56,8 @@ type RefPairLists []RefPairList type Refs []code.Ref type RefsAlphabetically Refs type RefsReverseAlphabetically Refs +type RefsSemver Refs +type RefsReverseSemver Refs func (rs Refs) Len() int { return len(rs) @@ -83,16 +87,58 @@ func (rs RefsReverseAlphabetically) Swap(i, j int) { rs[i], rs[j] = rs[j], rs[i] } +func (rs RefsSemver) Len() int { + return len(rs) +} + +func (rs RefsSemver) Less(i, j int) bool { + parti := strings.Split(rs[i].Name, ".") + partj := strings.Split(rs[j].Name, ".") + + for k := 0; k < len(partj); k++ { + if k >= len(parti) { + return true + } + + if len(parti[k]) < len(partj[k]) { + return true + } + if len(parti[k]) > len(partj[k]) { + return false + } + + if parti[k] < partj[k] { + return true + } + if parti[k] > partj[k] { + return false + } + } + return false +} + +func (rs RefsSemver) Swap(i, j int) { + rs[i], rs[j] = rs[j], rs[i] +} + +func (rs RefsReverseSemver) Len() int { + return len(rs) +} + +func (rs RefsReverseSemver) Less(i, j int) bool { + return RefsSemver(rs).Less(j, i) +} + +func (rs RefsReverseSemver) Swap(i, j int) { + rs[i], rs[j] = rs[j], rs[i] +} + // Calculate the TagPattern order by tagsOrder and return the Refs -func CaculateTagPattern(taskCtx core.SubTaskContext) (Refs, error) { +func CaculateTagPattern(db *gorm.DB, tagsPattern string, tagsLimit int, tagsOrder string) (Refs, error) { rs := Refs{} - data := taskCtx.GetData().(*RefdiffTaskData) - tagsPattern := data.Options.TagsPattern - tagsOrder := data.Options.TagsOrder - db := taskCtx.GetDb() // caculate Pattern part - if data.Options.TagsPattern == "" || data.Options.TagsLimit <= 1 { + if tagsPattern == "" || tagsLimit <= 1 { return rs, nil } rows, err := db.Model(&code.Ref{}).Order("created_date desc").Rows() @@ -111,7 +157,7 @@ func CaculateTagPattern(taskCtx core.SubTaskContext) (Refs, error) { return rs, err } - if ok := r.Match([]byte(ref.Id)); ok { + if ok := r.Match([]byte(ref.Name)); ok { rs = append(rs, ref) } } @@ -120,8 +166,17 @@ func CaculateTagPattern(taskCtx core.SubTaskContext) (Refs, error) { sort.Sort(RefsAlphabetically(rs)) case "reverse alphabetically": sort.Sort(RefsReverseAlphabetically(rs)) + case "semver": + sort.Sort(RefsSemver(rs)) + case "reverse semver": + sort.Sort(RefsReverseSemver(rs)) default: break } + + if tagsLimit < rs.Len() { + rs = rs[:tagsLimit] + } + return rs, nil }
