1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
package main
import (
"fmt"
"log"
"os"
"sort"
"github.com/go-git/go-billy/v5/memfs"
"github.com/go-git/go-git/v5"
"github.com/go-git/go-git/v5/plumbing"
"github.com/go-git/go-git/v5/storage/memory"
"github.com/spf13/cobra"
flags "github.com/spf13/pflag"
"github.com/Masterminds/semver/v3"
)
var (
clonedRepo = &git.Repository{}
localRepo = &git.Repository{}
repoDir string
rootCmd = &cobra.Command{
Use: "semverbump part [major|minor|patch]",
Short: "A tool for bumping semver git tags.",
ValidArgs: []string{"major", "minor", "patch"},
Args: cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
Long: `Inspired by the python bumpversion tool.`,
RunE: func(cmd *cobra.Command, args []string) error {
part := args[0]
localRepo, err := git.PlainOpen(repoDir)
if err != nil {
return err
}
remoteURL := getRemoteURL(localRepo)
fs := memfs.New()
storer := memory.NewStorage()
remoteRepo, err := git.Clone(storer, fs, &git.CloneOptions{
URL: remoteURL,
})
if err != nil {
log.Fatal(err)
}
tags := findTags(remoteRepo)
latestVersion := latestTag(tags)
if latestVersion == nil {
fmt.Println("No tags found. Not doing anything")
return nil
}
nextVersion := semver.Version{}
switch part {
case "major":
nextVersion = latestVersion.IncMajor()
case "minor":
nextVersion = latestVersion.IncMinor()
case "patch":
nextVersion = latestVersion.IncPatch()
}
fmt.Println(nextVersion)
return err
},
}
)
// TODO this only works for a single remote
func getRemoteURL(repo *git.Repository) string {
_, err := repo.Config()
if err != nil {
log.Fatal(err)
}
remotes, err := repo.Remotes()
if err != nil {
log.Fatalf("error getting remotes %s", err)
}
if len(remotes) == 0 {
return ""
}
primaryConfig := remotes[0].Config()
return primaryConfig.URLs[0]
}
func latestTag(tags []*semver.Version) *semver.Version {
numTags := len(tags)
if numTags == 0 {
return nil
}
return tags[numTags-1]
}
func findTags(repo *git.Repository) []*semver.Version {
repoTagsIter, err := repo.Tags()
if err != nil {
log.Fatal(err)
}
repoTags := []*semver.Version{}
if err := repoTagsIter.ForEach(func(ref *plumbing.Reference) error {
if err != nil {
log.Fatal(err)
}
rn := plumbing.ReferenceName(ref.Name())
version, err := semver.NewVersion(rn.Short())
if err != nil {
// not a semver
return nil
}
repoTags = append(repoTags, version)
return nil
}); err != nil {
// log.error
fmt.Printf("Iteration Error %s", err)
}
sort.Sort(semver.Collection(repoTags))
return repoTags
}
func main() {
// Clone the given repository to the given directory
//repo, err := git.PlainClone("/tmp/foo", false, &git.CloneOptions{
// URL: "https://github.com/grumps/selector",
// Progress: os.Stdout,
//})
//if err != nil {
// log.Fatal(err)
//}
if err := rootCmd.Execute(); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
func init() {
// global flags
cwd, err := os.Getwd()
if err != nil {
log.Fatalf("couldn't get cwd %s", err)
}
repoDir = *flags.String("repoDir", cwd, "repo to examine")
//pflag
}
|
