Update plugin example, sentiment, and devs pipelines for 'ticks'

Signed-off-by: Robert Lin <robertlin1@gmail.com>

contrib/_plugin_example/churn_analysis.go

@@ -33,7 +33,7 @@ type ChurnAnalysis struct {
 }
 
 type editInfo struct {
-	Day     int
+	Tick    int
 	Added   int
 	Removed int
 }
@@ -45,7 +45,7 @@ type ChurnAnalysisResult struct {
 }
 
 type Edits struct {
-	Days      []int
+	Ticks     []int
 	Additions []int
 	Removals  []int
 }
@@ -68,14 +68,14 @@ func (churn *ChurnAnalysis) Provides() []string {
 // file_diff - line diff for each commit change
 // changes - list of changed files for each commit
 // blob_cache - set of blobs affected by each commit
-// day - number of days since start for each commit
+// dick - number of ticks since start for each commit
 // author - author of the commit
 func (churn *ChurnAnalysis) Requires() []string {
 	arr := [...]string{
 		hercules.DependencyFileDiff,
 		hercules.DependencyTreeChanges,
 		hercules.DependencyBlobCache,
-		hercules.DependencyDay,
+		hercules.DependencyTick,
 		hercules.DependencyAuthor}
 	return arr[:]
 }
@@ -129,7 +129,7 @@ func (churn *ChurnAnalysis) Consume(deps map[string]interface{}) (map[string]int
 	fileDiffs := deps[hercules.DependencyFileDiff].(map[string]hercules.FileDiffData)
 	treeDiffs := deps[hercules.DependencyTreeChanges].(object.Changes)
 	cache := deps[hercules.DependencyBlobCache].(map[plumbing.Hash]*hercules.CachedBlob)
-	day := deps[hercules.DependencyDay].(int)
+	tick := deps[hercules.DependencyTick].(int)
 	author := deps[hercules.DependencyAuthor].(int)
 	for _, change := range treeDiffs {
 		action, err := change.Action()
@@ -161,7 +161,7 @@ func (churn *ChurnAnalysis) Consume(deps map[string]interface{}) (map[string]int
 		if err != nil {
 			return nil, err
 		}
-		ei := editInfo{Day: day, Added: added, Removed: removed}
+		ei := editInfo{Tick: tick, Added: added, Removed: removed}
 		churn.global = append(churn.global, ei)
 		if churn.TrackPeople {
 			seq, exists := churn.people[author]
@@ -230,13 +230,13 @@ func (churn *ChurnAnalysis) serializeBinary(result *ChurnAnalysisResult, writer
 func editInfosToEdits(eis []editInfo) Edits {
 	aux := map[int]*editInfo{}
 	for _, ei := range eis {
-		ptr := aux[ei.Day]
+		ptr := aux[ei.Tick]
 		if ptr == nil {
-			ptr = &editInfo{Day: ei.Day}
+			ptr = &editInfo{Tick: ei.Tick}
 		}
 		ptr.Added += ei.Added
 		ptr.Removed += ei.Removed
-		aux[ei.Day] = ptr
+		aux[ei.Tick] = ptr
 	}
 	seq := []int{}
 	for key := range aux {
@@ -244,14 +244,14 @@ func editInfosToEdits(eis []editInfo) Edits {
 	}
 	sort.Ints(seq)
 	edits := Edits{
-		Days:      make([]int, len(seq)),
+		Ticks:     make([]int, len(seq)),
 		Additions: make([]int, len(seq)),
 		Removals:  make([]int, len(seq)),
 	}
-	for i, day := range seq {
-		edits.Days[i] = day
-		edits.Additions[i] = aux[day].Added
-		edits.Removals[i] = aux[day].Removed
+	for i, tick := range seq {
+		edits.Ticks[i] = tick
+		edits.Additions[i] = aux[tick].Added
+		edits.Removals[i] = aux[tick].Removed
 	}
 	return edits
 }
@@ -268,14 +268,14 @@ func printEdits(edits Edits, writer io.Writer, indent int) {
 			}
 		}
 	}
-	printArray(edits.Days, "days")
+	printArray(edits.Ticks, "ticks")
 	printArray(edits.Additions, "additions")
 	printArray(edits.Removals, "removals")
 }
 
 func editsToEditsMessage(edits Edits) *EditsMessage {
 	message := &EditsMessage{
-		Days:      make([]uint32, len(edits.Days)),
+		Ticks:     make([]uint32, len(edits.Ticks)),
 		Additions: make([]uint32, len(edits.Additions)),
 		Removals:  make([]uint32, len(edits.Removals)),
 	}
@@ -284,7 +284,7 @@ func editsToEditsMessage(edits Edits) *EditsMessage {
 			where[i] = uint32(v)
 		}
 	}
-	copyInts(edits.Days, message.Days)
+	copyInts(edits.Ticks, message.Ticks)
 	copyInts(edits.Additions, message.Additions)
 	copyInts(edits.Removals, message.Removals)
 	return message

contrib/_plugin_example/churn_analysis.proto

@@ -3,7 +3,7 @@ option go_package = "main";
 
 message EditsMessage {
     // all three are of the same length
-    repeated uint32 days = 1;
+    repeated uint32 ticks = 1;
     repeated uint32 additions = 2;
     repeated uint32 removals = 3;
 }

internal/pb/pb.proto

@@ -39,7 +39,7 @@ message FilesOwnership {
 }
 
 message BurndownAnalysisResults {
-    // how many days are in each band [burndown_project, burndown_file, burndown_developer]
+    // how many ticks are in each band [burndown_project, burndown_file, burndown_developer]
     int32 granularity = 1;
     // how frequently we measure the state of each band [burndown_project, burndown_file, burndown_developer]
     int32 sampling = 2;
@@ -122,18 +122,18 @@ message LineStats {
     int32 changed = 3;
 }
 
-message DevDay {
+message DevTick {
     int32 commits = 1;
     LineStats stats = 2;
     map<string, LineStats> languages = 3;
 }
 
-message DayDevs {
-    map<int32, DevDay> devs = 1;
+message TickDevs {
+    map<int32, DevTick> devs = 1;
 }
 
 message DevsAnalysisResults {
-    map<int32, DayDevs> days = 1;
+    map<int32, TickDevs> ticks = 1;
     repeated string dev_index = 2;
 }
 
@@ -144,7 +144,7 @@ message Sentiment {
 }
 
 message CommentSentimentResults {
-    map<int32, Sentiment> sentiment_by_day = 1;
+    map<int32, Sentiment> sentiment_by_tick = 1;
 }
 
 message CommitFile {

leaves/comment_sentiment.go

@@ -21,7 +21,7 @@ import (
 	"gopkg.in/src-d/hercules.v9/internal/pb"
 	items "gopkg.in/src-d/hercules.v9/internal/plumbing"
 	uast_items "gopkg.in/src-d/hercules.v9/internal/plumbing/uast"
-	"gopkg.in/vmarkovtsev/BiDiSentiment.v1"
+	sentiment "gopkg.in/vmarkovtsev/BiDiSentiment.v1"
 )
 
 // CommentSentimentAnalysis measures comment sentiment through time.
@@ -31,17 +31,17 @@ type CommentSentimentAnalysis struct {
 	MinCommentLength int
 	Gap              float32
 
-	commentsByDay map[int][]string
-	commitsByDay  map[int][]plumbing.Hash
-	xpather       *uast_items.ChangesXPather
+	commentsByTick map[int][]string
+	commitsByTick  map[int][]plumbing.Hash
+	xpather        *uast_items.ChangesXPather
 }
 
-// CommentSentimentResult contains the sentiment values per day, where 1 means very negative
+// CommentSentimentResult contains the sentiment values per tick, where 1 means very negative
 // and 0 means very positive.
 type CommentSentimentResult struct {
-	EmotionsByDay map[int]float32
-	CommentsByDay map[int][]string
-	commitsByDay  map[int][]plumbing.Hash
+	EmotionsByTick map[int]float32
+	CommentsByTick map[int][]string
+	commitsByTick  map[int][]plumbing.Hash
 }
 
 const (
@@ -80,7 +80,7 @@ func (sent *CommentSentimentAnalysis) Provides() []string {
 // Each requested entity will be inserted into `deps` of Consume(). In turn, those
 // entities are Provides() upstream.
 func (sent *CommentSentimentAnalysis) Requires() []string {
-	arr := [...]string{uast_items.DependencyUastChanges, items.DependencyDay}
+	arr := [...]string{uast_items.DependencyUastChanges, items.DependencyTick}
 	return arr[:]
 }
 
@@ -123,7 +123,7 @@ func (sent *CommentSentimentAnalysis) Configure(facts map[string]interface{}) er
 		sent.MinCommentLength = val.(int)
 	}
 	sent.validate()
-	sent.commitsByDay = facts[items.FactCommitsByDay].(map[int][]plumbing.Hash)
+	sent.commitsByTick = facts[items.FactCommitsByTick].(map[int][]plumbing.Hash)
 	return nil
 }
 
@@ -143,7 +143,7 @@ func (sent *CommentSentimentAnalysis) validate() {
 // Initialize resets the temporary caches and prepares this PipelineItem for a series of Consume()
 // calls. The repository which is going to be analysed is supplied as an argument.
 func (sent *CommentSentimentAnalysis) Initialize(repository *git.Repository) error {
-	sent.commentsByDay = map[int][]string{}
+	sent.commentsByTick = map[int][]string{}
 	sent.xpather = &uast_items.ChangesXPather{XPath: "//uast:Comment"}
 	sent.validate()
 	sent.OneShotMergeProcessor.Initialize()
@@ -160,33 +160,33 @@ func (sent *CommentSentimentAnalysis) Consume(deps map[string]interface{}) (map[
 		return nil, nil
 	}
 	changes := deps[uast_items.DependencyUastChanges].([]uast_items.Change)
-	day := deps[items.DependencyDay].(int)
+	tick := deps[items.DependencyTick].(int)
 	commentNodes, _ := sent.xpather.Extract(changes)
 	comments := sent.mergeComments(commentNodes)
-	dayComments := sent.commentsByDay[day]
-	if dayComments == nil {
-		dayComments = []string{}
+	tickComments := sent.commentsByTick[tick]
+	if tickComments == nil {
+		tickComments = []string{}
 	}
-	dayComments = append(dayComments, comments...)
-	sent.commentsByDay[day] = dayComments
+	tickComments = append(tickComments, comments...)
+	sent.commentsByTick[tick] = tickComments
 	return nil, nil
 }
 
 // Finalize returns the result of the analysis. Further Consume() calls are not expected.
 func (sent *CommentSentimentAnalysis) Finalize() interface{} {
 	result := CommentSentimentResult{
-		EmotionsByDay: map[int]float32{},
-		CommentsByDay: map[int][]string{},
-		commitsByDay:  sent.commitsByDay,
+		EmotionsByTick: map[int]float32{},
+		CommentsByTick: map[int][]string{},
+		commitsByTick:  sent.commitsByTick,
 	}
-	days := make([]int, 0, len(sent.commentsByDay))
-	for day := range sent.commentsByDay {
-		days = append(days, day)
+	ticks := make([]int, 0, len(sent.commentsByTick))
+	for tick := range sent.commentsByTick {
+		ticks = append(ticks, tick)
 	}
-	sort.Ints(days)
+	sort.Ints(ticks)
 	var texts []string
-	for _, key := range days {
-		texts = append(texts, sent.commentsByDay[key]...)
+	for _, key := range ticks {
+		texts = append(texts, sent.commentsByTick[key]...)
 	}
 	session, err := sentiment.OpenSession()
 	if err != nil {
@@ -217,10 +217,10 @@ func (sent *CommentSentimentAnalysis) Finalize() interface{} {
 		panic(err)
 	}
 	pos := 0
-	for _, key := range days {
+	for _, key := range ticks {
 		sum := float32(0)
-		comments := make([]string, 0, len(sent.commentsByDay[key]))
-		for _, comment := range sent.commentsByDay[key] {
+		comments := make([]string, 0, len(sent.commentsByTick[key]))
+		for _, comment := range sent.commentsByTick[key] {
 			if weights[pos] < 0.5*(1-sent.Gap) || weights[pos] > 0.5*(1+sent.Gap) {
 				sum += weights[pos]
 				comments = append(comments, comment)
@@ -228,8 +228,8 @@ func (sent *CommentSentimentAnalysis) Finalize() interface{} {
 			pos++
 		}
 		if len(comments) > 0 {
-			result.EmotionsByDay[key] = sum / float32(len(comments))
-			result.CommentsByDay[key] = comments
+			result.EmotionsByTick[key] = sum / float32(len(comments))
+			result.CommentsByTick[key] = comments
 		}
 	}
 	return result
@@ -252,36 +252,36 @@ func (sent *CommentSentimentAnalysis) Serialize(result interface{}, binary bool,
 }
 
 func (sent *CommentSentimentAnalysis) serializeText(result *CommentSentimentResult, writer io.Writer) {
-	days := make([]int, 0, len(result.EmotionsByDay))
-	for day := range result.EmotionsByDay {
-		days = append(days, day)
+	ticks := make([]int, 0, len(result.EmotionsByTick))
+	for tick := range result.EmotionsByTick {
+		ticks = append(ticks, tick)
 	}
-	sort.Ints(days)
-	for _, day := range days {
-		commits := result.commitsByDay[day]
+	sort.Ints(ticks)
+	for _, tick := range ticks {
+		commits := result.commitsByTick[tick]
 		hashes := make([]string, len(commits))
 		for i, hash := range commits {
 			hashes[i] = hash.String()
 		}
 		fmt.Fprintf(writer, "  %d: [%.4f, [%s], \"%s\"]\n",
-			day, result.EmotionsByDay[day], strings.Join(hashes, ","),
-			strings.Join(result.CommentsByDay[day], "|"))
+			tick, result.EmotionsByTick[tick], strings.Join(hashes, ","),
+			strings.Join(result.CommentsByTick[tick], "|"))
 	}
 }
 
 func (sent *CommentSentimentAnalysis) serializeBinary(
 	result *CommentSentimentResult, writer io.Writer) error {
 	message := pb.CommentSentimentResults{
-		SentimentByDay: map[int32]*pb.Sentiment{},
+		SentimentByTick: map[int32]*pb.Sentiment{},
 	}
-	for key, val := range result.EmotionsByDay {
-		commits := make([]string, len(result.commitsByDay[key]))
-		for i, commit := range result.commitsByDay[key] {
+	for key, val := range result.EmotionsByTick {
+		commits := make([]string, len(result.commitsByTick[key]))
+		for i, commit := range result.commitsByTick[key] {
 			commits[i] = commit.String()
 		}
-		message.SentimentByDay[int32(key)] = &pb.Sentiment{
+		message.SentimentByTick[int32(key)] = &pb.Sentiment{
 			Value:    val,
-			Comments: result.CommentsByDay[key],
+			Comments: result.CommentsByTick[key],
 			Commits:  commits,
 		}
 	}

leaves/comment_sentiment_test.go

@@ -10,7 +10,7 @@ import (
 
 	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/assert"
-	"gopkg.in/bblfsh/client-go.v3"
+	bblfsh "gopkg.in/bblfsh/client-go.v3"
 	"gopkg.in/bblfsh/client-go.v3/tools"
 	"gopkg.in/bblfsh/sdk.v2/uast"
 	"gopkg.in/bblfsh/sdk.v2/uast/nodes"
@@ -30,7 +30,7 @@ func fixtureCommentSentiment() *CommentSentimentAnalysis {
 		MinCommentLength: DefaultCommentSentimentCommentMinLength,
 	}
 	facts := map[string]interface{}{
-		items.FactCommitsByDay: map[int][]plumbing.Hash{},
+		items.FactCommitsByTick: map[int][]plumbing.Hash{},
 	}
 	sent.Configure(facts)
 	sent.Initialize(test.Repository)
@@ -41,7 +41,7 @@ func TestCommentSentimentMeta(t *testing.T) {
 	sent := CommentSentimentAnalysis{}
 	assert.Equal(t, sent.Name(), "Sentiment")
 	assert.Equal(t, len(sent.Provides()), 0)
-	required := [...]string{uast_items.DependencyUastChanges, items.DependencyDay}
+	required := [...]string{uast_items.DependencyUastChanges, items.DependencyTick}
 	for _, name := range required {
 		assert.Contains(t, sent.Requires(), name)
 	}
@@ -62,7 +62,7 @@ func TestCommentSentimentConfigure(t *testing.T) {
 	facts := map[string]interface{}{}
 	facts[ConfigCommentSentimentMinLength] = 77
 	facts[ConfigCommentSentimentGap] = float32(0.77)
-	facts[items.FactCommitsByDay] = map[int][]plumbing.Hash{}
+	facts[items.FactCommitsByTick] = map[int][]plumbing.Hash{}
 	sent.Configure(facts)
 	assert.Equal(t, sent.Gap, float32(0.77))
 	assert.Equal(t, sent.MinCommentLength, 77)
@@ -100,13 +100,13 @@ func TestCommentSentimentFork(t *testing.T) {
 func TestCommentSentimentSerializeText(t *testing.T) {
 	sent := fixtureCommentSentiment()
 	result := CommentSentimentResult{
-		EmotionsByDay: map[int]float32{},
-		CommentsByDay: map[int][]string{},
-		commitsByDay:  map[int][]plumbing.Hash{},
+		EmotionsByTick: map[int]float32{},
+		CommentsByTick: map[int][]string{},
+		commitsByTick:  map[int][]plumbing.Hash{},
 	}
-	result.EmotionsByDay[9] = 0.5
-	result.CommentsByDay[9] = []string{"test", "hello"}
-	result.commitsByDay[9] = []plumbing.Hash{plumbing.NewHash("4f7c7a154638a0f2468276c56188d90c9cef0dfc")}
+	result.EmotionsByTick[9] = 0.5
+	result.CommentsByTick[9] = []string{"test", "hello"}
+	result.commitsByTick[9] = []plumbing.Hash{plumbing.NewHash("4f7c7a154638a0f2468276c56188d90c9cef0dfc")}
 	buffer := &bytes.Buffer{}
 	sent.Serialize(result, false, buffer)
 	assert.Equal(t, buffer.String(), "  9: [0.5000, [4f7c7a154638a0f2468276c56188d90c9cef0dfc], \"test|hello\"]\n")
@@ -115,32 +115,32 @@ func TestCommentSentimentSerializeText(t *testing.T) {
 func TestCommentSentimentSerializeBinary(t *testing.T) {
 	sent := fixtureCommentSentiment()
 	result := CommentSentimentResult{
-		EmotionsByDay: map[int]float32{},
-		CommentsByDay: map[int][]string{},
-		commitsByDay:  map[int][]plumbing.Hash{},
+		EmotionsByTick: map[int]float32{},
+		CommentsByTick: map[int][]string{},
+		commitsByTick:  map[int][]plumbing.Hash{},
 	}
-	result.EmotionsByDay[9] = 0.5
-	result.CommentsByDay[9] = []string{"test", "hello"}
-	result.commitsByDay[9] = []plumbing.Hash{plumbing.NewHash("4f7c7a154638a0f2468276c56188d90c9cef0dfc")}
+	result.EmotionsByTick[9] = 0.5
+	result.CommentsByTick[9] = []string{"test", "hello"}
+	result.commitsByTick[9] = []plumbing.Hash{plumbing.NewHash("4f7c7a154638a0f2468276c56188d90c9cef0dfc")}
 	buffer := &bytes.Buffer{}
 	sent.Serialize(result, true, buffer)
 	msg := pb.CommentSentimentResults{}
 	proto.Unmarshal(buffer.Bytes(), &msg)
-	assert.Len(t, msg.SentimentByDay, 1)
-	assert.Equal(t, msg.SentimentByDay[int32(9)].Commits, []string{"4f7c7a154638a0f2468276c56188d90c9cef0dfc"})
-	assert.Equal(t, msg.SentimentByDay[int32(9)].Comments, []string{"test", "hello"})
-	assert.Equal(t, msg.SentimentByDay[int32(9)].Value, float32(0.5))
+	assert.Len(t, msg.SentimentByTick, 1)
+	assert.Equal(t, msg.SentimentByTick[int32(9)].Commits, []string{"4f7c7a154638a0f2468276c56188d90c9cef0dfc"})
+	assert.Equal(t, msg.SentimentByTick[int32(9)].Comments, []string{"test", "hello"})
+	assert.Equal(t, msg.SentimentByTick[int32(9)].Value, float32(0.5))
 }
 
 func TestCommentSentimentFinalize(t *testing.T) {
 	sent := fixtureCommentSentiment()
-	sent.commitsByDay = testSentimentCommits
-	sent.commentsByDay = testSentimentComments
+	sent.commitsByTick = testSentimentCommits
+	sent.commentsByTick = testSentimentComments
 	result := sent.Finalize().(CommentSentimentResult)
 	for key, vals := range testSentimentComments {
-		assert.Equal(t, vals, result.CommentsByDay[key])
-		assert.True(t, result.EmotionsByDay[key] >= 0)
-		assert.True(t, result.EmotionsByDay[key] <= 1)
+		assert.Equal(t, vals, result.CommentsByTick[key])
+		assert.True(t, result.EmotionsByTick[key] >= 0)
+		assert.True(t, result.EmotionsByTick[key] <= 1)
 	}
 }
 
@@ -166,7 +166,7 @@ func TestCommentSentimentConsume(t *testing.T) {
 	}
 	gitChange := test.FakeChangeForName("labours.py", hash1, hash2)
 	deps := map[string]interface{}{
-		items.DependencyDay: 0,
+		items.DependencyTick: 0,
 		uast_items.DependencyUastChanges: []uast_items.Change{
 			{Before: root1, After: root2, Change: gitChange},
 		},
@@ -176,8 +176,8 @@ func TestCommentSentimentConsume(t *testing.T) {
 	result, err := sent.Consume(deps)
 	assert.Nil(t, err)
 	assert.Nil(t, result)
-	assert.Len(t, sent.commentsByDay, 1)
-	assert.Len(t, sent.commentsByDay[0], 4)
+	assert.Len(t, sent.commentsByTick, 1)
+	assert.Len(t, sent.commentsByTick[0], 4)
 }
 
 var (

leaves/devs.go

@@ -27,8 +27,8 @@ type DevsAnalysis struct {
 	// into account.
 	ConsiderEmptyCommits bool
 
-	// days maps days to developers to stats
-	days map[int]map[int]*DevDay
+	// ticks maps ticks to developers to stats
+	ticks map[int]map[int]*DevTick
 	// reversedPeopleDict references IdentityDetector.ReversedPeopleDict
 	reversedPeopleDict []string
 }
@@ -36,16 +36,16 @@ type DevsAnalysis struct {
 // DevsResult is returned by DevsAnalysis.Finalize() and carries the daily statistics
 // per developer.
 type DevsResult struct {
-	// Days is <day index> -> <developer index> -> daily stats
-	Days map[int]map[int]*DevDay
+	// Ticks is <tick index> -> <developer index> -> daily stats
+	Ticks map[int]map[int]*DevTick
 
 	// reversedPeopleDict references IdentityDetector.ReversedPeopleDict
 	reversedPeopleDict []string
 }
 
-// DevDay is the statistics for a development day and a particular developer.
-type DevDay struct {
-	// Commits is the number of commits made by a particular developer in a particular day.
+// DevTick is the statistics for a development tick and a particular developer.
+type DevTick struct {
+	// Commits is the number of commits made by a particular developer in a particular tick.
 	Commits int
 	items.LineStats
 	// LanguagesDetection carries fine-grained line stats per programming language.
@@ -114,7 +114,7 @@ func (devs *DevsAnalysis) Description() string {
 // Initialize resets the temporary caches and prepares this PipelineItem for a series of Consume()
 // calls. The repository which is going to be analysed is supplied as an argument.
 func (devs *DevsAnalysis) Initialize(repository *git.Repository) error {
-	devs.days = map[int]map[int]*DevDay{}
+	devs.ticks = map[int]map[int]*DevTick{}
 	devs.OneShotMergeProcessor.Initialize()
 	return nil
 }
@@ -133,16 +133,16 @@ func (devs *DevsAnalysis) Consume(deps map[string]interface{}) (map[string]inter
 	if len(treeDiff) == 0 && !devs.ConsiderEmptyCommits {
 		return nil, nil
 	}
-	day := deps[items.DependencyTick].(int)
-	devsDay, exists := devs.days[day]
+	tick := deps[items.DependencyTick].(int)
+	devstick, exists := devs.ticks[tick]
 	if !exists {
-		devsDay = map[int]*DevDay{}
-		devs.days[day] = devsDay
+		devstick = map[int]*DevTick{}
+		devs.ticks[tick] = devstick
 	}
-	dd, exists := devsDay[author]
+	dd, exists := devstick[author]
 	if !exists {
-		dd = &DevDay{Languages: map[string]items.LineStats{}}
-		devsDay[author] = dd
+		dd = &DevTick{Languages: map[string]items.LineStats{}}
+		devstick[author] = dd
 	}
 	dd.Commits++
 	if deps[core.DependencyIsMerge].(bool) {
@@ -170,7 +170,7 @@ func (devs *DevsAnalysis) Consume(deps map[string]interface{}) (map[string]inter
 // Finalize returns the result of the analysis. Further Consume() calls are not expected.
 func (devs *DevsAnalysis) Finalize() interface{} {
 	return DevsResult{
-		Days:               devs.days,
+		Ticks:              devs.ticks,
 		reversedPeopleDict: devs.reversedPeopleDict,
 	}
 }
@@ -198,16 +198,16 @@ func (devs *DevsAnalysis) Deserialize(pbmessage []byte) (interface{}, error) {
 	if err != nil {
 		return nil, err
 	}
-	days := map[int]map[int]*DevDay{}
-	for day, dd := range message.Days {
-		rdd := map[int]*DevDay{}
-		days[int(day)] = rdd
+	ticks := map[int]map[int]*DevTick{}
+	for tick, dd := range message.Ticks {
+		rdd := map[int]*DevTick{}
+		ticks[int(tick)] = rdd
 		for dev, stats := range dd.Devs {
 			if dev == -1 {
 				dev = identity.AuthorMissing
 			}
 			languages := map[string]items.LineStats{}
-			rdd[int(dev)] = &DevDay{
+			rdd[int(dev)] = &DevTick{
 				Commits: int(stats.Commits),
 				LineStats: items.LineStats{
 					Added:   int(stats.Stats.Added),
@@ -226,7 +226,7 @@ func (devs *DevsAnalysis) Deserialize(pbmessage []byte) (interface{}, error) {
 		}
 	}
 	result := DevsResult{
-		Days:               days,
+		Ticks:              ticks,
 		reversedPeopleDict: message.DevIndex,
 	}
 	return result, nil
@@ -269,13 +269,13 @@ func (devs *DevsAnalysis) MergeResults(r1, r2 interface{}, c1, c2 *core.CommonAn
 			invDevIndex2[pair.Index2-1] = i
 		}
 	}
-	newDays := map[int]map[int]*DevDay{}
-	merged.Days = newDays
-	for day, dd := range cr1.Days {
-		newdd, exists := newDays[day]
+	newticks := map[int]map[int]*DevTick{}
+	merged.Ticks = newticks
+	for tick, dd := range cr1.Ticks {
+		newdd, exists := newticks[tick]
 		if !exists {
-			newdd = map[int]*DevDay{}
-			newDays[day] = newdd
+			newdd = map[int]*DevTick{}
+			newticks[tick] = newdd
 		}
 		for dev, stats := range dd {
 			newdev := dev
@@ -284,7 +284,7 @@ func (devs *DevsAnalysis) MergeResults(r1, r2 interface{}, c1, c2 *core.CommonAn
 			}
 			newstats, exists := newdd[newdev]
 			if !exists {
-				newstats = &DevDay{Languages: map[string]items.LineStats{}}
+				newstats = &DevTick{Languages: map[string]items.LineStats{}}
 				newdd[newdev] = newstats
 			}
 			newstats.Commits += stats.Commits
@@ -301,11 +301,11 @@ func (devs *DevsAnalysis) MergeResults(r1, r2 interface{}, c1, c2 *core.CommonAn
 			}
 		}
 	}
-	for day, dd := range cr2.Days {
-		newdd, exists := newDays[day]
+	for tick, dd := range cr2.Ticks {
+		newdd, exists := newticks[tick]
 		if !exists {
-			newdd = map[int]*DevDay{}
-			newDays[day] = newdd
+			newdd = map[int]*DevTick{}
+			newticks[tick] = newdd
 		}
 		for dev, stats := range dd {
 			newdev := dev
@@ -314,7 +314,7 @@ func (devs *DevsAnalysis) MergeResults(r1, r2 interface{}, c1, c2 *core.CommonAn
 			}
 			newstats, exists := newdd[newdev]
 			if !exists {
-				newstats = &DevDay{Languages: map[string]items.LineStats{}}
+				newstats = &DevTick{Languages: map[string]items.LineStats{}}
 				newdd[newdev] = newstats
 			}
 			newstats.Commits += stats.Commits
@@ -335,30 +335,30 @@ func (devs *DevsAnalysis) MergeResults(r1, r2 interface{}, c1, c2 *core.CommonAn
 }
 
 func (devs *DevsAnalysis) serializeText(result *DevsResult, writer io.Writer) {
-	fmt.Fprintln(writer, "  days:")
-	days := make([]int, len(result.Days))
+	fmt.Fprintln(writer, "  ticks:")
+	ticks := make([]int, len(result.Ticks))
 	{
 		i := 0
-		for day := range result.Days {
-			days[i] = day
+		for tick := range result.Ticks {
+			ticks[i] = tick
 			i++
 		}
 	}
-	sort.Ints(days)
-	for _, day := range days {
-		fmt.Fprintf(writer, "    %d:\n", day)
-		rday := result.Days[day]
-		devseq := make([]int, len(rday))
+	sort.Ints(ticks)
+	for _, tick := range ticks {
+		fmt.Fprintf(writer, "    %d:\n", tick)
+		rtick := result.Ticks[tick]
+		devseq := make([]int, len(rtick))
 		{
 			i := 0
-			for dev := range rday {
+			for dev := range rtick {
 				devseq[i] = dev
 				i++
 			}
 		}
 		sort.Ints(devseq)
 		for _, dev := range devseq {
-			stats := rday[dev]
+			stats := rtick[dev]
 			if dev == identity.AuthorMissing {
 				dev = -1
 			}
@@ -385,17 +385,17 @@ func (devs *DevsAnalysis) serializeText(result *DevsResult, writer io.Writer) {
 func (devs *DevsAnalysis) serializeBinary(result *DevsResult, writer io.Writer) error {
 	message := pb.DevsAnalysisResults{}
 	message.DevIndex = result.reversedPeopleDict
-	message.Days = map[int32]*pb.DayDevs{}
-	for day, devs := range result.Days {
-		dd := &pb.DayDevs{}
-		message.Days[int32(day)] = dd
-		dd.Devs = map[int32]*pb.DevDay{}
+	message.Ticks = map[int32]*pb.TickDevs{}
+	for tick, devs := range result.Ticks {
+		dd := &pb.TickDevs{}
+		message.Ticks[int32(tick)] = dd
+		dd.Devs = map[int32]*pb.DevTick{}
 		for dev, stats := range devs {
 			if dev == identity.AuthorMissing {
 				dev = -1
 			}
 			languages := map[string]*pb.LineStats{}
-			dd.Devs[int32(dev)] = &pb.DevDay{
+			dd.Devs[int32(dev)] = &pb.DevTick{
 				Commits: int32(stats.Commits),
 				Stats: &pb.LineStats{
 					Added:   int32(stats.Added),

leaves/devs_test.go

@@ -68,7 +68,7 @@ func TestDevsConfigure(t *testing.T) {
 
 func TestDevsInitialize(t *testing.T) {
 	d := fixtureDevs()
-	assert.NotNil(t, d.days)
+	assert.NotNil(t, d.ticks)
 }
 
 func TestDevsConsumeFinalize(t *testing.T) {
@@ -148,8 +148,8 @@ func TestDevsConsumeFinalize(t *testing.T) {
 	result, err = devs.Consume(deps)
 	assert.Nil(t, result)
 	assert.Nil(t, err)
-	assert.Len(t, devs.days, 1)
-	day := devs.days[0]
+	assert.Len(t, devs.ticks, 1)
+	day := devs.ticks[0]
 	assert.Len(t, day, 1)
 	dev := day[0]
 	assert.Equal(t, dev.Commits, 1)
@@ -167,8 +167,8 @@ func TestDevsConsumeFinalize(t *testing.T) {
 	result, err = devs.Consume(deps)
 	assert.Nil(t, result)
 	assert.Nil(t, err)
-	assert.Len(t, devs.days, 1)
-	day = devs.days[0]
+	assert.Len(t, devs.ticks, 1)
+	day = devs.ticks[0]
 	assert.Len(t, day, 1)
 	dev = day[0]
 	assert.Equal(t, dev.Commits, 2)
@@ -187,8 +187,8 @@ func TestDevsConsumeFinalize(t *testing.T) {
 	result, err = devs.Consume(deps)
 	assert.Nil(t, result)
 	assert.Nil(t, err)
-	assert.Len(t, devs.days, 1)
-	day = devs.days[0]
+	assert.Len(t, devs.ticks, 1)
+	day = devs.ticks[0]
 	assert.Len(t, day, 2)
 	for i := 0; i < 2; i++ {
 		dev = day[i]
@@ -208,8 +208,8 @@ func TestDevsConsumeFinalize(t *testing.T) {
 	result, err = devs.Consume(deps)
 	assert.Nil(t, result)
 	assert.Nil(t, err)
-	assert.Len(t, devs.days, 1)
-	day = devs.days[0]
+	assert.Len(t, devs.ticks, 1)
+	day = devs.ticks[0]
 	assert.Len(t, day, 2)
 	dev = day[0]
 	assert.Equal(t, dev.Commits, 2)
@@ -232,8 +232,8 @@ func TestDevsConsumeFinalize(t *testing.T) {
 	result, err = devs.Consume(deps)
 	assert.Nil(t, result)
 	assert.Nil(t, err)
-	assert.Len(t, devs.days, 2)
-	day = devs.days[0]
+	assert.Len(t, devs.ticks, 2)
+	day = devs.ticks[0]
 	assert.Len(t, day, 2)
 	dev = day[0]
 	assert.Equal(t, dev.Commits, 2)
@@ -251,7 +251,7 @@ func TestDevsConsumeFinalize(t *testing.T) {
 	assert.Equal(t, dev.Languages["Go"].Added, 847*2)
 	assert.Equal(t, dev.Languages["Go"].Removed, 9*2)
 	assert.Equal(t, dev.Languages["Go"].Changed, 67*2)
-	day = devs.days[1]
+	day = devs.ticks[1]
 	assert.Len(t, day, 1)
 	dev = day[1]
 	assert.Equal(t, dev.Commits, 1)
@@ -269,10 +269,10 @@ func ls(added, removed, changed int) items.LineStats {
 
 func TestDevsFinalize(t *testing.T) {
 	devs := fixtureDevs()
-	devs.days[1] = map[int]*DevDay{}
-	devs.days[1][1] = &DevDay{10, ls(20, 30, 40), nil}
+	devs.ticks[1] = map[int]*DevTick{}
+	devs.ticks[1][1] = &DevTick{10, ls(20, 30, 40), nil}
 	x := devs.Finalize().(DevsResult)
-	assert.Equal(t, x.Days, devs.days)
+	assert.Equal(t, x.Ticks, devs.ticks)
 	assert.Equal(t, x.reversedPeopleDict, devs.reversedPeopleDict)
 }
 
@@ -284,12 +284,12 @@ func TestDevsFork(t *testing.T) {
 
 func TestDevsSerialize(t *testing.T) {
 	devs := fixtureDevs()
-	devs.days[1] = map[int]*DevDay{}
-	devs.days[1][0] = &DevDay{10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(2, 3, 4)}}
-	devs.days[1][1] = &DevDay{1, ls(2, 3, 4), map[string]items.LineStats{"Go": ls(25, 35, 45)}}
-	devs.days[10] = map[int]*DevDay{}
-	devs.days[10][0] = &DevDay{11, ls(21, 31, 41), map[string]items.LineStats{"": ls(12, 13, 14)}}
-	devs.days[10][identity.AuthorMissing] = &DevDay{
+	devs.ticks[1] = map[int]*DevTick{}
+	devs.ticks[1][0] = &DevTick{10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(2, 3, 4)}}
+	devs.ticks[1][1] = &DevTick{1, ls(2, 3, 4), map[string]items.LineStats{"Go": ls(25, 35, 45)}}
+	devs.ticks[10] = map[int]*DevTick{}
+	devs.ticks[10][0] = &DevTick{11, ls(21, 31, 41), map[string]items.LineStats{"": ls(12, 13, 14)}}
+	devs.ticks[10][identity.AuthorMissing] = &DevTick{
 		100, ls(200, 300, 400), map[string]items.LineStats{"Go": ls(32, 33, 34)}}
 	res := devs.Finalize().(DevsResult)
 	buffer := &bytes.Buffer{}
@@ -313,31 +313,31 @@ func TestDevsSerialize(t *testing.T) {
 	msg := pb.DevsAnalysisResults{}
 	assert.Nil(t, proto.Unmarshal(buffer.Bytes(), &msg))
 	assert.Equal(t, msg.DevIndex, devs.reversedPeopleDict)
-	assert.Len(t, msg.Days, 2)
-	assert.Len(t, msg.Days[1].Devs, 2)
-	assert.Equal(t, msg.Days[1].Devs[0], &pb.DevDay{
+	assert.Len(t, msg.Ticks, 2)
+	assert.Len(t, msg.Ticks[1].Devs, 2)
+	assert.Equal(t, msg.Ticks[1].Devs[0], &pb.DevTick{
 		Commits: 10, Stats: &pb.LineStats{Added: 20, Removed: 30, Changed: 40},
 		Languages: map[string]*pb.LineStats{"Go": {Added: 2, Removed: 3, Changed: 4}}})
-	assert.Equal(t, msg.Days[1].Devs[1], &pb.DevDay{
+	assert.Equal(t, msg.Ticks[1].Devs[1], &pb.DevTick{
 		Commits: 1, Stats: &pb.LineStats{Added: 2, Removed: 3, Changed: 4},
 		Languages: map[string]*pb.LineStats{"Go": {Added: 25, Removed: 35, Changed: 45}}})
-	assert.Len(t, msg.Days[10].Devs, 2)
-	assert.Equal(t, msg.Days[10].Devs[0], &pb.DevDay{
+	assert.Len(t, msg.Ticks[10].Devs, 2)
+	assert.Equal(t, msg.Ticks[10].Devs[0], &pb.DevTick{
 		Commits: 11, Stats: &pb.LineStats{Added: 21, Removed: 31, Changed: 41},
 		Languages: map[string]*pb.LineStats{"": {Added: 12, Removed: 13, Changed: 14}}})
-	assert.Equal(t, msg.Days[10].Devs[-1], &pb.DevDay{
+	assert.Equal(t, msg.Ticks[10].Devs[-1], &pb.DevTick{
 		Commits: 100, Stats: &pb.LineStats{Added: 200, Removed: 300, Changed: 400},
 		Languages: map[string]*pb.LineStats{"Go": {Added: 32, Removed: 33, Changed: 34}}})
 }
 
 func TestDevsDeserialize(t *testing.T) {
 	devs := fixtureDevs()
-	devs.days[1] = map[int]*DevDay{}
-	devs.days[1][0] = &DevDay{10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(12, 13, 14)}}
-	devs.days[1][1] = &DevDay{1, ls(2, 3, 4), map[string]items.LineStats{"Go": ls(22, 23, 24)}}
-	devs.days[10] = map[int]*DevDay{}
-	devs.days[10][0] = &DevDay{11, ls(21, 31, 41), map[string]items.LineStats{"Go": ls(32, 33, 34)}}
-	devs.days[10][identity.AuthorMissing] = &DevDay{
+	devs.ticks[1] = map[int]*DevTick{}
+	devs.ticks[1][0] = &DevTick{10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(12, 13, 14)}}
+	devs.ticks[1][1] = &DevTick{1, ls(2, 3, 4), map[string]items.LineStats{"Go": ls(22, 23, 24)}}
+	devs.ticks[10] = map[int]*DevTick{}
+	devs.ticks[10][0] = &DevTick{11, ls(21, 31, 41), map[string]items.LineStats{"Go": ls(32, 33, 34)}}
+	devs.ticks[10][identity.AuthorMissing] = &DevTick{
 		100, ls(200, 300, 400), map[string]items.LineStats{"Go": ls(42, 43, 44)}}
 	res := devs.Finalize().(DevsResult)
 	buffer := &bytes.Buffer{}
@@ -353,51 +353,51 @@ func TestDevsMergeResults(t *testing.T) {
 	people1 := [...]string{"1@srcd", "2@srcd"}
 	people2 := [...]string{"3@srcd", "1@srcd"}
 	r1 := DevsResult{
-		Days:               map[int]map[int]*DevDay{},
+		Ticks:              map[int]map[int]*DevTick{},
 		reversedPeopleDict: people1[:],
 	}
-	r1.Days[1] = map[int]*DevDay{}
-	r1.Days[1][0] = &DevDay{10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(12, 13, 14)}}
-	r1.Days[1][1] = &DevDay{1, ls(2, 3, 4), map[string]items.LineStats{"Go": ls(22, 23, 24)}}
-	r1.Days[10] = map[int]*DevDay{}
-	r1.Days[10][0] = &DevDay{11, ls(21, 31, 41), nil}
-	r1.Days[10][identity.AuthorMissing] = &DevDay{
+	r1.Ticks[1] = map[int]*DevTick{}
+	r1.Ticks[1][0] = &DevTick{10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(12, 13, 14)}}
+	r1.Ticks[1][1] = &DevTick{1, ls(2, 3, 4), map[string]items.LineStats{"Go": ls(22, 23, 24)}}
+	r1.Ticks[10] = map[int]*DevTick{}
+	r1.Ticks[10][0] = &DevTick{11, ls(21, 31, 41), nil}
+	r1.Ticks[10][identity.AuthorMissing] = &DevTick{
 		100, ls(200, 300, 400), map[string]items.LineStats{"Go": ls(32, 33, 34)}}
-	r1.Days[11] = map[int]*DevDay{}
-	r1.Days[11][1] = &DevDay{10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(42, 43, 44)}}
+	r1.Ticks[11] = map[int]*DevTick{}
+	r1.Ticks[11][1] = &DevTick{10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(42, 43, 44)}}
 	r2 := DevsResult{
-		Days:               map[int]map[int]*DevDay{},
+		Ticks:              map[int]map[int]*DevTick{},
 		reversedPeopleDict: people2[:],
 	}
-	r2.Days[1] = map[int]*DevDay{}
-	r2.Days[1][0] = &DevDay{10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(12, 13, 14)}}
-	r2.Days[1][1] = &DevDay{1, ls(2, 3, 4), map[string]items.LineStats{"Go": ls(22, 23, 24)}}
-	r2.Days[2] = map[int]*DevDay{}
-	r2.Days[2][0] = &DevDay{11, ls(21, 31, 41), map[string]items.LineStats{"Go": ls(32, 33, 34)}}
-	r2.Days[2][identity.AuthorMissing] = &DevDay{
+	r2.Ticks[1] = map[int]*DevTick{}
+	r2.Ticks[1][0] = &DevTick{10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(12, 13, 14)}}
+	r2.Ticks[1][1] = &DevTick{1, ls(2, 3, 4), map[string]items.LineStats{"Go": ls(22, 23, 24)}}
+	r2.Ticks[2] = map[int]*DevTick{}
+	r2.Ticks[2][0] = &DevTick{11, ls(21, 31, 41), map[string]items.LineStats{"Go": ls(32, 33, 34)}}
+	r2.Ticks[2][identity.AuthorMissing] = &DevTick{
 		100, ls(200, 300, 400), map[string]items.LineStats{"Go": ls(42, 43, 44)}}
-	r2.Days[10] = map[int]*DevDay{}
-	r2.Days[10][0] = &DevDay{11, ls(21, 31, 41), map[string]items.LineStats{"Go": ls(52, 53, 54)}}
-	r2.Days[10][identity.AuthorMissing] = &DevDay{
+	r2.Ticks[10] = map[int]*DevTick{}
+	r2.Ticks[10][0] = &DevTick{11, ls(21, 31, 41), map[string]items.LineStats{"Go": ls(52, 53, 54)}}
+	r2.Ticks[10][identity.AuthorMissing] = &DevTick{
 		100, ls(200, 300, 400), map[string]items.LineStats{"Go": ls(62, 63, 64)}}
 
 	devs := fixtureDevs()
 	rm := devs.MergeResults(r1, r2, nil, nil).(DevsResult)
 	peoplerm := [...]string{"1@srcd", "2@srcd", "3@srcd"}
 	assert.Equal(t, rm.reversedPeopleDict, peoplerm[:])
-	assert.Len(t, rm.Days, 4)
-	assert.Equal(t, rm.Days[11], map[int]*DevDay{
+	assert.Len(t, rm.Ticks, 4)
+	assert.Equal(t, rm.Ticks[11], map[int]*DevTick{
 		1: {10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(42, 43, 44)}}})
-	assert.Equal(t, rm.Days[2], map[int]*DevDay{
+	assert.Equal(t, rm.Ticks[2], map[int]*DevTick{
 		identity.AuthorMissing: {100, ls(200, 300, 400), map[string]items.LineStats{"Go": ls(42, 43, 44)}},
 		2:                      {11, ls(21, 31, 41), map[string]items.LineStats{"Go": ls(32, 33, 34)}},
 	})
-	assert.Equal(t, rm.Days[1], map[int]*DevDay{
+	assert.Equal(t, rm.Ticks[1], map[int]*DevTick{
 		0: {11, ls(22, 33, 44), map[string]items.LineStats{"Go": ls(34, 36, 38)}},
 		1: {1, ls(2, 3, 4), map[string]items.LineStats{"Go": ls(22, 23, 24)}},
 		2: {10, ls(20, 30, 40), map[string]items.LineStats{"Go": ls(12, 13, 14)}},
 	})
-	assert.Equal(t, rm.Days[10], map[int]*DevDay{
+	assert.Equal(t, rm.Ticks[10], map[int]*DevTick{
 		0: {11, ls(21, 31, 41), map[string]items.LineStats{}},
 		2: {11, ls(21, 31, 41), map[string]items.LineStats{"Go": ls(52, 53, 54)}},
 		identity.AuthorMissing: {