diff --git a/cmd/rp/cmd/run.go b/cmd/rp/cmd/run.go index de10927..55ca419 100644 --- a/cmd/rp/cmd/run.go +++ b/cmd/rp/cmd/run.go @@ -1,6 +1,7 @@ package cmd import ( + "fmt" "strings" "github.com/spf13/cobra" @@ -9,6 +10,7 @@ import ( "github.com/apricote/releaser-pleaser/internal/commitparser/conventionalcommits" "github.com/apricote/releaser-pleaser/internal/forge" "github.com/apricote/releaser-pleaser/internal/forge/github" + "github.com/apricote/releaser-pleaser/internal/forge/gitlab" "github.com/apricote/releaser-pleaser/internal/updater" "github.com/apricote/releaser-pleaser/internal/versioning" ) @@ -39,6 +41,8 @@ func init() { func run(cmd *cobra.Command, _ []string) error { ctx := cmd.Context() + var err error + logger.DebugContext(ctx, "run called", "forge", flagForge, "branch", flagBranch, @@ -53,9 +57,18 @@ func run(cmd *cobra.Command, _ []string) error { BaseBranch: flagBranch, } - switch flagForge { // nolint:gocritic // Will become a proper switch once gitlab is added - // case "gitlab": - // f = rp.NewGitLab(forgeOptions) + switch flagForge { + case "gitlab": + logger.DebugContext(ctx, "using forge GitLab") + f, err = gitlab.New(logger, &gitlab.Options{ + Options: forgeOptions, + Path: flagOwner, + Repo: flagRepo, + }) + if err != nil { + logger.ErrorContext(ctx, "failed to create client", "err", err) + return fmt.Errorf("failed to create gitlab client: %w", err) + } case "github": logger.DebugContext(ctx, "using forge GitHub") f = github.New(logger, &github.Options{ @@ -63,6 +76,8 @@ func run(cmd *cobra.Command, _ []string) error { Owner: flagOwner, Repo: flagRepo, }) + default: + return fmt.Errorf("unknown --forge: %s", flagForge) } extraFiles := parseExtraFiles(flagExtraFiles) @@ -71,7 +86,7 @@ func run(cmd *cobra.Command, _ []string) error { f, logger, flagBranch, - conventionalcommits.NewParser(), + conventionalcommits.NewParser(logger), versioning.SemVerNextVersion, extraFiles, []updater.NewUpdater{updater.Generic}, diff --git a/go.mod b/go.mod index 7e7b81f..0175391 100644 --- a/go.mod +++ b/go.mod @@ -10,6 +10,7 @@ require ( github.com/spf13/cobra v1.8.1 github.com/stretchr/testify v1.9.0 github.com/teekennedy/goldmark-markdown v0.3.0 + github.com/xanzy/go-gitlab v0.109.0 github.com/yuin/goldmark v1.7.4 ) @@ -24,7 +25,10 @@ require ( github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect github.com/go-git/go-billy/v5 v5.5.0 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/golang/protobuf v1.5.3 // indirect github.com/google/go-querystring v1.1.0 // indirect + github.com/hashicorp/go-cleanhttp v0.5.2 // indirect + github.com/hashicorp/go-retryablehttp v0.7.7 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect github.com/kevinburke/ssh_config v1.2.0 // indirect @@ -37,7 +41,11 @@ require ( github.com/xanzy/ssh-agent v0.3.3 // indirect golang.org/x/crypto v0.26.0 // indirect golang.org/x/net v0.28.0 // indirect + golang.org/x/oauth2 v0.6.0 // indirect golang.org/x/sys v0.24.0 // indirect + golang.org/x/time v0.3.0 // indirect + google.golang.org/appengine v1.6.7 // indirect + google.golang.org/protobuf v1.29.1 // indirect gopkg.in/warnings.v0 v0.1.2 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 65568ec..d2a734e 100644 --- a/go.sum +++ b/go.sum @@ -25,6 +25,8 @@ github.com/elazarl/goproxy v0.0.0-20230808193330-2592e75ae04a h1:mATvB/9r/3gvcej github.com/elazarl/goproxy v0.0.0-20230808193330-2592e75ae04a/go.mod h1:Ro8st/ElPeALwNFlcTpWmkr6IoMFfkjXAvTHpevnDsM= github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= +github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= +github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= github.com/gliderlabs/ssh v0.3.7 h1:iV3Bqi942d9huXnzEF2Mt+CY9gLu8DNM4Obd+8bODRE= github.com/gliderlabs/ssh v0.3.7/go.mod h1:zpHEXBstFnQYtGnB8k8kQLol82umzn/2/snG7alWVD8= github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI= @@ -37,13 +39,24 @@ github.com/go-git/go-git/v5 v5.12.0 h1:7Md+ndsjrzZxbddRDZjF14qK+NN56sy6wkqaVrjZt github.com/go-git/go-git/v5 v5.12.0/go.mod h1:FTM9VKtnI2m65hNI/TenDDDnUf2Q9FHnXYjuz9i5OEY= github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE= github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-github/v63 v63.0.0 h1:13xwK/wk9alSokujB9lJkuzdmQuVn2QCPeck76wR3nE= github.com/google/go-github/v63 v63.0.0/go.mod h1:IqbcrgUmIcEaioWrGYei/09o+ge5vhffGOcxrO0AfmA= github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= +github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= +github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= +github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k= +github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M= +github.com/hashicorp/go-retryablehttp v0.7.7 h1:C8hUCYzor8PIfXHa4UrZkU4VvK8o9ISHxT2Q8+VepXU= +github.com/hashicorp/go-retryablehttp v0.7.7/go.mod h1:pkQpWZeYWskR+D1tR2O5OcBFOxfA7DoAO6xtkuQnHTk= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A= @@ -59,6 +72,10 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/leodido/go-conventionalcommits v0.12.0 h1:pG01rl8Ze+mxnSSVB2wPdGASXyyU25EGwLUc0bWrmKc= github.com/leodido/go-conventionalcommits v0.12.0/go.mod h1:DW+n8pQb5w/c7Vba7iGOMS3rkbPqykVlnrDykGjlsJM= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI= github.com/onsi/gomega v1.27.10/go.mod h1:RsS8tutOdbdgzbPtzzATp12yT7kM5I5aElG3evPbQ0M= github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4= @@ -91,6 +108,8 @@ github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsT github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/teekennedy/goldmark-markdown v0.3.0 h1:ik9/biVGCwGWFg8dQ3KVm2pQ/wiiG0whYiUcz9xH0W8= github.com/teekennedy/goldmark-markdown v0.3.0/go.mod h1:kMhDz8La77A9UHvJGsxejd0QUflN9sS+QXCqnhmxmNo= +github.com/xanzy/go-gitlab v0.109.0 h1:RcRme5w8VpLXTSTTMZdVoQWY37qTJWg+gwdQl4aAttE= +github.com/xanzy/go-gitlab v0.109.0/go.mod h1:wKNKh3GkYDMOsGmnfuX+ITCmDuSDWFO0G+C4AygL9RY= github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= @@ -105,6 +124,7 @@ golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw= golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= @@ -114,6 +134,8 @@ golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE= golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg= +golang.org/x/oauth2 v0.6.0 h1:Lh8GPgSKBfWSwFvtuWOfeI3aAAnbXTSutYxJiOJFgIw= +golang.org/x/oauth2 v0.6.0/go.mod h1:ycmewcwgD4Rpr3eZJLSB4Kyyljb3qDh40vJ8STE5HKw= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -140,6 +162,7 @@ golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U= golang.org/x/term v0.23.0 h1:F6D4vR+EHoL9/sWAWgAR1H2DcHr4PareCbAaCo1RpuU= golang.org/x/term v0.23.0/go.mod h1:DgV24QBUrK6jhZXl+20l6UWznPlwAHm1Q1mGHtydmSk= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= @@ -148,12 +171,20 @@ golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc= golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= +golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4= +golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.29.1 h1:7QBf+IK2gx70Ap/hDsOmam3GE0v9HicjfEdAxE62UoM= +google.golang.org/protobuf v1.29.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= diff --git a/internal/commitparser/conventionalcommits/conventionalcommits.go b/internal/commitparser/conventionalcommits/conventionalcommits.go index 665a02d..b253354 100644 --- a/internal/commitparser/conventionalcommits/conventionalcommits.go +++ b/internal/commitparser/conventionalcommits/conventionalcommits.go @@ -2,6 +2,7 @@ package conventionalcommits import ( "fmt" + "log/slog" "github.com/leodido/go-conventionalcommits" "github.com/leodido/go-conventionalcommits/parser" @@ -12,9 +13,10 @@ import ( type Parser struct { machine conventionalcommits.Machine + logger *slog.Logger } -func NewParser() *Parser { +func NewParser(logger *slog.Logger) *Parser { parserMachine := parser.NewMachine( parser.WithBestEffort(), parser.WithTypes(conventionalcommits.TypesConventional), @@ -22,6 +24,7 @@ func NewParser() *Parser { return &Parser{ machine: parserMachine, + logger: logger, } } @@ -31,8 +34,10 @@ func (c *Parser) Analyze(commits []git.Commit) ([]commitparser.AnalyzedCommit, e for _, commit := range commits { msg, err := c.machine.Parse([]byte(commit.Message)) if err != nil { - return nil, fmt.Errorf("failed to parse message of commit %q: %w", commit.Hash, err) + c.logger.Warn("failed to parse message of commit, skipping", "commit.hash", commit.Hash, "err", err) + continue } + conventionalCommit, ok := msg.(*conventionalcommits.ConventionalCommit) if !ok { return nil, fmt.Errorf("unable to get ConventionalCommit from parser result: %T", msg) diff --git a/internal/commitparser/conventionalcommits/conventionalcommits_test.go b/internal/commitparser/conventionalcommits/conventionalcommits_test.go index 837035b..bc969de 100644 --- a/internal/commitparser/conventionalcommits/conventionalcommits_test.go +++ b/internal/commitparser/conventionalcommits/conventionalcommits_test.go @@ -1,6 +1,7 @@ package conventionalcommits import ( + "log/slog" "testing" "github.com/stretchr/testify/assert" @@ -23,14 +24,14 @@ func TestAnalyzeCommits(t *testing.T) { wantErr: assert.NoError, }, { - name: "malformed commit message", + name: "skips malformed commit message", commits: []git.Commit{ { Message: "aksdjaklsdjka", }, }, - expectedCommits: nil, - wantErr: assert.Error, + expectedCommits: []commitparser.AnalyzedCommit{}, + wantErr: assert.NoError, }, { name: "drops unreleasable", @@ -114,7 +115,7 @@ func TestAnalyzeCommits(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - analyzedCommits, err := NewParser().Analyze(tt.commits) + analyzedCommits, err := NewParser(slog.Default()).Analyze(tt.commits) if !tt.wantErr(t, err) { return } diff --git a/internal/forge/github/github.go b/internal/forge/github/github.go index d96fc9d..363c306 100644 --- a/internal/forge/github/github.go +++ b/internal/forge/github/github.go @@ -27,7 +27,6 @@ const ( EnvAPIToken = "GITHUB_TOKEN" // nolint:gosec // Not actually a hardcoded credential EnvUsername = "GITHUB_USER" EnvRepository = "GITHUB_REPOSITORY" - LabelColor = "dedede" ) var _ forge.Forge = &GitHub{} @@ -65,52 +64,44 @@ func (g *GitHub) GitAuth() transport.AuthMethod { func (g *GitHub) LatestTags(ctx context.Context) (git.Releases, error) { g.log.DebugContext(ctx, "listing all tags in github repository") - page := 1 + tags, err := all(func(listOptions github.ListOptions) ([]*github.RepositoryTag, *github.Response, error) { + return g.client.Repositories.ListTags( + ctx, g.options.Owner, g.options.Repo, + &listOptions, + ) + }) + if err != nil { + return git.Releases{}, err + } var releases git.Releases - for { - tags, resp, err := g.client.Repositories.ListTags( - ctx, g.options.Owner, g.options.Repo, - &github.ListOptions{Page: page, PerPage: PerPageMax}, - ) + for _, ghTag := range tags { + tag := &git.Tag{ + Hash: ghTag.GetCommit().GetSHA(), + Name: ghTag.GetName(), + } + + version, err := semver.Parse(strings.TrimPrefix(tag.Name, "v")) if err != nil { - return git.Releases{}, err + g.log.WarnContext( + ctx, "unable to parse tag as semver, skipping", + "tag.name", tag.Name, + "tag.hash", tag.Hash, + "error", err, + ) + continue } - for _, ghTag := range tags { - tag := &git.Tag{ - Hash: ghTag.GetCommit().GetSHA(), - Name: ghTag.GetName(), - } - - version, err := semver.Parse(strings.TrimPrefix(tag.Name, "v")) - if err != nil { - g.log.WarnContext( - ctx, "unable to parse tag as semver, skipping", - "tag.name", tag.Name, - "tag.hash", tag.Hash, - "error", err, - ) - continue - } - - if releases.Latest == nil { - releases.Latest = tag - } - if len(version.Pre) == 0 { - // Stable version tag - // We return once we have found the latest stable tag, not needed to look at every single tag. - releases.Stable = tag - break - } + if releases.Latest == nil { + releases.Latest = tag } - - if page == resp.LastPage || resp.LastPage == 0 { + if len(version.Pre) == 0 { + // Stable version tag + // We return once we have found the latest stable tag, not needed to look at every single tag. + releases.Stable = tag break } - - page = resp.NextPage } return releases, nil @@ -149,36 +140,21 @@ func (g *GitHub) CommitsSince(ctx context.Context, tag *git.Tag) ([]git.Commit, func (g *GitHub) commitsSinceTag(ctx context.Context, tag *git.Tag) ([]*github.RepositoryCommit, error) { head := g.options.BaseBranch log := g.log.With("base", tag.Hash, "head", head) - log.Debug("comparing commits", "base", tag.Hash, "head", head) + log.Debug("comparing commits") - page := 1 + repositoryCommits, err := all( + func(listOptions github.ListOptions) ([]*github.RepositoryCommit, *github.Response, error) { + comparison, resp, err := g.client.Repositories.CompareCommits( + ctx, g.options.Owner, g.options.Repo, + tag.Hash, head, &listOptions) + if err != nil { + return nil, nil, err + } - var repositoryCommits []*github.RepositoryCommit - for { - log.Debug("fetching page", "page", page) - comparison, resp, err := g.client.Repositories.CompareCommits( - ctx, g.options.Owner, g.options.Repo, - tag.Hash, head, &github.ListOptions{ - Page: page, - PerPage: PerPageMax, - }) - if err != nil { - return nil, err - } - - if repositoryCommits == nil { - // Pre-initialize slice on first request - log.Debug("found commits", "length", comparison.GetTotalCommits()) - repositoryCommits = make([]*github.RepositoryCommit, 0, comparison.GetTotalCommits()) - } - - repositoryCommits = append(repositoryCommits, comparison.Commits...) - - if page == resp.LastPage || resp.LastPage == 0 { - break - } - - page = resp.NextPage + return comparison.Commits, resp, err + }) + if err != nil { + return nil, err } return repositoryCommits, nil @@ -189,37 +165,17 @@ func (g *GitHub) commitsSinceInit(ctx context.Context) ([]*github.RepositoryComm log := g.log.With("head", head) log.Debug("listing all commits") - page := 1 - - var repositoryCommits []*github.RepositoryCommit - for { - log.Debug("fetching page", "page", page) - commits, resp, err := g.client.Repositories.ListCommits( - ctx, g.options.Owner, g.options.Repo, - &github.CommitsListOptions{ - SHA: head, - ListOptions: github.ListOptions{ - Page: page, - PerPage: PerPageMax, - }, - }) - if err != nil { - return nil, err - } - - if repositoryCommits == nil && resp.LastPage > 0 { - // Pre-initialize slice on first request - log.Debug("found commits", "pages", resp.LastPage) - repositoryCommits = make([]*github.RepositoryCommit, 0, resp.LastPage*PerPageMax) - } - - repositoryCommits = append(repositoryCommits, commits...) - - if page == resp.LastPage || resp.LastPage == 0 { - break - } - - page = resp.NextPage + repositoryCommits, err := all( + func(listOptions github.ListOptions) ([]*github.RepositoryCommit, *github.Response, error) { + return g.client.Repositories.ListCommits( + ctx, g.options.Owner, g.options.Repo, + &github.CommitsListOptions{ + SHA: head, + ListOptions: listOptions, + }) + }) + if err != nil { + return nil, err } return repositoryCommits, nil @@ -231,80 +187,55 @@ func (g *GitHub) prForCommit(ctx context.Context, commit git.Commit) (*git.PullR // Using the "List pull requests" endpoint might be faster, as it allows us to fetch 100 arbitrary PRs per request, // but worst case we need to look up all PRs made in the repository ever. - log := g.log.With("commit.hash", commit.Hash) - page := 1 - var associatedPRs []*github.PullRequest + g.log.Debug("fetching pull requests associated with commit", "commit.hash", commit.Hash) - for { - log.Debug("fetching pull requests associated with commit", "page", page) - prs, resp, err := g.client.PullRequests.ListPullRequestsWithCommit( - ctx, g.options.Owner, g.options.Repo, - commit.Hash, &github.ListOptions{ - Page: page, - PerPage: PerPageMax, - }) - if err != nil { - return nil, err - } - - associatedPRs = append(associatedPRs, prs...) - - if page == resp.LastPage || resp.LastPage == 0 { - break - } - page = resp.NextPage + associatedPRs, err := all( + func(listOptions github.ListOptions) ([]*github.PullRequest, *github.Response, error) { + return g.client.PullRequests.ListPullRequestsWithCommit( + ctx, g.options.Owner, g.options.Repo, + commit.Hash, &listOptions) + }) + if err != nil { + return nil, err } - var pullrequest *github.PullRequest + var pullRequest *github.PullRequest for _, pr := range associatedPRs { // We only look for the PR that has this commit set as the "merge commit" => The result of squashing this branch onto main if pr.GetMergeCommitSHA() == commit.Hash { - pullrequest = pr + pullRequest = pr break } } - if pullrequest == nil { + if pullRequest == nil { return nil, nil } - return gitHubPRToPullRequest(pullrequest), nil + return gitHubPRToPullRequest(pullRequest), nil } func (g *GitHub) EnsureLabelsExist(ctx context.Context, labels []releasepr.Label) error { - existingLabels := make([]string, 0, len(labels)) - - page := 1 - - for { - g.log.Debug("fetching labels on repo", "page", page) - ghLabels, resp, err := g.client.Issues.ListLabels( + g.log.Debug("fetching labels on repo") + ghLabels, err := all(func(listOptions github.ListOptions) ([]*github.Label, *github.Response, error) { + return g.client.Issues.ListLabels( ctx, g.options.Owner, g.options.Repo, - &github.ListOptions{ - Page: page, - PerPage: PerPageMax, - }) - if err != nil { - return err - } - - for _, label := range ghLabels { - existingLabels = append(existingLabels, label.GetName()) - } - - if page == resp.LastPage || resp.LastPage == 0 { - break - } - page = resp.NextPage + &listOptions) + }) + if err != nil { + return err } for _, label := range labels { - if !slices.Contains(existingLabels, string(label)) { - g.log.Info("creating label in repository", "label.name", label) - _, _, err := g.client.Issues.CreateLabel( + if !slices.ContainsFunc(ghLabels, func(ghLabel *github.Label) bool { + return ghLabel.GetName() == label.Name + }) { + g.log.Info("creating label in repository", "label.name", label.Name) + _, _, err = g.client.Issues.CreateLabel( ctx, g.options.Owner, g.options.Repo, &github.Label{ - Name: pointer.Pointer(string(label)), - Color: pointer.Pointer(LabelColor), + Name: pointer.Pointer(label.Name), + Color: pointer.Pointer(label.Color), + Description: pointer.Pointer(label.Description), }, ) if err != nil { @@ -317,33 +248,25 @@ func (g *GitHub) EnsureLabelsExist(ctx context.Context, labels []releasepr.Label } func (g *GitHub) PullRequestForBranch(ctx context.Context, branch string) (*releasepr.ReleasePullRequest, error) { - page := 1 - for { - prs, resp, err := g.client.PullRequests.ListPullRequestsWithCommit(ctx, g.options.Owner, g.options.Repo, branch, &github.ListOptions{ - Page: page, - PerPage: PerPageMax, + prs, err := all( + func(listOptions github.ListOptions) ([]*github.PullRequest, *github.Response, error) { + return g.client.PullRequests.ListPullRequestsWithCommit(ctx, g.options.Owner, g.options.Repo, branch, &listOptions) }) - if err != nil { - var ghErr *github.ErrorResponse - if errors.As(err, &ghErr) { - if ghErr.Message == fmt.Sprintf("No commit found for SHA: %s", branch) { - return nil, nil - } - } - return nil, err - } - - for _, pr := range prs { - if pr.GetBase().GetRef() == g.options.BaseBranch && pr.GetHead().GetRef() == branch && pr.GetState() == PRStateOpen { - return gitHubPRToReleasePullRequest(pr), nil + if err != nil { + var ghErr *github.ErrorResponse + if errors.As(err, &ghErr) { + if ghErr.Message == fmt.Sprintf("No commit found for SHA: %s", branch) { + return nil, nil } } + return nil, err + } - if page == resp.LastPage || resp.LastPage == 0 { - break + for _, pr := range prs { + if pr.GetBase().GetRef() == g.options.BaseBranch && pr.GetHead().GetRef() == branch && pr.GetState() == PRStateOpen { + return gitHubPRToReleasePullRequest(pr), nil } - page = resp.NextPage } return nil, nil @@ -393,7 +316,7 @@ func (g *GitHub) SetPullRequestLabels(ctx context.Context, pr *releasepr.Release for _, label := range remove { _, err := g.client.Issues.RemoveLabelForIssue( ctx, g.options.Owner, g.options.Repo, - pr.ID, string(label), + pr.ID, label.Name, ) if err != nil { return err @@ -402,7 +325,7 @@ func (g *GitHub) SetPullRequestLabels(ctx context.Context, pr *releasepr.Release addString := make([]string, 0, len(add)) for _, label := range add { - addString = append(addString, string(label)) + addString = append(addString, label.Name) } _, _, err := g.client.Issues.AddLabelsToIssue( @@ -431,52 +354,36 @@ func (g *GitHub) ClosePullRequest(ctx context.Context, pr *releasepr.ReleasePull } func (g *GitHub) PendingReleases(ctx context.Context, pendingLabel releasepr.Label) ([]*releasepr.ReleasePullRequest, error) { - page := 1 - - var prs []*releasepr.ReleasePullRequest - - for { - ghPRs, resp, err := g.client.PullRequests.List( + ghPRs, err := all(func(listOptions github.ListOptions) ([]*github.PullRequest, *github.Response, error) { + return g.client.PullRequests.List( ctx, g.options.Owner, g.options.Repo, &github.PullRequestListOptions{ - State: PRStateClosed, - Base: g.options.BaseBranch, - ListOptions: github.ListOptions{ - Page: page, - PerPage: PerPageMax, - }, + State: PRStateClosed, + Base: g.options.BaseBranch, + ListOptions: listOptions, }) - if err != nil { - return nil, err + }) + if err != nil { + return nil, err + } + + prs := make([]*releasepr.ReleasePullRequest, 0, len(ghPRs)) + + for _, pr := range ghPRs { + pending := slices.ContainsFunc(pr.Labels, func(l *github.Label) bool { + return l.GetName() == pendingLabel.Name + }) + if !pending { + continue } - if prs == nil && resp.LastPage > 0 { - // Pre-initialize slice on first request - g.log.Debug("found pending releases", "pages", resp.LastPage) - prs = make([]*releasepr.ReleasePullRequest, 0, (resp.LastPage-1)*PerPageMax) + // pr.Merged is always nil :( + if pr.MergedAt == nil { + // Closed and not merged + continue } - for _, pr := range ghPRs { - pending := slices.ContainsFunc(pr.Labels, func(l *github.Label) bool { - return l.GetName() == string(pendingLabel) - }) - if !pending { - continue - } - - // pr.Merged is always nil :( - if pr.MergedAt == nil { - // Closed and not merged - continue - } - - prs = append(prs, gitHubPRToReleasePullRequest(pr)) - } - - if page == resp.LastPage || resp.LastPage == 0 { - break - } - page = resp.NextPage + prs = append(prs, gitHubPRToReleasePullRequest(pr)) } return prs, nil @@ -507,6 +414,25 @@ func (g *GitHub) CreateRelease(ctx context.Context, commit git.Commit, title, ch return nil } +func all[T any](f func(listOptions github.ListOptions) ([]T, *github.Response, error)) ([]T, error) { + results := make([]T, 0) + page := 1 + + for { + pageResults, resp, err := f(github.ListOptions{Page: page, PerPage: PerPageMax}) + if err != nil { + return nil, err + } + + results = append(results, pageResults...) + + if page == resp.LastPage || resp.LastPage == 0 { + return results, nil + } + page = resp.NextPage + } +} + func gitHubPRToPullRequest(pr *github.PullRequest) *git.PullRequest { return &git.PullRequest{ ID: pr.GetNumber(), @@ -518,9 +444,11 @@ func gitHubPRToPullRequest(pr *github.PullRequest) *git.PullRequest { func gitHubPRToReleasePullRequest(pr *github.PullRequest) *releasepr.ReleasePullRequest { labels := make([]releasepr.Label, 0, len(pr.Labels)) for _, label := range pr.Labels { - labelName := releasepr.Label(label.GetName()) - if slices.Contains(releasepr.KnownLabels, releasepr.Label(label.GetName())) { - labels = append(labels, labelName) + labelName := label.GetName() + if i := slices.IndexFunc(releasepr.KnownLabels, func(label releasepr.Label) bool { + return label.Name == labelName + }); i >= 0 { + labels = append(labels, releasepr.KnownLabels[i]) } } diff --git a/internal/forge/gitlab/gitlab.go b/internal/forge/gitlab/gitlab.go index 98a4252..8808773 100644 --- a/internal/forge/gitlab/gitlab.go +++ b/internal/forge/gitlab/gitlab.go @@ -1,31 +1,430 @@ package gitlab import ( + "context" "fmt" + "log/slog" + "os" + "slices" + "strings" + + "github.com/blang/semver/v4" + "github.com/go-git/go-git/v5/plumbing/transport" + "github.com/go-git/go-git/v5/plumbing/transport/http" + "github.com/xanzy/go-gitlab" "github.com/apricote/releaser-pleaser/internal/forge" + "github.com/apricote/releaser-pleaser/internal/git" + "github.com/apricote/releaser-pleaser/internal/pointer" + "github.com/apricote/releaser-pleaser/internal/releasepr" ) -// var _ forge.Forge = &GitLab{} +const ( + PerPageMax = 100 + PRStateOpen = "opened" + PRStateMerged = "merged" + PRStateEventClose = "close" + EnvAPIToken = "GITLAB_TOKEN" // nolint:gosec // Not actually a hardcoded credential +) type GitLab struct { - options forge.Options -} + options *Options -func (g *GitLab) autodiscover() { - // Read settings from GitLab-CI env vars -} - -func New(options forge.Options) *GitLab { - gl := &GitLab{ - options: options, - } - - gl.autodiscover() - - return gl + client *gitlab.Client + log *slog.Logger } func (g *GitLab) RepoURL() string { return fmt.Sprintf("https://gitlab.com/%s", g.options.Repository) } + +func (g *GitLab) CloneURL() string { + return fmt.Sprintf("https://gitlab.com/%s/%s.git", g.options.Path, g.options.Repo) +} + +func (g *GitLab) ReleaseURL(version string) string { + return fmt.Sprintf("https://gitlab.com/%s/%s/-/releases/%s", g.options.Path, g.options.Repo, version) +} + +func (g *GitLab) PullRequestURL(id int) string { + return fmt.Sprintf("https://gitlab.com/%s/%s/-/merge_requests/%d", g.options.Path, g.options.Repo, id) +} + +func (g *GitLab) GitAuth() transport.AuthMethod { + return &http.BasicAuth{ + // Username just needs to be any non-blank value + Username: "api-token", + Password: g.options.APIToken, + } +} + +func (g *GitLab) LatestTags(ctx context.Context) (git.Releases, error) { + g.log.DebugContext(ctx, "listing all tags in gitlab repository") + + tags, err := all(func(listOptions gitlab.ListOptions) ([]*gitlab.Tag, *gitlab.Response, error) { + return g.client.Tags.ListTags(g.options.ProjectID, &gitlab.ListTagsOptions{ + OrderBy: pointer.Pointer("updated"), + ListOptions: listOptions, + }, gitlab.WithContext(ctx)) + }) + if err != nil { + return git.Releases{}, err + } + + var releases git.Releases + for _, glTag := range tags { + tag := &git.Tag{ + Hash: glTag.Commit.ID, + Name: glTag.Name, + } + + version, err := semver.Parse(strings.TrimPrefix(tag.Name, "v")) + if err != nil { + g.log.WarnContext( + ctx, "unable to parse tag as semver, skipping", + "tag.name", tag.Name, + "tag.hash", tag.Hash, + "error", err, + ) + continue + } + + if releases.Latest == nil { + releases.Latest = tag + } + if len(version.Pre) == 0 { + // Stable version tag + // We return once we have found the latest stable tag, not needed to look at every single tag. + releases.Stable = tag + break + } + + } + + return releases, nil +} + +func (g *GitLab) CommitsSince(ctx context.Context, tag *git.Tag) ([]git.Commit, error) { + var err error + + head := g.options.BaseBranch + log := g.log.With("head", head) + + refName := "" + if tag != nil { + log = log.With("base", tag.Hash) + refName = fmt.Sprintf("%s..%s", tag.Hash, head) + } else { + refName = head + } + log.Debug("listing commits", "ref.name", refName) + + gitLabCommits, err := all(func(listOptions gitlab.ListOptions) ([]*gitlab.Commit, *gitlab.Response, error) { + return g.client.Commits.ListCommits(g.options.ProjectID, &gitlab.ListCommitsOptions{ + RefName: &refName, + ListOptions: listOptions, + }, gitlab.WithContext(ctx)) + }) + if err != nil { + return nil, err + } + + var commits = make([]git.Commit, 0, len(gitLabCommits)) + for _, ghCommit := range gitLabCommits { + commit := git.Commit{ + Hash: ghCommit.ID, + Message: ghCommit.Message, + } + commit.PullRequest, err = g.prForCommit(ctx, commit) + if err != nil { + return nil, fmt.Errorf("failed to check for commit pull request: %w", err) + } + + commits = append(commits, commit) + } + + return commits, nil +} + +func (g *GitLab) prForCommit(ctx context.Context, commit git.Commit) (*git.PullRequest, error) { + // We naively look up the associated MR for each commit through the "List merge requests associated with a commit" + // endpoint. This requires len(commits) requests. + // Using the "List merge requests" endpoint might be faster, as it allows us to fetch 100 arbitrary MRs per request, + // but worst case we need to look up all MRs made in the repository ever. + + log := g.log.With("commit.hash", commit.Hash) + + log.Debug("fetching pull requests associated with commit") + associatedMRs, _, err := g.client.Commits.ListMergeRequestsByCommit( + g.options.ProjectID, commit.Hash, + gitlab.WithContext(ctx), + ) + if err != nil { + return nil, err + } + + var mergeRequest *gitlab.MergeRequest + for _, mr := range associatedMRs { + // We only look for the MR that has this commit set as the "merge commit" => The result of squashing this branch onto main + if mr.MergeCommitSHA == commit.Hash { + mergeRequest = mr + break + } + } + + if mergeRequest == nil { + return nil, nil + } + + return gitlabMRToPullRequest(mergeRequest), nil +} + +func (g *GitLab) EnsureLabelsExist(ctx context.Context, labels []releasepr.Label) error { + g.log.Debug("fetching labels on repo") + glLabels, err := all(func(listOptions gitlab.ListOptions) ([]*gitlab.Label, *gitlab.Response, error) { + return g.client.Labels.ListLabels(g.options.ProjectID, &gitlab.ListLabelsOptions{ + ListOptions: listOptions, + }, gitlab.WithContext(ctx)) + }) + if err != nil { + return err + } + + for _, label := range labels { + if !slices.ContainsFunc(glLabels, func(glLabel *gitlab.Label) bool { + return glLabel.Name == label.Name + }) { + g.log.Info("creating label in repository", "label.name", label) + _, _, err := g.client.Labels.CreateLabel(g.options.ProjectID, &gitlab.CreateLabelOptions{ + Name: pointer.Pointer(label.Name), + Color: pointer.Pointer("#" + label.Color), + Description: pointer.Pointer(label.Description), + }, + ) + if err != nil { + return err + } + } + } + + return nil +} + +func (g *GitLab) PullRequestForBranch(ctx context.Context, branch string) (*releasepr.ReleasePullRequest, error) { + // There should only be a single open merge request from branch into g.options.BaseBranch at any given moment. + // We can skip pagination and just return the first result. + mrs, _, err := g.client.MergeRequests.ListProjectMergeRequests(g.options.ProjectID, &gitlab.ListProjectMergeRequestsOptions{ + State: pointer.Pointer(PRStateOpen), + SourceBranch: pointer.Pointer(branch), + TargetBranch: pointer.Pointer(g.options.BaseBranch), + ListOptions: gitlab.ListOptions{ + Page: 1, + PerPage: PerPageMax, + }, + }, gitlab.WithContext(ctx)) + if err != nil { + return nil, err + } + + if len(mrs) >= 1 { + return gitlabMRToReleasePullRequest(mrs[0]), nil + } + + return nil, nil +} + +func (g *GitLab) CreatePullRequest(ctx context.Context, pr *releasepr.ReleasePullRequest) error { + labels := make(gitlab.LabelOptions, 0, len(pr.Labels)) + for _, label := range pr.Labels { + labels = append(labels, label.Name) + } + + glMR, _, err := g.client.MergeRequests.CreateMergeRequest(g.options.ProjectID, &gitlab.CreateMergeRequestOptions{ + Title: &pr.Title, + Description: &pr.Description, + SourceBranch: &pr.Head, + TargetBranch: &g.options.BaseBranch, + Labels: &labels, + }, gitlab.WithContext(ctx)) + if err != nil { + return err + } + + pr.ID = glMR.IID + + return nil +} + +func (g *GitLab) UpdatePullRequest(ctx context.Context, pr *releasepr.ReleasePullRequest) error { + _, _, err := g.client.MergeRequests.UpdateMergeRequest(g.options.ProjectID, pr.ID, &gitlab.UpdateMergeRequestOptions{ + Title: &pr.Title, + Description: &pr.Description, + }, gitlab.WithContext(ctx)) + + if err != nil { + return err + } + + return nil +} + +func (g *GitLab) SetPullRequestLabels(ctx context.Context, pr *releasepr.ReleasePullRequest, remove, add []releasepr.Label) error { + removeLabels := make(gitlab.LabelOptions, 0, len(remove)) + for _, label := range remove { + removeLabels = append(removeLabels, label.Name) + } + + addLabels := make(gitlab.LabelOptions, 0, len(add)) + for _, label := range add { + addLabels = append(addLabels, label.Name) + } + + _, _, err := g.client.MergeRequests.UpdateMergeRequest(g.options.ProjectID, pr.ID, &gitlab.UpdateMergeRequestOptions{ + RemoveLabels: &removeLabels, + AddLabels: &addLabels, + }, gitlab.WithContext(ctx)) + + if err != nil { + return err + } + + return nil +} + +func (g *GitLab) ClosePullRequest(ctx context.Context, pr *releasepr.ReleasePullRequest) error { + _, _, err := g.client.MergeRequests.UpdateMergeRequest(g.options.ProjectID, pr.ID, &gitlab.UpdateMergeRequestOptions{ + StateEvent: pointer.Pointer(PRStateEventClose), + }, gitlab.WithContext(ctx)) + + if err != nil { + return err + } + + return nil +} + +func (g *GitLab) PendingReleases(ctx context.Context, pendingLabel releasepr.Label) ([]*releasepr.ReleasePullRequest, error) { + glMRs, err := all(func(listOptions gitlab.ListOptions) ([]*gitlab.MergeRequest, *gitlab.Response, error) { + return g.client.MergeRequests.ListMergeRequests(&gitlab.ListMergeRequestsOptions{ + State: pointer.Pointer(PRStateMerged), + Labels: &gitlab.LabelOptions{pendingLabel.Name}, + TargetBranch: pointer.Pointer(g.options.BaseBranch), + ListOptions: listOptions, + }, gitlab.WithContext(ctx)) + }) + if err != nil { + return nil, err + } + + prs := make([]*releasepr.ReleasePullRequest, 0, len(glMRs)) + + for _, mr := range glMRs { + prs = append(prs, gitlabMRToReleasePullRequest(mr)) + } + + return prs, nil +} + +func (g *GitLab) CreateRelease(ctx context.Context, commit git.Commit, title, changelog string, _, _ bool) error { + _, _, err := g.client.Releases.CreateRelease(g.options.ProjectID, &gitlab.CreateReleaseOptions{ + Name: &title, + TagName: &title, + Description: &changelog, + Ref: &commit.Hash, + }, gitlab.WithContext(ctx)) + if err != nil { + return err + } + + return nil +} + +func all[T any](f func(listOptions gitlab.ListOptions) ([]T, *gitlab.Response, error)) ([]T, error) { + results := make([]T, 0) + page := 1 + + for { + pageResults, resp, err := f(gitlab.ListOptions{Page: page, PerPage: PerPageMax}) + if err != nil { + return nil, err + } + + results = append(results, pageResults...) + + if page == resp.TotalPages || resp.TotalPages == 0 { + return results, nil + } + page = resp.NextPage + } +} + +func gitlabMRToPullRequest(pr *gitlab.MergeRequest) *git.PullRequest { + return &git.PullRequest{ + ID: pr.IID, + Title: pr.Title, + Description: pr.Description, + } +} + +func gitlabMRToReleasePullRequest(pr *gitlab.MergeRequest) *releasepr.ReleasePullRequest { + labels := make([]releasepr.Label, 0, len(pr.Labels)) + for _, labelName := range pr.Labels { + if i := slices.IndexFunc(releasepr.KnownLabels, func(label releasepr.Label) bool { + return label.Name == labelName + }); i >= 0 { + labels = append(labels, releasepr.KnownLabels[i]) + } + } + + var releaseCommit *git.Commit + if pr.MergeCommitSHA != "" { + releaseCommit = &git.Commit{Hash: pr.MergeCommitSHA} + } + + return &releasepr.ReleasePullRequest{ + PullRequest: *gitlabMRToPullRequest(pr), + Labels: labels, + + Head: pr.SHA, + ReleaseCommit: releaseCommit, + } +} + +func (g *Options) autodiscover() { + // Read settings from GitLab-CI env vars + if apiToken := os.Getenv(EnvAPIToken); apiToken != "" { + g.APIToken = apiToken + } + + // TODO: Replace hardcode project-id with a better alternative + g.ProjectID = 60698565 +} + +type Options struct { + forge.Options + + Path string + Repo string + ProjectID int + + APIToken string +} + +func New(log *slog.Logger, options *Options) (*GitLab, error) { + log = log.With("forge", "gitlab") + options.autodiscover() + + client, err := gitlab.NewClient(options.APIToken) + if err != nil { + return nil, err + } + + gl := &GitLab{ + options: options, + + client: client, + log: log, + } + + return gl, nil +} diff --git a/internal/releasepr/label.go b/internal/releasepr/label.go index 518eb87..7b529be 100644 --- a/internal/releasepr/label.go +++ b/internal/releasepr/label.go @@ -1 +1,54 @@ package releasepr + +// Label is the string identifier of a pull/merge request label on the forge. +type Label struct { + Color string + Name string + Description string +} + +var ( + LabelNextVersionTypeNormal = Label{ + Color: "EFC15B", + Name: "rp-next-version::normal", + Description: "Request a stable version", + } + LabelNextVersionTypeRC = Label{ + Color: "EFC15B", + Name: "rp-next-version::rc", + Description: "Request a pre-release -rc version", + } + LabelNextVersionTypeBeta = Label{ + Color: "EFC15B", + Name: "rp-next-version::beta", + Description: "Request a pre-release -beta version", + } + LabelNextVersionTypeAlpha = Label{ + Color: "EFC15B", + Name: "rp-next-version::alpha", + Description: "Request a pre-release -alpha version", + } +) + +var ( + LabelReleasePending = Label{ + Color: "DEDEDE", + Name: "rp-release::pending", + Description: "Release for this PR is pending", + } + LabelReleaseTagged = Label{ + Color: "0E8A16", + Name: "rp-release::tagged", + Description: "Release for this PR is created", + } +) + +var KnownLabels = []Label{ + LabelNextVersionTypeNormal, + LabelNextVersionTypeRC, + LabelNextVersionTypeBeta, + LabelNextVersionTypeAlpha, + + LabelReleasePending, + LabelReleaseTagged, +} diff --git a/internal/releasepr/releasepr.go b/internal/releasepr/releasepr.go index 505b3c0..22eac0a 100644 --- a/internal/releasepr/releasepr.go +++ b/internal/releasepr/releasepr.go @@ -36,9 +36,6 @@ type ReleasePullRequest struct { ReleaseCommit *git.Commit } -// Label is the string identifier of a pull/merge request label on the forge. -type Label string - func NewReleasePullRequest(head, branch, version, changelogEntry string) (*ReleasePullRequest, error) { rp := &ReleasePullRequest{ Head: head, @@ -59,26 +56,6 @@ type ReleaseOverrides struct { NextVersionType versioning.NextVersionType } -const ( - LabelNextVersionTypeNormal Label = "rp-next-version::normal" - LabelNextVersionTypeRC Label = "rp-next-version::rc" - LabelNextVersionTypeBeta Label = "rp-next-version::beta" - LabelNextVersionTypeAlpha Label = "rp-next-version::alpha" - - LabelReleasePending Label = "rp-release::pending" - LabelReleaseTagged Label = "rp-release::tagged" -) - -var KnownLabels = []Label{ - LabelNextVersionTypeNormal, - LabelNextVersionTypeRC, - LabelNextVersionTypeBeta, - LabelNextVersionTypeAlpha, - - LabelReleasePending, - LabelReleaseTagged, -} - const ( DescriptionLanguagePrefix = "rp-prefix" DescriptionLanguageSuffix = "rp-suffix"