commit 8f48b53b6b7769da473aae5a34b5bc2301b1ce98 · julien.rbrt.fr/tangled-core

+43

appview/pages/markup/markdown.go

···

       3
       3
        
       

     

       4
       4
        
       import (

     

       5
       5
        
       	"bytes"

     

       6
       6
       +
       	"fmt"

     

       6
       7
        
       

     

       7
       8
        
       	"github.com/yuin/goldmark"

     

       9
       9
       +
       	"github.com/yuin/goldmark/ast"

     

       8
       10
        
       	"github.com/yuin/goldmark/extension"

     

       9
       11
        
       	"github.com/yuin/goldmark/parser"

     

       12
       12
       +
       	"github.com/yuin/goldmark/text"

     

       13
       13
       +
       	"github.com/yuin/goldmark/util"

     

       10
       14
        
       )

     

       11
       15
        
       

     

       12
       16
        
       func RenderMarkdown(source string) string {

     
···

       22
       26
        
       	}

     

       23
       27
        
       	return buf.String()

     

       24
       28
        
       }

     

       29
       29
       +
       

     

       30
       30
       +
       type RelativeLinkTransformer struct {

     

       31
       31
       +
       	User string

     

       32
       32
       +
       	Repo string

     

       33
       33
       +
       	Ref  string

     

       34
       34
       +
       }

     

       35
       35
       +
       

     

       36
       36
       +
       func (t *RelativeLinkTransformer) Transform(node *ast.Document, reader text.Reader, pc parser.Context) {

     

       37
       37
       +
       	ast.Walk(node, func(n ast.Node, entering bool) (ast.WalkStatus, error) {

     

       38
       38
       +
       		if !entering {

     

       39
       39
       +
       			fmt.Printf("Node: %T\n", n)

     

       40
       40
       +
       		}

     

       41
       41
       +
       		return ast.WalkContinue, nil

     

       42
       42
       +
       	})

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       func RenderMarkdownExtended(source, user, repo, ref string) string {

     

       46
       46
       +
       	md := goldmark.New(

     

       47
       47
       +
       		goldmark.WithExtensions(extension.GFM),

     

       48
       48
       +
       		goldmark.WithParserOptions(parser.WithAutoHeadingID()),

     

       49
       49
       +
       		goldmark.WithParser(

     

       50
       50
       +
       			parser.NewParser(

     

       51
       51
       +
       				parser.WithASTTransformers(

     

       52
       52
       +
       					util.Prioritized(&RelativeLinkTransformer{

     

       53
       53
       +
       						User: user,

     

       54
       54
       +
       						Repo: repo,

     

       55
       55
       +
       						Ref:  ref,

     

       56
       56
       +
       					}, 999),

     

       57
       57
       +
       				),

     

       58
       58
       +
       			),

     

       59
       59
       +
       		),

     

       60
       60
       +
       	)

     

       61
       61
       +
       

     

       62
       62
       +
       	var buf bytes.Buffer

     

       63
       63
       +
       	if err := md.Convert([]byte(source), &buf); err != nil {

     

       64
       64
       +
       		return source

     

       65
       65
       +
       	}

     

       66
       66
       +
       	return buf.String()

     

       67
       67
       +
       }

appview/pages/markup/readme.go appview/pages/markup/format.go

+13 -2

appview/pages/pages.go

···

       231
       231
        
       	OwnerHandle  string

     

       232
       232
        
       	Description  string

     

       233
       233
        
       	Knot         string

     

       234
       234
       +
       	Ref          string

     

       234
       235
        
       	RepoAt       syntax.ATURI

     

       235
       236
        
       	IsStarred    bool

     

       236
       237
        
       	Stats        db.RepoStats

     
···

       351
       352
        
       		ext := filepath.Ext(params.ReadmeFileName)

     

       352
       353
        
       		switch ext {

     

       353
       354
        
       		case ".md", ".markdown", ".mdown", ".mkdn", ".mkd":

     

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

     

       355
       355
       +
       			htmlString = markup.RenderMarkdownExtended(

     

       356
       356
       +
       				params.Readme,

     

       357
       357
       +
       				params.RepoInfo.OwnerHandle,

     

       358
       358
       +
       				params.RepoInfo.Name,

     

       359
       359
       +
       				params.RepoInfo.Ref,

     

       360
       360
       +
       			)

     

       355
       361
        
       			params.Raw = false

     

       356
       362
        
       			params.HTMLReadme = template.HTML(bluemonday.UGCPolicy().Sanitize(htmlString))

     

       357
       363
        
       		default:

     
···

       466
       472
        
       	if params.ShowRendered {

     

       467
       473
        
       		switch markup.GetFormat(params.Path) {

     

       468
       474
        
       		case markup.FormatMarkdown:

     

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

     

       475
       475
       +
       			params.RenderedContents = template.HTML(markup.RenderMarkdownExtended(

     

       476
       476
       +
       				params.Contents,

     

       477
       477
       +
       				params.RepoInfo.OwnerHandle,

     

       478
       478
       +
       				params.RepoInfo.Name,

     

       479
       479
       +
       				params.RepoInfo.Ref,

     

       480
       480
       +
       			))

     

       470
       481
        
       		}

     

       471
       482
        
       	}

     

       472
       483

+2 -2

appview/state/middleware.go

···

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

     

       145
       145
        
       				return

     

       146
       146
        
       			}

     

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

     

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

     

       148
       148
        
       			if err != nil {

     

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

     

       150
       150
        
       				return

     
···

       225
       225
        
       func ResolvePull(s *State) Middleware {

     

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

     

       227
       227
        
       		return http.HandlerFunc(func(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 fully resolve repo", err)

     

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

+14 -14

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

     
···

       262
       262
        
       

     

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

     

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

     

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

     

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

     

       266
       266
        
       	if err != nil {

     

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

     

       268
       268
        
       		return

     
···

       349
       349
        
       		state = db.PullMerged

     

       350
       350
        
       	}

     

       351
       351
        
       

     

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

     

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

     

       353
       353
        
       	if err != nil {

     

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

     

       355
       355
        
       		return

     
···

       402
       402
        
       

     

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

     

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

     

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

     

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

     

       406
       406
        
       	if err != nil {

     

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

     

       408
       408
        
       		return

     
···

       509
       509
        
       

     

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

     

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

     

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

     

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

     

       513
       513
        
       	if err != nil {

     

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

     

       515
       515
        
       		return

     
···

       842
       842
        
       

     

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

     

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

     

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

     

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

     

       846
       846
        
       	if err != nil {

     

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

     

       848
       848
        
       		return

     
···

       855
       855
        
       

     

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

     

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

     

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

     

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

     

       859
       859
        
       	if err != nil {

     

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

     

       861
       861
        
       		return

     
···

       895
       895
        
       

     

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

     

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

     

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

     

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

     

       899
       899
        
       	if err != nil {

     

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

     

       901
       901
        
       		return

     
···

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

     

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

     

       918
       918
        
       

     

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

     

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

     

       920
       920
        
       	if err != nil {

     

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

     

       922
       922
        
       		return

     
···

       994
       994
        
       

     

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

     

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

     

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

     

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

     

       998
       998
        
       	if err != nil {

     

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

     

       1000
       1000
        
       		return

     
···

       1193
       1193
        
       }

     

       1194
       1194
        
       

     

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

     

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

     

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

     

       1197
       1197
        
       	if err != nil {

     

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

     

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

     
···

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

     

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

     

       1260
       1260
        
       

     

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

     

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

     

       1262
       1262
        
       	if err != nil {

     

       1263
       1263
        
       		log.Println("malformed middleware")

     

       1264
       1264
        
       		return

     
···

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

     

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

     

       1314
       1314
        
       

     

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

     

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

     

       1316
       1316
        
       	if err != nil {

     

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

     

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

+34 -39

appview/state/repo.go

···

       34
       34
        
       

     

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

     

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

     

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

     

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

     

       38
       38
        
       	if err != nil {

     

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

     

       40
       40
        
       		return

     
···

       93
       93
        
       }

     

       94
       94
        
       

     

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

     

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

     

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

     

       97
       97
        
       	if err != nil {

     

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

     

       99
       99
        
       		return

     
···

       144
       144
        
       }

     

       145
       145
        
       

     

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

     

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

     

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

     

       148
       148
        
       	if err != nil {

     

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

     

       150
       150
        
       		w.WriteHeader(http.StatusBadRequest)

     
···

       159
       159
        
       }

     

       160
       160
        
       

     

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

     

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

     

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

     

       163
       163
        
       	if err != nil {

     

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

     

       165
       165
        
       		w.WriteHeader(http.StatusBadRequest)

     
···

       238
       238
        
       }

     

       239
       239
        
       

     

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

     

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

     

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

     

       242
       242
        
       	if err != nil {

     

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

     

       244
       244
        
       		return

     
···

       278
       278
        
       }

     

       279
       279
        
       

     

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

     

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

     

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

     

       282
       282
        
       	if err != nil {

     

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

     

       284
       284
        
       		return

     
···

       309
       309
        
       		return

     

       310
       310
        
       	}

     

       311
       311
        
       

     

       312
       312
       +
       	if result.Parent == treePath {

     

       313
       313
       +
       		fmt.Println("here")

     

       314
       314
       +
       		http.Redirect(w, r, fmt.Sprintf("/%s/%s/blob/%s/%s", f.OwnerHandle(), f.RepoName, ref, treePath), http.StatusPermanentRedirect)

     

       315
       315
       +
       		return

     

       316
       316
       +
       	}

     

       317
       317
       +
       

     

       312
       318
        
       	user := s.auth.GetUser(r)

     

       313
       319
        
       

     

       314
       320
        
       	var breadcrumbs [][]string

     
···

       334
       340
        
       }

     

       335
       341
        
       

     

       336
       342
        
       func (s *State) RepoTags(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       338
       344
        
       	if err != nil {

     

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

     

       340
       346
        
       		return

     
···

       374
       380
        
       }

     

       375
       381
        
       

     

       376
       382
        
       func (s *State) RepoBranches(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       378
       384
        
       	if err != nil {

     

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

     

       380
       386
        
       		return

     
···

       415
       421
        
       }

     

       416
       422
        
       

     

       417
       423
        
       func (s *State) RepoBlob(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       419
       425
        
       	if err != nil {

     

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

     

       421
       427
        
       		return

     
···

       475
       481
        
       }

     

       476
       482
        
       

     

       477
       483
        
       func (s *State) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       479
       485
        
       	if err != nil {

     

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

     

       481
       487
        
       		return

     
···

       519
       525
        
       }

     

       520
       526
        
       

     

       521
       527
        
       func (s *State) AddCollaborator(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       523
       529
        
       	if err != nil {

     

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

     

       525
       531
        
       		return

     
···

       610
       616
        
       func (s *State) DeleteRepo(w http.ResponseWriter, r *http.Request) {

     

       611
       617
        
       	user := s.auth.GetUser(r)

     

       612
       618
        
       

     

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

     

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

     

       614
       620
        
       	if err != nil {

     

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

     

       616
       622
        
       		return

     
···

       714
       720
        
       }

     

       715
       721
        
       

     

       716
       722
        
       func (s *State) SetDefaultBranch(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       718
       724
        
       	if err != nil {

     

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

     

       720
       726
        
       		return

     
···

       753
       759
        
       }

     

       754
       760
        
       

     

       755
       761
        
       func (s *State) RepoSettings(w http.ResponseWriter, r *http.Request) {

     

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

     

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

     

       757
       763
        
       	if err != nil {

     

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

     

       759
       765
        
       		return

     
···

       804
       810
        
       				}

     

       805
       811
        
       			}

     

       806
       812
        
       

     

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

     

       813
       813
       +
       			result, err := us.DefaultBranch(f.OwnerDid(), f.RepoName)

     

       808
       814
        
       			if err != nil {

     

       809
       815
        
       				log.Println("failed to reach knotserver", err)

     

       810
       816
        
       			} else {

     

       811
       811
       -
       				defer resp.Body.Close()

     

       812
       812
       -
       

     

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

     

       814
       814
       -
       				if err != nil {

     

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

     

       816
       816
       -
       				} else {

     

       817
       817
       -
       					var result types.RepoDefaultBranchResponse

     

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

     

       819
       819
       -
       					if err != nil {

     

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

     

       821
       821
       -
       					} else {

     

       822
       822
       -
       						defaultBranch = result.Branch

     

       823
       823
       -
       					}

     

       824
       824
       -
       				}

     

       817
       817
       +
       				defaultBranch = result.Branch

     

       825
       818
        
       			}

     

       826
       819
        
       		}

     

       827
       820
        
       

     
···

       840
       833
        
       	Knot        string

     

       841
       834
        
       	OwnerId     identity.Identity

     

       842
       835
        
       	RepoName    string

     

       836
       836
       +
       	Ref         string

     

       843
       837
        
       	RepoAt      syntax.ATURI

     

       844
       838
        
       	Description string

     

       845
       839
        
       	AddedAt     string

     
···

       984
       978
        
       		Description: f.Description,

     

       985
       979
        
       		IsStarred:   isStarred,

     

       986
       980
        
       		Knot:        knot,

     

       981
       981
       +
       		Ref:         f.Ref,

     

       987
       982
        
       		Roles:       RolesInRepo(s, u, f),

     

       988
       983
        
       		Stats: db.RepoStats{

     

       989
       984
        
       			StarCount:  starCount,

     
···

       1003
       998
        
       

     

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

     

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

     

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

     

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

     

       1007
       1002
        
       	if err != nil {

     

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

     

       1009
       1004
        
       		return

     
···

       1057
       1052
        
       

     

       1058
       1053
        
       func (s *State) CloseIssue(w http.ResponseWriter, r *http.Request) {

     

       1059
       1054
        
       	user := s.auth.GetUser(r)

     

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

     

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

     

       1061
       1056
        
       	if err != nil {

     

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

     

       1063
       1058
        
       		return

     
···

       1129
       1124
        
       

     

       1130
       1125
        
       func (s *State) ReopenIssue(w http.ResponseWriter, r *http.Request) {

     

       1131
       1126
        
       	user := s.auth.GetUser(r)

     

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

     

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

     

       1133
       1128
        
       	if err != nil {

     

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

     

       1135
       1130
        
       		return

     
···

       1177
       1172
        
       

     

       1178
       1173
        
       func (s *State) NewIssueComment(w http.ResponseWriter, r *http.Request) {

     

       1179
       1174
        
       	user := s.auth.GetUser(r)

     

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

     

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

     

       1181
       1176
        
       	if err != nil {

     

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

     

       1183
       1178
        
       		return

     
···

       1256
       1251
        
       

     

       1257
       1252
        
       func (s *State) IssueComment(w http.ResponseWriter, r *http.Request) {

     

       1258
       1253
        
       	user := s.auth.GetUser(r)

     

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

     

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

     

       1260
       1255
        
       	if err != nil {

     

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

     

       1262
       1257
        
       		return

     
···

       1315
       1310
        
       

     

       1316
       1311
        
       func (s *State) EditIssueComment(w http.ResponseWriter, r *http.Request) {

     

       1317
       1312
        
       	user := s.auth.GetUser(r)

     

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

     

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

     

       1319
       1314
        
       	if err != nil {

     

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

     

       1321
       1316
        
       		return

     
···

       1440
       1435
        
       

     

       1441
       1436
        
       func (s *State) DeleteIssueComment(w http.ResponseWriter, r *http.Request) {

     

       1442
       1437
        
       	user := s.auth.GetUser(r)

     

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

     

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

     

       1444
       1439
        
       	if err != nil {

     

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

     

       1446
       1441
        
       		return

     
···

       1539
       1534
        
       	}

     

       1540
       1535
        
       

     

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

     

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

     

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

     

       1543
       1538
        
       	if err != nil {

     

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

     

       1545
       1540
        
       		return

     
···

       1579
       1574
        
       func (s *State) NewIssue(w http.ResponseWriter, r *http.Request) {

     

       1580
       1575
        
       	user := s.auth.GetUser(r)

     

       1581
       1576
        
       

     

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

     

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

     

       1583
       1578
        
       	if err != nil {

     

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

     

       1585
       1580
        
       		return

     
···

       1661
       1656
        
       

     

       1662
       1657
        
       func (s *State) ForkRepo(w http.ResponseWriter, r *http.Request) {

     

       1663
       1658
        
       	user := s.auth.GetUser(r)

     

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

     

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

     

       1665
       1660
        
       	if err != nil {

     

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

     

       1667
       1662
        
       		return

+19 -2

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
       +
       	ref := chi.URLParam(r, "ref")

     

       23
       23
       +
       

     

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

     

       23
       25
        
       	if !ok {

     

       24
       26
        
       		log.Println("malformed middleware")

     
···

       36
       38
        
       		return nil, fmt.Errorf("malformed middleware")

     

       37
       39
        
       	}

     

       38
       40
        
       

     

       41
       41
       +
       	if ref == "" {

     

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

     

       43
       43
       +
       		if err != nil {

     

       44
       44
       +
       			return nil, fmt.Errorf("failed to setup new signed client: %w", err)

     

       45
       45
       +
       		}

     

       46
       46
       +
       

     

       47
       47
       +
       		def, err := us.DefaultBranch(id.DID.String(), repoName)

     

       48
       48
       +
       		if err != nil {

     

       49
       49
       +
       			return nil, fmt.Errorf("failed to get default branch: %w", err)

     

       50
       50
       +
       		}

     

       51
       51
       +
       

     

       52
       52
       +
       		ref = def.Branch

     

       53
       53
       +
       	}

     

       54
       54
       +
       

     

       39
       55
        
       	parsedRepoAt, err := syntax.ParseATURI(repoAt)

     

       40
       56
        
       	if err != nil {

     

       41
       57
        
       		log.Println("malformed repo at-uri")

     

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

     

       58
       58
       +
       		return nil, fmt.Errorf("malformed middleware: %w", err)

     

       43
       59
        
       	}

     

       44
       60
        
       

     

       45
       61
        
       	// pass through values from the middleware

     
···

       53
       69
        
       		RepoAt:      parsedRepoAt,

     

       54
       70
        
       		Description: description,

     

       55
       71
        
       		AddedAt:     addedAt,

     

       72
       72
       +
       		Ref:         ref,

     

       56
       73
        
       	}, nil

     

       57
       74
        
       }

     

       58
       75

+13 -2

appview/state/signer.go

···

       336
       336
        
       	return us.client.Do(req)

     

       337
       337
        
       }

     

       338
       338
        
       

     

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

     

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

     

       340
       340
        
       	const (

     

       341
       341
        
       		Method = "GET"

     

       342
       342
        
       	)

     
···

       348
       348
        
       		return nil, err

     

       349
       349
        
       	}

     

       350
       350
        
       

     

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

     

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

     

       352
       352
       +
       	if err != nil {

     

       353
       353
       +
       		return nil, err

     

       354
       354
       +
       	}

     

       355
       355
       +
       	defer resp.Body.Close()

     

       356
       356
       +
       

     

       357
       357
       +
       	var branchResponse types.RepoDefaultBranchResponse

     

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

     

       359
       359
       +
       		return nil, err

     

       360
       360
       +
       	}

     

       361
       361
       +
       

     

       362
       362
       +
       	return &branchResponse, nil

     

       352
       363
        
       }

     

       353
       364
        
       

     

       354
       365
        
       func (us *UnsignedClient) Capabilities() (*types.Capabilities, error) {

+1 -1

go.mod

···

       25
       25
        
       	github.com/resend/resend-go/v2 v2.15.0

     

       26
       26
        
       	github.com/sethvargo/go-envconfig v1.1.0

     

       27
       27
        
       	github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e

     

       28
       28
       -
       	github.com/yuin/goldmark v1.4.13

     

       28
       28
       +
       	github.com/yuin/goldmark v1.7.8

     

       29
       29
        
       	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028

     

       30
       30
        
       )

     

       31
       31

+2 -1

go.sum

···

       262
       262
        
       github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       263
       263
        
       github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       264
       264
        
       github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=

     

       265
       265
       -
       github.com/yuin/goldmark v1.4.13 h1:fVcFKWvrslecOb/tg+Cc05dkeYx540o0FuFt3nUVDoE=

     

       266
       265
        
       github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=

     

       266
       266
       +
       github.com/yuin/goldmark v1.7.8 h1:iERMLn0/QJeHFhxSt3p6PeN9mGnvIKSpG9YYorDMnic=

     

       267
       267
       +
       github.com/yuin/goldmark v1.7.8/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=

     

       267
       268
        
       gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b h1:CzigHMRySiX3drau9C6Q5CAbNIApmLdat5jPMqChvDA=

     

       268
       269
        
       gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b/go.mod h1:/y/V339mxv2sZmYYR64O07VuCpdNZqCTwO8ZcouTMI8=

     

       269
       270
        
       gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 h1:qwDnMxjkyLmAFgcfgTnfJrmYKWhHnci3GjDqcZp1M3Q=