refactor(*): clean up code

internal/cache/cache.go

@@ -3,40 +3,49 @@ package cache
 
 import (
 	"io/ioutil"
+	"path"
 
 	"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"`
+type ReleaseVersion struct {
+	Last   ReleaseVersionEntry `yaml:"last"`
+	Next   ReleaseVersionEntry `yaml:"next"`
+	Branch string              `yaml:"branch"`
+}
+
+//VersionFileEntry struct
+type ReleaseVersionEntry struct {
+	Commit  string `yaml:"commit"`
+	Version string `yaml:"version"`
 }
 
 // Write version into .version
-func Write(versionFileContent VersionFileContent) error {
+func Write(repository string, versionFileContent ReleaseVersion) error {
+	completePath := path.Join(path.Dir(repository), ".version")
+
 	data, err := yaml.Marshal(&versionFileContent)
 	if err != nil {
 		return err
 	}
 
-	return ioutil.WriteFile(".version", data, 0644)
+	return ioutil.WriteFile(completePath, data, 0644)
 }
 
 // Read version into .version
-func Read() (*VersionFileContent, error) {
+func Read(repository string) (*ReleaseVersion, error) {
+	completePath := path.Join(path.Dir(repository), ".version")
 
-	content, err := ioutil.ReadFile(".version")
+	content, err := ioutil.ReadFile(completePath)
 	if err != nil {
-		return &VersionFileContent{}, err
+		return &ReleaseVersion{}, err
 	}
 
-	var versionFileContent VersionFileContent
+	var versionFileContent ReleaseVersion
 	err = yaml.Unmarshal(content, &versionFileContent)
 	if err != nil {
-		return &VersionFileContent{}, err
+		return &ReleaseVersion{}, err
 	}
 
 	return &versionFileContent, nil

internal/changelog/changelog.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/Nightapes/go-semantic-release/internal/analyzer"
+	"github.com/Nightapes/go-semantic-release/internal/shared"
 	"github.com/Nightapes/go-semantic-release/pkg/config"
 
 	log "github.com/sirupsen/logrus"
@@ -49,7 +50,7 @@ func New(config *config.ReleaseConfig, rules []analyzer.Rule) *Changelog {
 }
 
 // GenerateChanglog from given commits
-func (c *Changelog) GenerateChanglog(version, url string, analyzedCommits map[string][]analyzer.AnalyzedCommit) (string, string, error) {
+func (c *Changelog) GenerateChanglog(templateConfig shared.ChangelogTemplateConfig, analyzedCommits map[string][]analyzer.AnalyzedCommit) (*shared.GeneratedChangelog, error) {
 
 	commitsPerScope := map[string][]analyzer.AnalyzedCommit{}
 	order := make([]string, 0)
@@ -73,22 +74,22 @@ func (c *Changelog) GenerateChanglog(version, url string, analyzedCommits map[st
 	}
 
 	changelogContent := changelogContent{
-		Version:  version,
+		Version:  templateConfig.Version,
 		Commits:  commitsPerScope,
 		Now:      time.Now(),
 		Backtick: "`",
 		Order:    order,
-		HasURL:   url != "",
-		URL:      url,
+		HasURL:   templateConfig.CommitURL != "",
+		URL:      templateConfig.CommitURL,
 	}
 
 	title, err := generateTemplate(defaultChangelogTitle, changelogContent)
 	if err != nil {
-		return "", "", err
+		return nil, err
 	}
 	content, err := generateTemplate(defaultChangelog, changelogContent)
 
-	return title, content, err
+	return &shared.GeneratedChangelog{Title: title, Content: content}, err
 }
 
 func generateTemplate(text string, values changelogContent) (string, error) {

internal/gitutil/gitutil.go

@@ -136,7 +136,7 @@ func (g *GitUtil) GetCommits(lastTagHash string) ([]Commit, error) {
 			log.Debugf("Found commit with hash %s, will stop here", c.Hash.String())
 			foundEnd = true
 		}
-
+		log.Tracef("Found commit with hash %s", c.Hash.String())
 		if !foundEnd {
 			commit := Commit{
 				Message: c.Message,

internal/releaser/github.go

@@ -1,83 +0,0 @@
-package releaser
-
-import (
-	"context"
-	"fmt"
-	"github.com/Nightapes/go-semantic-release/pkg/config"
-	"github.com/google/go-github/v25/github"
-	"net/http"
-	"os"
-)
-
-// GITHUB identifer for github interface
-const GITHUB = "GitHub"
-
-// GitHubReleaser type struct
-type GitHubReleaser struct {
-	config  *config.ReleaseConfig
-	client  *github.Client
-	context context.Context
-	release *github.RepositoryRelease
-}
-
-type gitHubCreateReleaseResponse struct {
-	ReleaseURL     string `json:url`
-	AssetUploadURL string `json:upload_url`
-}
-
-// NewGitHubReleaser initialize a new GitHubRelease
-func NewGitHubReleaser(c *config.ReleaseConfig) *GitHubReleaser {
-	ctx := context.Background()
-	httpClient := createHTTPClient(ctx, c.GitProvider.AccessToken)
-
-	return &GitHubReleaser{
-		config:  c,
-		client:  github.NewClient(httpClient),
-		context: ctx,
-	}
-}
-
-// CreateRelease creates release on remote
-func (g GitHubReleaser) CreateRelease(tag, releaseName, releaseMessage, targetBranch string) error {
-
-	release, resp, err := g.client.Repositories.CreateRelease(g.context, g.config.GitProvider.User, g.config.GitProvider.Repo, &github.RepositoryRelease{
-		TagName:         &tag,
-		TargetCommitish: &targetBranch,
-		Name:            &releaseName,
-		Body:            &releaseMessage,
-		Draft:           &g.config.IsDraft,
-		Prerelease:      &g.config.IsPreRelease,
-	})
-
-	if err != nil {
-		return fmt.Errorf("releaser: github: Could not create release: %v", err)
-	}
-
-	if resp.StatusCode >= http.StatusBadRequest {
-		return fmt.Errorf("releaser: github: Could not create release: response statuscode: %s", resp.Status)
-	}
-
-	g.release = release
-	return nil
-
-}
-
-// UploadAssets uploads specified assets
-func (g GitHubReleaser) UploadAssets(assets []config.Asset) error {
-	for _, asset := range assets {
-		file, err := os.Open(asset.Name)
-		if err != nil {
-			return err
-		}
-
-		_, resp, err := g.client.Repositories.UploadReleaseAsset(g.context, g.config.GitProvider.User, g.config.GitProvider.Repo, *g.release.ID, &github.UploadOptions{Name: asset.Name}, file)
-		if err != nil {
-			return err
-		}
-
-		if resp.StatusCode >= http.StatusBadRequest {
-			return fmt.Errorf("releaser: github: Could not create release: response statuscode: %s", resp.Status)
-		}
-	}
-	return nil
-}

internal/releaser/github/github.go

@@ -0,0 +1,128 @@
+package github
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/Nightapes/go-semantic-release/internal/releaser/util"
+	"github.com/Nightapes/go-semantic-release/internal/shared"
+	"github.com/Nightapes/go-semantic-release/pkg/config"
+
+	"github.com/google/go-github/v25/github"
+)
+
+// GITHUB identifer for github interface
+const GITHUB = "github"
+
+// GitHubReleaser type struct
+type GitHubReleaser struct {
+	config  *config.GitHubProvider
+	client  *github.Client
+	context context.Context
+	release *github.RepositoryRelease
+	baseURL string
+	token   string
+}
+
+// New initialize a new GitHubRelease
+func New(c *config.GitHubProvider) (*GitHubReleaser, error) {
+	ctx := context.Background()
+	httpClient := util.CreateBearerHTTPClient(ctx, c.AccessToken)
+
+	var client *github.Client
+	var err error
+	baseURL := "https://github.com"
+	if c.CustomURL == "" {
+		client = github.NewClient(httpClient)
+	} else {
+		client, err = github.NewEnterpriseClient(c.CustomURL, c.CustomURL+"/api/v3/", httpClient)
+		baseURL = c.CustomURL
+	}
+	return &GitHubReleaser{
+		config:  c,
+		client:  client,
+		context: ctx,
+		baseURL: baseURL,
+	}, err
+}
+
+//GetCommitURL for github
+func (g GitHubReleaser) GetCommitURL() string {
+	return fmt.Sprintf("%s/%s/%s/commit/{{hash}}", g.baseURL, g.config.User, g.config.Repo)
+}
+
+//GetCompareURL for github
+func (g GitHubReleaser) GetCompareURL(oldVersion, newVersion string) string {
+	return fmt.Sprintf("%s/%s/%s/compare/%s...%s", g.baseURL, g.config.User, g.config.Repo, oldVersion, newVersion)
+}
+
+//ValidateConfig for github
+func (g GitHubReleaser) ValidateConfig() error {
+
+	if g.config.Repo == "" {
+		return fmt.Errorf("Github Repro is not set")
+	}
+
+	if g.config.User == "" {
+		return fmt.Errorf("Github User is not set")
+	}
+
+	envName := fmt.Sprintf("%s_ACCESS_TOKEN", strings.ToUpper(GITHUB))
+	token, isSet := os.LookupEnv(envName)
+	if !isSet {
+		return fmt.Errorf("Can not find environment variable %s", envName)
+	}
+	g.token = token
+	return nil
+
+}
+
+// CreateRelease creates release on remote
+func (g GitHubReleaser) CreateRelease(releaseVersion *shared.ReleaseVersion, generatedChangelog *shared.GeneratedChangelog) error {
+
+	tag := releaseVersion.Next.Version.String()
+	prerelease := releaseVersion.Next.Version.Prerelease() != ""
+	release, resp, err := g.client.Repositories.CreateRelease(g.context, g.config.User, g.config.Repo, &github.RepositoryRelease{
+		TagName:         &tag,
+		TargetCommitish: &releaseVersion.Branch,
+		Name:            &generatedChangelog.Title,
+		Body:            &generatedChangelog.Content,
+		Draft:           &prerelease,
+		Prerelease:      &prerelease,
+	})
+
+	if err != nil {
+		return fmt.Errorf("Could not create release: %v", err)
+	}
+
+	if resp.StatusCode >= http.StatusBadRequest {
+		return fmt.Errorf("Could not create release: response statuscode: %s", resp.Status)
+	}
+
+	g.release = release
+	return nil
+
+}
+
+// UploadAssets uploads specified assets
+func (g GitHubReleaser) UploadAssets(assets []config.Asset) error {
+	for _, asset := range assets {
+		file, err := os.Open(asset.Name)
+		if err != nil {
+			return err
+		}
+
+		_, resp, err := g.client.Repositories.UploadReleaseAsset(g.context, g.config.User, g.config.Repo, *g.release.ID, &github.UploadOptions{Name: asset.Name}, file)
+		if err != nil {
+			return err
+		}
+
+		if resp.StatusCode >= http.StatusBadRequest {
+			return fmt.Errorf("releaser: github: Could not create release: response statuscode: %s", resp.Status)
+		}
+	}
+	return nil
+}

internal/releaser/releaser.go

@@ -1,12 +1,13 @@
 package releaser
 
 import (
-	"context"
 	"fmt"
-	"github.com/Nightapes/go-semantic-release/pkg/config"
-	"golang.org/x/oauth2"
-	"net/http"
 	"os"
+
+	"github.com/Nightapes/go-semantic-release/internal/releaser/github"
+	"github.com/Nightapes/go-semantic-release/internal/shared"
+
+	"github.com/Nightapes/go-semantic-release/pkg/config"
 )
 
 // Releasers struct type
@@ -16,8 +17,11 @@ type Releasers struct {
 
 // Releaser interface for providers
 type Releaser interface {
-	CreateRelease(tag, releaseName, releaseMessage, targetBranch string) error
+	ValidateConfig() error
+	CreateRelease(*shared.ReleaseVersion, *shared.GeneratedChangelog) error
 	UploadAssets(assets []config.Asset) error
+	GetCommitURL() string
+	GetCompareURL(oldVersion, newVersion string) string
 }
 
 // New initialize a Relerser
@@ -29,23 +33,11 @@ func New(c *config.ReleaseConfig) *Releasers {
 
 //GetReleaser returns an initialized releaser
 func (r *Releasers) GetReleaser() (Releaser, error) {
-	switch r.config.GitProvider.Name {
-	case GITHUB:
-		return NewGitHubReleaser(r.config), nil
+	switch r.config.Release {
+	case github.GITHUB:
+		return github.New(&r.config.GitHubProvider)
 	}
-	return nil, fmt.Errorf("Could not initialize a releaser from this type: %s", r.config.GitProvider.Name)
-}
-
-// tbd. http helper function
-
-func createHTTPClient(ctx context.Context, token string) *http.Client {
-	tokenSource := oauth2.StaticTokenSource(&oauth2.Token{
-		AccessToken: token},
-	)
-
-	client := oauth2.NewClient(ctx, tokenSource)
-
-	return client
+	return nil, fmt.Errorf("Could not initialize a releaser from this type: %s", r.config.Release)
 }
 
 func checkIfAssetsExists(assets []config.Asset) error {

internal/releaser/util/util.go

@@ -0,0 +1,19 @@
+package util
+
+import (
+	"context"
+	"net/http"
+
+	"golang.org/x/oauth2"
+)
+
+//CreateBearerHTTPClient with given token
+func CreateBearerHTTPClient(ctx context.Context, token string) *http.Client {
+	tokenSource := oauth2.StaticTokenSource(&oauth2.Token{
+		AccessToken: token},
+	)
+
+	client := oauth2.NewClient(ctx, tokenSource)
+
+	return client
+}

internal/shared/shared.go

@@ -0,0 +1,32 @@
+package shared
+
+import (
+	"github.com/Masterminds/semver"
+)
+
+//ReleaseVersion struct
+type ReleaseVersion struct {
+	Last   ReleaseVersionEntry
+	Next   ReleaseVersionEntry
+	Branch string
+}
+
+//ReleaseVersionEntry struct
+type ReleaseVersionEntry struct {
+	Commit  string
+	Version *semver.Version
+}
+
+//GeneratedChangelog struct
+type GeneratedChangelog struct {
+	Title   string
+	Content string
+}
+
+//GenerateChangelogConfig struct
+type ChangelogTemplateConfig struct {
+	CommitURL  string
+	CompareURL string
+	Hash       string
+	Version    string
+}