refactor(*): clean up code

pkg/config/config.go

@@ -2,18 +2,12 @@
 package config
 
 import (
-	"fmt"
 	"io/ioutil"
-	"os"
-	"strings"
 
 	log "github.com/sirupsen/logrus"
 	"gopkg.in/yaml.v2"
 )
 
-// List of all supported git providers
-var gitProviders = map[string]string{"GitHub": "https://github.com/", "GitLab": "https://gitlab.com/"}
-
 // ChangelogConfig struct
 type ChangelogConfig struct {
 	PrintAll     bool   `yaml:"printAll,omitempty"`
@@ -21,28 +15,27 @@ type ChangelogConfig struct {
 	TemplatePath string `yaml:"templatePath,omitempty"`
 }
 
-// GitProvider struct
-type GitProvider struct {
-	Name              string `yaml:"name"`
-	Repo              string `yaml:"repo"`
-	User              string `yaml:"user"`
-	customProviderURL string `yaml:"customURL"`
-	AccessToken       string
-}
-
 //Asset type struct
 type Asset struct {
 	Name     string `yaml:"name"`
 	Compress bool   `yaml:"compress"`
 }
 
+// GitHubProvider struct
+type GitHubProvider struct {
+	Repo        string `yaml:"repo"`
+	User        string `yaml:"user"`
+	CustomURL   string `yaml:"customUrl,omitempty"`
+	AccessToken string
+}
+
 // ReleaseConfig struct
 type ReleaseConfig struct {
 	CommitFormat          string            `yaml:"commitFormat"`
 	Branch                map[string]string `yaml:"branch"`
 	Changelog             ChangelogConfig   `yaml:"changelog,omitempty"`
 	Release               string            `yaml:"release,omitempty"`
-	GitProvider           GitProvider       `yaml:"provider,omitempty"`
+	GitHubProvider        GitHubProvider    `yaml:"github,omitempty"`
 	Assets                []Asset           `yaml:"assets"`
 	ReleaseTitle          string            `yaml:"title"`
 	IsPreRelease, IsDraft bool
@@ -64,36 +57,5 @@ func Read(configPath string) (*ReleaseConfig, error) {
 
 	log.Debugf("Found config %+v", releaseConfig)
 
-	releaseConfig, err = checkProvider(releaseConfig)
-	if err != nil {
-		return &ReleaseConfig{}, err
-	}
 	return &releaseConfig, nil
 }
-
-func checkProvider(config ReleaseConfig) (ReleaseConfig, error) {
-	if config.GitProvider != (GitProvider{}) {
-		if _, ok := gitProviders[config.GitProvider.Name]; !ok {
-			return ReleaseConfig{}, fmt.Errorf("config: provider: configured provider %s is not supported", config.GitProvider.Name)
-		}
-		envName := fmt.Sprintf("%s_ACCESS_TOKEN", strings.ToUpper(config.GitProvider.Name))
-
-		token, isSet := os.LookupEnv(envName)
-		if !isSet {
-			return ReleaseConfig{}, fmt.Errorf("config: Can not find environment variable %s", envName)
-		}
-		config.GitProvider.AccessToken = token
-	} else {
-		log.Debugln("No provider is set, will continue")
-	}
-	return config, nil
-}
-
-// GetRepositoryURL returns the repo FQDN
-func (c *ReleaseConfig) GetRepositoryURL() string {
-	if c.GitProvider.customProviderURL != "" {
-		return fmt.Sprintf("%s/%s/%s/", c.GitProvider.customProviderURL, c.GitProvider.User, c.GitProvider.Repo)
-	} else {
-		return fmt.Sprintf("%s/%s/%s/", gitProviders[c.GitProvider.Name], c.GitProvider.User, c.GitProvider.Repo)
-	}
-}

pkg/semanticrelease/helper.go

@@ -0,0 +1,87 @@
+package semanticrelease
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/Masterminds/semver"
+	"github.com/Nightapes/go-semantic-release/internal/cache"
+	"github.com/Nightapes/go-semantic-release/internal/shared"
+	log "github.com/sirupsen/logrus"
+)
+
+func (s *SemanticRelease) incPrerelease(preReleaseType string, version semver.Version) semver.Version {
+	defaultPrerelease := preReleaseType + ".0"
+	if version.Prerelease() == "" || !strings.HasPrefix(version.Prerelease(), preReleaseType) {
+		version, _ = version.SetPrerelease(defaultPrerelease)
+	} else {
+		parts := strings.Split(version.Prerelease(), ".")
+		if len(parts) == 2 {
+			i, err := strconv.Atoi(parts[1])
+			if err != nil {
+				version, _ = version.SetPrerelease(defaultPrerelease)
+				log.Warnf("Could not parse release tag %s, use version %s", version.Prerelease(), version.String())
+			} else {
+				version, _ = version.SetPrerelease(preReleaseType + "." + strconv.Itoa((i + 1)))
+			}
+		} else {
+			version, _ = version.SetPrerelease(defaultPrerelease)
+			log.Warnf("Could not parse release tag %s, use version %s", version.Prerelease(), version.String())
+		}
+	}
+
+	return version
+}
+
+func (s *SemanticRelease) saveToCache(releaseVersion shared.ReleaseVersion) error {
+
+	toCache := cache.ReleaseVersion{
+		Next: cache.ReleaseVersionEntry{
+			Commit:  releaseVersion.Next.Commit,
+			Version: releaseVersion.Next.Version.String(),
+		},
+		Last: cache.ReleaseVersionEntry{
+			Commit:  releaseVersion.Last.Commit,
+			Version: releaseVersion.Last.Version.String(),
+		},
+		Branch: releaseVersion.Branch,
+	}
+
+	log.Debugf("Save %s with hash %s to cache", releaseVersion.Next.Version.String(), releaseVersion.Next.Commit)
+	return cache.Write(s.repository, toCache)
+}
+
+func (s *SemanticRelease) readFromCache(currentHash string) (*shared.ReleaseVersion, error) {
+	content, err := cache.Read(s.repository)
+
+	if err == nil && content.Next.Commit == currentHash {
+
+		nextVersion, err := semver.NewVersion(content.Next.Version)
+		if err != nil {
+			return nil, err
+		}
+
+		lastVersion, err := semver.NewVersion(content.Last.Version)
+		if err != nil {
+			return nil, err
+		}
+
+		releaseVersion := &shared.ReleaseVersion{
+			Next: shared.ReleaseVersionEntry{
+				Commit:  content.Next.Commit,
+				Version: nextVersion,
+			},
+			Last: shared.ReleaseVersionEntry{
+				Commit:  content.Last.Commit,
+				Version: lastVersion,
+			},
+			Branch: content.Branch,
+		}
+
+		log.Infof("Found cache, will return cached version %s", content.Next.Version)
+		return releaseVersion, nil
+
+	}
+	log.Debugf("Mismatch git and version file  %s - %s", content.Next.Commit, currentHash)
+	return nil, nil
+}

pkg/semanticrelease/semantic-release.go

@@ -1,61 +1,83 @@
-// Package semanticrelease provides public methods to include in own code
 package semanticrelease
 
 import (
-	"fmt"
 	"io/ioutil"
-	"strconv"
 	"strings"
 
 	"github.com/Masterminds/semver"
 	"github.com/Nightapes/go-semantic-release/internal/analyzer"
-	"github.com/Nightapes/go-semantic-release/internal/cache"
 	"github.com/Nightapes/go-semantic-release/internal/changelog"
 	"github.com/Nightapes/go-semantic-release/internal/gitutil"
 	"github.com/Nightapes/go-semantic-release/internal/releaser"
+	"github.com/Nightapes/go-semantic-release/internal/shared"
 	"github.com/Nightapes/go-semantic-release/pkg/config"
 	log "github.com/sirupsen/logrus"
 )
 
 // SemanticRelease struct
 type SemanticRelease struct {
-	config *config.ReleaseConfig
+	config     *config.ReleaseConfig
+	gitutil    *gitutil.GitUtil
+	analyzer   *analyzer.Analyzer
+	releaser   releaser.Releaser
+	repository string
 }
 
 // New SemanticRelease struct
-func New(c *config.ReleaseConfig) *SemanticRelease {
-	return &SemanticRelease{
-		config: c,
+func New(c *config.ReleaseConfig, repository string) (*SemanticRelease, error) {
+	util, err := gitutil.New(repository)
+	if err != nil {
+		return nil, err
 	}
+
+	analyzer, err := analyzer.New(c.CommitFormat, c.Changelog)
+	if err != nil {
+		return nil, err
+	}
+
+	releaser, err := releaser.New(c).GetReleaser()
+	if err != nil {
+		return nil, err
+	}
+
+	return &SemanticRelease{
+		config:     c,
+		gitutil:    util,
+		releaser:   releaser,
+		analyzer:   analyzer,
+		repository: repository,
+	}, nil
 }
 
 // GetNextVersion from .version or calculate new from commits
-func (s *SemanticRelease) GetNextVersion(repo string, force bool) (string, error) {
-	util, err := gitutil.New(repo)
+func (s *SemanticRelease) GetNextVersion(force bool) (*shared.ReleaseVersion, error) {
+	hash, err := s.gitutil.GetHash()
 	if err != nil {
-		return "", err
-	}
-
-	hash, err := util.GetHash()
-	if err != nil {
-		return "", err
+		return nil, err
 	}
 
 	log.Debugf("Ignore .version file if exits, %t", force)
 	if !force {
-		content, err := cache.Read()
-
-		if err == nil && content.Commit == hash {
-			log.Infof("Found cache, will return cached version %s", content.NextVersion)
-			return content.NextVersion, err
+		releaseVersion, err := s.readFromCache(hash)
+		if err != nil {
+			return nil, err
+		}
+
+		if releaseVersion != nil {
+			return releaseVersion, nil
 		}
-		log.Debugf("Mismatch git and version file  %s - %s", content.Commit, hash)
 	}
 
-	lastVersion, lastVersionHash, err := util.GetLastVersion()
+	currentBranch, err := s.gitutil.GetBranch()
 	if err != nil {
-		return "", err
+		return nil, err
 	}
+
+	lastVersion, lastVersionHash, err := s.gitutil.GetLastVersion()
+	if err != nil {
+		return nil, err
+	}
+
 	var newVersion semver.Version
 
 	if lastVersion == nil {
@@ -66,30 +88,25 @@ func (s *SemanticRelease) GetNextVersion(repo string, force bool) (string, error
 		newVersion = *lastVersion
 	}
 
-	commits, err := util.GetCommits(lastVersionHash)
+	commits, err := s.gitutil.GetCommits(lastVersionHash)
 	if err != nil {
-		return "", err
+		return 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 "", err
+		return nil, err
 	}
 	result := a.Analyze(commits)
 
-	currentBranch, err := util.GetBranch()
-	if err != nil {
-		return "", err
-	}
-
 	for branch, releaseType := range s.config.Branch {
 		if currentBranch == branch || strings.HasPrefix(currentBranch, branch) {
 			log.Debugf("Found branch config for branch %s with release type %s", currentBranch, releaseType)
 			switch releaseType {
 			case "rc", "beta", "alpha":
-				newVersion = incPrerelease(releaseType, newVersion)
+				newVersion = s.incPrerelease(releaseType, newVersion)
 			case "release":
 				if len(result["major"]) > 0 {
 					newVersion = newVersion.IncMajor()
@@ -102,121 +119,83 @@ func (s *SemanticRelease) GetNextVersion(repo string, force bool) (string, error
 		}
 	}
 
-	log.Infof("New version %s -> %s", lastVersion.String(), newVersion.String())
-	err = saveToCache(util, lastVersion, &newVersion)
-	if err != nil {
-		return "", err
+	releaseVersion := shared.ReleaseVersion{
+		Next: shared.ReleaseVersionEntry{
+			Commit:  hash,
+			Version: &newVersion,
+		},
+		Last: shared.ReleaseVersionEntry{
+			Commit:  lastVersionHash,
+			Version: lastVersion,
+		},
+		Branch: currentBranch,
 	}
-	return newVersion.String(), err
+
+	log.Infof("New version %s -> %s", lastVersion.String(), newVersion.String())
+	err = s.saveToCache(releaseVersion)
+	if err != nil {
+		return nil, err
+	}
+	return &releaseVersion, err
 }
 
 //SetVersion for git repository
-func (s *SemanticRelease) SetVersion(version string, repo string) error {
-
-	util, err := gitutil.New(repo)
-	if err != nil {
-		return err
-	}
+func (s *SemanticRelease) SetVersion(version string) error {
 
 	newVersion, err := semver.NewVersion(version)
 	if err != nil {
 		return err
 	}
 
-	lastVersion, _, err := util.GetLastVersion()
+	lastVersion, lastVersionHash, err := s.gitutil.GetLastVersion()
+	if err != nil {
+		return err
+	}
+	if lastVersion == nil {
+		lastVersion, _ = semver.NewVersion("1.0.0")
+	}
+
+	hash, err := s.gitutil.GetHash()
 	if err != nil {
 		return err
 	}
 
-	return saveToCache(util, lastVersion, newVersion)
-}
-
-func saveToCache(util *gitutil.GitUtil, lastVersion *semver.Version, nextVersion *semver.Version) error {
-
-	hash, err := util.GetHash()
+	currentBranch, err := s.gitutil.GetBranch()
 	if err != nil {
 		return err
 	}
 
-	branch, err := util.GetBranch()
-	if err != nil {
-		return err
-	}
-
-	newVersionContent := cache.VersionFileContent{
-		Commit:      hash,
-		NextVersion: nextVersion.String(),
-		Branch:      branch,
-	}
-
-	if lastVersion != nil {
-		newVersionContent.Version = lastVersion.String()
-	}
-
-	log.Debugf("Save %s with hash %s to cache", nextVersion.String(), hash)
-	return cache.Write(newVersionContent)
-}
-
-func incPrerelease(preReleaseType string, version semver.Version) semver.Version {
-	defaultPrerelease := preReleaseType + ".0"
-	if version.Prerelease() == "" || !strings.HasPrefix(version.Prerelease(), preReleaseType) {
-		version, _ = version.SetPrerelease(defaultPrerelease)
-	} else {
-		parts := strings.Split(version.Prerelease(), ".")
-		if len(parts) == 2 {
-			i, err := strconv.Atoi(parts[1])
-			if err != nil {
-				version, _ = version.SetPrerelease(defaultPrerelease)
-				log.Warnf("Could not parse release tag %s, use version %s", version.Prerelease(), version.String())
-			} else {
-				version, _ = version.SetPrerelease(preReleaseType + "." + strconv.Itoa((i + 1)))
-			}
-		} else {
-			version, _ = version.SetPrerelease(defaultPrerelease)
-			log.Warnf("Could not parse release tag %s, use version %s", version.Prerelease(), version.String())
-		}
-	}
-
-	return version
+	return s.saveToCache(shared.ReleaseVersion{
+		Next: shared.ReleaseVersionEntry{
+			Commit:  hash,
+			Version: newVersion,
+		},
+		Last: shared.ReleaseVersionEntry{
+			Commit:  lastVersionHash,
+			Version: lastVersion,
+		},
+		Branch: currentBranch,
+	})
 }
 
 // GetChangelog from last version till now
-func (s *SemanticRelease) GetChangelog(repo string) (string, error) {
-	nextVersion, err := s.GetNextVersion(repo, false)
+func (s *SemanticRelease) GetChangelog(releaseVersion *shared.ReleaseVersion) (*shared.GeneratedChangelog, error) {
+	commits, err := s.gitutil.GetCommits(releaseVersion.Last.Commit)
 	if err != nil {
-		log.Debugf("Could not get next version")
-		return "", err
+		return nil, err
 	}
 
-	util, err := gitutil.New(repo)
-	if err != nil {
-		return "", err
-	}
-
-	_, lastVersionHash, err := util.GetLastVersion()
-	if err != nil {
-		return "", err
-	}
-
-	commits, err := util.GetCommits(lastVersionHash)
-	if err != nil {
-		return "", err
-	}
+	result := s.analyzer.Analyze(commits)
 
 	log.Debugf("Found %d commits till last release", len(commits))
 
-	a, err := analyzer.New(s.config.CommitFormat, s.config.Changelog)
-	if err != nil {
-		return "", err
-	}
-	result := a.Analyze(commits)
-
-	c := changelog.New(s.config, a.GetRules())
-	_, content, err := c.GenerateChanglog(nextVersion, s.config.GetRepositoryURL()+"/commit/{{hash}}", result)
-	if err != nil {
-		return "", err
-	}
-	return content, nil
+	c := changelog.New(s.config, s.analyzer.GetRules())
+	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)
 
 }
 
@@ -226,38 +205,37 @@ func (s *SemanticRelease) WriteChangeLog(changelogContent, file string) error {
 }
 
 // Release pusblish release to provider
-func (s *SemanticRelease) Release(repo string) error {
-	util, err := gitutil.New(repo)
-	if err != nil {
-		return err
-	}
-	currentBranch, err := util.GetBranch()
+func (s *SemanticRelease) Release(force bool) error {
+	currentBranch, err := s.gitutil.GetBranch()
 
 	if _, ok := s.config.Branch[currentBranch]; !ok {
 		log.Debugf("Will not perform a new release. Current %s branch is not configured in release config", currentBranch)
 		return nil
 	}
 
-	nextVersion, err := s.GetNextVersion(repo, false)
+	releaseVersion, err := s.GetNextVersion(force)
 	if err != nil {
 		log.Debugf("Could not get next version")
 		return err
 	}
 
-	changelog, err := s.GetChangelog(repo)
+	generatedChanglog, err := s.GetChangelog(releaseVersion)
 	if err != nil {
 		log.Debugf("Could not get changelog")
 		return err
 	}
 
-	releaseTitle := fmt.Sprintf("%s v%s", s.config.ReleaseTitle, nextVersion)
-
 	releaser, err := releaser.New(s.config).GetReleaser()
 	if err != nil {
 		return err
 	}
 
-	if err = releaser.CreateRelease(nextVersion, releaseTitle, changelog, "master"); err != nil {
+	err = releaser.ValidateConfig()
+	if err != nil {
+		return err
+	}
+
+	if err = releaser.CreateRelease(releaseVersion, generatedChanglog); err != nil {
 		return err
 	}