appview: strip scheme from `CoreConfig.AppviewHost`

Signed-off-by: Seongmin Lee <[e-mail]>

appview/config/config.go

···
 	TmpAltAppPassword string `env:"ALT_APP_PASSWORD"`
 }
 
+func (c *CoreConfig) UseTLS() bool {
+	return !c.Dev
+}
+
+func (c *CoreConfig) BaseUrl() string {
+	if c.UseTLS() {
+		return "https://" + c.AppviewHost
+	}
+	return "http://" + c.AppviewHost
+}
+
 type OAuthConfig struct {
 	ClientSecret string `env:"CLIENT_SECRET"`
 	ClientKid    string `env:"CLIENT_KID"`

appview/oauth/oauth.go

···
 
 func New(config *config.Config, ph posthog.Client, db *db.DB, enforcer *rbac.Enforcer, res *idresolver.Resolver, logger *slog.Logger) (*OAuth, error) {
 	var oauthConfig oauth.ClientConfig
-	var clientUri string
+	clientUri := config.Core.BaseUrl()
+	callbackUri := clientUri + "/oauth/callback"
 	if config.Core.Dev {
-		clientUri = "http://127.0.0.1:3000"
-		callbackUri := clientUri + "/oauth/callback"
 		oauthConfig = oauth.NewLocalhostConfig(callbackUri, []string{"atproto", "transition:generic"})
 	} else {
-		clientUri = config.Core.AppviewHost
 		clientId := fmt.Sprintf("%s/oauth/client-metadata.json", clientUri)
-		callbackUri := clientUri + "/oauth/callback"
 		oauthConfig = oauth.NewPublicConfig(clientId, callbackUri, []string{"atproto", "transition:generic"})
 	}
 

appview/pages/markup/extension/tangledlink.go

···
 
 func (t *tangledLinkTransformer) parseLinkCommitSha(raw string) string {
 	u, err := url.Parse(raw)
-	if err != nil || u.Host != "tangled.org" {
+	if err != nil || u.Host != t.host {
 		return ""
 	}
 

appview/pages/markup/extension/tangledlink_test.go

···
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			md := markup.NewMarkdown()
+			md := markup.NewMarkdown("tangled.org")
 
 			var buf bytes.Buffer
 			if err := md.Convert([]byte(tt.markdown), &buf); err != nil {

appview/pages/markup/markdown.go

···
 	CamoSecret string
 	repoinfo.RepoInfo
 	IsDev        bool
+	Hostname     string
 	RendererType RendererType
 	Sanitizer    Sanitizer
 	Files        fs.FS
 }
 
-func NewMarkdown() goldmark.Markdown {
+func NewMarkdown(hostname string) goldmark.Markdown {
 	md := goldmark.New(
 		goldmark.WithExtensions(
 			extension.GFM,
···
 			),
 			callout.CalloutExtention,
 			textension.AtExt,
-			textension.NewTangledLinkExt("tangled.org"),
+			textension.NewTangledLinkExt(hostname),
 			emoji.Emoji,
 		),
 		goldmark.WithParserOptions(
···
 }
 
 func (rctx *RenderContext) RenderMarkdown(source string) string {
-	return rctx.RenderMarkdownWith(source, NewMarkdown())
+	return rctx.RenderMarkdownWith(source, NewMarkdown(rctx.Hostname))
 }
 
 func (rctx *RenderContext) RenderMarkdownWith(source string, md goldmark.Markdown) string {

appview/pages/markup/markdown_test.go

···
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			md := NewMarkdown()
+			md := NewMarkdown("tangled.org")
 
 			var buf bytes.Buffer
 			if err := md.Convert([]byte(tt.markdown), &buf); err != nil {
···
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			md := NewMarkdown()
+			md := NewMarkdown("tangled.org")
 
 			var buf bytes.Buffer
 			if err := md.Convert([]byte(tt.markdown), &buf); err != nil {

appview/pages/markup/reference_link.go

···
 // like issues, PRs, comments or even @-mentions
 // This funciton doesn't actually check for the existence of records in the DB
 // or the PDS; it merely returns a list of what are presumed to be references.
-func FindReferences(baseUrl string, source string) ([]string, []models.ReferenceLink) {
+func FindReferences(host string, source string) ([]string, []models.ReferenceLink) {
 	var (
 		refLinkSet  = make(map[models.ReferenceLink]struct{})
 		mentionsSet = make(map[string]struct{})
-		md          = NewMarkdown()
+		md          = NewMarkdown(host)
 		sourceBytes = []byte(source)
 		root        = md.Parser().Parse(text.NewReader(sourceBytes))
 	)
-	// trim url scheme. the SSL shouldn't matter
-	baseUrl = strings.TrimPrefix(baseUrl, "https://")
-	baseUrl = strings.TrimPrefix(baseUrl, "http://")
 
 	ast.Walk(root, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
 		if !entering {
···
 			return ast.WalkSkipChildren, nil
 		case ast.KindLink:
 			dest := string(n.(*ast.Link).Destination)
-			ref := parseTangledLink(baseUrl, dest)
+			ref := parseTangledLink(host, dest)
 			if ref != nil {
 				refLinkSet[*ref] = struct{}{}
 			}
···
 			an := n.(*ast.AutoLink)
 			if an.AutoLinkType == ast.AutoLinkURL {
 				dest := string(an.URL(sourceBytes))
-				ref := parseTangledLink(baseUrl, dest)
+				ref := parseTangledLink(host, dest)
 				if ref != nil {
 					refLinkSet[*ref] = struct{}{}
 				}

appview/pages/markup/reference_link_test.go

···
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			handles, refLinks := markup.FindReferences("http://127.0.0.1:3000", tt.source)
+			handles, refLinks := markup.FindReferences("127.0.0.1:3000", tt.source)
 			assert.ElementsMatch(t, tt.wantHandles, handles)
 			assert.ElementsMatch(t, tt.wantRefLinks, refLinks)
 		})

appview/pages/pages.go

···
 	// initialized with safe defaults, can be overriden per use
 	rctx := &markup.RenderContext{
 		IsDev:      config.Core.Dev,
+		Hostname:   config.Core.AppviewHost,
 		CamoUrl:    config.Camo.Host,
 		CamoSecret: config.Camo.SharedSecret,
 		Sanitizer:  markup.NewSanitizer(),

appview/repo/archive.go

···
 	if link := resp.Header.Get("Link"); link != "" {
 		if resolvedRef, err := extractImmutableLink(link); err == nil {
 			newLink := fmt.Sprintf("<%s/%s/archive/%s.tar.gz>; rel=\"immutable\"",
-				rp.config.Core.AppviewHost, f.DidSlashRepo(), resolvedRef)
+				rp.config.Core.BaseUrl(), f.DidSlashRepo(), resolvedRef)
 			w.Header().Set("Link", newLink)
 		}
 	}

appview/repo/feed.go

···
 
 	feed := &feeds.Feed{
 		Title:   fmt.Sprintf("activity feed for @%s", ownerSlashRepo),
-		Link:    &feeds.Link{Href: fmt.Sprintf("%s/%s", rp.config.Core.AppviewHost, ownerSlashRepo), Type: "text/html", Rel: "alternate"},
+		Link:    &feeds.Link{Href: fmt.Sprintf("%s/%s", rp.config.Core.BaseUrl(), ownerSlashRepo), Type: "text/html", Rel: "alternate"},
 		Items:   make([]*feeds.Item, 0),
 		Updated: time.UnixMilli(0),
 	}
···
 	mainItem := &feeds.Item{
 		Title:       fmt.Sprintf("[PR #%d] %s", pull.PullId, pull.Title),
 		Description: description,
-		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d", rp.config.Core.AppviewHost, ownerSlashRepo, pull.PullId)},
+		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d", rp.config.Core.BaseUrl(), ownerSlashRepo, pull.PullId)},
 		Created:     pull.Created,
 		Author:      &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},
 	}
···
 		roundItem := &feeds.Item{
 			Title:       fmt.Sprintf("[PR #%d] %s (round #%d)", pull.PullId, pull.Title, round.RoundNumber),
 			Description: fmt.Sprintf("@%s submitted changes (at round #%d) on PR #%d in @%s", owner.Handle, round.RoundNumber, pull.PullId, ownerSlashRepo),
-			Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d/round/%d/", rp.config.Core.AppviewHost, ownerSlashRepo, pull.PullId, round.RoundNumber)},
+			Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d/round/%d/", rp.config.Core.BaseUrl(), ownerSlashRepo, pull.PullId, round.RoundNumber)},
 			Created:     round.Created,
 			Author:      &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},
 		}
···
 	return &feeds.Item{
 		Title:       fmt.Sprintf("[Issue #%d] %s", issue.IssueId, issue.Title),
 		Description: fmt.Sprintf("@%s %s issue #%d in @%s", owner.Handle, state, issue.IssueId, ownerSlashRepo),
-		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/issues/%d", rp.config.Core.AppviewHost, ownerSlashRepo, issue.IssueId)},
+		Link:        &feeds.Link{Href: fmt.Sprintf("%s/%s/issues/%d", rp.config.Core.BaseUrl(), ownerSlashRepo, issue.IssueId)},
 		Created:     issue.Created,
 		Author:      &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)},
 	}, nil

appview/settings/settings.go

···
 }
 
 func (s *Settings) verifyUrl(did string, email string, code string) string {
-	var appUrl string
-	if s.Config.Core.Dev {
-		appUrl = "http://" + s.Config.Core.ListenAddr
-	} else {
-		appUrl = s.Config.Core.AppviewHost
-	}
-
-	return fmt.Sprintf("%s/settings/emails/verify?did=%s&email=%s&code=%s", appUrl, url.QueryEscape(did), url.QueryEscape(email), url.QueryEscape(code))
+	return fmt.Sprintf(
+		"%s/settings/emails/verify?did=%s&email=%s&code=%s",
+		s.Config.Core.BaseUrl(),
+		url.QueryEscape(did),
+		url.QueryEscape(email),
+		url.QueryEscape(code),
+	)
 }
 
 func (s *Settings) emailsVerify(w http.ResponseWriter, r *http.Request) {

appview/state/profile.go

···
 
 	feed := feeds.Feed{
 		Title:   fmt.Sprintf("%s's timeline", author.Name),
-		Link:    &feeds.Link{Href: fmt.Sprintf("%s/@%s", s.config.Core.AppviewHost, id.Handle), Type: "text/html", Rel: "alternate"},
+		Link:    &feeds.Link{Href: fmt.Sprintf("%s/@%s", s.config.Core.BaseUrl(), id.Handle), Type: "text/html", Rel: "alternate"},
 		Items:   make([]*feeds.Item, 0),
 		Updated: time.UnixMilli(0),
 		Author:  author,
···
 func (s *State) createPullRequestItem(pull *models.Pull, owner *identity.Identity, author *feeds.Author) *feeds.Item {
 	return &feeds.Item{
 		Title:   fmt.Sprintf("%s created pull request '%s' in @%s/%s", author.Name, pull.Title, owner.Handle, pull.Repo.Name),
-		Link:    &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/pulls/%d", s.config.Core.AppviewHost, owner.Handle, pull.Repo.Name, pull.PullId), Type: "text/html", Rel: "alternate"},
+		Link:    &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/pulls/%d", s.config.Core.BaseUrl(), owner.Handle, pull.Repo.Name, pull.PullId), Type: "text/html", Rel: "alternate"},
 		Created: pull.Created,
 		Author:  author,
 	}
···
 func (s *State) createIssueItem(issue *models.Issue, owner *identity.Identity, author *feeds.Author) *feeds.Item {
 	return &feeds.Item{
 		Title:   fmt.Sprintf("%s created issue '%s' in @%s/%s", author.Name, issue.Title, owner.Handle, issue.Repo.Name),
-		Link:    &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/issues/%d", s.config.Core.AppviewHost, owner.Handle, issue.Repo.Name, issue.IssueId), Type: "text/html", Rel: "alternate"},
+		Link:    &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/issues/%d", s.config.Core.BaseUrl(), owner.Handle, issue.Repo.Name, issue.IssueId), Type: "text/html", Rel: "alternate"},
 		Created: issue.Created,
 		Author:  author,
 	}
···
 
 	return &feeds.Item{
 		Title:   title,
-		Link:    &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s", s.config.Core.AppviewHost, author.Name[1:], repo.Repo.Name), Type: "text/html", Rel: "alternate"}, // Remove @ prefix
+		Link:    &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s", s.config.Core.BaseUrl(), author.Name[1:], repo.Repo.Name), Type: "text/html", Rel: "alternate"}, // Remove @ prefix
 		Created: repo.Repo.Created,
 		Author:  author,
 	}, nil

nix/modules/appview.nix

···
 
         appviewHost = mkOption {
           type = types.str;
-          default = "https://tangled.org";
-          example = "https://example.com";
+          default = "tangled.org";
+          example = "example.com";
           description = "Public host URL for the appview instance";
         };