Disregard contributor count prior to article fork

modules/git/repo_stats.go

@@ -154,15 +154,24 @@ func (repo *Repository) GetCodeActivityStats(fromTime time.Time, branch string)
 	return stats, nil
 }
 
-// GetContributorCount returns the number of unique contributors for the given branch
-func (repo *Repository) GetContributorCount(branch string) (int64, error) {
+// GetContributorCount returns the number of unique contributors for the given branch.
+// If since is non-zero, only counts contributors who made commits after that time.
+// This is useful for forks where we only want to count post-fork contributions.
+func (repo *Repository) GetContributorCount(branch string, since time.Time) (int64, error) {
 	if len(branch) == 0 {
 		branch = "HEAD"
 	}
 
 	// Use git shortlog to get unique contributors efficiently
-	stdout, _, err := gitcmd.NewCommand("shortlog", "-sn", "--all").
-		AddDynamicArguments(branch).
+	cmd := gitcmd.NewCommand("shortlog", "-sn", "--all")
+
+	// If since is provided, only count commits after that time
+	// This is used for forks to exclude inherited history from the parent repository
+	if !since.IsZero() {
+		cmd.AddOptionFormat("--since=%s", since.Format(time.RFC3339))
+	}
+
+	stdout, _, err := cmd.AddDynamicArguments(branch).
 		RunStdString(repo.Ctx, &gitcmd.RunOpts{Dir: repo.Path})
 	if err != nil {
 		return 0, err

modules/git/repo_stats_test.go

@@ -34,3 +34,28 @@ func TestRepository_GetCodeActivityStats(t *testing.T) {
 	assert.EqualValues(t, 3, code.Authors[1].Commits)
 	assert.EqualValues(t, 5, code.Authors[0].Commits)
 }
+
+func TestRepository_GetContributorCount(t *testing.T) {
+	bareRepo1Path := filepath.Join(testReposDir, "repo1_bare")
+	bareRepo1, err := OpenRepository(t.Context(), bareRepo1Path)
+	assert.NoError(t, err)
+	defer bareRepo1.Close()
+
+	// Test without since filter - should count all contributors
+	count, err := bareRepo1.GetContributorCount("master", time.Time{})
+	assert.NoError(t, err)
+	assert.Positive(t, count, "Expected at least one contributor")
+
+	// Test with a future since date - should return 0 contributors
+	futureTime := time.Now().AddDate(1, 0, 0) // 1 year in the future
+	count, err = bareRepo1.GetContributorCount("master", futureTime)
+	assert.NoError(t, err)
+	assert.EqualValues(t, 0, count, "Expected 0 contributors for future since date")
+
+	// Test with a past since date that includes all commits
+	pastTime, err := time.Parse(time.RFC3339, "2016-01-01T00:00:00+00:00")
+	assert.NoError(t, err)
+	countWithPastSince, err := bareRepo1.GetContributorCount("master", pastTime)
+	assert.NoError(t, err)
+	assert.Positive(t, countWithPastSince, "Expected contributors with past since date")
+}

routers/web/explore/repo.go

@@ -11,6 +11,7 @@ import (
 	"net/http"
 	"path"
 	"strings"
+	"time"
 
 	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/models/renderhelper"
@@ -505,7 +506,8 @@ func RenderRepositoryHistory(ctx *context.Context) {
 		if branch == "" {
 			branch = setting.Repository.DefaultBranch
 		}
-		if count, err := gitRepo.GetContributorCount(branch); err == nil {
+		// Root repo is not a fork, so count all contributors (no since filter)
+		if count, err := gitRepo.GetContributorCount(branch, time.Time{}); err == nil {
 			rootEntry.ContributorCount = count
 		} else {
 			log.Warn("GetContributorCount for %s: %v", rootRepo.FullName(), err)
@@ -537,7 +539,9 @@ func RenderRepositoryHistory(ctx *context.Context) {
 			if err != nil {
 				log.Warn("OpenRepository for fork %s: %v", fork.FullName(), err)
 			} else {
-				if count, err := forkGitRepo.GetContributorCount(branch); err == nil {
+				// For forks, only count contributors who made commits after the fork was created
+				// to exclude inherited history from the parent repository
+				if count, err := forkGitRepo.GetContributorCount(branch, fork.CreatedUnix.AsTime()); err == nil {
 					entry.ContributorCount = count
 				} else {
 					log.Warn("GetContributorCount for fork %s: %v", fork.FullName(), err)
@@ -618,8 +622,14 @@ func prepareArticleView(ctx *context.Context, gitRepo *git.Repository, entries [
 	}
 
 	// Get contributor count for the readme file (use default branch for contributor count)
+	// For forks, only count contributors who made commits after the fork was created
+	// to exclude inherited history from the parent repository
 	defaultBranch := ctx.Repo.Repository.DefaultBranch
-	contributorCount, err := getFileContributorCount(gitRepo, defaultBranch, readmeTreePath)
+	var contributorSince timeutil.TimeStamp
+	if ctx.Repo.Repository.IsFork {
+		contributorSince = ctx.Repo.Repository.CreatedUnix
+	}
+	contributorCount, err := getFileContributorCount(gitRepo, defaultBranch, readmeTreePath, contributorSince)
 	if err != nil {
 		log.Warn("Failed to get contributor count: %v", err)
 		contributorCount = 0
@@ -805,11 +815,20 @@ func processGitCommits(ctx *context.Context, commits []*git.Commit) ([]*user_mod
 	return userCommits, nil
 }
 
-// getFileContributorCount gets the number of unique contributors for a specific file
-func getFileContributorCount(gitRepo *git.Repository, branch, filePath string) (int64, error) {
+// getFileContributorCount gets the number of unique contributors for a specific file.
+// If since is non-zero, only counts contributors who made commits after that time.
+// This is useful for forks where we only want to count post-fork contributions.
+func getFileContributorCount(gitRepo *git.Repository, branch, filePath string, since timeutil.TimeStamp) (int64, error) {
 	// Use git shortlog to get unique contributors for the file
-	stdout, _, err := gitcmd.NewCommand("shortlog", "-sn").
-		AddDynamicArguments(branch, "--", filePath).
+	cmd := gitcmd.NewCommand("shortlog", "-sn")
+
+	// If since is provided, only count commits after that time
+	// This is used for forks to exclude inherited history from the parent repository
+	if since > 0 {
+		cmd.AddOptionFormat("--since=%s", since.AsTime().Format(time.RFC3339))
+	}
+
+	stdout, _, err := cmd.AddDynamicArguments(branch, "--", filePath).
 		RunStdString(gitRepo.Ctx, &gitcmd.RunOpts{Dir: gitRepo.Path})
 	if err != nil {
 		return 0, err

services/context/repo.go

@@ -13,6 +13,7 @@ import (
 	"net/url"
 	"path"
 	"strings"
+	"time"
 
 	asymkey_model "code.gitea.io/gitea/models/asymkey"
 	"code.gitea.io/gitea/models/db"
@@ -1162,9 +1163,15 @@ func RepoAssignmentBySubject(ctx *Context) {
 	}
 
 	// Set up contributor count data
+	// For forks, only count contributors who made commits after the fork was created
+	// to avoid including inherited history from the parent repository
 	ctx.Data["ContributorCount"] = int64(0)
 	if !repo.IsEmpty && ctx.Repo.GitRepo != nil {
-		contributorCount, err := ctx.Repo.GitRepo.GetContributorCount(repo.DefaultBranch)
+		var since time.Time
+		if repo.IsFork {
+			since = repo.CreatedUnix.AsTime()
+		}
+		contributorCount, err := ctx.Repo.GitRepo.GetContributorCount(repo.DefaultBranch, since)
 		if err != nil {
 			log.Warn("Failed to get contributor count for repository %s: %v", repo.FullName(), err)
 		} else {

services/repository/fork_graph.go

@@ -291,7 +291,13 @@ func buildNode(ctx context.Context, repo *repo_model.Repository, level int, para
 
 	// Add contributor stats if requested
 	if params.IncludeContributors {
-		stats, err := getContributorStats(repo, params.ContributorDays)
+		// For forks, only count contributors who made commits after the fork was created
+		// to exclude inherited history from the parent repository
+		var since time.Time
+		if repo.IsFork {
+			since = repo.CreatedUnix.AsTime()
+		}
+		stats, err := getContributorStats(repo, params.ContributorDays, since)
 		if err != nil {
 			log.Warn("Failed to get contributor stats for repo %d: %v", repo.ID, err)
 		} else {
@@ -312,7 +318,13 @@ func createLeafNode(repo *repo_model.Repository, level int, params ForkGraphPara
 	}
 
 	if params.IncludeContributors {
-		stats, err := getContributorStats(repo, params.ContributorDays)
+		// For forks, only count contributors who made commits after the fork was created
+		// to exclude inherited history from the parent repository
+		var since time.Time
+		if repo.IsFork {
+			since = repo.CreatedUnix.AsTime()
+		}
+		stats, err := getContributorStats(repo, params.ContributorDays, since)
 		if err != nil {
 			log.Warn("Failed to get contributor stats for repo %d: %v", repo.ID, err)
 		} else {
@@ -395,8 +407,30 @@ func sortRepositories(repos []*repo_model.Repository, sortBy string) {
 	})
 }
 
-// getContributorStats gets contributor statistics for a repository
-func getContributorStats(repo *repo_model.Repository, days int) (*ContributorStats, error) {
+// hasCommitsAfter checks if a contributor has any commits after the given time.
+// Returns true if since is zero (no filtering) or if the contributor has at least one commit after since.
+// Note: Since week.Week is the Unix timestamp of the start of the week (Sunday), we check if the
+// week *ends* after since to include commits made mid-week after a fork created earlier that week.
+func hasCommitsAfter(contributor *ContributorData, since time.Time) bool {
+	if since.IsZero() {
+		return true
+	}
+	for _, week := range contributor.Weeks {
+		weekTime := time.UnixMilli(week.Week)
+		// Check if the week ends after since (week end = week start + 7 days)
+		// This ensures we include weeks that overlap with the post-fork period
+		weekEndTime := weekTime.AddDate(0, 0, 7)
+		if weekEndTime.After(since) && week.Commits > 0 {
+			return true
+		}
+	}
+	return false
+}
+
+// getContributorStats gets contributor statistics for a repository.
+// If since is non-zero, only counts contributors who made commits after that time.
+// This is useful for forks where we only want to count post-fork contributions.
+func getContributorStats(repo *repo_model.Repository, days int, since time.Time) (*ContributorStats, error) {
 	// Use existing contributor stats service
 	c := cache.GetCache()
 	if c == nil {
@@ -416,12 +450,23 @@ func getContributorStats(repo *repo_model.Repository, days int) (*ContributorSta
 	}
 
 	// Count total contributors (exclude "total" summary entry)
-	totalCount := len(stats)
-	if _, hasTotal := stats["total"]; hasTotal {
-		totalCount-- // Don't count the "total" summary as a contributor
+	// For forks, only count contributors who have commits after the fork creation time
+	totalCount := 0
+	for email, contributor := range stats {
+		// Skip the "total" summary entry
+		if email == "total" {
+			continue
+		}
+
+		// For forks, skip contributors with no post-fork commits
+		if !hasCommitsAfter(contributor, since) {
+			continue
+		}
+
+		totalCount++
 	}
 
-	// Count recent contributors
+	// Count recent contributors (within the specified days window)
 	cutoffTime := time.Now().AddDate(0, 0, -days)
 	recentCount := 0
 
@@ -431,7 +476,12 @@ func getContributorStats(repo *repo_model.Repository, days int) (*ContributorSta
 			continue
 		}
 
-		// Check if contributor has commits in the time window
+		// For forks, skip contributors with no post-fork commits
+		if !hasCommitsAfter(contributor, since) {
+			continue
+		}
+
+		// Check if contributor has commits in the recent time window
 		for _, week := range contributor.Weeks {
 			weekTime := time.UnixMilli(week.Week)
 			if weekTime.After(cutoffTime) && week.Commits > 0 {

services/repository/fork_graph_test.go

@@ -227,14 +227,90 @@ func TestGetContributorStats(t *testing.T) {
 
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
 
-	// Test getting contributor stats
-	stats, err := getContributorStats(repo, 90)
+	// Test getting contributor stats without since filter (non-fork)
+	stats, err := getContributorStats(repo, 90, time.Time{})
 
 	// Should not error even if stats are not available
 	assert.NoError(t, err)
 	assert.NotNil(t, stats)
 	assert.GreaterOrEqual(t, stats.TotalCount, 0)
 	assert.GreaterOrEqual(t, stats.RecentCount, 0)
+
+	// Test getting contributor stats with since filter (simulating fork)
+	// Using a future time should result in 0 contributors
+	futureTime := time.Now().AddDate(1, 0, 0)
+	statsWithFutureSince, err := getContributorStats(repo, 90, futureTime)
+	assert.NoError(t, err)
+	assert.NotNil(t, statsWithFutureSince)
+	assert.Equal(t, 0, statsWithFutureSince.TotalCount, "Expected 0 contributors for future since date")
+	assert.Equal(t, 0, statsWithFutureSince.RecentCount, "Expected 0 recent contributors for future since date")
+}
+
+func TestHasCommitsAfter(t *testing.T) {
+	// Test the hasCommitsAfter helper function directly to verify mid-week edge case handling
+
+	// Create a mock contributor with commits in a specific week
+	// Week starts on Sunday 2024-01-07 (Unix timestamp in milliseconds)
+	weekStart := time.Date(2024, 1, 7, 0, 0, 0, 0, time.UTC) // Sunday
+	weekStartMs := weekStart.UnixMilli()
+
+	contributor := &ContributorData{
+		Name:         "Test User",
+		TotalCommits: 5,
+		Weeks: map[int64]*WeekData{
+			weekStartMs: {
+				Week:    weekStartMs,
+				Commits: 5,
+			},
+		},
+	}
+
+	// Test 1: Zero since time should always return true
+	assert.True(t, hasCommitsAfter(contributor, time.Time{}),
+		"Zero since time should return true")
+
+	// Test 2: Since time before the week should return true
+	beforeWeek := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC) // Before the week
+	assert.True(t, hasCommitsAfter(contributor, beforeWeek),
+		"Since time before the week should return true")
+
+	// Test 3: Since time after the week ends should return false
+	afterWeek := time.Date(2024, 1, 15, 0, 0, 0, 0, time.UTC) // After the week ends
+	assert.False(t, hasCommitsAfter(contributor, afterWeek),
+		"Since time after the week ends should return false")
+
+	// Test 4: MID-WEEK EDGE CASE - Since time mid-week (Wednesday) should return true
+	// This is the key edge case: fork created on Wednesday, commits exist in that week
+	// The week started Sunday (before fork) but ends Sunday (after fork)
+	// So commits made Thursday-Saturday should be counted
+	midWeek := time.Date(2024, 1, 10, 12, 0, 0, 0, time.UTC) // Wednesday noon
+	assert.True(t, hasCommitsAfter(contributor, midWeek),
+		"Mid-week since time should return true because week ends after since")
+
+	// Test 5: Since time exactly at week end should return false
+	// Week ends at the start of the next Sunday (2024-01-14 00:00:00)
+	weekEnd := time.Date(2024, 1, 14, 0, 0, 0, 0, time.UTC)
+	assert.False(t, hasCommitsAfter(contributor, weekEnd),
+		"Since time at week end should return false")
+
+	// Test 6: Since time just before week end should return true
+	justBeforeWeekEnd := time.Date(2024, 1, 13, 23, 59, 59, 0, time.UTC) // Saturday 23:59:59
+	assert.True(t, hasCommitsAfter(contributor, justBeforeWeekEnd),
+		"Since time just before week end should return true")
+
+	// Test 7: Contributor with no commits should return false
+	emptyContributor := &ContributorData{
+		Name:         "Empty User",
+		TotalCommits: 0,
+		Weeks: map[int64]*WeekData{
+			weekStartMs: {
+				Week:    weekStartMs,
+				Commits: 0, // No commits in this week
+			},
+		},
+	}
+	assert.False(t, hasCommitsAfter(emptyContributor, beforeWeek),
+		"Contributor with no commits should return false even with valid since time")
 }
 
 func TestProcessingTimeout(t *testing.T) {