Merge pull request #134 from neel1996/v2.0.2

A placeholder release v2.0.2 

The actual release version will be tracked as v2.1.0, as the backend was modified to use libgit2 bindings which is a major change

Author: neel1996

SECURITY.md

@@ -0,0 +1,15 @@
+# Security Policy
+
+## Supported Versions
+
+>The back-end of the project was migrated from Node JS to Golang after release v2.0.0, so the versions before v2 will not be supported with bug fixes or security patches
+
+| Version | Supported          |
+| ------- | ------------------ |
+| >= 2.0.0   | :white_check_mark: |
+| < 2.0.0   | :x:                |
+| 1.x.x   | :x:                |
+
+## Reporting a Vulnerability
+
+If you find any potential security issues, then please do report it [here](https://github.com/neel1996/gitconvex/issues/new?assignees=&labels=security-issue&template=bug_report.md&title=Security%20Issue&assignee=neel1996)

api/add_repo.go

@@ -15,6 +15,22 @@ import (
 	"time"
 )
 
+type AddRepoInterface interface {
+	AddRepo() *model.AddRepoParams
+	repoDataFileWriter(repoId string, repoAddStatus chan string)
+}
+
+type AddRepoInputs struct {
+	RepoName    string
+	RepoPath    string
+	CloneSwitch bool
+	RepoURL     *string
+	InitSwitch  bool
+	AuthOption  string
+	UserName    *string
+	Password    *string
+}
+
 type RepoData struct {
 	Id        string `json:"id"`
 	RepoName  string `json:"repoName"`
@@ -71,13 +87,13 @@ func dataFileWriteHandler(dbFile string, repoDataArray []RepoData) error {
 }
 
 // repoDataFileWriter writes the new repo details to the repo_datastore.json file
-func repoDataFileWriter(repoId string, repoName string, repoPath string, repoAddStatus chan string) {
+func (inputs AddRepoInputs) repoDataFileWriter(repoId string, repoAddStatus chan string) {
 	rArray := make([]RepoData, 1)
 
 	rArray[0] = RepoData{
 		Id:        repoId,
-		RepoName:  repoName,
-		RepoPath:  repoPath,
+		RepoName:  inputs.RepoName,
+		RepoPath:  inputs.RepoPath,
 		TimeStamp: time.Now().String(),
 	}
 
@@ -116,9 +132,7 @@ func repoDataFileWriter(repoId string, repoName string, repoPath string, repoAdd
 // AddRepo function gets the repository details and includes a record to the gitconvex repo datastore file
 // If initSwitch is 'true' then the git repo init function will be invoked to initialize a new repo
 // If cloneSwitch is 'true' then the repo will be cloned to the file system using the repoURL field
-func AddRepo(inputs model.NewRepoInputs) *model.AddRepoParams {
-	var repoIdChannel = make(chan string)
-
+func (inputs AddRepoInputs) AddRepo() *model.AddRepoParams {
 	repoName := inputs.RepoName
 	repoPath := inputs.RepoPath
 	cloneSwitch := inputs.CloneSwitch
@@ -130,8 +144,18 @@ func AddRepo(inputs model.NewRepoInputs) *model.AddRepoParams {
 
 	if cloneSwitch && len(*repoURL) > 0 {
 		repoPath = repoPath + "/" + repoName
+		inputs.RepoPath = repoPath
+
+		var cloneObject git.CloneInterface
+		cloneObject = git.CloneStruct{
+			RepoPath:   repoPath,
+			RepoURL:    *repoURL,
+			AuthOption: authOption,
+			UserName:   userName,
+			Password:   password,
+		}
 
-		_, err := git.CloneHandler(repoPath, *repoURL, authOption, userName, password)
+		_, err := cloneObject.CloneHandler()
 		if err != nil {
 			localLogger(fmt.Sprintf("%v", err), global.StatusError)
 			return &model.AddRepoParams{
@@ -165,11 +189,12 @@ func AddRepo(inputs model.NewRepoInputs) *model.AddRepoParams {
 		}
 	}
 
+	var repoIdChannel = make(chan string)
 	go repoIdGenerator(repoIdChannel)
 	repoId := <-repoIdChannel
 
 	var repoAddStatusChannel = make(chan string)
-	go repoDataFileWriter(repoId, repoName, repoPath, repoAddStatusChannel)
+	go inputs.repoDataFileWriter(repoId, repoAddStatusChannel)
 	status := <-repoAddStatusChannel
 
 	close(repoIdChannel)

api/code_file_view.go

@@ -8,11 +8,20 @@ import (
 	"os"
 )
 
+type CodeViewInputs struct {
+	RepoPath string
+	FileName string
+}
+
+type CodeViewInterface interface {
+	CodeFileView() *model.CodeFileType
+}
+
 // CodeFileView returns the lines from the target file and the latest commit corresponding to the file
-func CodeFileView(repoPath string, fileName string) *model.CodeFileType {
+func (c CodeViewInputs) CodeFileView() *model.CodeFileType {
 	var codeLines []*string
 
-	targetFile := repoPath + "/" + fileName
+	targetFile := c.RepoPath + "/" + c.FileName
 	logger := global.Logger{}
 	file, err := os.Open(targetFile)
 

api/repo_status.go

@@ -19,7 +19,9 @@ func RepoStatus(repoId string) *model.GitRepoStatusResults {
 	commitChan := make(chan git.AllCommitData)
 	trackedFileCountChan := make(chan int)
 
-	go git.Repo(repoId, repoChan)
+	var repoObject git.RepoInterface
+	repoObject = git.RepoStruct{RepoId: repoId}
+	go repoObject.Repo(repoChan)
 
 	var repoName *string
 	r := <-repoChan
@@ -42,7 +44,14 @@ func RepoStatus(repoId string) *model.GitRepoStatusResults {
 	remote := ""
 	var remoteURL *string
 	remoteURL = &remote
-	go git.RemoteData(repo, remoteChan)
+
+	var remoteDataObject git.RemoteDataInterface
+	remoteDataObject = git.RemoteDataStruct{
+		Repo:      repo,
+		RemoteURL: *remoteURL,
+	}
+
+	go remoteDataObject.RemoteData(remoteChan)
 	remoteData := <-remoteChan
 	remotes := remoteData.RemoteURL
 
@@ -71,21 +80,31 @@ func RepoStatus(repoId string) *model.GitRepoStatusResults {
 		*remoteURL = *remotes[0]
 	}
 
-	go git.GetBranchList(repo, branchChan)
+	var branchListObject git.BranchListInterface
+	branchListObject = git.BranchListInputs{Repo: repo}
+	go branchListObject.GetBranchList(branchChan)
+
 	branchList := <-branchChan
 	currentBranch := &branchList.CurrentBranch
 	branches := branchList.BranchList
 	allBranches := branchList.AllBranchList
 
 	var latestCommit *string
 
-	go git.AllCommits(repo, commitChan)
+	var allCommitObject git.AllCommitInterface
+	allCommitObject = git.AllCommitStruct{Repo: repo}
+	go allCommitObject.AllCommits(commitChan)
 	commitData := <-commitChan
 	latestCommit = &commitData.LatestCommit
 	totalCommits := commitData.TotalCommits
 	totalCommitsPtr := &totalCommits
 
-	go git.TrackedFileCount(repo, trackedFileCountChan)
+	var listFilesObject git.ListFilesInterface
+	listFilesObject = git.ListFilesStruct{
+		Repo: repo,
+	}
+
+	go listFilesObject.TrackedFileCount(trackedFileCountChan)
 	trackedFileCount := <-trackedFileCountChan
 	trackedFilePtr := &trackedFileCount
 

git/git_branch_add.go

@@ -7,9 +7,22 @@ import (
 	"github.com/neel1996/gitconvex-server/global"
 )
 
+type AddBranchInterface interface {
+	AddBranch() string
+}
+
+type AddBranchInput struct {
+	Repo       *git.Repository
+	BranchName string
+}
+
 // AddBranch adds a new branch to the target repo
-func AddBranch(repo *git.Repository, branchName string) string {
+func (input AddBranchInput) AddBranch() string {
 	logger := global.Logger{}
+
+	repo := input.Repo
+	branchName := input.BranchName
+
 	headRef, headErr := repo.Head()
 
 	logger.Log(fmt.Sprintf("Adding new branch -> %s", branchName), global.StatusInfo)

git/git_branch_checkout.go

@@ -8,21 +8,58 @@ import (
 	"strings"
 )
 
+type BranchCheckoutInterface interface {
+	intermediateFetch()
+	CheckoutBranch() string
+}
+
+type BranchCheckoutInputs struct {
+	Repo       *git.Repository
+	BranchName string
+}
+
 // intermediateFetch performs a remote fetch if the selected checkout branch is a remote branch
-func intermediateFetch(repo *git.Repository, branchName string) {
+func (inputs BranchCheckoutInputs) intermediateFetch() {
+	repo := inputs.Repo
+	branchName := inputs.BranchName
+
 	logger.Log("Fetching from remote for remote branch -> "+branchName, global.StatusInfo)
 	remoteChan := make(chan RemoteDataModel)
-	go RemoteData(repo, remoteChan)
+
+	var remoteDataObject RemoteDataInterface
+	remoteDataObject = RemoteDataStruct{
+		Repo: repo,
+	}
+	go remoteDataObject.RemoteData(remoteChan)
+
 	remoteData := <-remoteChan
 	remoteURL := remoteData.RemoteURL
-	FetchFromRemote(repo, *remoteURL[0], branchName)
+
+	remoteDataObject = RemoteDataStruct{
+		Repo:      repo,
+		RemoteURL: *remoteURL[0],
+	}
+
+	var fetchObject FetchInterface
+	fetchObject = FetchStruct{
+		Repo:         repo,
+		RemoteName:   remoteDataObject.GetRemoteName(),
+		RepoPath:     "",
+		RemoteURL:    *remoteURL[0],
+		RemoteBranch: branchName,
+	}
+
+	fetchObject.FetchFromRemote()
 }
 
 // CheckoutBranch checks out the branchName received as argument
-func CheckoutBranch(repo *git.Repository, branchName string) string {
+func (inputs BranchCheckoutInputs) CheckoutBranch() string {
 	var isRemoteBranch bool
 	var referenceBranchName string
 
+	repo := inputs.Repo
+	branchName := inputs.BranchName
+
 	logger := global.Logger{}
 	w, _ := repo.Worktree()
 
@@ -38,7 +75,7 @@ func CheckoutBranch(repo *git.Repository, branchName string) string {
 	// If the branch is a remote branch then a remote fetch will be performed and then the branch checkout will be initiated
 	if isRemoteBranch {
 		logger.Log(fmt.Sprintf("Branch - %s is a remote branch\nTrying with intermediate remote fetch!", branchName), global.StatusWarning)
-		intermediateFetch(repo, branchName)
+		inputs.intermediateFetch()
 
 		checkoutErr := w.Checkout(&git.CheckoutOptions{
 			Branch: plumbing.ReferenceName(referenceBranchName),

git/git_branch_compare.go

@@ -10,11 +10,25 @@ import (
 	"strings"
 )
 
+type BranchCompareInterface interface {
+	CompareBranch() []*model.BranchCompareResults
+}
+
+type BranchCompareInputs struct {
+	Repo       *git.Repository
+	BaseBranch string
+	DiffBranch string
+}
+
 // CompareBranch compares two branches and returns the commits which are different from each other
 // The function uses the git client to fetch the results as go-git lacks this feature
-func CompareBranch(repo *git.Repository, baseBranch string, compareBranch string) []*model.BranchCompareResults {
+func (inputs BranchCompareInputs) CompareBranch() []*model.BranchCompareResults {
 	var diffCommits []*model.BranchCompareResults
 	var commits []model.GitCommits
+	repo := inputs.Repo
+	baseBranch := inputs.BaseBranch
+	compareBranch := inputs.DiffBranch
+
 	w, _ := repo.Worktree()
 
 	if w == nil {

git/git_branch_delete.go

@@ -8,13 +8,27 @@ import (
 	"github.com/neel1996/gitconvex-server/graph/model"
 )
 
+type DeleteBranchInterface interface {
+	DeleteBranch() *model.BranchDeleteStatus
+}
+
+type DeleteBranchInputs struct {
+	Repo       *git.Repository
+	BranchName string
+	ForceFlag  bool
+}
+
 // DeleteBranch deleted a branch from the repo
 // If forceFlag is true then it will forcefully delete a branch
 // If forceFlag is false, then the branch status will be checked for unmerged changes and then it will be removed from the repo
-func DeleteBranch(repo *git.Repository, branchName string, forceFlag bool) *model.BranchDeleteStatus {
+func (inputs DeleteBranchInputs) DeleteBranch() *model.BranchDeleteStatus {
 	var branchErr error
 	logger := global.Logger{}
 
+	repo := inputs.Repo
+	branchName := inputs.BranchName
+	forceFlag := inputs.ForceFlag
+
 	headRef, _ := repo.Head()
 	ref := plumbing.NewHashReference(plumbing.ReferenceName(fmt.Sprintf("refs/heads/%v", branchName)), headRef.Hash())
 

git/git_branch_list.go

@@ -9,6 +9,14 @@ import (
 	"strings"
 )
 
+type BranchListInterface interface {
+	GetBranchList(branchChan chan Branch)
+}
+
+type BranchListInputs struct {
+	Repo *git.Repository
+}
+
 type Branch struct {
 	CurrentBranch string
 	BranchList    []*string
@@ -39,13 +47,13 @@ func isBranchNameValid(branchName string) bool {
 
 // GetBranchList fetches all the branches from the target repository
 // The result will be returned as a struct with the current branch and all the available branches
-func GetBranchList(repo *git.Repository, branchChan chan Branch) {
+func (inputs BranchListInputs) GetBranchList(branchChan chan Branch) {
 	var (
 		branches      []*string
 		allBranchList []*string
 	)
 	var currentBranch string
-
+	repo := inputs.Repo
 	logger := global.Logger{}
 
 	if repo != nil {