go/goreleaser
go/goreleaser
1
0
Fork 0
mirror of https://github.com/goreleaser/goreleaser.git synced 2025-02-01 13:07:49 +02:00
Code Issues Releases Activity

feat: full gitlab support for brew and scoop (#1084)

Browse Source 
* makes context tokentype a public var

* passes artifacts object into client upload function. extracts gitlab upload hash from url

* adds gitlab url to brew config

* build brew formula depending on token type

* fixes client for release tests

* fixes exiting brew tests

* fixes scoop test with dummy client adaption

* uses new artifact upload hash

* fixes brew usage

* updates gitlab createFile for brew

* fixes logging for non-existing file in gitlab logging

* fix: gitlab createFile

* fix: removes encoding from gitlab create and update file opts

* fix: gitlab upload and artifact set upload hash

* fix: linter

* changed artifact item to a pointer in ctx

* docs: updates homebrew

* feat: enables scoop for gitlab release

* fix: scoop panic for pointer access

* chore: rename formula build func for brew

* chore: brew removes comments

* fix: brew tests

* test: updates brew tests

* docs: updates homebrew

* test: for token type not implemented for brew

* tests: for multiple linux builds

* fix: build artifacts are pointer in scoop

* test: for scoop and gitlab

* test: for artifacts set upload hash

* adds missing files after adaption

* chore: removes and clarifies comments

* fix: moves artifact upload hash to extra map

* adds comment why we initialize the extra map
This commit is contained in:
Manuel Vogel 2019-08-13 20:28:03 +02:00 committed by Carlos Alexandro Becker
parent 23e275e946
commit e92bbe32ce
20 changed files with 787 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
internal/client/client.go
View File

@ -4,6 +4,7 @@ package client
import (
"os"
"github.com/goreleaser/goreleaser/internal/artifact"
"github.com/goreleaser/goreleaser/pkg/config"
"github.com/goreleaser/goreleaser/pkg/context"
)
@ -19,7 +20,7 @@ type Info struct {
type Client interface {
CreateRelease(ctx *context.Context, body string) (releaseID string, err error)
CreateFile(ctx *context.Context, commitAuthor config.CommitAuthor, repo config.Repo, content []byte, path, message string) (err error)
Upload(ctx *context.Context, releaseID string, name string, file *os.File) (err error)
Upload(ctx *context.Context, releaseID string, artifact *artifact.Artifact, file *os.File) (err error)
}
// New creates a new client depending on the token type

5
internal/client/github.go
View File

@ -10,6 +10,7 @@ import (
"github.com/apex/log"
"github.com/google/go-github/v25/github"
"github.com/goreleaser/goreleaser/internal/artifact"
"github.com/goreleaser/goreleaser/internal/tmpl"
"github.com/goreleaser/goreleaser/pkg/config"
"github.com/goreleaser/goreleaser/pkg/context"
@ -150,7 +151,7 @@ func (c *githubClient) CreateRelease(ctx *context.Context, body string) (string,
func (c *githubClient) Upload(
ctx *context.Context,
releaseID string,
name string,
artifact *artifact.Artifact,
file *os.File,
) error {
githubReleaseID, err := strconv.ParseInt(releaseID, 10, 64)
@ -163,7 +164,7 @@ func (c *githubClient) Upload(
ctx.Config.Release.GitHub.Name,
githubReleaseID,
&github.UploadOptions{
Name: name,
Name: artifact.Name,
},
file,
)

154
internal/client/gitlab.go
View File

@ -2,16 +2,22 @@ package client
import (
"crypto/tls"
"errors"
"net/http"
"os"
"strings"
"github.com/apex/log"
"github.com/goreleaser/goreleaser/internal/artifact"
"github.com/goreleaser/goreleaser/internal/tmpl"
"github.com/goreleaser/goreleaser/pkg/config"
"github.com/goreleaser/goreleaser/pkg/context"
"github.com/xanzy/go-gitlab"
)
// ErrExtractHashFromFileUploadURL indicates the file upload hash could not ne extracted from the url
var ErrExtractHashFromFileUploadURL = errors.New("could not extract hash from gitlab file upload url")
type gitlabClient struct {
client *gitlab.Client
}
@ -36,18 +42,113 @@ func NewGitLab(ctx *context.Context) (Client, error) {
return &gitlabClient{client: client}, nil
}
// CreateFile creates a file in the repository at a given path
// or updates the file if it exists
// CreateFile gets a file in the repository at a given path
// and updates if it exists or creates it for later pipes in the pipeline
func (c *gitlabClient) CreateFile(
ctx *context.Context,
commitAuthor config.CommitAuthor,
repo config.Repo,
content []byte,
path,
message string,
content []byte, // the content of the formula.rb
path, // the path to the formula.rb
message string, // the commit msg
) error {
// Used by brew and scoop, hence those two pipes are
// only supported for github atm. So we disable it for now.
fileName := path
// we assume having the formula in the master branch only
ref := "master"
branch := "master"
opts := &gitlab.GetFileOptions{Ref: &ref}
castedContent := string(content)
projectID := repo.Owner + "/" + repo.Name
log.WithFields(log.Fields{
"owner": repo.Owner,
"name": repo.Name,
}).Debug("projectID at brew")
_, res, err := c.client.RepositoryFiles.GetFile(projectID, fileName, opts)
if err != nil && (res == nil || res.StatusCode != 404) {
log.WithFields(log.Fields{
"fileName": fileName,
"ref": ref,
"projectID": projectID,
"statusCode": res.StatusCode,
"err": err.Error(),
}).Error("error getting file for brew formula")
return err
}
log.WithFields(log.Fields{
"fileName": fileName,
"branch": branch,
"projectID": projectID,
}).Debug("found already existing brew formula file")
if res.StatusCode == 404 {
log.WithFields(log.Fields{
"fileName": fileName,
"ref": ref,
"projectID": projectID,
}).Debug("creating brew formula")
createOpts := &gitlab.CreateFileOptions{
AuthorName: &commitAuthor.Name,
AuthorEmail: &commitAuthor.Email,
Content: &castedContent,
Branch: &branch,
CommitMessage: &message,
}
fileInfo, res, err := c.client.RepositoryFiles.CreateFile(projectID, fileName, createOpts)
if err != nil {
log.WithFields(log.Fields{
"fileName": fileName,
"branch": branch,
"projectID": projectID,
"statusCode": res.StatusCode,
"err": err.Error(),
}).Error("error creating brew formula file")
return err
}
log.WithFields(log.Fields{
"fileName": fileName,
"branch": branch,
"projectID": projectID,
"filePath": fileInfo.FilePath,
}).Debug("created brew formula file")
return nil
}
log.WithFields(log.Fields{
"fileName": fileName,
"ref": ref,
"projectID": projectID,
}).Debug("updating brew formula")
updateOpts := &gitlab.UpdateFileOptions{
AuthorName: &commitAuthor.Name,
AuthorEmail: &commitAuthor.Email,
Content: &castedContent,
Branch: &branch,
CommitMessage: &message,
}
updateFileInfo, res, err := c.client.RepositoryFiles.UpdateFile(projectID, fileName, updateOpts)
if err != nil {
log.WithFields(log.Fields{
"fileName": fileName,
"branch": branch,
"projectID": projectID,
"statusCode": res.StatusCode,
"err": err.Error(),
}).Error("error updating brew formula file")
return err
}
log.WithFields(log.Fields{
"fileName": fileName,
"branch": branch,
"projectID": projectID,
"filePath": updateFileInfo.FilePath,
"statusCode": res.StatusCode,
}).Debug("updated brew formula file")
return nil
}
@ -128,7 +229,7 @@ func (c *gitlabClient) CreateRelease(ctx *context.Context, body string) (release
func (c *gitlabClient) Upload(
ctx *context.Context,
releaseID string,
name string,
artifact *artifact.Artifact,
file *os.File,
) error {
projectID := ctx.Config.Release.GitLab.Owner + "/" + ctx.Config.Release.GitLab.Name
@ -150,9 +251,9 @@ func (c *gitlabClient) Upload(
}).Debug("uploaded file")
gitlabBaseURL := ctx.Config.GitLabURLs.Download
// projectFile from upload: /uploads/<sha>/filename.txt
relativeUploadURL := projectFile.URL
linkURL := gitlabBaseURL + "/" + projectID + relativeUploadURL
// projectFile.URL from upload: /uploads/<hash>/filename.txt
linkURL := gitlabBaseURL + "/" + projectID + projectFile.URL
name := artifact.Name
releaseLink, _, err := c.client.ReleaseLinks.CreateReleaseLink(
projectID,
releaseID,
@ -170,5 +271,36 @@ func (c *gitlabClient) Upload(
"url": releaseLink.URL,
}).Debug("created release link")
fileUploadHash, err := extractProjectFileHashFrom(projectFile.URL)
if err != nil {
return err
}
// for checksums.txt the field is nil, so we initialize it
if artifact.Extra == nil {
artifact.Extra = make(map[string]interface{})
}
// we set this hash to be able to download the file
// in following publish pipes like brew, scoop
artifact.Extra["ArtifactUploadHash"] = fileUploadHash
return err
}
// extractProjectFileHashFrom extracts the hash from the
// relative project file url of the format '/uploads/<hash>/filename.ext'
func extractProjectFileHashFrom(projectFileURL string) (string, error) {
log.WithField("projectFileURL", projectFileURL).Debug("extract file hash from")
splittedProjectFileURL := strings.Split(projectFileURL, "/")
if len(splittedProjectFileURL) != 4 {
log.WithField("projectFileURL", projectFileURL).Debug("could not extract file hash")
return "", ErrExtractHashFromFileUploadURL
}
fileHash := splittedProjectFileURL[2]
log.WithFields(log.Fields{
"projectFileURL": projectFileURL,
"fileHash": fileHash,
}).Debug("extracted file hash")
return fileHash, nil
}

33
internal/client/gitlab_test.go Normal file
View File

@ -0,0 +1,33 @@
package client
import (
"fmt"
"testing"
"github.com/stretchr/testify/assert"
)
func TestExtractHashFromProjectFileURL(t *testing.T) {
givenHash := "22e8b1508b0f28433b94754a5ea2f4aa"
projectFileURL := fmt.Sprintf("/uploads/%s/release-testing_0.3.7_Darwin_x86_64.tar.gz", givenHash)
extractedHash, err := extractProjectFileHashFrom(projectFileURL)
if err != nil {
t.Errorf("expexted no error but got: %v", err)
}
assert.Equal(t, givenHash, extractedHash)
}
func TestFailToExtractHashFromProjectFileURL(t *testing.T) {
givenHash := "22e8b1508b0f28433b94754a5ea2f4aa"
projectFileURL := fmt.Sprintf("/uploads/%s/new-path/file.ext", givenHash)
_, err := extractProjectFileHashFrom(projectFileURL)
if err == nil {
t.Errorf("expected an error but got none for new-path in url")
}
projectFileURL = fmt.Sprintf("/%s/file.ext", givenHash)
_, err = extractProjectFileHashFrom(projectFileURL)
if err == nil {
t.Errorf("expected an error but got none for path-too-small in url")
}
}

68
internal/pipe/brew/brew.go
View File

@ -30,6 +30,9 @@ var ErrNoArchivesFound = errors.New("brew tap: no archives found matching criter
// TODO: improve this confusing error message
var ErrMultipleArchivesSameOS = errors.New("brew tap: one tap can handle only 1 linux and 1 macos archive")
// ErrTokenTypeNotImplementedForBrew indicates that a new token type was not implemented for this pipe
var ErrTokenTypeNotImplementedForBrew = errors.New("token type not implemented for brew pipe")
// Pipe for brew deployment
type Pipe struct{}
@ -39,7 +42,7 @@ func (Pipe) String() string {
// Publish brew formula
func (Pipe) Publish(ctx *context.Context) error {
client, err := client.NewGitHub(ctx)
client, err := client.New(ctx)
if err != nil {
return err
}
@ -112,15 +115,14 @@ func contains(ss []string, s string) bool {
}
func doRun(ctx *context.Context, brew config.Homebrew, client client.Client) error {
if brew.GitHub.Name == "" {
if brew.GitHub.Name == "" && brew.GitLab.Name == "" {
return pipe.Skip("brew section is not configured")
}
// If we'd use 'ctx.TokenType != context.TokenTypeGitHub' we'd have to adapt all the tests
// For simplicity we use this check because the functionality will be implemented later for
// all types of releases. See https://github.com/goreleaser/goreleaser/pull/1038#issuecomment-498891464
if ctx.TokenType == context.TokenTypeGitLab {
return pipe.Skip("brew pipe is only configured for github releases")
}
// TODO mavogel: in another PR
// check if release pipe is not configured!
// if ctx.Config.Release.Disable {
// }
var filters = []artifact.Filter{
artifact.Or(
@ -140,7 +142,7 @@ func doRun(ctx *context.Context, brew config.Homebrew, client client.Client) err
return ErrNoArchivesFound
}
content, err := buildFormula(ctx, brew, archives)
content, err := buildFormula(ctx, brew, ctx.TokenType, archives)
if err != nil {
return err
}
@ -165,21 +167,31 @@ func doRun(ctx *context.Context, brew config.Homebrew, client client.Client) err
return pipe.Skip("prerelease detected with 'auto' upload, skipping homebrew publish")
}
var gpath = ghFormulaPath(brew.Folder, filename)
var repo config.Repo
switch ctx.TokenType {
case context.TokenTypeGitHub:
repo = brew.GitHub
case context.TokenTypeGitLab:
repo = brew.GitLab
default:
return ErrTokenTypeNotImplementedForBrew
}
var gpath = buildFormulaPath(brew.Folder, filename)
log.WithField("formula", gpath).
WithField("repo", brew.GitHub.String()).
WithField("repo", repo.String()).
Info("pushing")
var msg = fmt.Sprintf("Brew formula update for %s version %s", ctx.Config.ProjectName, ctx.Git.CurrentTag)
return client.CreateFile(ctx, brew.CommitAuthor, brew.GitHub, []byte(content), gpath, msg)
return client.CreateFile(ctx, brew.CommitAuthor, repo, []byte(content), gpath, msg)
}
func ghFormulaPath(folder, filename string) string {
func buildFormulaPath(folder, filename string) string {
return path.Join(folder, filename)
}
func buildFormula(ctx *context.Context, brew config.Homebrew, artifacts []*artifact.Artifact) (string, error) {
data, err := dataFor(ctx, brew, artifacts)
func buildFormula(ctx *context.Context, brew config.Homebrew, tokenType context.TokenType, artifacts []*artifact.Artifact) (string, error) {
data, err := dataFor(ctx, brew, tokenType, artifacts)
if err != nil {
return "", err
}
@ -198,7 +210,7 @@ func doBuildFormula(ctx *context.Context, data templateData) (string, error) {
return tmpl.New(ctx).Apply(out.String())
}
func dataFor(ctx *context.Context, cfg config.Homebrew, artifacts []*artifact.Artifact) (templateData, error) {
func dataFor(ctx *context.Context, cfg config.Homebrew, tokenType context.TokenType, artifacts []*artifact.Artifact) (templateData, error) {
var result = templateData{
Name: formulaNameFor(cfg.Name),
Desc: cfg.Description,
@ -222,12 +234,24 @@ func dataFor(ctx *context.Context, cfg config.Homebrew, artifacts []*artifact.Ar
}
if cfg.URLTemplate == "" {
cfg.URLTemplate = fmt.Sprintf(
"%s/%s/%s/releases/download/{{ .Tag }}/{{ .ArtifactName }}",
ctx.Config.GitHubURLs.Download,
ctx.Config.Release.GitHub.Owner,
ctx.Config.Release.GitHub.Name,
)
switch tokenType {
case context.TokenTypeGitHub:
cfg.URLTemplate = fmt.Sprintf(
"%s/%s/%s/releases/download/{{ .Tag }}/{{ .ArtifactName }}",
ctx.Config.GitHubURLs.Download,
ctx.Config.Release.GitHub.Owner,
ctx.Config.Release.GitHub.Name,
)
case context.TokenTypeGitLab:
cfg.URLTemplate = fmt.Sprintf(
"%s/%s/%s/uploads/{{ .ArtifactUploadHash }}/{{ .ArtifactName }}",
ctx.Config.GitLabURLs.Download,
ctx.Config.Release.GitLab.Owner,
ctx.Config.Release.GitLab.Name,
)
default:
return result, ErrTokenTypeNotImplementedForBrew
}
}
url, err := tmpl.New(ctx).WithArtifact(artifact, map[string]string{}).Apply(cfg.URLTemplate)
if err != nil {

203
internal/pipe/brew/brew_test.go
View File

@ -109,20 +109,80 @@ func TestSplit(t *testing.T) {
func TestRunPipe(t *testing.T) {
for name, fn := range map[string]func(ctx *context.Context){
"default": func(ctx *context.Context) {},
"default": func(ctx *context.Context) {
ctx.TokenType = context.TokenTypeGitHub
ctx.Config.GitHubURLs.Download = "https://github.com"
ctx.Config.Release.GitHub.Owner = "test"
ctx.Config.Release.GitHub.Name = "test"
ctx.Config.Brews[0].GitHub.Owner = "test"
ctx.Config.Brews[0].GitHub.Name = "test"
ctx.Config.Brews[0].Homepage = "https://github.com/goreleaser"
},
"github_enterprise_url": func(ctx *context.Context) {
ctx.TokenType = context.TokenTypeGitHub
ctx.Config.GitHubURLs.Download = "https://github.com"
ctx.Config.Release.GitHub.Owner = "test"
ctx.Config.Release.GitHub.Name = "test"
ctx.Config.Brews[0].GitHub.Owner = "test"
ctx.Config.Brews[0].GitHub.Name = "test"
ctx.Config.Brews[0].Homepage = "https://github.com/goreleaser"
ctx.Config.GitHubURLs.Download = "http://github.example.org"
},
"custom_download_strategy": func(ctx *context.Context) {
ctx.TokenType = context.TokenTypeGitHub
ctx.Config.GitHubURLs.Download = "https://github.com"
ctx.Config.Release.GitHub.Owner = "test"
ctx.Config.Release.GitHub.Name = "test"
ctx.Config.Brews[0].GitHub.Owner = "test"
ctx.Config.Brews[0].GitHub.Name = "test"
ctx.Config.Brews[0].Homepage = "https://github.com/goreleaser"
ctx.Config.Brews[0].DownloadStrategy = "GitHubPrivateRepositoryReleaseDownloadStrategy"
},
"custom_require": func(ctx *context.Context) {
ctx.TokenType = context.TokenTypeGitHub
ctx.Config.GitHubURLs.Download = "https://github.com"
ctx.Config.Release.GitHub.Owner = "test"
ctx.Config.Release.GitHub.Name = "test"
ctx.Config.Brews[0].GitHub.Owner = "test"
ctx.Config.Brews[0].GitHub.Name = "test"
ctx.Config.Brews[0].Homepage = "https://github.com/goreleaser"
ctx.Config.Brews[0].DownloadStrategy = "CustomDownloadStrategy"
ctx.Config.Brews[0].CustomRequire = "custom_download_strategy"
},
"custom_block": func(ctx *context.Context) {
ctx.TokenType = context.TokenTypeGitHub
ctx.Config.GitHubURLs.Download = "https://github.com"
ctx.Config.Release.GitHub.Owner = "test"
ctx.Config.Release.GitHub.Name = "test"
ctx.Config.Brews[0].GitHub.Owner = "test"
ctx.Config.Brews[0].GitHub.Name = "test"
ctx.Config.Brews[0].Homepage = "https://github.com/goreleaser"
ctx.Config.Brews[0].CustomBlock = `head "https://github.com/caarlos0/test.git"`
},
"default_gitlab": func(ctx *context.Context) {
ctx.TokenType = context.TokenTypeGitLab
ctx.Config.GitLabURLs.Download = "https://gitlab.com"
ctx.Config.Release.GitLab.Owner = "test"
ctx.Config.Release.GitLab.Name = "test"
ctx.Config.Brews[0].GitLab.Owner = "test"
ctx.Config.Brews[0].GitLab.Name = "test"
ctx.Config.Brews[0].Homepage = "https://gitlab.com/goreleaser"
},
"gitlab_enterprise_url": func(ctx *context.Context) {
ctx.TokenType = context.TokenTypeGitLab
ctx.Config.GitLabURLs.Download = "https://gitlab.com"
ctx.Config.Release.GitLab.Owner = "test"
ctx.Config.Release.GitLab.Name = "test"
ctx.Config.Brews[0].GitLab.Owner = "test"
ctx.Config.Brews[0].GitLab.Name = "test"
ctx.Config.Brews[0].Homepage = "https://gitlab.com/goreleaser"
ctx.Config.GitLabURLs.Download = "https://gitlab.my-company.org"
},
} {
t.Run(name, func(t *testing.T) {
folder, err := ioutil.TempDir("", "goreleasertest")
@ -139,27 +199,13 @@ func TestRunPipe(t *testing.T) {
Config: config.Project{
Dist: folder,
ProjectName: name,
GitHubURLs: config.GitHubURLs{
Download: "https://github.com",
},
Release: config.Release{
GitHub: config.Repo{
Owner: "test",
Name: "test",
},
},
Brews: []config.Homebrew{
{
Name: name,
GitHub: config.Repo{
Owner: "test",
Name: "test",
},
IDs: []string{
"foo",
},
Description: "A run pipe test formula and FOO={{ .Env.FOO }}",
Homepage: "https://github.com/goreleaser",
Caveats: "don't do this {{ .ProjectName }}",
Test: "system \"true\"\nsystem \"#{bin}/foo -h\"",
Plist: `<xml>whatever</xml>`,
@ -178,8 +224,9 @@ func TestRunPipe(t *testing.T) {
Goarch: "amd64",
Type: artifact.UploadableArchive,
Extra: map[string]interface{}{
"ID": "bar",
"Format": "tar.gz",
"ID": "bar",
"Format": "tar.gz",
"ArtifactUploadHash": "820ead5d9d2266c728dce6d4d55b6460",
},
})
var path = filepath.Join(folder, "bin.tar.gz")
@ -190,8 +237,9 @@ func TestRunPipe(t *testing.T) {
Goarch: "amd64",
Type: artifact.UploadableArchive,
Extra: map[string]interface{}{
"ID": "foo",
"Format": "tar.gz",
"ID": "foo",
"Format": "tar.gz",
"ArtifactUploadHash": "820ead5d9d2266c728dce6d4d55b6460",
},
})
@ -219,6 +267,7 @@ func TestRunPipe(t *testing.T) {
func TestRunPipeNoDarwin64Build(t *testing.T) {
var ctx = &context.Context{
TokenType: context.TokenTypeGitHub,
Config: config.Project{
Brews: []config.Homebrew{
{
@ -235,7 +284,7 @@ func TestRunPipeNoDarwin64Build(t *testing.T) {
assert.False(t, client.CreatedFile)
}
func TestRunPipeMultipleDarwin64Build(t *testing.T) {
func TestRunPipeMultipleArchivesSameOsBuild(t *testing.T) {
var ctx = context.New(
config.Project{
Brews: []config.Homebrew{
@ -249,34 +298,50 @@ func TestRunPipeMultipleDarwin64Build(t *testing.T) {
},
)
ctx.TokenType = context.TokenTypeGitHub
f, err := ioutil.TempFile("", "")
assert.NoError(t, err)
defer f.Close()
ctx.Artifacts.Add(&artifact.Artifact{
Name: "bin1",
Path: f.Name(),
Goos: "darwin",
Goarch: "amd64",
Type: artifact.UploadableArchive,
Extra: map[string]interface{}{
"ID": "foo",
"Format": "tar.gz",
},
})
ctx.Artifacts.Add(&artifact.Artifact{
Name: "bin2",
Path: f.Name(),
Goos: "darwin",
Goarch: "amd64",
Type: artifact.UploadableArchive,
Extra: map[string]interface{}{
"ID": "bar",
"Format": "tar.gz",
},
})
client := &DummyClient{}
assert.Equal(t, ErrMultipleArchivesSameOS, doRun(ctx, ctx.Config.Brews[0], client))
assert.False(t, client.CreatedFile)
osarchs := []struct {
goos string
goarch string
}{
{goos: "darwin", goarch: "amd64"},
{goos: "linux", goarch: "amd64"},
}
for idx, ttt := range osarchs {
t.Run(ttt.goos, func(tt *testing.T) {
ctx.Artifacts.Add(&artifact.Artifact{
Name: fmt.Sprintf("bin%d", idx),
Path: f.Name(),
Goos: ttt.goos,
Goarch: ttt.goarch,
Type: artifact.UploadableArchive,
Extra: map[string]interface{}{
"ID": "foo",
"Format": "tar.gz",
},
})
ctx.Artifacts.Add(&artifact.Artifact{
Name: fmt.Sprintf("bin%d", idx),
Path: f.Name(),
Goos: ttt.goos,
Goarch: ttt.goarch,
Type: artifact.UploadableArchive,
Extra: map[string]interface{}{
"ID": "bar",
"Format": "tar.gz",
},
})
client := &DummyClient{}
assert.Equal(t, ErrMultipleArchivesSameOS, doRun(ctx, ctx.Config.Brews[0], client))
assert.False(t, client.CreatedFile)
// clean the artifacts for the next run
ctx.Artifacts = artifact.New()
})
}
}
func TestRunPipeBrewNotSetup(t *testing.T) {
@ -329,6 +394,7 @@ func TestRunPipeNoUpload(t *testing.T) {
},
},
})
ctx.TokenType = context.TokenTypeGitHub
ctx.Git = context.GitInfo{CurrentTag: "v1.0.1"}
var path = filepath.Join(folder, "whatever.tar.gz")
_, err = os.Create(path)
@ -380,13 +446,41 @@ func TestRunPipeNoUpload(t *testing.T) {
}
assertNoPublish(tt)
})
t.Run("skip publish because not a github release", func(tt *testing.T) {
ctx.Config.Release.Draft = false
ctx.Config.Brew.SkipUpload = "false"
ctx.SkipPublish = false
ctx.TokenType = context.TokenTypeGitLab
assertNoPublish(tt)
}
func TestRunTokenTypeNotImplementedForBrew(t *testing.T) {
folder, err := ioutil.TempDir("", "goreleasertest")
assert.NoError(t, err)
var ctx = context.New(config.Project{
Dist: folder,
ProjectName: "foo",
Release: config.Release{},
Brews: []config.Homebrew{
{
GitHub: config.Repo{
Owner: "test",
Name: "test",
},
},
},
})
ctx.Git = context.GitInfo{CurrentTag: "v1.0.1"}
var path = filepath.Join(folder, "whatever.tar.gz")
_, err = os.Create(path)
assert.NoError(t, err)
ctx.Artifacts.Add(&artifact.Artifact{
Name: "bin",
Path: path,
Goos: "darwin",
Goarch: "amd64",
Type: artifact.UploadableArchive,
Extra: map[string]interface{}{
"ID": "foo",
"Format": "tar.gz",
},
})
client := &DummyClient{}
assert.Equal(t, ErrTokenTypeNotImplementedForBrew, doRun(ctx, ctx.Config.Brews[0], client))
}
func TestDefault(t *testing.T) {
@ -394,6 +488,7 @@ func TestDefault(t *testing.T) {
defer back()
var ctx = &context.Context{
TokenType: context.TokenTypeGitHub,
Config: config.Project{
ProjectName: "myproject",
Brews: []config.Homebrew{},
@ -427,8 +522,8 @@ func TestDefault(t *testing.T) {
}
func TestGHFolder(t *testing.T) {
assert.Equal(t, "bar.rb", ghFormulaPath("", "bar.rb"))
assert.Equal(t, "fooo/bar.rb", ghFormulaPath("fooo", "bar.rb"))
assert.Equal(t, "bar.rb", buildFormulaPath("", "bar.rb"))
assert.Equal(t, "fooo/bar.rb", buildFormulaPath("fooo", "bar.rb"))
}
type DummyClient struct {
@ -446,6 +541,6 @@ func (client *DummyClient) CreateFile(ctx *context.Context, commitAuthor config.
return
}
func (client *DummyClient) Upload(ctx *context.Context, releaseID string, name string, file *os.File) (err error) {
func (client *DummyClient) Upload(ctx *context.Context, releaseID string, artifact *artifact.Artifact, file *os.File) (err error) {
return
}

40
internal/pipe/brew/testdata/default_gitlab.rb.golden vendored Normal file
View File

@ -0,0 +1,40 @@
# This file was generated by GoReleaser. DO NOT EDIT.
class DefaultGitlab < Formula
desc "A run pipe test formula and FOO=foo_is_bar"
homepage "https://gitlab.com/goreleaser"
version "1.0.1"
bottle :unneeded
if OS.mac?
url "https://gitlab.com/test/test/uploads/820ead5d9d2266c728dce6d4d55b6460/bin.tar.gz"
sha256 "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
elsif OS.linux?
end
depends_on "zsh"
depends_on "bash"
conflicts_with "gtk+"
conflicts_with "qt"
def install
bin.install "default_gitlab"
end
def caveats; <<~EOS
don't do this default_gitlab
EOS
end
plist_options :startup => false
def plist; <<~EOS
<xml>whatever</xml>
EOS
end
test do
system "true"
system "#{bin}/foo -h"
end
end

40
internal/pipe/brew/testdata/gitlab_enterprise_url.rb.golden vendored Normal file
View File

@ -0,0 +1,40 @@
# This file was generated by GoReleaser. DO NOT EDIT.
class GitlabEnterpriseUrl < Formula
desc "A run pipe test formula and FOO=foo_is_bar"
homepage "https://gitlab.com/goreleaser"
version "1.0.1"
bottle :unneeded
if OS.mac?
url "https://gitlab.my-company.org/test/test/uploads/820ead5d9d2266c728dce6d4d55b6460/bin.tar.gz"
sha256 "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
elsif OS.linux?
end
depends_on "zsh"
depends_on "bash"
conflicts_with "gtk+"
conflicts_with "qt"
def install
bin.install "gitlab_enterprise_url"
end
def caveats; <<~EOS
don't do this gitlab_enterprise_url
EOS
end
plist_options :startup => false
def plist; <<~EOS
<xml>whatever</xml>
EOS
end
test do
system "true"
system "#{bin}/foo -h"
end
end

3
internal/pipe/defaults/defaults_test.go
View File

@ -21,7 +21,8 @@ func TestFillBasicData(t *testing.T) {
testlib.GitRemoteAdd(t, "git@github.com:goreleaser/goreleaser.git")
var ctx = &context.Context{
Config: config.Project{},
TokenType: context.TokenTypeGitHub,
Config: config.Project{},
}
assert.NoError(t, Pipe{}.Run(ctx))

2
internal/pipe/release/release.go
View File

@ -142,5 +142,5 @@ func upload(ctx *context.Context, client client.Client, releaseID string, artifa
}
defer file.Close() // nolint: errcheck
log.WithField("file", file.Name()).WithField("name", artifact.Name).Info("uploading to release")
return client.Upload(ctx, releaseID, artifact.Name, file)
return client.Upload(ctx, releaseID, artifact, file)
}

4
internal/pipe/release/release_test.go
View File

@ -374,7 +374,7 @@ func (client *DummyClient) CreateFile(ctx *context.Context, commitAuthor config.
return
}
func (client *DummyClient) Upload(ctx *context.Context, releaseID string, name string, file *os.File) error {
func (client *DummyClient) Upload(ctx *context.Context, releaseID string, artifact *artifact.Artifact, file *os.File) error {
client.Lock.Lock()
defer client.Lock.Unlock()
// ensure file is read to better mimic real behavior
@ -390,6 +390,6 @@ func (client *DummyClient) Upload(ctx *context.Context, releaseID string, name s
return errors.New("upload failed, should retry")
}
client.UploadedFile = true
client.UploadedFileNames = append(client.UploadedFileNames, name)
client.UploadedFileNames = append(client.UploadedFileNames, artifact.Name)
return nil
}

45
internal/pipe/scoop/scoop.go
View File

@ -17,6 +17,9 @@ import (
// ErrNoWindows when there is no build for windows (goos doesn't contain windows)
var ErrNoWindows = errors.New("scoop requires a windows build")
// ErrTokenTypeNotImplementedForScoop indicates that a new token type was not implemented for this pipe
var ErrTokenTypeNotImplementedForScoop = errors.New("token type not implemented for scoop pipe")
// Pipe for build
type Pipe struct{}
@ -44,14 +47,7 @@ func (Pipe) Default(ctx *context.Context) error {
if ctx.Config.Scoop.CommitAuthor.Email == "" {
ctx.Config.Scoop.CommitAuthor.Email = "goreleaser@carlosbecker.com"
}
if ctx.Config.Scoop.URLTemplate == "" {
ctx.Config.Scoop.URLTemplate = fmt.Sprintf(
"%s/%s/%s/releases/download/{{ .Tag }}/{{ .ArtifactName }}",
ctx.Config.GitHubURLs.Download,
ctx.Config.Release.GitHub.Owner,
ctx.Config.Release.GitHub.Name,
)
}
return nil
}
@ -59,12 +55,12 @@ func doRun(ctx *context.Context, client client.Client) error {
if ctx.Config.Scoop.Bucket.Name == "" {
return pipe.Skip("scoop section is not configured")
}
// If we'd use 'ctx.TokenType != context.TokenTypeGitHub' we'd have to adapt all the tests
// For simplicity we use this check because the functionality will be implemented later for
// all types of releases. See https://github.com/goreleaser/goreleaser/pull/1038#issuecomment-498891464
if ctx.TokenType == context.TokenTypeGitLab {
return pipe.Skip("scoop pipe is only configured for github releases")
}
// TODO mavogel: in another PR
// check if release pipe is not configured!
// if ctx.Config.Release.Disable {
// }
if ctx.Config.Archive.Format == "binary" {
return pipe.Skip("archive format is binary")
}
@ -131,6 +127,27 @@ func buildManifest(ctx *context.Context, artifacts []*artifact.Artifact) (bytes.
Persist: ctx.Config.Scoop.Persist,
}
if ctx.Config.Scoop.URLTemplate == "" {
switch ctx.TokenType {
case context.TokenTypeGitHub:
ctx.Config.Scoop.URLTemplate = fmt.Sprintf(
"%s/%s/%s/releases/download/{{ .Tag }}/{{ .ArtifactName }}",
ctx.Config.GitHubURLs.Download,
ctx.Config.Release.GitHub.Owner,
ctx.Config.Release.GitHub.Name,
)
case context.TokenTypeGitLab:
ctx.Config.Scoop.URLTemplate = fmt.Sprintf(
"%s/%s/%s/uploads/{{ .ArtifactUploadHash }}/{{ .ArtifactName }}",
ctx.Config.GitLabURLs.Download,
ctx.Config.Release.GitLab.Owner,
ctx.Config.Release.GitLab.Name,
)
default:
return result, ErrTokenTypeNotImplementedForScoop
}
}
for _, artifact := range artifacts {
var arch = "64bit"
if artifact.Goarch == "386" {

264
internal/pipe/scoop/scoop_test.go
View File

@ -28,6 +28,7 @@ func TestDefault(t *testing.T) {
defer back()
var ctx = &context.Context{
TokenType: context.TokenTypeGitHub,
Config: config.Project{
ProjectName: "barr",
Builds: []config.Build{
@ -85,9 +86,10 @@ func Test_doRun(t *testing.T) {
assertError errChecker
}{
{
"valid",
"valid public github",
args{
&context.Context{
TokenType: context.TokenTypeGitHub,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
@ -127,9 +129,10 @@ func Test_doRun(t *testing.T) {
shouldNotErr,
},
{
"valid",
"valid enterprise github",
args{
&context.Context{
TokenType: context.TokenTypeGitHub,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
@ -169,10 +172,172 @@ func Test_doRun(t *testing.T) {
},
shouldNotErr,
},
{
"valid public gitlab",
args{
&context.Context{
TokenType: context.TokenTypeGitLab,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
Version: "1.0.1",
Artifacts: artifact.New(),
Config: config.Project{
Builds: []config.Build{
{Binary: "test", Goarch: []string{"amd64"}, Goos: []string{"windows"}},
},
Dist: ".",
ProjectName: "run-pipe",
Archive: config.Archive{
Format: "tar.gz",
},
Release: config.Release{
GitLab: config.Repo{
Owner: "test",
Name: "test",
},
},
Scoop: config.Scoop{
Bucket: config.Repo{
Owner: "test",
Name: "test",
},
Description: "A run pipe test formula",
Homepage: "https://gitlab.com/goreleaser",
},
},
},
&DummyClient{},
},
[]*artifact.Artifact{
{
Name: "foo_1.0.1_windows_amd64.tar.gz",
Goos: "windows",
Goarch: "amd64",
Path: file,
Extra: map[string]interface{}{
"ArtifactUploadHash": "820ead5d9d2266c728dce6d4d55b6460",
},
},
{
Name: "foo_1.0.1_windows_386.tar.gz",
Goos: "windows",
Goarch: "386",
Path: file,
Extra: map[string]interface{}{
"ArtifactUploadHash": "820ead5d9d2266c728dce6d4d55b6460",
},
},
},
shouldNotErr,
},
{
"valid enterprise gitlab",
args{
&context.Context{
TokenType: context.TokenTypeGitLab,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
Version: "1.0.1",
Artifacts: artifact.New(),
Config: config.Project{
GitHubURLs: config.GitHubURLs{Download: "https://api.custom.gitlab.enterprise.com"},
Builds: []config.Build{
{Binary: "test", Goarch: []string{"amd64"}, Goos: []string{"windows"}},
},
Dist: ".",
ProjectName: "run-pipe",
Archive: config.Archive{
Format: "tar.gz",
},
Release: config.Release{
GitHub: config.Repo{
Owner: "test",
Name: "test",
},
},
Scoop: config.Scoop{
Bucket: config.Repo{
Owner: "test",
Name: "test",
},
Description: "A run pipe test formula",
Homepage: "https://gitlab.com/goreleaser",
},
},
},
&DummyClient{},
},
[]*artifact.Artifact{
{
Name: "foo_1.0.1_windows_amd64.tar.gz",
Goos: "windows",
Goarch: "amd64",
Path: file,
Extra: map[string]interface{}{
"ArtifactUploadHash": "820ead5d9d2266c728dce6d4d55b6460",
},
},
{
Name: "foo_1.0.1_windows_386.tar.gz",
Goos: "windows",
Goarch: "386",
Path: file,
Extra: map[string]interface{}{
"ArtifactUploadHash": "820ead5d9d2266c728dce6d4d55b6460",
},
},
},
shouldNotErr,
},
{
"token type not implemented for pipe",
args{
&context.Context{
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
Version: "1.0.1",
Artifacts: artifact.New(),
Config: config.Project{
Builds: []config.Build{
{Binary: "test", Goarch: []string{"amd64"}, Goos: []string{"windows"}},
},
Dist: ".",
ProjectName: "run-pipe",
Archive: config.Archive{
Format: "tar.gz",
},
Release: config.Release{
GitHub: config.Repo{
Owner: "test",
Name: "test",
},
},
Scoop: config.Scoop{
Bucket: config.Repo{
Owner: "test",
Name: "test",
},
Description: "A run pipe test formula",
Homepage: "https://github.com/goreleaser",
},
},
},
&DummyClient{},
},
[]*artifact.Artifact{
{Name: "foo_1.0.1_windows_amd64.tar.gz", Goos: "windows", Goarch: "amd64", Path: file},
{Name: "foo_1.0.1_windows_386.tar.gz", Goos: "windows", Goarch: "386", Path: file},
},
shouldErr(ErrTokenTypeNotImplementedForScoop.Error()),
},
{
"no windows build",
args{
&context.Context{
TokenType: context.TokenTypeGitHub,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
@ -215,6 +380,7 @@ func Test_doRun(t *testing.T) {
"no scoop",
args{
&context.Context{
TokenType: context.TokenTypeGitHub,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
@ -249,6 +415,7 @@ func Test_doRun(t *testing.T) {
"no publish",
args{
&context.Context{
TokenType: context.TokenTypeGitHub,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
@ -292,6 +459,7 @@ func Test_doRun(t *testing.T) {
"is draft",
args{
&context.Context{
TokenType: context.TokenTypeGitHub,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
@ -331,6 +499,7 @@ func Test_doRun(t *testing.T) {
"no archive",
args{
&context.Context{
TokenType: context.TokenTypeGitHub,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
@ -360,54 +529,11 @@ func Test_doRun(t *testing.T) {
},
&DummyClient{},
},
[]*artifact.Artifact{
{Name: "foo_1.0.1_windows_amd64.tar.gz", Goos: "windows", Goarch: "amd64"},
{Name: "foo_1.0.1_windows_386.tar.gz", Goos: "windows", Goarch: "386"},
},
shouldErr("archive format is binary"),
},
{
"valid but non github release",
args{
&context.Context{
TokenType: context.TokenTypeGitLab,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
Version: "1.0.1",
Artifacts: artifact.New(),
Config: config.Project{
Builds: []config.Build{
{Binary: "test", Goarch: []string{"amd64"}, Goos: []string{"windows"}},
},
Dist: ".",
ProjectName: "run-pipe",
Archive: config.Archive{
Format: "tar.gz",
},
Release: config.Release{
GitLab: config.Repo{
Owner: "test",
Name: "test",
},
},
Scoop: config.Scoop{
Bucket: config.Repo{
Owner: "test",
Name: "test",
},
Description: "A run pipe test formula",
Homepage: "https://github.com/goreleaser",
},
},
},
&DummyClient{},
},
[]*artifact.Artifact{
{Name: "foo_1.0.1_windows_amd64.tar.gz", Goos: "windows", Goarch: "amd64", Path: file},
{Name: "foo_1.0.1_windows_386.tar.gz", Goos: "windows", Goarch: "386", Path: file},
},
shouldErr("scoop pipe is only configured for github releases"),
shouldErr("archive format is binary"),
},
}
for _, tt := range tests {
@ -435,6 +561,7 @@ func Test_buildManifest(t *testing.T) {
{
"testdata/test_buildmanifest.json.golden",
&context.Context{
TokenType: context.TokenTypeGitHub,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
@ -470,6 +597,7 @@ func Test_buildManifest(t *testing.T) {
{
"testdata/test_buildmanifest_url_template.json.golden",
&context.Context{
TokenType: context.TokenTypeGitHub,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
@ -506,6 +634,46 @@ func Test_buildManifest(t *testing.T) {
},
},
},
{
"testdata/test_buildmanifest_gitlab_url_template.json.golden",
&context.Context{
TokenType: context.TokenTypeGitLab,
Git: context.GitInfo{
CurrentTag: "v1.0.1",
},
Version: "1.0.1",
Artifacts: artifact.New(),
Config: config.Project{
GitLabURLs: config.GitLabURLs{
Download: "https://gitlab.com",
},
Builds: []config.Build{
{Binary: "test"},
},
Dist: ".",
ProjectName: "run-pipe",
Archive: config.Archive{
Format: "tar.gz",
},
Release: config.Release{
GitHub: config.Repo{
Owner: "test",
Name: "test",
},
},
Scoop: config.Scoop{
Bucket: config.Repo{
Owner: "test",
Name: "test",
},
Description: "A run pipe test formula",
Homepage: "https://gitlab.com/goreleaser",
URLTemplate: "http://gitlab.mycompany.com/foo/bar/uploads/{{ .ArtifactUploadHash }}/{{ .ArtifactName }}",
Persist: []string{"data.cfg", "etc"},
},
},
},
},
}
for _, tt := range tests {
@ -520,6 +688,7 @@ func Test_buildManifest(t *testing.T) {
Goarch: "amd64",
Path: file,
Extra: map[string]interface{}{
"ArtifactUploadHash": "820ead5d9d2266c728dce6d4d55b6460",
"Builds": []*artifact.Artifact{
{
Extra: map[string]interface{}{
@ -540,6 +709,7 @@ func Test_buildManifest(t *testing.T) {
Goarch: "386",
Path: file,
Extra: map[string]interface{}{
"ArtifactUploadHash": "820ead5d9d2266c728dce6d4d55b6460",
"Builds": []*artifact.Artifact{
{
Extra: map[string]interface{}{
@ -583,6 +753,6 @@ func (client *DummyClient) CreateFile(ctx *context.Context, commitAuthor config.
return
}
func (client *DummyClient) Upload(ctx *context.Context, releaseID string, name string, file *os.File) (err error) {
func (client *DummyClient) Upload(ctx *context.Context, releaseID string, artifact *artifact.Artifact, file *os.File) (err error) {
return
}

27
internal/pipe/scoop/testdata/test_buildmanifest_gitlab_url_template.json.golden vendored Normal file
View File

@ -0,0 +1,27 @@
{
"version": "1.0.1",
"architecture": {
"32bit": {
"url": "http://gitlab.mycompany.com/foo/bar/uploads/820ead5d9d2266c728dce6d4d55b6460/foo_1.0.1_windows_386.tar.gz",
"bin": [
"foo.exe",
"bar.exe"
],
"hash": "5e2bf57d3f40c4b6df69daf1936cb766f832374b4fc0259a7cbff06e2f70f269"
},
"64bit": {
"url": "http://gitlab.mycompany.com/foo/bar/uploads/820ead5d9d2266c728dce6d4d55b6460/foo_1.0.1_windows_amd64.tar.gz",
"bin": [
"foo.exe",
"bar.exe"
],
"hash": "5e2bf57d3f40c4b6df69daf1936cb766f832374b4fc0259a7cbff06e2f70f269"
}
},
"homepage": "https://gitlab.com/goreleaser",
"description": "A run pipe test formula",
"persist": [
"data.cfg",
"etc"
]
}

7
internal/tmpl/tmpl.go
View File

@ -40,6 +40,8 @@ const (
arm = "Arm"
binary = "Binary"
artifactName = "ArtifactName"
// gitlab only
artifactUploadHash = "ArtifactUploadHash"
)
// New Template
@ -92,6 +94,11 @@ func (t *Template) WithArtifact(a *artifact.Artifact, replacements map[string]st
t.fields[arm] = replace(replacements, a.Goarm)
t.fields[binary] = bin.(string)
t.fields[artifactName] = a.Name
if val, ok := a.Extra["ArtifactUploadHash"]; ok {
t.fields[artifactUploadHash] = val
} else {
t.fields[artifactUploadHash] = ""
}
return t
}

19
internal/tmpl/tmpl_test.go
View File

@ -39,6 +39,7 @@ func TestWithArtifact(t *testing.T) {
"shortcommit": "{{.ShortCommit}}",
"binary": "{{.Binary}}",
"proj": "{{.ProjectName}}",
"": "{{.ArtifactUploadHash}}",
} {
tmpl := tmpl
expect := expect
@ -61,6 +62,24 @@ func TestWithArtifact(t *testing.T) {
})
}
t.Run("artifact with gitlab ArtifactUploadHash", func(tt *testing.T) {
tt.Parallel()
uploadHash := "820ead5d9d2266c728dce6d4d55b6460"
result, err := New(ctx).WithArtifact(
&artifact.Artifact{
Name: "another-binary",
Goarch: "amd64",
Goos: "linux",
Goarm: "6",
Extra: map[string]interface{}{
"ArtifactUploadHash": uploadHash,
},
}, map[string]string{},
).Apply("{{ .ArtifactUploadHash }}")
assert.NoError(tt, err)
assert.Equal(tt, uploadHash, result)
})
t.Run("artifact without binary name", func(tt *testing.T) {
tt.Parallel()
result, err := New(ctx).WithArtifact(

1
pkg/config/config.go
View File

@ -45,6 +45,7 @@ func (r Repo) String() string {
type Homebrew struct {
Name string `yaml:",omitempty"`
GitHub Repo `yaml:",omitempty"`
GitLab Repo `yaml:",omitempty"`
CommitAuthor CommitAuthor `yaml:"commit_author,omitempty"`
Folder string `yaml:",omitempty"`
Caveats string `yaml:",omitempty"`

10
pkg/context/context.go
View File

@ -38,14 +38,14 @@ func (e Env) Strings() []string {
return result
}
// tokenType is either github or gitlab
type tokenType string
// TokenType is either github or gitlab
type TokenType string
const (
// TokenTypeGitHub defines github as type of the token
TokenTypeGitHub tokenType = "github"
TokenTypeGitHub TokenType = "github"
// TokenTypeGitLab defines gitlab as type of the token
TokenTypeGitLab tokenType = "gitlab"
TokenTypeGitLab TokenType = "gitlab"
)
// Context carries along some data through the pipes
@ -54,7 +54,7 @@ type Context struct {
Config config.Project
Env Env
Token string
TokenType tokenType
TokenType TokenType
Git GitInfo
Artifacts artifact.Artifacts
ReleaseNotes string

20
www/content/homebrew.md
View File

@ -5,7 +5,7 @@ hideFromIndex: true
weight: 90
---
After releasing to GitHub (GitLab is not supported yet), GoReleaser can generate and publish a _homebrew-tap_
After releasing to GitHub or GitLab, GoReleaser can generate and publish a _homebrew-tap_
recipe into a repository that you have access to.
The `brew` section specifies how the formula should be created.
@ -29,13 +29,23 @@ brews:
- foo
- bar
# Repository to push the tap to.
# NOTE: make sure the url_template, the token and given repo (github or gitlab) owner and name are from the
# same kind. We will probably unify this in the next major version like it is done with scoop.
# Github repository to push the tap to.
github:
owner: user
owner: github-user
name: homebrew-tap
# Template for the url.
# Default is "https://github.com/<repo_owner>/<repo_name>/releases/download/{{ .Tag }}/{{ .ArtifactName }}"
# OR Gitlab
# gitlab:
# owner: gitlab-user
# name: homebrew-tap
# Template for the url which is determined by the given Token (github or gitlab)
# Default for github is "https://github.com/<repo_owner>/<repo_name>/releases/download/{{ .Tag }}/{{ .ArtifactName }}"
# Default for gitlab is "https://gitlab.com/<repo_owner>/<repo_name>/uploads/{{ .ArtifactUploadHash }}/{{ .ArtifactName }}"
url_template: "http://github.mycompany.com/foo/bar/releases/{{ .Tag }}/{{ .ArtifactName }}"
# Allows you to set a custom download strategy.

7
www/content/scoop.md
View File

@ -5,7 +5,7 @@ hideFromIndex: true
weight: 100
---
After releasing to GitHub (GitLab is not supported yet), GoReleaser can generate and publish a
After releasing to GitHub or GitLab, GoReleaser can generate and publish a
_Scoop App Manifest_ into a repository that you have access to.
The `scoop` section specifies how the manifest should be created. See
@ -14,8 +14,9 @@ the commented example bellow:
```yml
# .goreleaser.yml
scoop:
# Template for the url.
# Default is "https://github.com/<repo_owner>/<repo_name>/releases/download/{{ .Tag }}/{{ .ArtifactName }}"
# Template for the url which is determined by the given Token (github or gitlab)
# Default for github is "https://github.com/<repo_owner>/<repo_name>/releases/download/{{ .Tag }}/{{ .ArtifactName }}"
# Default for gitlab is "https://gitlab.com/<repo_owner>/<repo_name>/uploads/{{ .ArtifactUploadHash }}/{{ .ArtifactName }}"
url_template: "http://github.mycompany.com/foo/bar/releases/{{ .Tag }}/{{ .ArtifactName }}"
# Repository to push the app manifest to.