cybercinch/go-semantic-release
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 14 Wiki Activity

refactor(pkg): clean up semantic release interface

Browse Source
This commit is contained in:
Nightapes
2019-07-24 22:14:03 +02:00
parent e222734a1a
commit 1daff2bc8a
9 changed files with 171 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pkg/config/config.go
View File

@@ -55,7 +55,7 @@ func Read(configPath string) (*ReleaseConfig, error) {
return &ReleaseConfig{}, err
}
log.Debugf("Found config %+v", releaseConfig)
log.Tracef("Found config %+v", releaseConfig)
return &releaseConfig, nil
}

112
pkg/config/config_test.go Normal file
View File

@@ -0,0 +1,112 @@
package config_test
import (
"testing"
"github.com/Nightapes/go-semantic-release/pkg/config"
"github.com/stretchr/testify/assert"
"io/ioutil"
"os"
"path"
)
func TestReadCacheNotFound(t *testing.T) {
_, err := config.Read("notfound/dir")
assert.Errorf(t, err, "Read non exsiting file")
}
func TestReadCacheInvalidContent(t *testing.T) {
dir, err := ioutil.TempDir("", "prefix")
assert.NoError(t, err)
defer os.RemoveAll(dir)
completePath := path.Join(path.Dir(dir), ".release.yml")
brokenContent := []byte("hello broken\ngo: lang\n")
err = ioutil.WriteFile(completePath, brokenContent, 0644)
assert.NoError(t, err)
_, readError := config.Read(completePath)
assert.Errorf(t, readError, "Should give error, when broken content")
}
func TestWriteAndReadCache(t *testing.T) {
dir, err := ioutil.TempDir("", "prefix")
assert.NoError(t, err)
defer os.RemoveAll(dir)
completePath := path.Join(path.Dir(dir), ".release.yml")
content := []byte(`
commitFormat: angular
title: "go-semantic-release release"
branch:
master: release
rc: rc
beta: beta
alpha: alpha
add_git_releases: alpha
changelog:
printAll: false
template: ''
templatePath: ''
release: 'github'
assets:
- name: ./build/go-semantic-release
compress: false
github:
repo: "go-semantic-release"
user: "nightapes"
customUrl: ""
`)
err = ioutil.WriteFile(completePath, content, 0644)
assert.NoError(t, err)
result, readError := config.Read(completePath)
assert.NoErrorf(t, readError, "Should read file")
assert.EqualValues(t, &config.ReleaseConfig{
CommitFormat: "angular",
Branch: map[string]string{"add_git_releases": "alpha", "alpha": "alpha", "beta": "beta", "master": "release", "rc": "rc"},
Changelog: config.ChangelogConfig{
PrintAll: false,
Template: "",
TemplatePath: ""},
Release: "github",
GitHubProvider: config.GitHubProvider{
Repo: "go-semantic-release",
User: "nightapes",
CustomURL: "",
AccessToken: ""},
Assets: []config.Asset{
config.Asset{
Name: "./build/go-semantic-release",
Compress: false}},
ReleaseTitle: "go-semantic-release release",
IsPreRelease: false,
IsDraft: false,
}, result)
}
// func TestWriteNotFound(t *testing.T) {
// err := cache.Write("notfound/dir", shared.ReleaseVersion{
// Last: shared.ReleaseVersionEntry{
// Commit: "12345",
// Version: createVersion("1.0.0"),
// },
// Next: shared.ReleaseVersionEntry{
// Commit: "12346",
// Version: createVersion("1.1.0"),
// },
// Branch: "master",
// Draft: true,
// })
// assert.Errorf(t, err, "Write non exsiting file")
// }

79
pkg/semanticrelease/semantic-release.go
View File

@@ -1,7 +1,6 @@
package semanticrelease
import (
"fmt"
"io/ioutil"
"strings"
"time"
@@ -57,36 +56,28 @@ func New(c *config.ReleaseConfig, repository string) (*SemanticRelease, error) {
}, nil
}
//GetCIProvider result with ci config
func (s *SemanticRelease) GetCIProvider() (*ci.ProviderConfig, error) {
return ci.GetCIProvider(s.gitutil, ci.ReadAllEnvs())
}
// GetNextVersion from .version or calculate new from commits
func (s *SemanticRelease) GetNextVersion(force bool) (*shared.ReleaseVersion, error) {
provider, err := ci.GetCIProvider(s.gitutil, ci.ReadAllEnvs())
if err != nil {
fakeVersion, _ := semver.NewVersion("0.0.0-fake.0")
log.Warnf("Will not calculate version, set fake version. Could not find CI Provider, if running locally, set env CI=true")
return &shared.ReleaseVersion{
Next: shared.ReleaseVersionEntry{
Commit: "",
Version: fakeVersion,
},
}, nil
}
func (s *SemanticRelease) GetNextVersion(provider *ci.ProviderConfig, force bool) (*shared.ReleaseVersion, map[analyzer.Release][]analyzer.AnalyzedCommit, error) {
log.Debugf("Ignore .version file if exits, %t", force)
if !force {
releaseVersion, err := cache.Read(s.repository)
if err != nil {
return nil, err
return nil, nil, err
}
if releaseVersion.Next.Commit == provider.Commit && releaseVersion != nil {
return releaseVersion, nil
return releaseVersion, nil, nil
}
}
lastVersion, lastVersionHash, err := s.gitutil.GetLastVersion()
if err != nil {
return nil, err
return nil, nil, err
}
firstRelease := false
@@ -99,22 +90,19 @@ func (s *SemanticRelease) GetNextVersion(force bool) (*shared.ReleaseVersion, er
commits, err := s.gitutil.GetCommits(lastVersionHash)
if err != nil {
return nil, err
return nil, nil, err
}
log.Debugf("Found %d commits till last release", len(commits))
a, err := analyzer.New(s.config.CommitFormat, s.config.Changelog)
if err != nil {
return nil, err
}
analyzedCommits := s.analyzer.Analyze(commits)
isDraft := false
var newVersion semver.Version
for branch, releaseType := range s.config.Branch {
if provider.Branch == branch || strings.HasPrefix(provider.Branch, branch) {
log.Debugf("Found branch config for branch %s with release type %s", provider.Branch, releaseType)
newVersion, isDraft = s.calculator.CalculateNewVersion(a.Analyze(commits), lastVersion, releaseType, firstRelease)
newVersion, isDraft = s.calculator.CalculateNewVersion(analyzedCommits, lastVersion, releaseType, firstRelease)
break
}
}
@@ -135,25 +123,19 @@ func (s *SemanticRelease) GetNextVersion(force bool) (*shared.ReleaseVersion, er
log.Infof("New version %s -> %s", lastVersion.String(), newVersion.String())
err = cache.Write(s.repository, releaseVersion)
if err != nil {
return nil, err
return nil, nil, err
}
return &releaseVersion, err
return &releaseVersion, analyzedCommits, err
}
//SetVersion for git repository
func (s *SemanticRelease) SetVersion(version string) error {
func (s *SemanticRelease) SetVersion(provider *ci.ProviderConfig, version string) error {
newVersion, err := semver.NewVersion(version)
if err != nil {
return err
}
provider, err := ci.GetCIProvider(s.gitutil, ci.ReadAllEnvs())
if err != nil {
return fmt.Errorf("will not set version. Could not find CI Provider, if running locally, set env CI=true")
}
lastVersion, lastVersionHash, err := s.gitutil.GetLastVersion()
if err != nil {
return err
@@ -176,23 +158,14 @@ func (s *SemanticRelease) SetVersion(version string) error {
}
// GetChangelog from last version till now
func (s *SemanticRelease) GetChangelog(releaseVersion *shared.ReleaseVersion) (*shared.GeneratedChangelog, error) {
commits, err := s.gitutil.GetCommits(releaseVersion.Last.Commit)
if err != nil {
return nil, err
}
result := s.analyzer.Analyze(commits)
log.Debugf("Found %d commits till last release", len(commits))
func (s *SemanticRelease) GetChangelog(analyzedCommits map[analyzer.Release][]analyzer.AnalyzedCommit, releaseVersion *shared.ReleaseVersion) (*shared.GeneratedChangelog, error) {
c := changelog.New(s.config, s.analyzer.GetRules(), time.Now())
return c.GenerateChanglog(shared.ChangelogTemplateConfig{
Version: releaseVersion.Next.Version.String(),
Hash: releaseVersion.Last.Commit,
CommitURL: s.releaser.GetCommitURL(),
CompareURL: s.releaser.GetCompareURL(releaseVersion.Last.Version.String(), releaseVersion.Next.Version.String()),
}, result)
}, analyzedCommits)
}
@@ -202,14 +175,7 @@ func (s *SemanticRelease) WriteChangeLog(changelogContent, file string) error {
}
// Release pusblish release to provider
func (s *SemanticRelease) Release(force bool) error {
provider, err := ci.GetCIProvider(s.gitutil, ci.ReadAllEnvs())
if err != nil {
log.Debugf("Will not perform a new release. Could not find CI Provider")
return nil
}
func (s *SemanticRelease) Release(provider *ci.ProviderConfig, force bool) error {
if provider.IsPR {
log.Debugf("Will not perform a new release. This is a pull request")
@@ -221,13 +187,18 @@ func (s *SemanticRelease) Release(force bool) error {
return nil
}
releaseVersion, err := s.GetNextVersion(force)
releaseVersion, analyzedCommits, err := s.GetNextVersion(provider, force)
if err != nil {
log.Debugf("Could not get next version")
return err
}
generatedChanglog, err := s.GetChangelog(releaseVersion)
if releaseVersion.Next.Version.Equal(releaseVersion.Next.Version) {
log.Infof("No new version, no release needed")
return nil
}
generatedChanglog, err := s.GetChangelog(analyzedCommits, releaseVersion)
if err != nil {
log.Debugf("Could not get changelog")
return err