commit 04e2bc407a5a4243cf7dff60a3ea4cf102a4506e · julien.rbrt.fr/tangled-core

+2 -1

appview/pages/funcmap.go

···

       143
       143
        
       			return v.Slice(start, end).Interface()

     

       144
       144
        
       		},

     

       145
       145
        
       		"markdown": func(text string) template.HTML {

     

       146
       146
       -
       			return template.HTML(markup.RenderMarkdown(text))

     

       146
       146
       +
       			rctx := &markup.RenderContext{}

     

       147
       147
       +
       			return template.HTML(rctx.RenderMarkdown(text))

     

       147
       148
        
       		},

     

       148
       149
        
       		"isNil": func(t any) bool {

     

       149
       150
        
       			// returns false for other "zero" values

+4 -11

appview/pages/markup/markdown.go

···

       19
       19
        
       const (

     

       20
       20
        
       	// RendererTypeRepoMarkdown is for repository documentation markdown files

     

       21
       21
        
       	RendererTypeRepoMarkdown RendererType = iota

     

       22
       22
       -
       	// RendererTypeIssueComment is for issue comments

     

       23
       23
       -
       	RendererTypeIssueComment

     

       24
       24
       -
       	// RendererTypePullComment is for pull request comments

     

       25
       25
       -
       	RendererTypePullComment

     

       26
       26
       -
       	// RendererTypeDefault is the default renderer with minimal transformations

     

       27
       27
       -
       	RendererTypeDefault

     

       28
       22
        
       )

     

       29
       23
        
       

     

       30
       24
        
       // RenderContext holds the contextual data for rendering markdown.

     

       31
       31
       -
       // It can be initialized empty, and that'll skip any transformations

     

       32
       32
       -
       // and use the default renderer (RendererTypeDefault).

     

       25
       25
       +
       // It can be initialized empty, and that'll skip any transformations.

     

       33
       26
        
       type RenderContext struct {

     

       34
       27
        
       	Ref          string

     

       35
       28
        
       	FullRepoName string

     
···

       73
       66
        
       

     

       74
       67
        
       		switch a.rctx.RendererType {

     

       75
       68
        
       		case RendererTypeRepoMarkdown:

     

       76
       76
       -
       			a.rctx.relativeLinkTransformer(n.(*ast.Link))

     

       77
       77
       -
       		case RendererTypeDefault:

     

       78
       78
       -
       			a.rctx.relativeLinkTransformer(n.(*ast.Link))

     

       69
       69
       +
       			if v, ok := n.(*ast.Link); ok {

     

       70
       70
       +
       				a.rctx.relativeLinkTransformer(v)

     

       71
       71
       +
       			}

     

       79
       72
        
       			// more types here like RendererTypeIssue/Pull etc.

     

       80
       73
        
       		}

     

       81
       74

+13 -2

appview/pages/pages.go

···

       366
       366
        
       	Roles        RolesInRepo

     

       367
       367
        
       	Source       *db.Repo

     

       368
       368
        
       	SourceHandle string

     

       369
       369
       +
       	Ref          string

     

       369
       370
        
       	DisableFork  bool

     

       370
       371
        
       }

     

       371
       372
        
       

     
···

       478
       479
        
       		return p.executeRepo("repo/empty", w, params)

     

       479
       480
        
       	}

     

       480
       481
        
       

     

       482
       482
       +
       	rctx := markup.RenderContext{

     

       483
       483
       +
       		Ref:          params.RepoInfo.Ref,

     

       484
       484
       +
       		FullRepoName: params.RepoInfo.FullName(),

     

       485
       485
       +
       	}

     

       486
       486
       +
       

     

       481
       487
        
       	if params.ReadmeFileName != "" {

     

       482
       488
        
       		var htmlString string

     

       483
       489
        
       		ext := filepath.Ext(params.ReadmeFileName)

     

       484
       490
        
       		switch ext {

     

       485
       491
        
       		case ".md", ".markdown", ".mdown", ".mkdn", ".mkd":

     

       486
       486
       -
       			htmlString = markup.RenderMarkdown(params.Readme)

     

       492
       492
       +
       			htmlString = rctx.RenderMarkdown(params.Readme)

     

       487
       493
        
       			params.Raw = false

     

       488
       494
        
       			params.HTMLReadme = template.HTML(bluemonday.UGCPolicy().Sanitize(htmlString))

     

       489
       495
        
       		default:

     
···

       601
       607
        
       	if params.ShowRendered {

     

       602
       608
        
       		switch markup.GetFormat(params.Path) {

     

       603
       609
        
       		case markup.FormatMarkdown:

     

       604
       604
       -
       			params.RenderedContents = template.HTML(markup.RenderMarkdown(params.Contents))

     

       610
       610
       +
       			rctx := markup.RenderContext{

     

       611
       611
       +
       				Ref:          params.RepoInfo.Ref,

     

       612
       612
       +
       				FullRepoName: params.RepoInfo.FullName(),

     

       613
       613
       +
       				RendererType: markup.RendererTypeRepoMarkdown,

     

       614
       614
       +
       			}

     

       615
       615
       +
       			params.RenderedContents = template.HTML(rctx.RenderMarkdown(params.Contents))

     

       605
       616
        
       		}

     

       606
       617
        
       	}

     

       607
       618

+2 -2

appview/state/middleware.go

···

       61
       61
        
       				http.Error(w, "Forbiden", http.StatusUnauthorized)

     

       62
       62
        
       				return

     

       63
       63
        
       			}

     

       64
       64
       -
       			f, err := fullyResolvedRepo(r)

     

       64
       64
       +
       			f, err := s.fullyResolvedRepo(r)

     

       65
       65
        
       			if err != nil {

     

       66
       66
        
       				http.Error(w, "malformed url", http.StatusBadRequest)

     

       67
       67
        
       				return

     
···

       148
       148
        
       func ResolvePull(s *State) middleware.Middleware {

     

       149
       149
        
       	return func(next http.Handler) http.Handler {

     

       150
       150
        
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       151
       151
       -
       			f, err := fullyResolvedRepo(r)

     

       151
       151
       +
       			f, err := s.fullyResolvedRepo(r)

     

       152
       152
        
       			if err != nil {

     

       153
       153
        
       				log.Println("failed to fully resolve repo", err)

     

       154
       154
        
       				http.Error(w, "invalid repo url", http.StatusNotFound)

+19 -19

appview/state/pull.go

···

       30
       30
        
       	switch r.Method {

     

       31
       31
        
       	case http.MethodGet:

     

       32
       32
        
       		user := s.auth.GetUser(r)

     

       33
       33
       -
       		f, err := fullyResolvedRepo(r)

     

       33
       33
       +
       		f, err := s.fullyResolvedRepo(r)

     

       34
       34
        
       		if err != nil {

     

       35
       35
        
       			log.Println("failed to get repo and knot", err)

     

       36
       36
        
       			return

     
···

       74
       74
        
       

     

       75
       75
        
       func (s *State) RepoSinglePull(w http.ResponseWriter, r *http.Request) {

     

       76
       76
        
       	user := s.auth.GetUser(r)

     

       77
       77
       -
       	f, err := fullyResolvedRepo(r)

     

       77
       77
       +
       	f, err := s.fullyResolvedRepo(r)

     

       78
       78
        
       	if err != nil {

     

       79
       79
        
       		log.Println("failed to get repo and knot", err)

     

       80
       80
        
       		return

     
···

       251
       251
        
       

     

       252
       252
        
       func (s *State) RepoPullPatch(w http.ResponseWriter, r *http.Request) {

     

       253
       253
        
       	user := s.auth.GetUser(r)

     

       254
       254
       -
       	f, err := fullyResolvedRepo(r)

     

       254
       254
       +
       	f, err := s.fullyResolvedRepo(r)

     

       255
       255
        
       	if err != nil {

     

       256
       256
        
       		log.Println("failed to get repo and knot", err)

     

       257
       257
        
       		return

     
···

       300
       300
        
       func (s *State) RepoPullInterdiff(w http.ResponseWriter, r *http.Request) {

     

       301
       301
        
       	user := s.auth.GetUser(r)

     

       302
       302
        
       

     

       303
       303
       -
       	f, err := fullyResolvedRepo(r)

     

       303
       303
       +
       	f, err := s.fullyResolvedRepo(r)

     

       304
       304
        
       	if err != nil {

     

       305
       305
        
       		log.Println("failed to get repo and knot", err)

     

       306
       306
        
       		return

     
···

       408
       408
        
       		state = db.PullMerged

     

       409
       409
        
       	}

     

       410
       410
        
       

     

       411
       411
       -
       	f, err := fullyResolvedRepo(r)

     

       411
       411
       +
       	f, err := s.fullyResolvedRepo(r)

     

       412
       412
        
       	if err != nil {

     

       413
       413
        
       		log.Println("failed to get repo and knot", err)

     

       414
       414
        
       		return

     
···

       462
       462
        
       

     

       463
       463
        
       func (s *State) PullComment(w http.ResponseWriter, r *http.Request) {

     

       464
       464
        
       	user := s.auth.GetUser(r)

     

       465
       465
       -
       	f, err := fullyResolvedRepo(r)

     

       465
       465
       +
       	f, err := s.fullyResolvedRepo(r)

     

       466
       466
        
       	if err != nil {

     

       467
       467
        
       		log.Println("failed to get repo and knot", err)

     

       468
       468
        
       		return

     
···

       569
       569
        
       

     

       570
       570
        
       func (s *State) NewPull(w http.ResponseWriter, r *http.Request) {

     

       571
       571
        
       	user := s.auth.GetUser(r)

     

       572
       572
       -
       	f, err := fullyResolvedRepo(r)

     

       572
       572
       +
       	f, err := s.fullyResolvedRepo(r)

     

       573
       573
        
       	if err != nil {

     

       574
       574
        
       		log.Println("failed to get repo and knot", err)

     

       575
       575
        
       		return

     
···

       904
       904
        
       }

     

       905
       905
        
       

     

       906
       906
        
       func (s *State) ValidatePatch(w http.ResponseWriter, r *http.Request) {

     

       907
       907
       -
       	_, err := fullyResolvedRepo(r)

     

       907
       907
       +
       	_, err := s.fullyResolvedRepo(r)

     

       908
       908
        
       	if err != nil {

     

       909
       909
        
       		log.Println("failed to get repo and knot", err)

     

       910
       910
        
       		return

     
···

       930
       930
        
       

     

       931
       931
        
       func (s *State) PatchUploadFragment(w http.ResponseWriter, r *http.Request) {

     

       932
       932
        
       	user := s.auth.GetUser(r)

     

       933
       933
       -
       	f, err := fullyResolvedRepo(r)

     

       933
       933
       +
       	f, err := s.fullyResolvedRepo(r)

     

       934
       934
        
       	if err != nil {

     

       935
       935
        
       		log.Println("failed to get repo and knot", err)

     

       936
       936
        
       		return

     
···

       943
       943
        
       

     

       944
       944
        
       func (s *State) CompareBranchesFragment(w http.ResponseWriter, r *http.Request) {

     

       945
       945
        
       	user := s.auth.GetUser(r)

     

       946
       946
       -
       	f, err := fullyResolvedRepo(r)

     

       946
       946
       +
       	f, err := s.fullyResolvedRepo(r)

     

       947
       947
        
       	if err != nil {

     

       948
       948
        
       		log.Println("failed to get repo and knot", err)

     

       949
       949
        
       		return

     
···

       983
       983
        
       

     

       984
       984
        
       func (s *State) CompareForksFragment(w http.ResponseWriter, r *http.Request) {

     

       985
       985
        
       	user := s.auth.GetUser(r)

     

       986
       986
       -
       	f, err := fullyResolvedRepo(r)

     

       986
       986
       +
       	f, err := s.fullyResolvedRepo(r)

     

       987
       987
        
       	if err != nil {

     

       988
       988
        
       		log.Println("failed to get repo and knot", err)

     

       989
       989
        
       		return

     
···

       1004
       1004
        
       func (s *State) CompareForksBranchesFragment(w http.ResponseWriter, r *http.Request) {

     

       1005
       1005
        
       	user := s.auth.GetUser(r)

     

       1006
       1006
        
       

     

       1007
       1007
       -
       	f, err := fullyResolvedRepo(r)

     

       1007
       1007
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1008
       1008
        
       	if err != nil {

     

       1009
       1009
        
       		log.Println("failed to get repo and knot", err)

     

       1010
       1010
        
       		return

     
···

       1082
       1082
        
       

     

       1083
       1083
        
       func (s *State) ResubmitPull(w http.ResponseWriter, r *http.Request) {

     

       1084
       1084
        
       	user := s.auth.GetUser(r)

     

       1085
       1085
       -
       	f, err := fullyResolvedRepo(r)

     

       1085
       1085
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1086
       1086
        
       	if err != nil {

     

       1087
       1087
        
       		log.Println("failed to get repo and knot", err)

     

       1088
       1088
        
       		return

     
···

       1126
       1126
        
       		return

     

       1127
       1127
        
       	}

     

       1128
       1128
        
       

     

       1129
       1129
       -
       	f, err := fullyResolvedRepo(r)

     

       1129
       1129
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1130
       1130
        
       	if err != nil {

     

       1131
       1131
        
       		log.Println("failed to get repo and knot", err)

     

       1132
       1132
        
       		return

     
···

       1209
       1209
        
       		return

     

       1210
       1210
        
       	}

     

       1211
       1211
        
       

     

       1212
       1212
       -
       	f, err := fullyResolvedRepo(r)

     

       1212
       1212
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1213
       1213
        
       	if err != nil {

     

       1214
       1214
        
       		log.Println("failed to get repo and knot", err)

     

       1215
       1215
        
       		return

     
···

       1322
       1322
        
       		return

     

       1323
       1323
        
       	}

     

       1324
       1324
        
       

     

       1325
       1325
       -
       	f, err := fullyResolvedRepo(r)

     

       1325
       1325
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1326
       1326
        
       	if err != nil {

     

       1327
       1327
        
       		log.Println("failed to get repo and knot", err)

     

       1328
       1328
        
       		return

     
···

       1470
       1470
        
       }

     

       1471
       1471
        
       

     

       1472
       1472
        
       func (s *State) MergePull(w http.ResponseWriter, r *http.Request) {

     

       1473
       1473
       -
       	f, err := fullyResolvedRepo(r)

     

       1473
       1473
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1474
       1474
        
       	if err != nil {

     

       1475
       1475
        
       		log.Println("failed to resolve repo:", err)

     

       1476
       1476
        
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     
···

       1535
       1535
        
       func (s *State) ClosePull(w http.ResponseWriter, r *http.Request) {

     

       1536
       1536
        
       	user := s.auth.GetUser(r)

     

       1537
       1537
        
       

     

       1538
       1538
       -
       	f, err := fullyResolvedRepo(r)

     

       1538
       1538
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1539
       1539
        
       	if err != nil {

     

       1540
       1540
        
       		log.Println("malformed middleware")

     

       1541
       1541
        
       		return

     
···

       1589
       1589
        
       func (s *State) ReopenPull(w http.ResponseWriter, r *http.Request) {

     

       1590
       1590
        
       	user := s.auth.GetUser(r)

     

       1591
       1591
        
       

     

       1592
       1592
       -
       	f, err := fullyResolvedRepo(r)

     

       1592
       1592
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1593
       1593
        
       	if err != nil {

     

       1594
       1594
        
       		log.Println("failed to resolve repo", err)

     

       1595
       1595
        
       		s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")

+35 -40

appview/state/repo.go

···

       37
       37
        
       

     

       38
       38
        
       func (s *State) RepoIndex(w http.ResponseWriter, r *http.Request) {

     

       39
       39
        
       	ref := chi.URLParam(r, "ref")

     

       40
       40
       -
       	f, err := fullyResolvedRepo(r)

     

       40
       40
       +
       	f, err := s.fullyResolvedRepo(r)

     

       41
       41
        
       	if err != nil {

     

       42
       42
        
       		log.Println("failed to fully resolve repo", err)

     

       43
       43
        
       		return

     
···

       129
       129
        
       }

     

       130
       130
        
       

     

       131
       131
        
       func (s *State) RepoLog(w http.ResponseWriter, r *http.Request) {

     

       132
       132
       -
       	f, err := fullyResolvedRepo(r)

     

       132
       132
       +
       	f, err := s.fullyResolvedRepo(r)

     

       133
       133
        
       	if err != nil {

     

       134
       134
        
       		log.Println("failed to fully resolve repo", err)

     

       135
       135
        
       		return

     
···

       210
       210
        
       }

     

       211
       211
        
       

     

       212
       212
        
       func (s *State) RepoDescriptionEdit(w http.ResponseWriter, r *http.Request) {

     

       213
       213
       -
       	f, err := fullyResolvedRepo(r)

     

       213
       213
       +
       	f, err := s.fullyResolvedRepo(r)

     

       214
       214
        
       	if err != nil {

     

       215
       215
        
       		log.Println("failed to get repo and knot", err)

     

       216
       216
        
       		w.WriteHeader(http.StatusBadRequest)

     
···

       225
       225
        
       }

     

       226
       226
        
       

     

       227
       227
        
       func (s *State) RepoDescription(w http.ResponseWriter, r *http.Request) {

     

       228
       228
       -
       	f, err := fullyResolvedRepo(r)

     

       228
       228
       +
       	f, err := s.fullyResolvedRepo(r)

     

       229
       229
        
       	if err != nil {

     

       230
       230
        
       		log.Println("failed to get repo and knot", err)

     

       231
       231
        
       		w.WriteHeader(http.StatusBadRequest)

     
···

       304
       304
        
       }

     

       305
       305
        
       

     

       306
       306
        
       func (s *State) RepoCommit(w http.ResponseWriter, r *http.Request) {

     

       307
       307
       -
       	f, err := fullyResolvedRepo(r)

     

       307
       307
       +
       	f, err := s.fullyResolvedRepo(r)

     

       308
       308
        
       	if err != nil {

     

       309
       309
        
       		log.Println("failed to fully resolve repo", err)

     

       310
       310
        
       		return

     
···

       350
       350
        
       }

     

       351
       351
        
       

     

       352
       352
        
       func (s *State) RepoTree(w http.ResponseWriter, r *http.Request) {

     

       353
       353
       -
       	f, err := fullyResolvedRepo(r)

     

       353
       353
       +
       	f, err := s.fullyResolvedRepo(r)

     

       354
       354
        
       	if err != nil {

     

       355
       355
        
       		log.Println("failed to fully resolve repo", err)

     

       356
       356
        
       		return

     
···

       378
       378
        
       	err = json.Unmarshal(body, &result)

     

       379
       379
        
       	if err != nil {

     

       380
       380
        
       		log.Println("failed to parse response:", err)

     

       381
       381
       +
       		return

     

       382
       382
       +
       	}

     

       383
       383
       +
       

     

       384
       384
       +
       	// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,

     

       385
       385
       +
       	// so we can safely redirect to the "parent" (which is the same file).

     

       386
       386
       +
       	if len(result.Files) == 0 && result.Parent == treePath {

     

       387
       387
       +
       		http.Redirect(w, r, fmt.Sprintf("/%s/blob/%s/%s", f.OwnerSlashRepo(), ref, result.Parent), http.StatusFound)

     

       381
       388
        
       		return

     

       382
       389
        
       	}

     

       383
       390
        
       

     
···

       406
       413
        
       }

     

       407
       414
        
       

     

       408
       415
        
       func (s *State) RepoTags(w http.ResponseWriter, r *http.Request) {

     

       409
       409
       -
       	f, err := fullyResolvedRepo(r)

     

       416
       416
       +
       	f, err := s.fullyResolvedRepo(r)

     

       410
       417
        
       	if err != nil {

     

       411
       418
        
       		log.Println("failed to get repo and knot", err)

     

       412
       419
        
       		return

     
···

       447
       454
        
       }

     

       448
       455
        
       

     

       449
       456
        
       func (s *State) RepoBranches(w http.ResponseWriter, r *http.Request) {

     

       450
       450
       -
       	f, err := fullyResolvedRepo(r)

     

       457
       457
       +
       	f, err := s.fullyResolvedRepo(r)

     

       451
       458
        
       	if err != nil {

     

       452
       459
        
       		log.Println("failed to get repo and knot", err)

     

       453
       460
        
       		return

     
···

       502
       509
        
       }

     

       503
       510
        
       

     

       504
       511
        
       func (s *State) RepoBlob(w http.ResponseWriter, r *http.Request) {

     

       505
       505
       -
       	f, err := fullyResolvedRepo(r)

     

       512
       512
       +
       	f, err := s.fullyResolvedRepo(r)

     

       506
       513
        
       	if err != nil {

     

       507
       514
        
       		log.Println("failed to get repo and knot", err)

     

       508
       515
        
       		return

     
···

       562
       569
        
       }

     

       563
       570
        
       

     

       564
       571
        
       func (s *State) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {

     

       565
       565
       -
       	f, err := fullyResolvedRepo(r)

     

       572
       572
       +
       	f, err := s.fullyResolvedRepo(r)

     

       566
       573
        
       	if err != nil {

     

       567
       574
        
       		log.Println("failed to get repo and knot", err)

     

       568
       575
        
       		return

     
···

       606
       613
        
       }

     

       607
       614
        
       

     

       608
       615
        
       func (s *State) AddCollaborator(w http.ResponseWriter, r *http.Request) {

     

       609
       609
       -
       	f, err := fullyResolvedRepo(r)

     

       616
       616
       +
       	f, err := s.fullyResolvedRepo(r)

     

       610
       617
        
       	if err != nil {

     

       611
       618
        
       		log.Println("failed to get repo and knot", err)

     

       612
       619
        
       		return

     
···

       697
       704
        
       func (s *State) DeleteRepo(w http.ResponseWriter, r *http.Request) {

     

       698
       705
        
       	user := s.auth.GetUser(r)

     

       699
       706
        
       

     

       700
       700
       -
       	f, err := fullyResolvedRepo(r)

     

       707
       707
       +
       	f, err := s.fullyResolvedRepo(r)

     

       701
       708
        
       	if err != nil {

     

       702
       709
        
       		log.Println("failed to get repo and knot", err)

     

       703
       710
        
       		return

     
···

       801
       808
        
       }

     

       802
       809
        
       

     

       803
       810
        
       func (s *State) SetDefaultBranch(w http.ResponseWriter, r *http.Request) {

     

       804
       804
       -
       	f, err := fullyResolvedRepo(r)

     

       811
       811
       +
       	f, err := s.fullyResolvedRepo(r)

     

       805
       812
        
       	if err != nil {

     

       806
       813
        
       		log.Println("failed to get repo and knot", err)

     

       807
       814
        
       		return

     
···

       840
       847
        
       }

     

       841
       848
        
       

     

       842
       849
        
       func (s *State) RepoSettings(w http.ResponseWriter, r *http.Request) {

     

       843
       843
       -
       	f, err := fullyResolvedRepo(r)

     

       850
       850
       +
       	f, err := s.fullyResolvedRepo(r)

     

       844
       851
        
       	if err != nil {

     

       845
       852
        
       		log.Println("failed to get repo and knot", err)

     

       846
       853
        
       		return

     
···

       891
       898
        
       				}

     

       892
       899
        
       			}

     

       893
       900
        
       

     

       894
       894
       -
       			resp, err = us.DefaultBranch(f.OwnerDid(), f.RepoName)

     

       901
       901
       +
       			defaultBranchResp, err := us.DefaultBranch(f.OwnerDid(), f.RepoName)

     

       895
       902
        
       			if err != nil {

     

       896
       903
        
       				log.Println("failed to reach knotserver", err)

     

       897
       904
        
       			} else {

     

       898
       898
       -
       				defer resp.Body.Close()

     

       899
       899
       -
       

     

       900
       900
       -
       				body, err := io.ReadAll(resp.Body)

     

       901
       901
       -
       				if err != nil {

     

       902
       902
       -
       					log.Printf("Error reading response body: %v", err)

     

       903
       903
       -
       				} else {

     

       904
       904
       -
       					var result types.RepoDefaultBranchResponse

     

       905
       905
       -
       					err = json.Unmarshal(body, &result)

     

       906
       906
       -
       					if err != nil {

     

       907
       907
       -
       						log.Println("failed to parse response:", err)

     

       908
       908
       -
       					} else {

     

       909
       909
       -
       						defaultBranch = result.Branch

     

       910
       910
       -
       					}

     

       911
       911
       -
       				}

     

       905
       905
       +
       				defaultBranch = defaultBranchResp.Branch

     

       912
       906
        
       			}

     

       913
       907
        
       		}

     

       914
       914
       -
       

     

       915
       908
        
       		s.pages.RepoSettings(w, pages.RepoSettingsParams{

     

       916
       909
        
       			LoggedInUser:                user,

     

       917
       910
        
       			RepoInfo:                    f.RepoInfo(s, user),

     
···

       930
       923
        
       	RepoAt      syntax.ATURI

     

       931
       924
        
       	Description string

     

       932
       925
        
       	CreatedAt   string

     

       926
       926
       +
       	Ref         string

     

       933
       927
        
       }

     

       934
       928
        
       

     

       935
       929
        
       func (f *FullyResolvedRepo) OwnerDid() string {

     
···

       1082
       1076
        
       		Name:        f.RepoName,

     

       1083
       1077
        
       		RepoAt:      f.RepoAt,

     

       1084
       1078
        
       		Description: f.Description,

     

       1079
       1079
       +
       		Ref:         f.Ref,

     

       1085
       1080
        
       		IsStarred:   isStarred,

     

       1086
       1081
        
       		Knot:        knot,

     

       1087
       1082
        
       		Roles:       RolesInRepo(s, u, f),

     
···

       1103
       1098
        
       

     

       1104
       1099
        
       func (s *State) RepoSingleIssue(w http.ResponseWriter, r *http.Request) {

     

       1105
       1100
        
       	user := s.auth.GetUser(r)

     

       1106
       1106
       -
       	f, err := fullyResolvedRepo(r)

     

       1101
       1101
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1107
       1102
        
       	if err != nil {

     

       1108
       1103
        
       		log.Println("failed to get repo and knot", err)

     

       1109
       1104
        
       		return

     
···

       1157
       1152
        
       

     

       1158
       1153
        
       func (s *State) CloseIssue(w http.ResponseWriter, r *http.Request) {

     

       1159
       1154
        
       	user := s.auth.GetUser(r)

     

       1160
       1160
       -
       	f, err := fullyResolvedRepo(r)

     

       1155
       1155
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1161
       1156
        
       	if err != nil {

     

       1162
       1157
        
       		log.Println("failed to get repo and knot", err)

     

       1163
       1158
        
       		return

     
···

       1229
       1224
        
       

     

       1230
       1225
        
       func (s *State) ReopenIssue(w http.ResponseWriter, r *http.Request) {

     

       1231
       1226
        
       	user := s.auth.GetUser(r)

     

       1232
       1232
       -
       	f, err := fullyResolvedRepo(r)

     

       1227
       1227
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1233
       1228
        
       	if err != nil {

     

       1234
       1229
        
       		log.Println("failed to get repo and knot", err)

     

       1235
       1230
        
       		return

     
···

       1277
       1272
        
       

     

       1278
       1273
        
       func (s *State) NewIssueComment(w http.ResponseWriter, r *http.Request) {

     

       1279
       1274
        
       	user := s.auth.GetUser(r)

     

       1280
       1280
       -
       	f, err := fullyResolvedRepo(r)

     

       1275
       1275
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1281
       1276
        
       	if err != nil {

     

       1282
       1277
        
       		log.Println("failed to get repo and knot", err)

     

       1283
       1278
        
       		return

     
···

       1356
       1351
        
       

     

       1357
       1352
        
       func (s *State) IssueComment(w http.ResponseWriter, r *http.Request) {

     

       1358
       1353
        
       	user := s.auth.GetUser(r)

     

       1359
       1359
       -
       	f, err := fullyResolvedRepo(r)

     

       1354
       1354
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1360
       1355
        
       	if err != nil {

     

       1361
       1356
        
       		log.Println("failed to get repo and knot", err)

     

       1362
       1357
        
       		return

     
···

       1415
       1410
        
       

     

       1416
       1411
        
       func (s *State) EditIssueComment(w http.ResponseWriter, r *http.Request) {

     

       1417
       1412
        
       	user := s.auth.GetUser(r)

     

       1418
       1418
       -
       	f, err := fullyResolvedRepo(r)

     

       1413
       1413
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1419
       1414
        
       	if err != nil {

     

       1420
       1415
        
       		log.Println("failed to get repo and knot", err)

     

       1421
       1416
        
       		return

     
···

       1540
       1535
        
       

     

       1541
       1536
        
       func (s *State) DeleteIssueComment(w http.ResponseWriter, r *http.Request) {

     

       1542
       1537
        
       	user := s.auth.GetUser(r)

     

       1543
       1543
       -
       	f, err := fullyResolvedRepo(r)

     

       1538
       1538
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1544
       1539
        
       	if err != nil {

     

       1545
       1540
        
       		log.Println("failed to get repo and knot", err)

     

       1546
       1541
        
       		return

     
···

       1645
       1640
        
       	}

     

       1646
       1641
        
       

     

       1647
       1642
        
       	user := s.auth.GetUser(r)

     

       1648
       1648
       -
       	f, err := fullyResolvedRepo(r)

     

       1643
       1643
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1649
       1644
        
       	if err != nil {

     

       1650
       1645
        
       		log.Println("failed to get repo and knot", err)

     

       1651
       1646
        
       		return

     
···

       1686
       1681
        
       func (s *State) NewIssue(w http.ResponseWriter, r *http.Request) {

     

       1687
       1682
        
       	user := s.auth.GetUser(r)

     

       1688
       1683
        
       

     

       1689
       1689
       -
       	f, err := fullyResolvedRepo(r)

     

       1684
       1684
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1690
       1685
        
       	if err != nil {

     

       1691
       1686
        
       		log.Println("failed to get repo and knot", err)

     

       1692
       1687
        
       		return

     
···

       1768
       1763
        
       

     

       1769
       1764
        
       func (s *State) ForkRepo(w http.ResponseWriter, r *http.Request) {

     

       1770
       1765
        
       	user := s.auth.GetUser(r)

     

       1771
       1771
       -
       	f, err := fullyResolvedRepo(r)

     

       1766
       1766
       +
       	f, err := s.fullyResolvedRepo(r)

     

       1772
       1767
        
       	if err != nil {

     

       1773
       1768
        
       		log.Printf("failed to resolve source repo: %v", err)

     

       1774
       1769
        
       		return

+18 -1

appview/state/repo_util.go

···

       17
       17
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       18
       18
        
       )

     

       19
       19
        
       

     

       20
       20
       -
       func fullyResolvedRepo(r *http.Request) (*FullyResolvedRepo, error) {

     

       20
       20
       +
       func (s *State) fullyResolvedRepo(r *http.Request) (*FullyResolvedRepo, error) {

     

       21
       21
        
       	repoName := chi.URLParam(r, "repo")

     

       22
       22
        
       	knot, ok := r.Context().Value("knot").(string)

     

       23
       23
        
       	if !ok {

     
···

       42
       42
        
       		return nil, fmt.Errorf("malformed middleware")

     

       43
       43
        
       	}

     

       44
       44
        
       

     

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

     

       46
       46
       +
       

     

       47
       47
       +
       	if ref == "" {

     

       48
       48
       +
       		us, err := NewUnsignedClient(knot, s.config.Dev)

     

       49
       49
       +
       		if err != nil {

     

       50
       50
       +
       			return nil, err

     

       51
       51
       +
       		}

     

       52
       52
       +
       

     

       53
       53
       +
       		defaultBranch, err := us.DefaultBranch(id.DID.String(), repoName)

     

       54
       54
       +
       		if err != nil {

     

       55
       55
       +
       			return nil, err

     

       56
       56
       +
       		}

     

       57
       57
       +
       

     

       58
       58
       +
       		ref = defaultBranch.Branch

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       45
       61
        
       	// pass through values from the middleware

     

       46
       62
        
       	description, ok := r.Context().Value("repoDescription").(string)

     

       47
       63
        
       	addedAt, ok := r.Context().Value("repoAddedAt").(string)

     
···

       53
       69
        
       		RepoAt:      parsedRepoAt,

     

       54
       70
        
       		Description: description,

     

       55
       71
        
       		CreatedAt:   addedAt,

     

       72
       72
       +
       		Ref:         ref,

     

       56
       73
        
       	}, nil

     

       57
       74
        
       }

     

       58
       75

+13 -2

appview/state/signer.go

···

       380
       380
        
       	return us.client.Do(req)

     

       381
       381
        
       }

     

       382
       382
        
       

     

       383
       383
       -
       func (us *UnsignedClient) DefaultBranch(ownerDid, repoName string) (*http.Response, error) {

     

       383
       383
       +
       func (us *UnsignedClient) DefaultBranch(ownerDid, repoName string) (*types.RepoDefaultBranchResponse, error) {

     

       384
       384
        
       	const (

     

       385
       385
        
       		Method = "GET"

     

       386
       386
        
       	)

     
···

       392
       392
        
       		return nil, err

     

       393
       393
        
       	}

     

       394
       394
        
       

     

       395
       395
       -
       	return us.client.Do(req)

     

       395
       395
       +
       	resp, err := us.client.Do(req)

     

       396
       396
       +
       	if err != nil {

     

       397
       397
       +
       		return nil, err

     

       398
       398
       +
       	}

     

       399
       399
       +
       	defer resp.Body.Close()

     

       400
       400
       +
       

     

       401
       401
       +
       	var defaultBranch types.RepoDefaultBranchResponse

     

       402
       402
       +
       	if err := json.NewDecoder(resp.Body).Decode(&defaultBranch); err != nil {

     

       403
       403
       +
       		return nil, err

     

       404
       404
       +
       	}

     

       405
       405
       +
       

     

       406
       406
       +
       	return &defaultBranch, nil

     

       396
       407
        
       }

     

       397
       408
        
       

     

       398
       409
        
       func (us *UnsignedClient) Capabilities() (*types.Capabilities, error) {