refactor(pkg/semanticrelease): clean up code

internal/cache/cache.go

@@ -2,9 +2,12 @@
 package cache
 
 import (
+	log "github.com/sirupsen/logrus"
 	"io/ioutil"
 	"path"
 
+	"github.com/Masterminds/semver"
+	"github.com/Nightapes/go-semantic-release/internal/shared"
 	"gopkg.in/yaml.v2"
 )
 
@@ -23,31 +26,68 @@ type ReleaseVersionEntry struct {
 }
 
 // Write version into .version
-func Write(repository string, versionFileContent ReleaseVersion) error {
+func Write(repository string, releaseVersion shared.ReleaseVersion) error {
 	completePath := path.Join(path.Dir(repository), ".version")
 
-	data, err := yaml.Marshal(&versionFileContent)
+	toCache := &ReleaseVersion{
+		Next: ReleaseVersionEntry{
+			Commit:  releaseVersion.Next.Commit,
+			Version: releaseVersion.Next.Version.String(),
+		},
+		Last: ReleaseVersionEntry{
+			Commit:  releaseVersion.Last.Commit,
+			Version: releaseVersion.Last.Version.String(),
+		},
+		Branch: releaseVersion.Branch,
+		Draft:  releaseVersion.Draft,
+	}
+
+	data, err := yaml.Marshal(toCache)
 	if err != nil {
 		return err
 	}
 
+	log.Debugf("Save %s with hash %s to cache", releaseVersion.Next.Version.String(), releaseVersion.Next.Commit)
 	return ioutil.WriteFile(completePath, data, 0644)
 }
 
 // Read version into .version
-func Read(repository string) (*ReleaseVersion, error) {
+func Read(repository string) (*shared.ReleaseVersion, error) {
 	completePath := path.Join(path.Dir(repository), ".version")
 
 	content, err := ioutil.ReadFile(completePath)
 	if err != nil {
-		return &ReleaseVersion{}, err
+		return &shared.ReleaseVersion{}, err
 	}
 
-	var versionFileContent ReleaseVersion
-	err = yaml.Unmarshal(content, &versionFileContent)
+	var parsedContent ReleaseVersion
+	err = yaml.Unmarshal(content, &parsedContent)
 	if err != nil {
-		return &ReleaseVersion{}, err
+		return &shared.ReleaseVersion{}, err
 	}
 
-	return &versionFileContent, nil
+	nextVersion, err := semver.NewVersion(parsedContent.Next.Version)
+	if err != nil {
+		return nil, err
+	}
+
+	lastVersion, err := semver.NewVersion(parsedContent.Last.Version)
+	if err != nil {
+		return nil, err
+	}
+
+	releaseVersion := &shared.ReleaseVersion{
+		Next: shared.ReleaseVersionEntry{
+			Commit:  parsedContent.Next.Commit,
+			Version: nextVersion,
+		},
+		Last: shared.ReleaseVersionEntry{
+			Commit:  parsedContent.Last.Commit,
+			Version: lastVersion,
+		},
+		Branch: parsedContent.Branch,
+		Draft:  parsedContent.Draft,
+	}
+	log.Infof("Found cache, will return cached version %s", parsedContent.Next.Version)
+	return releaseVersion, nil
 }

internal/calculator/calculator.go

@@ -0,0 +1,68 @@
+package calculator
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/Masterminds/semver"
+	"github.com/Nightapes/go-semantic-release/internal/analyzer"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// Calculator struct
+type Calculator struct{}
+
+// New Calculator struct
+func New() *Calculator {
+	return &Calculator{}
+}
+
+//IncPrerelease increase prerelease by one
+func (c *Calculator) IncPrerelease(preReleaseType string, version *semver.Version) (semver.Version, error) {
+	defaultPrerelease := preReleaseType + ".0"
+	if version.Prerelease() == "" || !strings.HasPrefix(version.Prerelease(), preReleaseType) {
+		return version.SetPrerelease(defaultPrerelease)
+	}
+
+	parts := strings.Split(version.Prerelease(), ".")
+	if len(parts) == 2 {
+		i, err := strconv.Atoi(parts[1])
+		if err != nil {
+			log.Warnf("Could not parse release tag %s, use version %s", version.Prerelease(), version.String())
+			return version.SetPrerelease(defaultPrerelease)
+		}
+		return version.SetPrerelease(preReleaseType + "." + strconv.Itoa((i + 1)))
+
+	}
+	log.Warnf("Could not parse release tag %s, use version %s", version.Prerelease(), version.String())
+	return version.SetPrerelease(defaultPrerelease)
+}
+
+//CalculateNewVersion from given commits and lastversion
+func (c *Calculator) CalculateNewVersion(commits map[analyzer.Release][]analyzer.AnalyzedCommit, lastVersion *semver.Version, releaseType string, firstRelease bool) (semver.Version, bool) {
+	switch releaseType {
+	case "beta", "alpha":
+		if len(commits["major"]) > 0 || len(commits["minor"]) > 0 || len(commits["patch"]) > 0 {
+			version, _ := c.IncPrerelease(releaseType, lastVersion)
+			return version, true
+		}
+	case "rc":
+		if len(commits["major"]) > 0 || len(commits["minor"]) > 0 || len(commits["patch"]) > 0 {
+			version, _ := c.IncPrerelease(releaseType, lastVersion)
+			return version, false
+		}
+	case "release":
+		if !firstRelease {
+			if len(commits["major"]) > 0 {
+				return lastVersion.IncMajor(), false
+			} else if len(commits["minor"]) > 0 {
+				return lastVersion.IncMinor(), false
+			} else if len(commits["patch"]) > 0 {
+				return lastVersion.IncPatch(), false
+			}
+		}
+	}
+
+	return *lastVersion, false
+}

internal/releaser/util/util.go

@@ -46,7 +46,7 @@ func PrepareAssets(repository string, assets []config.Asset) ([]*string, error)
 	filesToUpload := []*string{}
 	for _, asset := range assets {
 		if asset.Name == "" {
-			return nil, fmt.Errorf("Asset name declaration is empty, please check your configuration file")
+			return nil, fmt.Errorf("asset name declaration is empty, please check your configuration file")
 		} else if asset.Compress {
 			log.Debugf("Asset %s will now be compressed", asset.Name)
 			log.Debugf("Repo url %s", repository)