mirror of
https://github.com/jesseduffield/lazygit.git
synced 2024-12-14 11:23:09 +02:00
f0d0d45ba7
fix: 🐛 The root URI for Azure DevOps repositories contains _git
refactor so that we don't have conditional logic based on service definition
no need for this commend anymore
add comment
Fixed RegEx for HTTP remote git URL
Added Tests
pretty sure we can do this safely
185 lines
6.0 KiB
Go
185 lines
6.0 KiB
Go
package hosting_service
|
|
|
|
import (
|
|
"net/url"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"github.com/go-errors/errors"
|
|
"github.com/jesseduffield/lazygit/pkg/i18n"
|
|
"github.com/jesseduffield/lazygit/pkg/utils"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// This package is for handling logic specific to a git hosting service like github, gitlab, bitbucket, etc.
|
|
// Different git hosting services have different URL formats for when you want to open a PR or view a commit,
|
|
// and this package's responsibility is to determine which service you're using based on the remote URL,
|
|
// and then which URL you need for whatever use case you have.
|
|
|
|
type HostingServiceMgr struct {
|
|
log logrus.FieldLogger
|
|
tr *i18n.TranslationSet
|
|
remoteURL string // e.g. https://github.com/jesseduffield/lazygit
|
|
|
|
// see https://github.com/jesseduffield/lazygit/blob/master/docs/Config.md#custom-pull-request-urls
|
|
configServiceDomains map[string]string
|
|
}
|
|
|
|
// NewHostingServiceMgr creates new instance of PullRequest
|
|
func NewHostingServiceMgr(log logrus.FieldLogger, tr *i18n.TranslationSet, remoteURL string, configServiceDomains map[string]string) *HostingServiceMgr {
|
|
return &HostingServiceMgr{
|
|
log: log,
|
|
tr: tr,
|
|
remoteURL: remoteURL,
|
|
configServiceDomains: configServiceDomains,
|
|
}
|
|
}
|
|
|
|
func (self *HostingServiceMgr) GetPullRequestURL(from string, to string) (string, error) {
|
|
gitService, err := self.getService()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
if to == "" {
|
|
return gitService.getPullRequestURLIntoDefaultBranch(url.QueryEscape(from)), nil
|
|
} else {
|
|
return gitService.getPullRequestURLIntoTargetBranch(url.QueryEscape(from), url.QueryEscape(to)), nil
|
|
}
|
|
}
|
|
|
|
func (self *HostingServiceMgr) GetCommitURL(commitSha string) (string, error) {
|
|
gitService, err := self.getService()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
pullRequestURL := gitService.getCommitURL(commitSha)
|
|
|
|
return pullRequestURL, nil
|
|
}
|
|
|
|
func (self *HostingServiceMgr) getService() (*Service, error) {
|
|
serviceDomain, err := self.getServiceDomain(self.remoteURL)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
repoURL, err := serviceDomain.serviceDefinition.getRepoURLFromRemoteURL(self.remoteURL, serviceDomain.webDomain)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Service{
|
|
repoURL: repoURL,
|
|
ServiceDefinition: serviceDomain.serviceDefinition,
|
|
}, nil
|
|
}
|
|
|
|
func (self *HostingServiceMgr) getServiceDomain(repoURL string) (*ServiceDomain, error) {
|
|
candidateServiceDomains := self.getCandidateServiceDomains()
|
|
|
|
for _, serviceDomain := range candidateServiceDomains {
|
|
if strings.Contains(repoURL, serviceDomain.gitDomain) {
|
|
return &serviceDomain, nil
|
|
}
|
|
}
|
|
|
|
return nil, errors.New(self.tr.UnsupportedGitService)
|
|
}
|
|
|
|
func (self *HostingServiceMgr) getCandidateServiceDomains() []ServiceDomain {
|
|
serviceDefinitionByProvider := map[string]ServiceDefinition{}
|
|
for _, serviceDefinition := range serviceDefinitions {
|
|
serviceDefinitionByProvider[serviceDefinition.provider] = serviceDefinition
|
|
}
|
|
|
|
var serviceDomains = make([]ServiceDomain, len(defaultServiceDomains))
|
|
copy(serviceDomains, defaultServiceDomains)
|
|
|
|
if len(self.configServiceDomains) > 0 {
|
|
for gitDomain, typeAndDomain := range self.configServiceDomains {
|
|
splitData := strings.Split(typeAndDomain, ":")
|
|
if len(splitData) != 2 {
|
|
self.log.Errorf("Unexpected format for git service: '%s'. Expected something like 'github.com:github.com'", typeAndDomain)
|
|
continue
|
|
}
|
|
|
|
provider := splitData[0]
|
|
webDomain := splitData[1]
|
|
|
|
serviceDefinition, ok := serviceDefinitionByProvider[provider]
|
|
if !ok {
|
|
providerNames := []string{}
|
|
for _, serviceDefinition := range serviceDefinitions {
|
|
providerNames = append(providerNames, serviceDefinition.provider)
|
|
}
|
|
self.log.Errorf("Unknown git service type: '%s'. Expected one of %s", provider, strings.Join(providerNames, ", "))
|
|
continue
|
|
}
|
|
|
|
serviceDomains = append(serviceDomains, ServiceDomain{
|
|
gitDomain: gitDomain,
|
|
webDomain: webDomain,
|
|
serviceDefinition: serviceDefinition,
|
|
})
|
|
}
|
|
}
|
|
|
|
return serviceDomains
|
|
}
|
|
|
|
// a service domains pairs a service definition with the actual domain it's being served from.
|
|
// Sometimes the git service is hosted in a custom domains so although it'll use say
|
|
// the github service definition, it'll actually be served from e.g. my-custom-github.com
|
|
type ServiceDomain struct {
|
|
gitDomain string // the one that appears in the git remote url
|
|
webDomain string // the one that appears in the web url
|
|
serviceDefinition ServiceDefinition
|
|
}
|
|
|
|
type ServiceDefinition struct {
|
|
provider string
|
|
pullRequestURLIntoDefaultBranch string
|
|
pullRequestURLIntoTargetBranch string
|
|
commitURL string
|
|
regexStrings []string
|
|
|
|
// can expect 'webdomain' to be passed in. Otherwise, you get to pick what we match in the regex
|
|
repoURLTemplate string
|
|
}
|
|
|
|
func (self ServiceDefinition) getRepoURLFromRemoteURL(url string, webDomain string) (string, error) {
|
|
for _, regexStr := range self.regexStrings {
|
|
re := regexp.MustCompile(regexStr)
|
|
input := utils.FindNamedMatches(re, url)
|
|
if input != nil {
|
|
input["webDomain"] = webDomain
|
|
return utils.ResolvePlaceholderString(self.repoURLTemplate, input), nil
|
|
}
|
|
}
|
|
|
|
return "", errors.New("Failed to parse repo information from url")
|
|
}
|
|
|
|
type Service struct {
|
|
repoURL string
|
|
ServiceDefinition
|
|
}
|
|
|
|
func (self *Service) getPullRequestURLIntoDefaultBranch(from string) string {
|
|
return self.resolveUrl(self.pullRequestURLIntoDefaultBranch, map[string]string{"From": from})
|
|
}
|
|
|
|
func (self *Service) getPullRequestURLIntoTargetBranch(from string, to string) string {
|
|
return self.resolveUrl(self.pullRequestURLIntoTargetBranch, map[string]string{"From": from, "To": to})
|
|
}
|
|
|
|
func (self *Service) getCommitURL(commitSha string) string {
|
|
return self.resolveUrl(self.commitURL, map[string]string{"CommitSha": commitSha})
|
|
}
|
|
|
|
func (self *Service) resolveUrl(templateString string, args map[string]string) string {
|
|
return self.repoURL + utils.ResolvePlaceholderString(templateString, args)
|
|
}
|