feat(init): increase version depending on commit (angular format)

internal/analyzer/analyzer.go

@@ -0,0 +1,63 @@
+package analyzer
+
+import (
+	"github.com/Nightapes/go-semantic-release/internal/gitutil"
+	log "github.com/sirupsen/logrus"
+)
+
+type Analyzer struct {
+	CommitFormat string
+}
+
+type Rules struct {
+	Tag     string
+	Release string
+}
+
+type AnalyzeCommit interface {
+	Analyze(commit gitutil.Commit, tag string) (AnalyzedCommit, bool)
+	GetRules() []Rules
+}
+
+type AnalyzedCommit struct {
+	Commit                      gitutil.Commit
+	ParsedMessage               string
+	Scope                       string
+	ParsedBreakingChangeMessage string
+}
+
+func New(format string) *Analyzer {
+	return &Analyzer{
+		CommitFormat: format,
+	}
+
+}
+
+func (a *Analyzer) Analyze(commits []gitutil.Commit) map[string][]AnalyzedCommit {
+
+	var commitAnalayzer AnalyzeCommit
+	switch a.CommitFormat {
+	case "angular":
+		log.Infof("analyze angular format")
+		commitAnalayzer = NewAngular()
+	}
+
+	analyzedCommits := make(map[string][]AnalyzedCommit)
+	analyzedCommits["major"] = make([]AnalyzedCommit, 0)
+	analyzedCommits["minor"] = make([]AnalyzedCommit, 0)
+	analyzedCommits["patch"] = make([]AnalyzedCommit, 0)
+
+	for _, commit := range commits {
+		for _, rule := range commitAnalayzer.GetRules() {
+			analyzedCommit, hasBreakingChange := commitAnalayzer.Analyze(commit, rule.Tag)
+			if hasBreakingChange {
+				analyzedCommits["major"] = append(analyzedCommits["major"], analyzedCommit)
+			} else {
+				analyzedCommits[rule.Release] = append(analyzedCommits[rule.Release], analyzedCommit)
+			}
+
+		}
+	}
+
+	return analyzedCommits
+}

internal/analyzer/angular.go

@@ -0,0 +1,65 @@
+package analyzer
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/Nightapes/go-semantic-release/internal/gitutil"
+)
+
+type Angular struct {
+	rules []Rules
+	regex string
+}
+
+func NewAngular() *Angular {
+	return &Angular{
+		regex: `(TAG)(?:\((.*)\))?: (.*)`,
+		rules: []Rules{
+			{
+				Tag:     "feat",
+				Release: "minor",
+			},
+			{
+				Tag:     "fix",
+				Release: "patch",
+			}, {
+				Tag:     "perf",
+				Release: "patch",
+			},
+		},
+	}
+}
+
+func (a *Angular) GetRules() []Rules {
+	return a.rules
+}
+
+func (a *Angular) Analyze(commit gitutil.Commit, tag string) (AnalyzedCommit, bool) {
+
+	analyzed := AnalyzedCommit{
+		Commit: commit,
+	}
+
+	re := regexp.MustCompile(strings.Replace(a.regex, "TAG", tag, -1))
+	matches := re.FindAllStringSubmatch(commit.Message+" "+commit.Message, -1)
+	if len(matches) >= 1 {
+		if len(matches[0]) >= 3 {
+			analyzed.Scope = matches[0][2]
+
+			message := strings.Join(matches[0][3:], "")
+			splitted := strings.SplitN(message, "BREAKING CHANGE:", 1)
+
+			if len(splitted) == 1 {
+				analyzed.ParsedMessage = splitted[0]
+				return analyzed, false
+			}
+			analyzed.ParsedMessage = splitted[0]
+			analyzed.ParsedBreakingChangeMessage = splitted[1]
+			return analyzed, true
+
+		}
+	}
+	return analyzed, false
+
+}

internal/gitutil/gitutil.go

@@ -0,0 +1,140 @@
+package gitutil
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/Masterminds/semver"
+	log "github.com/sirupsen/logrus"
+	"gopkg.in/src-d/go-git.v4"
+	"gopkg.in/src-d/go-git.v4/plumbing/object"
+)
+
+type Commit struct {
+	Message string
+	Author  string
+	Hash    string
+}
+
+type GitUtils struct {
+	Repository *git.Repository
+}
+
+func New(folder string) (*GitUtils, error) {
+	r, err := git.PlainOpen(folder)
+	if err != nil {
+		return nil, err
+	}
+	utils := &GitUtils{
+		Repository: r,
+	}
+	return utils, nil
+
+}
+
+func (g *GitUtils) GetHash() (string, error) {
+	ref, err := g.Repository.Head()
+	if err != nil {
+		return "", err
+	}
+	return ref.Hash().String(), nil
+}
+
+func (g *GitUtils) GetBranch() (string, error) {
+	ref, err := g.Repository.Head()
+	if err != nil {
+		return "", err
+	}
+
+	if !ref.Name().IsBranch() {
+		return "", fmt.Errorf("No branch found, found %s, please checkout a branch (git checkout <BRANCH>)", ref.Name().String())
+	}
+
+	return ref.Name().Short(), nil
+}
+
+func (g *GitUtils) GetLastVersion() (*semver.Version, string, error) {
+
+	log.Debugf("GetLastVersion")
+
+	tagObjects, err := g.Repository.TagObjects()
+	if err != nil {
+		return nil, "", err
+	}
+
+	var tags []*semver.Version
+
+	err = tagObjects.ForEach(func(t *object.Tag) error {
+		v, err := semver.NewVersion(t.Name)
+
+		if err != nil {
+			log.Debugf("Tag %s is not a valid version, skip", t.Name)
+		} else {
+			log.Debugf("Add tag %s", t.Name)
+			tags = append(tags, v)
+		}
+		return nil
+	})
+
+	if err != nil {
+		return nil, "", err
+	}
+
+	sort.Sort(sort.Reverse(semver.Collection(tags)))
+
+	if len(tags) == 0 {
+		log.Debugf("Found no tags")
+		return nil, "", nil
+	}
+
+	log.Debugf("Found old version %s", tags[0].String())
+
+	tag, err := g.Repository.Tag(tags[0].Original())
+	if err != nil {
+		return nil, "", err
+	}
+
+	tagObject, err := g.Repository.TagObject(tag.Hash())
+	if err != nil {
+		return nil, "", err
+	}
+
+	log.Debugf("Found old hash %s", tagObject.Target.String())
+	return tags[0], tagObject.Target.String(), nil
+}
+
+func (g *GitUtils) GetCommits(lastTagHash string) ([]Commit, error) {
+
+	log.Printf("Read head")
+	ref, err := g.Repository.Head()
+	if err != nil {
+		return nil, err
+	}
+
+	cIter, err := g.Repository.Log(&git.LogOptions{From: ref.Hash(), Order: git.LogOrderCommitterTime})
+	if err != nil {
+		return nil, err
+	}
+
+	var commits []Commit
+	var foundEnd bool
+
+	err = cIter.ForEach(func(c *object.Commit) error {
+		if c.Hash.String() == lastTagHash {
+			log.Infof("%s == %s", c.Hash.String(), lastTagHash)
+			foundEnd = true
+		}
+
+		if !foundEnd {
+			commit := Commit{
+				Message: c.Message,
+				Author:  c.Committer.Name,
+				Hash:    c.Hash.String(),
+			}
+			commits = append(commits, commit)
+		}
+		return nil
+	})
+
+	return commits, nil
+}

internal/storage/storage.go

@@ -0,0 +1,42 @@
+package storage
+
+import (
+	"io/ioutil"
+
+	"gopkg.in/yaml.v2"
+)
+
+// VersionFileContent struct
+type VersionFileContent struct {
+	Version     string `yaml:"version"`
+	NextVersion string `yaml:"nextVersion"`
+	Commit      string `yaml:"commit"`
+	Branch      string `yaml:"branch"`
+}
+
+// Write version into .version
+func Write(versionFileContent VersionFileContent) error {
+	data, err := yaml.Marshal(&versionFileContent)
+	if err != nil {
+		return err
+	}
+
+	return ioutil.WriteFile(".version", data, 0644)
+}
+
+// Read version into .version
+func Read() (*VersionFileContent, error) {
+
+	content, err := ioutil.ReadFile(".version")
+	if err != nil {
+		return &VersionFileContent{}, err
+	}
+
+	var versionFileContent VersionFileContent
+	err = yaml.Unmarshal(content, &versionFileContent)
+	if err != nil {
+		return &VersionFileContent{}, err
+	}
+
+	return &versionFileContent, nil
+}