feat: Simplified the logic around merges

Author: viccon

aggregated_files.go

@@ -14,27 +14,23 @@ func createPathFileMap(files AggregatedFiles) map[string]AggregatedFile {
 	return pathFileMap
 }
 
-// merge takes two slices of aggregated files, merges them, and returns the result.
 func (a AggregatedFiles) merge(b AggregatedFiles) AggregatedFiles {
-	mergedFiles := make([]AggregatedFile, 0)
 	aFileMap := createPathFileMap(a)
 	bFileMap := createPathFileMap(b)
 
-	// Add files that are unique for "a", and merge collisions.
-	for _, aFile := range a {
-		if bFile, ok := bFileMap[aFile.Path]; ok {
-			mergedFiles = append(mergedFiles, aFile.merge(bFile))
-			continue
-		}
-		mergedFiles = append(mergedFiles, aFile)
+	allPaths := make(map[string]bool)
+	for path := range aFileMap {
+		allPaths[path] = true
 	}
-
-	// Add the files that are unique for "b".
-	for _, bFile := range b {
-		if _, ok := aFileMap[bFile.Path]; !ok {
-			mergedFiles = append(mergedFiles, bFile)
-		}
+	for path := range bFileMap {
+		allPaths[path] = true
 	}
 
+	mergedFiles := make([]AggregatedFile, 0, len(allPaths))
+	for path := range allPaths {
+		aFile := aFileMap[path]
+		bFile := bFileMap[path]
+		mergedFiles = append(mergedFiles, aFile.merge(bFile))
+	}
 	return mergedFiles
 }

aggregated_session.go

@@ -5,7 +5,7 @@ package pulse
 type AggregatedSession struct {
 	ID           string       `bson:"_id,omitempty"`
 	Period       Period       `bson:"period"`
-	Date         int64        `bson:"date"`
+	EpochDateMs  int64        `bson:"date"`
 	DateString   string       `bson:"date_string"`
 	TotalTimeMs  int64        `bson:"total_time_ms"`
 	Repositories Repositories `bson:"repositories"`
@@ -15,7 +15,7 @@ type AggregatedSession struct {
 func (a AggregatedSession) merge(b AggregatedSession, date int64, timePeriod Period) AggregatedSession {
 	mergedSession := AggregatedSession{
 		Period:       timePeriod,
-		Date:         date,
+		EpochDateMs:  date,
 		DateString:   a.DateString,
 		TotalTimeMs:  a.TotalTimeMs + b.TotalTimeMs,
 		Repositories: a.Repositories.merge(b.Repositories),

aggregated_sessions.go

@@ -7,52 +7,32 @@ import (
 
 type AggregatedSessions []AggregatedSession
 
-type truncateTimeFunc func(AggregatedSession) int64
-
-// merge takes a slice of aggregated sessions as well as a truncate function,
-// which is used to cluster and merge the sessions by time period.
-func merge(sessions AggregatedSessions, truncate truncateTimeFunc, timePeriod Period) AggregatedSessions {
-	sessionMap := make(map[int64]AggregatedSession)
+func merge(sessions AggregatedSessions, truncate func(int64) int64, timePeriod Period) AggregatedSessions {
+	truncatedDateAggregatedSession := make(map[int64]AggregatedSession)
 	for _, s := range sessions {
-		key := truncate(s)
-		if session, ok := sessionMap[key]; !ok {
-			sessionMap[key] = s
-		} else {
-			sessionMap[key] = s.merge(session, truncate(s), timePeriod)
-		}
+		truncatedDate := truncate(s.EpochDateMs)
+		currentSession := truncatedDateAggregatedSession[truncatedDate]
+		truncatedDateAggregatedSession[truncatedDate] = s.merge(currentSession, truncatedDate, timePeriod)
 	}
-
-	return maps.Values(sessionMap)
+	return maps.Values(truncatedDateAggregatedSession)
 }
 
 // MergeByDay merges sessions that occurred the same day.
 func (s AggregatedSessions) MergeByDay() AggregatedSessions {
-	truncateFunc := func(s AggregatedSession) int64 {
-		return truncate.Day(s.Date)
-	}
-	return merge(s, truncateFunc, Day)
+	return merge(s, truncate.Day, Day)
 }
 
 // MergeByWeek merges sessions that occurred the same week.
 func (s AggregatedSessions) MergeByWeek() AggregatedSessions {
-	truncateFunc := func(s AggregatedSession) int64 {
-		return truncate.Week(s.Date)
-	}
-	return merge(s, truncateFunc, Week)
+	return merge(s, truncate.Week, Week)
 }
 
 // MergeByWeek merges sessions that occurred the same month.
 func (s AggregatedSessions) MergeByMonth() AggregatedSessions {
-	truncateFunc := func(s AggregatedSession) int64 {
-		return truncate.Month(s.Date)
-	}
-	return merge(s, truncateFunc, Month)
+	return merge(s, truncate.Month, Month)
 }
 
 // MergeByYear merges sessions that occurred the same year.
 func (s AggregatedSessions) MergeByYear() AggregatedSessions {
-	truncateFunc := func(s AggregatedSession) int64 {
-		return truncate.Year(s.Date)
-	}
-	return merge(s, truncateFunc, Year)
+	return merge(s, truncate.Year, Year)
 }

buffer_stack.go

@@ -32,13 +32,14 @@ func (b *bufferStack) files() Files {
 
 	// Merge the buffers by filepath.
 	for _, buffer := range b.buffers {
-		if file, exists := pathFile[buffer.Filepath]; !exists {
+		file, exists := pathFile[buffer.Filepath]
+		if !exists {
 			sortOrder = append(sortOrder, buffer.Filepath)
 			pathFile[buffer.Filepath] = fileFromBuffer(buffer)
-		} else {
-			file.Duration += buffer.Duration()
-			pathFile[buffer.Filepath] = file
+			continue
 		}
+		file.Duration += buffer.Duration()
+		pathFile[buffer.Filepath] = file
 	}
 
 	// Return the buffers in the original order.

mongo/mongo.go

@@ -58,8 +58,8 @@ func createDateFilter(minDate, maxDate int64) primitive.D {
 func dateRange(sessions []pulse.AggregatedSession) (minDate, maxDate int64) {
 	minDate, maxDate = math.MaxInt64, math.MinInt64
 	for _, s := range sessions {
-		minDate = min(minDate, s.Date)
-		maxDate = max(maxDate, s.Date)
+		minDate = min(minDate, s.EpochDateMs)
+		maxDate = max(maxDate, s.EpochDateMs)
 	}
 	return minDate, maxDate
 }

repositories.go

@@ -5,17 +5,16 @@ type Repositories []Repository
 
 // repositories take a slice of sessions and returns the repositories.
 func repositories(sessions Sessions) Repositories {
-	filesByRepo := repositoryPathFile(sessions)
-	repos := make(Repositories, 0)
-
-	for repositoryName, filenameFileMap := range filesByRepo {
-		var durationMs int64
-		files := make([]AggregatedFile, 0)
-		for _, file := range filenameFileMap {
-			files = append(files, file)
-			durationMs += file.DurationMs
+	namesWithFiles := repositoryNamesWithFiles(sessions)
+	repos := make(Repositories, 0, len(namesWithFiles))
+
+	for repositoryName, filepathFile := range namesWithFiles {
+		files := make(AggregatedFiles, 0, len(filepathFile))
+		repo := Repository{Name: repositoryName, Files: files}
+		for _, file := range filepathFile {
+			repo.Files = append(repo.Files, file)
+			repo.DurationMs += file.DurationMs
 		}
-		repo := Repository{Name: repositoryName, Files: files, DurationMs: durationMs}
 		repos = append(repos, repo)
 	}
 
@@ -34,25 +33,20 @@ func repositoriesByName(repos Repositories) map[string]Repository {
 
 // merge takes two lists of repositories, merges them, and returns the result.
 func (r Repositories) merge(b Repositories) Repositories {
-	mergedRepositories := make([]Repository, 0)
-	aRepoMap, bRepoMap := repositoriesByName(r), repositoriesByName(b)
-
-	// Add repos that are unique for a and merge collisions.
-	for _, aRepo := range r {
-		if bRepo, ok := bRepoMap[aRepo.Name]; !ok {
-			mergedRepositories = append(mergedRepositories, aRepo)
-		} else {
-			mergedRepositories = append(mergedRepositories, aRepo.merge(bRepo))
-		}
+	aNames, bNames := repositoriesByName(r), repositoriesByName(b)
+	allNames := make(map[string]bool)
+	for name := range aNames {
+		allNames[name] = true
 	}
-
-	// The merging is done at this point. Here we'll add the
-	// repositories that are unique to the new session.
-	for _, newRepo := range b {
-		if _, ok := aRepoMap[newRepo.Name]; !ok {
-			mergedRepositories = append(mergedRepositories, newRepo)
-		}
+	for name := range bNames {
+		allNames[name] = true
 	}
 
+	mergedRepositories := make([]Repository, 0)
+	for name := range allNames {
+		aRepo := aNames[name]
+		bRepo := bNames[name]
+		mergedRepositories = append(mergedRepositories, aRepo.merge(bRepo))
+	}
 	return mergedRepositories
 }

repository.go

@@ -18,12 +18,12 @@ func (r Repository) merge(b Repository) Repository {
 	}
 }
 
-// repositoryPathFile processes a slice of coding sessions by creating a nested
+// repositoryNamesWithFiles processes a slice of coding sessions by creating a nested
 // map that organizes and merges file data. The outer map's keys are repository
 // names. Each associated value is another map, where the keys are relative file
 // paths within the repository, and the values are the corresponding file data.
 // Files are merged automatically if they have been modified in multiple sessions.
-func repositoryPathFile(sessions []Session) map[string]map[string]AggregatedFile {
+func repositoryNamesWithFiles(sessions []Session) map[string]map[string]AggregatedFile {
 	repoPathFile := make(map[string]map[string]AggregatedFile)
 	for _, session := range sessions {
 		for _, file := range session.Files {
@@ -41,13 +41,9 @@ func repositoryPathFile(sessions []Session) map[string]map[string]AggregatedFile
 				repoPathFile[file.Repository] = make(map[string]AggregatedFile)
 			}
 
-			// Check if it is the first time we're seeing this file in this
-			// repository. If it is not the first time, we'll merge them.
-			if f, ok := repoPathFile[file.Repository][file.Path]; !ok {
-				repoPathFile[file.Repository][file.Path] = aggregatedFile
-			} else {
-				repoPathFile[file.Repository][file.Path] = f.merge(aggregatedFile)
-			}
+			// Merge the aggregatedFile with a previous file, or the zero value of a file.
+			f := repoPathFile[file.Repository][file.Path]
+			repoPathFile[file.Repository][file.Path] = f.merge(aggregatedFile)
 		}
 	}
 

sessions.go

@@ -43,7 +43,7 @@ func (s Sessions) Aggregate() AggregatedSessions {
 		}
 		session := AggregatedSession{
 			Period:       Day,
-			Date:         date,
+			EpochDateMs:  date,
 			DateString:   time.UnixMilli(date).Format("2006-01-02"),
 			TotalTimeMs:  totalTimeMs,
 			Repositories: repositories(tempSessions),

truncate/truncate.go

@@ -11,24 +11,21 @@ func Day(timestamp int64) int64 {
 
 // Week truncates the timestamp to the start of the week.
 func Week(timestamp int64) int64 {
-	t := time.Unix(0, timestamp*int64(time.Millisecond))
+	t := time.UnixMilli(timestamp)
 	for t.Weekday() != time.Monday {
 		t = t.AddDate(0, 0, -1)
 	}
-	t = time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location())
-	return t.UnixMilli()
+	return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location()).UnixMilli()
 }
 
 // Month truncates the timestamp to the start of the month.
 func Month(timestamp int64) int64 {
-	t := time.Unix(0, timestamp*int64(time.Millisecond))
-	t = time.Date(t.Year(), t.Month(), 1, 0, 0, 0, 0, t.Location())
-	return t.UnixMilli()
+	t := time.UnixMilli(timestamp)
+	return time.Date(t.Year(), t.Month(), 1, 0, 0, 0, 0, t.Location()).UnixMilli()
 }
 
 // Year truncates the timestamp to the start of the year.
 func Year(timestamp int64) int64 {
-	t := time.Unix(0, timestamp*int64(time.Millisecond))
-	t = time.Date(t.Year(), time.January, 1, 0, 0, 0, 0, t.Location())
-	return t.UnixMilli()
+	t := time.UnixMilli(timestamp)
+	return time.Date(t.Year(), time.January, 1, 0, 0, 0, 0, t.Location()).UnixMilli()
 }