Run go fmt

burndown.go

@@ -321,7 +321,7 @@ func (analyser *BurndownAnalysis) handleDeletion(
 
 func (analyser *BurndownAnalysis) handleModification(
 	change *object.Change, author int, cache map[plumbing.Hash]*object.Blob,
-  diffs map[string]FileDiffData) error {
+	diffs map[string]FileDiffData) error {
 
 	file, exists := analyser.files[change.From.Name]
 	if !exists {

burndown_test.go

@@ -24,7 +24,7 @@ func TestBurndownConsumeFinalize(t *testing.T) {
 		Granularity:  30,
 		Sampling:     30,
 		PeopleNumber: 2,
-		TrackFiles: true,
+		TrackFiles:   true,
 	}
 	burndown.Initialize(testRepository)
 	deps := map[string]interface{}{}
@@ -104,8 +104,8 @@ func TestBurndownConsumeFinalize(t *testing.T) {
 	assert.Equal(t, len(burndown.globalHistory), 0)
 	assert.Equal(t, len(burndown.fileHistories), 0)
 	burndown2 := BurndownAnalysis{
-		Granularity:  30,
-		Sampling:     0,
+		Granularity: 30,
+		Sampling:    0,
 	}
 	burndown2.Initialize(testRepository)
 	_, err = burndown2.Consume(deps)
@@ -202,10 +202,10 @@ func TestBurndownConsumeFinalize(t *testing.T) {
 	assert.Equal(t, len(burndown.fileHistories), 3)
 	out := burndown.Finalize().(BurndownResult)
 	/*
-	GlobalHistory   [][]int64
-	FileHistories   map[string][][]int64
-	PeopleHistories [][][]int64
-	PeopleMatrix    [][]int64
+		GlobalHistory   [][]int64
+		FileHistories   map[string][][]int64
+		PeopleHistories [][][]int64
+		PeopleMatrix    [][]int64
 	*/
 	assert.Equal(t, len(out.GlobalHistory), 2)
 	for i := 0; i < 2; i++ {
@@ -249,5 +249,5 @@ func (c panickingCloser) Close() error {
 
 func TestCheckClose(t *testing.T) {
 	closer := panickingCloser{}
-	assert.Panics(t, func() {checkClose(closer)})
+	assert.Panics(t, func() { checkClose(closer) })
 }

couples_test.go

@@ -32,12 +32,12 @@ func generateChanges(names ...string) object.Changes {
 		if action == "+" {
 			change = object.Change{
 				From: object.ChangeEntry{},
-				To: object.ChangeEntry{Name: name},
+				To:   object.ChangeEntry{Name: name},
 			}
 		} else if action == "-" {
 			change = object.Change{
 				From: object.ChangeEntry{Name: name},
-				To: object.ChangeEntry{},
+				To:   object.ChangeEntry{},
 			}
 		} else if action == "=" {
 			change = object.Change{
@@ -60,7 +60,7 @@ func generateChanges(names ...string) object.Changes {
 }
 
 func TestCouplesConsumeFinalize(t *testing.T) {
-  c := fixtureCouples()
+	c := fixtureCouples()
 	deps := map[string]interface{}{}
 	deps["author"] = 0
 	deps["renamed_changes"] = generateChanges("+two", "+four", "+six")

day_test.go

@@ -54,7 +54,7 @@ func TestDaysSinceStartConsume(t *testing.T) {
 	deps["index"] = 20
 	res, err = dss.Consume(deps)
 	assert.Nil(t, err)
-  assert.Equal(t, res["day"].(int), 1)
+	assert.Equal(t, res["day"].(int), 1)
 	assert.Equal(t, dss.previousDay, 1)
 
 	commit, _ = testRepository.CommitObject(plumbing.NewHash(
@@ -63,7 +63,7 @@ func TestDaysSinceStartConsume(t *testing.T) {
 	deps["index"] = 20
 	res, err = dss.Consume(deps)
 	assert.Nil(t, err)
-  assert.Equal(t, res["day"].(int), 2)
+	assert.Equal(t, res["day"].(int), 2)
 	assert.Equal(t, dss.previousDay, 2)
 
 	commit, _ = testRepository.CommitObject(plumbing.NewHash(
@@ -72,6 +72,6 @@ func TestDaysSinceStartConsume(t *testing.T) {
 	deps["index"] = 30
 	res, err = dss.Consume(deps)
 	assert.Nil(t, err)
-  assert.Equal(t, res["day"].(int), 2)
+	assert.Equal(t, res["day"].(int), 2)
 	assert.Equal(t, dss.previousDay, 2)
 }

diff.go

@@ -6,8 +6,8 @@ import (
 
 	"github.com/sergi/go-diff/diffmatchpatch"
 	"gopkg.in/src-d/go-git.v4"
-	"gopkg.in/src-d/go-git.v4/plumbing/object"
 	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/object"
 	"gopkg.in/src-d/go-git.v4/utils/merkletrie"
 )
 
@@ -18,7 +18,7 @@ type FileDiff struct {
 type FileDiffData struct {
 	OldLinesOfCode int
 	NewLinesOfCode int
-	Diffs []diffmatchpatch.Diff
+	Diffs          []diffmatchpatch.Diff
 }
 
 func (diff *FileDiff) Name() string {
@@ -67,7 +67,7 @@ func (diff *FileDiff) Consume(deps map[string]interface{}) (map[string]interface
 			result[change.To.Name] = FileDiffData{
 				OldLinesOfCode: len(src),
 				NewLinesOfCode: len(dst),
-				Diffs: diffs,
+				Diffs:          diffs,
 			}
 		default:
 			continue

diff_test.go

@@ -3,10 +3,10 @@ package hercules
 import (
 	"testing"
 
+	"github.com/sergi/go-diff/diffmatchpatch"
 	"github.com/stretchr/testify/assert"
 	"gopkg.in/src-d/go-git.v4/plumbing"
 	"gopkg.in/src-d/go-git.v4/plumbing/object"
-	"github.com/sergi/go-diff/diffmatchpatch"
 	"unicode/utf8"
 )
 
@@ -110,7 +110,7 @@ func TestFileDiffConsume(t *testing.T) {
 }
 
 func TestFileDiffConsumeInvalidBlob(t *testing.T) {
-  fd := fixtureFileDiff()
+	fd := fixtureFileDiff()
 	deps := map[string]interface{}{}
 	cache := map[plumbing.Hash]*object.Blob{}
 	hash := plumbing.NewHash("291286b4ac41952cbd1389fda66420ec03c1a9fe")

dummies_test.go

@@ -4,12 +4,12 @@ import (
 	"io"
 	"testing"
 
-	"gopkg.in/src-d/go-git.v4/plumbing"
 	"github.com/stretchr/testify/assert"
+	"gopkg.in/src-d/go-git.v4/plumbing"
 )
 
 func TestCreateDummyBlob(t *testing.T) {
-  dummy, err := createDummyBlob(plumbing.NewHash("334cde09da4afcb74f8d2b3e6fd6cce61228b485"))
+	dummy, err := createDummyBlob(plumbing.NewHash("334cde09da4afcb74f8d2b3e6fd6cce61228b485"))
 	assert.Nil(t, err)
 	assert.Equal(t, dummy.Hash.String(), "334cde09da4afcb74f8d2b3e6fd6cce61228b485")
 	assert.Equal(t, dummy.Size, int64(0))
@@ -29,9 +29,9 @@ func TestNotUsedDummyStuff(t *testing.T) {
 	n, err := dio.Write([]byte{})
 	assert.Nil(t, err)
 	assert.Equal(t, n, 0)
-  obj := dummyEncodedObject{}
+	obj := dummyEncodedObject{}
 	obj.SetSize(int64(100))
-  obj.SetType(plumbing.CommitObject)
+	obj.SetType(plumbing.CommitObject)
 	writer, err := obj.Writer()
 	assert.Nil(t, err)
 	assert.NotNil(t, writer)

file_test.go

@@ -383,11 +383,11 @@ func TestMinMaxAbs64Funcs(t *testing.T) {
 func TestNewFileFromTreeInvalidSize(t *testing.T) {
 	keys := [...]int{1, 2, 3}
 	vals := [...]int{4, 5}
-	assert.Panics(t, func() {NewFileFromTree(keys[:], vals[:])})
+	assert.Panics(t, func() { NewFileFromTree(keys[:], vals[:]) })
 }
 
 func TestUpdatePanic(t *testing.T) {
-  keys := [...]int{0}
+	keys := [...]int{0}
 	vals := [...]int{-1}
 	file := NewFileFromTree(keys[:], vals[:])
 	file.tree.DeleteWithKey(0)
@@ -395,16 +395,16 @@ func TestUpdatePanic(t *testing.T) {
 	var paniced interface{}
 	func() {
 		defer func() {
-      paniced = recover()
-    }()
+			paniced = recover()
+		}()
 		file.Update(1, 0, 1, 0)
 	}()
-  assert.Contains(t, paniced, "invalid tree state")
+	assert.Contains(t, paniced, "invalid tree state")
 }
 
 func TestFileStatus(t *testing.T) {
 	f, _ := fixtureFile()
-	assert.Panics(t, func() {f.Status(1)})
+	assert.Panics(t, func() { f.Status(1) })
 	assert.NotNil(t, f.Status(0))
 }
 
@@ -414,18 +414,18 @@ func TestFileValidate(t *testing.T) {
 	file := NewFileFromTree(keys[:], vals[:])
 	file.tree.DeleteWithKey(0)
 	file.tree.Insert(rbtree.Item{-1, -1})
-	assert.Panics(t, func() {file.Validate()})
+	assert.Panics(t, func() { file.Validate() })
 	file.tree.DeleteWithKey(-1)
 	file.tree.Insert(rbtree.Item{0, -1})
 	file.Validate()
 	file.tree.DeleteWithKey(0)
 	file.tree.Insert(rbtree.Item{0, 0})
-	assert.Panics(t, func() {file.Validate()})
+	assert.Panics(t, func() { file.Validate() })
 	file.tree.DeleteWithKey(0)
 	file.tree.Insert(rbtree.Item{0, 1})
 	file.tree.Insert(rbtree.Item{1, 1})
 	file.tree.Insert(rbtree.Item{2, -1})
 	file.Validate()
 	file.tree.FindGE(2).Item().Key = 1
-	assert.Panics(t, func() {file.Validate()})
+	assert.Panics(t, func() { file.Validate() })
 }

identity_test.go

@@ -213,7 +213,7 @@ func (obj fakeTreeEncodedObject) Writer() (io.WriteCloser, error) {
 }
 
 type fakeEncodedObjectStorer struct {
-	Name string
+	Name     string
 	Contents string
 }
 
@@ -226,11 +226,11 @@ func (strr fakeEncodedObjectStorer) SetEncodedObject(plumbing.EncodedObject) (pl
 }
 
 func (strr fakeEncodedObjectStorer) EncodedObject(objType plumbing.ObjectType, hash plumbing.Hash) (plumbing.EncodedObject, error) {
-  if objType == plumbing.TreeObject {
-	  return fakeTreeEncodedObject{Name: strr.Name}, nil
-  } else if objType == plumbing.BlobObject {
-	  return fakeBlobEncodedObject{Contents: strr.Contents}, nil
-  }
+	if objType == plumbing.TreeObject {
+		return fakeTreeEncodedObject{Name: strr.Name}, nil
+	} else if objType == plumbing.BlobObject {
+		return fakeBlobEncodedObject{Contents: strr.Contents}, nil
+	}
 	return nil, nil
 }
 
@@ -242,14 +242,14 @@ func getFakeCommitWithFile(name string, contents string) *object.Commit {
 	c := object.Commit{
 		Hash: plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff"),
 		Author: object.Signature{
-			Name: "Vadim Markovtsev",
+			Name:  "Vadim Markovtsev",
 			Email: "vadim@sourced.tech",
 		},
 		Committer: object.Signature{
-			Name: "Vadim Markovtsev",
+			Name:  "Vadim Markovtsev",
 			Email: "vadim@sourced.tech",
 		},
-		Message: "Virtual file " + name,
+		Message:  "Virtual file " + name,
 		TreeHash: plumbing.NewHash("ffffffffffffffffffffffffffffffffffffffff"),
 	}
 	voc := reflect.ValueOf(&c)
@@ -272,9 +272,9 @@ func TestGeneratePeopleDictMailmap(t *testing.T) {
 		}
 		commits = append(commits, commit)
 	}
-  fake := getFakeCommitWithFile(
-	  ".mailmap",
-	  "Strange Guy <vadim@sourced.tech>\nVadim Markovtsev <vadim@sourced.tech> Strange Guy <vadim@sourced.tech>")
+	fake := getFakeCommitWithFile(
+		".mailmap",
+		"Strange Guy <vadim@sourced.tech>\nVadim Markovtsev <vadim@sourced.tech> Strange Guy <vadim@sourced.tech>")
 	commits = append(commits, fake)
 	id.GeneratePeopleDict(commits)
 	assert.Contains(t, id.ReversePeopleDict,

renames.go

@@ -78,7 +78,8 @@ func (ra *RenameAnalysis) Consume(deps map[string]interface{}) (map[string]inter
 			reduced_changes = append(
 				reduced_changes,
 				&object.Change{From: deleted[d].change.From, To: added[a].change.To})
-			a++; d++
+			a++
+			d++
 		} else if added[a].Less(&deleted[d]) {
 			still_added = append(still_added, added[a].change)
 			a++

renames_test.go

@@ -1,14 +1,14 @@
 package hercules
 
 import (
-	"testing"
 	"github.com/stretchr/testify/assert"
-	"gopkg.in/src-d/go-git.v4/plumbing/object"
 	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/object"
+	"testing"
 )
 
 func fixtureRenameAnalysis() *RenameAnalysis {
-  ra := RenameAnalysis{SimilarityThreshold: 80}
+	ra := RenameAnalysis{SimilarityThreshold: 80}
 	ra.Initialize(testRepository)
 	return &ra
 }
@@ -25,9 +25,9 @@ func TestRenameAnalysisMeta(t *testing.T) {
 
 func TestRenameAnalysisInitializeInvalidThreshold(t *testing.T) {
 	ra := RenameAnalysis{SimilarityThreshold: -10}
-	assert.Panics(t, func() {ra.Initialize(testRepository)})
+	assert.Panics(t, func() { ra.Initialize(testRepository) })
 	ra = RenameAnalysis{SimilarityThreshold: 110}
-	assert.Panics(t, func() {ra.Initialize(testRepository)})
+	assert.Panics(t, func() { ra.Initialize(testRepository) })
 	ra = RenameAnalysis{SimilarityThreshold: 0}
 	ra.Initialize(testRepository)
 	ra = RenameAnalysis{SimilarityThreshold: 100}