···

       
106
       
 
       
	return s.client.Do(req)

     

       
107
       
 
       
}

     

       
108
       
 
       


     

       
109
       
-
       
func (s *SignedClient) RepoLanguages(ownerDid, source, name, branch string) (*types.RepoLanguageResponse, error) {

     

       
110
       
 
       
	const (

     

       
111
       
 
       
		Method = "GET"

     

       
112
       
 
       
	)

     

       
113
       
-
       
	endpoint := fmt.Sprintf("/repo/languages/%s", url.PathEscape(branch))

     

       
114
       
 
       


     

       
115
       
-
       
	body, _ := json.Marshal(map[string]any{

     

       
116
       
-
       
		"did":    ownerDid,

     

       
117
       
-
       
		"source": source,

     

       
118
       
-
       
		"name":   name,

     

       
119
       
-
       
	})

     

       
120
       
-
       


     

       
121
       
-
       
	req, err := s.newRequest(Method, endpoint, body)

     

       
122
       
 
       
	if err != nil {

     

       
123
       
 
       
		return nil, err

     

       
124
       
 
       
	}

     
···

       
128
       
 
       
		return nil, err

     

       
129
       
 
       
	}

     

       
130
       
 
       


     

       
131
       
-
       
	var languagePercentages types.RepoLanguageResponse

     

       
132
       
-
       
	if err := json.NewDecoder(resp.Body).Decode(&languagePercentages); err != nil {

     

       
133
       
-
       
		log.Printf("failed to decode fork status: %s", err)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
134
       
 
       
		return nil, err

     

       
135
       
 
       
	}

     

       
136
       
 
       


     

       
137
       
-
       
	return &languagePercentages, nil

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
138
       
 
       
}

     

       
139
       
 
       


     

       
140
       
 
       
func (s *SignedClient) RepoForkAheadBehind(ownerDid, source, name, branch, hiddenRef string) (*http.Response, error) {

     

···

       
106
       
 
       
	return s.client.Do(req)

     

       
107
       
 
       
}

     

       
108
       
 
       


     

       
109
       
+
       
func (s *SignedClient) RepoLanguages(ownerDid, repoName, ref string) (*types.RepoLanguageResponse, error) {

     

       
110
       
 
       
	const (

     

       
111
       
 
       
		Method = "GET"

     

       
112
       
 
       
	)

     

       
113
       
+
       
	endpoint := fmt.Sprintf("/%s/%s/languages/%s", ownerDid, repoName, url.PathEscape(ref))

     

       
114
       
 
       


     

       
115
       
+
       
	req, err := s.newRequest(Method, endpoint, nil)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
116
       
 
       
	if err != nil {

     

       
117
       
 
       
		return nil, err

     

       
118
       
 
       
	}

     
···

       
122
       
 
       
		return nil, err

     

       
123
       
 
       
	}

     

       
124
       
 
       


     

       
125
       
+
       
	var result types.RepoLanguageResponse

     

       
126
       
+
       
	if resp.StatusCode != http.StatusOK {

     

       
127
       
+
       
		log.Println("failed to calculate languages", resp.Status)

     

       
128
       
+
       
		return &types.RepoLanguageResponse{}, nil

     

       
129
       
+
       
	}

     

       
130
       
+
       


     

       
131
       
+
       
	body, err := io.ReadAll(resp.Body)

     

       
132
       
+
       
	if err != nil {

     

       
133
       
 
       
		return nil, err

     

       
134
       
 
       
	}

     

       
135
       
 
       


     

       
136
       
+
       
	err = json.Unmarshal(body, &result)

     

       
137
       
+
       
	if err != nil {

     

       
138
       
+
       
		return nil, err

     

       
139
       
+
       
	}

     

       
140
       
+
       


     

       
141
       
+
       
	return &result, nil

     

       
142
       
 
       
}

     

       
143
       
 
       


     

       
144
       
 
       
func (s *SignedClient) RepoForkAheadBehind(ownerDid, source, name, branch, hiddenRef string) (*http.Response, error) {

     

···

       
403
       
 
       
}

     

       
404
       
 
       


     

       
405
       
 
       
type RepoIndexParams struct {

     

       
406
       
-
       
	LoggedInUser  *oauth.User

     

       
407
       
-
       
	RepoInfo      repoinfo.RepoInfo

     

       
408
       
-
       
	Active        string

     

       
409
       
-
       
	TagMap        map[string][]string

     

       
410
       
-
       
	CommitsTrunc  []*object.Commit

     

       
411
       
-
       
	TagsTrunc     []*types.TagReference

     

       
412
       
-
       
	BranchesTrunc []types.Branch

     

       
413
       
-
       
	ForkInfo      *types.ForkInfo

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
414
       
 
       
	types.RepoIndexResponse

     

       
415
       
-
       
	HTMLReadme          template.HTML

     

       
416
       
-
       
	Raw                 bool

     

       
417
       
-
       
	EmailToDidOrHandle  map[string]string

     

       
418
       
-
       
	LanguagePercentages map[string]float64

     

       
419
       
 
       
}

     

       
420
       
 
       


     

       
421
       
 
       
func (p *Pages) RepoIndexPage(w io.Writer, params RepoIndexParams) error {

     

···

       
403
       
 
       
}

     

       
404
       
 
       


     

       
405
       
 
       
type RepoIndexParams struct {

     

       
406
       
+
       
	LoggedInUser       *oauth.User

     

       
407
       
+
       
	RepoInfo           repoinfo.RepoInfo

     

       
408
       
+
       
	Active             string

     

       
409
       
+
       
	TagMap             map[string][]string

     

       
410
       
+
       
	CommitsTrunc       []*object.Commit

     

       
411
       
+
       
	TagsTrunc          []*types.TagReference

     

       
412
       
+
       
	BranchesTrunc      []types.Branch

     

       
413
       
+
       
	ForkInfo           *types.ForkInfo

     

       
414
       
+
       
	HTMLReadme         template.HTML

     

       
415
       
+
       
	Raw                bool

     

       
416
       
+
       
	EmailToDidOrHandle map[string]string

     

       
417
       
+
       
	Languages          *types.RepoLanguageResponse

     

       
418
       
 
       
	types.RepoIndexResponse

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
419
       
 
       
}

     

       
420
       
 
       


     

       
421
       
 
       
func (p *Pages) RepoIndexPage(w io.Writer, params RepoIndexParams) error {

     

···

       
138
       
 
       


     

       
139
       
 
       
	var forkInfo *types.ForkInfo

     

       
140
       
 
       
	if user != nil && (repoInfo.Roles.IsOwner() || repoInfo.Roles.IsCollaborator()) {

     

       
141
       
-
       
	forkInfo, err = getForkInfo(repoInfo, s, f, w, user, signedClient)

     

       
142
       
 
       
		if err != nil {

     

       
143
       
 
       
			log.Printf("Failed to fetch fork information: %v", err)

     

       
144
       
 
       
			return

     

       
145
       
 
       
		}

     

       
146
       
 
       
	}

     

       
147
       
 
       


     

       
148
       
-
       
	repoLanguages, err := signedClient.RepoLanguages(user.Did, string(f.RepoAt), repoInfo.Name, f.Ref)

     

       
149
       
 
       
	if err != nil {

     

       
150
       
 
       
		log.Printf("failed to compute language percentages: %s", err)

     

       
151
       
-
       
		return

     

       
152
       
 
       
	}

     

       
153
       
 
       


     

       
154
       
 
       
	s.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       
155
       
-
       
		LoggedInUser:        user,

     

       
156
       
-
       
		RepoInfo:            repoInfo,

     

       
157
       
-
       
		TagMap:              tagMap,

     

       
158
       
-
       
		RepoIndexResponse:   result,

     

       
159
       
-
       
		CommitsTrunc:        commitsTrunc,

     

       
160
       
-
       
		TagsTrunc:           tagsTrunc,

     

       
161
       
-
       
		ForkInfo:            forkInfo,

     

       
162
       
-
       
		BranchesTrunc:       branchesTrunc,

     

       
163
       
-
       
		EmailToDidOrHandle:  EmailToDidOrHandle(s, emails),

     

       
164
       
-
       
		LanguagePercentages: repoLanguages.Languages,

     

       
165
       
 
       
	})

     

       
166
       
 
       
	return

     

       
167
       
 
       
}

     
···

       
170
       
 
       
	repoInfo repoinfo.RepoInfo,

     

       
171
       
 
       
	s *State,

     

       
172
       
 
       
	f *FullyResolvedRepo,

     

       
173
       
-
       
	w http.ResponseWriter,

     

       
174
       
 
       
	user *oauth.User,

     

       
175
       
 
       
	signedClient *knotclient.SignedClient,

     

       
176
       
 
       
) (*types.ForkInfo, error) {

     

···

       
138
       
 
       


     

       
139
       
 
       
	var forkInfo *types.ForkInfo

     

       
140
       
 
       
	if user != nil && (repoInfo.Roles.IsOwner() || repoInfo.Roles.IsCollaborator()) {

     

       
141
       
+
       
		forkInfo, err = getForkInfo(repoInfo, s, f, user, signedClient)

     

       
142
       
 
       
		if err != nil {

     

       
143
       
 
       
			log.Printf("Failed to fetch fork information: %v", err)

     

       
144
       
 
       
			return

     

       
145
       
 
       
		}

     

       
146
       
 
       
	}

     

       
147
       
 
       


     

       
148
       
+
       
	repoLanguages, err := signedClient.RepoLanguages(f.OwnerDid(), f.RepoName, ref)

     

       
149
       
 
       
	if err != nil {

     

       
150
       
 
       
		log.Printf("failed to compute language percentages: %s", err)

     

       
151
       
+
       
		// non-fatal

     

       
152
       
 
       
	}

     

       
153
       
 
       


     

       
154
       
 
       
	s.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       
155
       
+
       
		LoggedInUser:       user,

     

       
156
       
+
       
		RepoInfo:           repoInfo,

     

       
157
       
+
       
		TagMap:             tagMap,

     

       
158
       
+
       
		RepoIndexResponse:  result,

     

       
159
       
+
       
		CommitsTrunc:       commitsTrunc,

     

       
160
       
+
       
		TagsTrunc:          tagsTrunc,

     

       
161
       
+
       
		ForkInfo:           forkInfo,

     

       
162
       
+
       
		BranchesTrunc:      branchesTrunc,

     

       
163
       
+
       
		EmailToDidOrHandle: EmailToDidOrHandle(s, emails),

     

       
164
       
+
       
		Languages:          repoLanguages,

     

       
165
       
 
       
	})

     

       
166
       
 
       
	return

     

       
167
       
 
       
}

     
···

       
170
       
 
       
	repoInfo repoinfo.RepoInfo,

     

       
171
       
 
       
	s *State,

     

       
172
       
 
       
	f *FullyResolvedRepo,

     

       
0
       
 
       

     

       
173
       
 
       
	user *oauth.User,

     

       
174
       
 
       
	signedClient *knotclient.SignedClient,

     

       
175
       
 
       
) (*types.ForkInfo, error) {

     

···

       
80
       
 
       
				r.Post("/add", h.AddRepoCollaborator)

     

       
81
       
 
       
			})

     

       
82
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
83
       
 
       
			r.Get("/", h.RepoIndex)

     

       
84
       
 
       
			r.Get("/info/refs", h.InfoRefs)

     

       
85
       
 
       
			r.Post("/git-upload-pack", h.UploadPack)

     
···

       
126
       
 
       
	r.Route("/repo", func(r chi.Router) {

     

       
127
       
 
       
		r.Use(h.VerifySignature)

     

       
128
       
 
       
		r.Put("/new", h.NewRepo)

     

       
129
       
-
       
		r.Get("/languages/{branch}", h.RepoLanguages)

     

       
130
       
 
       
		r.Delete("/", h.RemoveRepo)

     

       
131
       
 
       
		r.Route("/fork", func(r chi.Router) {

     

       
132
       
 
       
			r.Post("/", h.RepoFork)

     

···

       
80
       
 
       
				r.Post("/add", h.AddRepoCollaborator)

     

       
81
       
 
       
			})

     

       
82
       
 
       


     

       
83
       
+
       
			r.Route("/languages", func(r chi.Router) {

     

       
84
       
+
       
				r.With(h.VerifySignature)

     

       
85
       
+
       
				r.Get("/", h.RepoLanguages)

     

       
86
       
+
       
				r.Get("/{ref}", h.RepoLanguages)

     

       
87
       
+
       
			})

     

       
88
       
+
       


     

       
89
       
 
       
			r.Get("/", h.RepoIndex)

     

       
90
       
 
       
			r.Get("/info/refs", h.InfoRefs)

     

       
91
       
 
       
			r.Post("/git-upload-pack", h.UploadPack)

     
···

       
132
       
 
       
	r.Route("/repo", func(r chi.Router) {

     

       
133
       
 
       
		r.Use(h.VerifySignature)

     

       
134
       
 
       
		r.Put("/new", h.NewRepo)

     

       
0
       
 
       

     

       
135
       
 
       
		r.Delete("/", h.RemoveRepo)

     

       
136
       
 
       
		r.Route("/fork", func(r chi.Router) {

     

       
137
       
 
       
			r.Post("/", h.RepoFork)

     

···

       
715
       
 
       
}

     

       
716
       
 
       


     

       
717
       
 
       
func (h *Handle) RepoLanguages(w http.ResponseWriter, r *http.Request) {

     

       
718
       
-
       
	l := h.l.With("handler", "RepoForkSync")

     

       
0
       
 
       

     

       
0
       
 
       

     

       
719
       
 
       


     

       
720
       
-
       
	data := struct {

     

       
721
       
-
       
		Did    string `json:"did"`

     

       
722
       
-
       
		Source string `json:"source"`

     

       
723
       
-
       
		Name   string `json:"name,omitempty"`

     

       
724
       
-
       
	}{}

     

       
725
       
 
       


     

       
726
       
-
       
	if err := json.NewDecoder(r.Body).Decode(&data); err != nil {

     

       
727
       
-
       
		writeError(w, "invalid request body", http.StatusBadRequest)

     

       
728
       
-
       
		return

     

       
729
       
-
       
	}

     

       
730
       
-
       


     

       
731
       
-
       
	did := data.Did

     

       
732
       
-
       
	source := data.Source

     

       
733
       
-
       


     

       
734
       
-
       
	if did == "" || source == "" {

     

       
735
       
-
       
		l.Error("invalid request body, empty did or name")

     

       
736
       
-
       
		w.WriteHeader(http.StatusBadRequest)

     

       
737
       
-
       
		return

     

       
738
       
-
       
	}

     

       
739
       
-
       


     

       
740
       
-
       
	var name string

     

       
741
       
-
       
	if data.Name != "" {

     

       
742
       
-
       
		name = data.Name

     

       
743
       
-
       
	} else {

     

       
744
       
-
       
		name = filepath.Base(source)

     

       
745
       
-
       
	}

     

       
746
       
-
       


     

       
747
       
-
       
	branch := chi.URLParam(r, "branch")

     

       
748
       
-
       
	branch, _ = url.PathUnescape(branch)

     

       
749
       
-
       


     

       
750
       
-
       
	relativeRepoPath := filepath.Join(did, name)

     

       
751
       
-
       
	repoPath, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, relativeRepoPath)

     

       
752
       
-
       


     

       
753
       
-
       
	gr, err := git.Open(repoPath, branch)

     

       
754
       
 
       
	if err != nil {

     

       
755
       
-
       
		log.Println(err)

     

       
756
       
 
       
		notFound(w)

     

       
757
       
 
       
		return

     

       
758
       
 
       
	}

     

       
759
       
 
       


     

       
760
       
 
       
	languageFileCount := make(map[string]int)

     

       
761
       
-
       
	languagePercentage := make(map[string]float64)

     

       
762
       
 
       


     

       
763
       
 
       
	err = recurseEntireTree(gr, func(absPath string) {

     

       
764
       
 
       
		lang, safe := enry.GetLanguageByExtension(absPath)

     
···

       
782
       
 
       
		}

     

       
783
       
 
       
	}, "")

     

       
784
       
 
       
	if err != nil {

     

       
785
       
-
       
		log.Println(err)

     

       
786
       
 
       
		writeError(w, err.Error(), http.StatusNoContent)

     

       
787
       
 
       
		return

     

       
788
       
 
       
	}

     

       
789
       
 
       


     

       
790
       
-
       
	for path, fileCount := range languageFileCount {

     

       
791
       
-
       
		percentage := float64(fileCount) / float64(len(languageFileCount)) * 100.0

     

       
792
       
-
       
		languagePercentage[path] = percentage

     

       
793
       
-
       
	}

     

       
794
       
 
       


     

       
795
       
-
       
	w.Header().Set("Content-Type", "application/json")

     

       
796
       
-
       
	json.NewEncoder(w).Encode(types.RepoLanguageResponse{Languages: languagePercentage})

     

       
797
       
 
       
}

     

       
798
       
 
       


     

       
799
       
 
       
func recurseEntireTree(git *git.GitRepo, callback func(absPath string), filePath string) error {

     

···

       
715
       
 
       
}

     

       
716
       
 
       


     

       
717
       
 
       
func (h *Handle) RepoLanguages(w http.ResponseWriter, r *http.Request) {

     

       
718
       
+
       
	path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r))

     

       
719
       
+
       
	ref := chi.URLParam(r, "ref")

     

       
720
       
+
       
	ref, _ = url.PathUnescape(ref)

     

       
721
       
 
       


     

       
722
       
+
       
	l := h.l.With("handler", "RepoLanguages")

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
723
       
 
       


     

       
724
       
+
       
	gr, err := git.Open(path, ref)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
725
       
 
       
	if err != nil {

     

       
726
       
+
       
		l.Error("opening repo", "error", err.Error())

     

       
727
       
 
       
		notFound(w)

     

       
728
       
 
       
		return

     

       
729
       
 
       
	}

     

       
730
       
 
       


     

       
731
       
 
       
	languageFileCount := make(map[string]int)

     

       
0
       
 
       

     

       
732
       
 
       


     

       
733
       
 
       
	err = recurseEntireTree(gr, func(absPath string) {

     

       
734
       
 
       
		lang, safe := enry.GetLanguageByExtension(absPath)

     
···

       
752
       
 
       
		}

     

       
753
       
 
       
	}, "")

     

       
754
       
 
       
	if err != nil {

     

       
755
       
+
       
		l.Error("failed to recurse file tree", "error", err.Error())

     

       
756
       
 
       
		writeError(w, err.Error(), http.StatusNoContent)

     

       
757
       
 
       
		return

     

       
758
       
 
       
	}

     

       
759
       
 
       


     

       
760
       
+
       
	resp := types.RepoLanguageResponse{Languages: languageFileCount}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
761
       
 
       


     

       
762
       
+
       
	writeJSON(w, resp)

     

       
763
       
+
       
	return

     

       
764
       
 
       
}

     

       
765
       
 
       


     

       
766
       
 
       
func recurseEntireTree(git *git.GitRepo, callback func(absPath string), filePath string) error {

     

···

       
112
       
 
       


     

       
113
       
 
       
type RepoLanguageResponse struct {

     

       
114
       
 
       
	// Language: Percentage

     

       
115
       
-
       
	Languages map[string]float64 `json:"languages"`

     

       
116
       
 
       
}

     

···

       
112
       
 
       


     

       
113
       
 
       
type RepoLanguageResponse struct {

     

       
114
       
 
       
	// Language: Percentage

     

       
115
       
+
       
	Languages map[string]int `json:"languages"`

     

       
116
       
 
       
}