初始提交: Gitea 项目代码
This commit is contained in:
root
@@ -0,0 +1,611 @@
|
||||
// Copyright 2019 The Gitea Authors. All rights reserved.
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
package references
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"net/url"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"gitea.dev/modules/log"
|
||||
"gitea.dev/modules/markup/mdstripper"
|
||||
"gitea.dev/modules/setting"
|
||||
"gitea.dev/modules/util"
|
||||
)
|
||||
|
||||
var (
|
||||
// validNamePattern performs only the most basic validation for user or repository names
|
||||
// Repository name should contain only alphanumeric, dash ('-'), underscore ('_') and dot ('.') characters.
|
||||
validNamePattern = regexp.MustCompile(`^[a-z0-9_.-]+$`)
|
||||
|
||||
// NOTE: All below regex matching do not perform any extra validation.
|
||||
// Thus a link is produced even if the linked entity does not exist.
|
||||
// While fast, this is also incorrect and lead to false positives.
|
||||
// TODO: fix invalid linking issue
|
||||
|
||||
// mentionPattern matches all mentions in the form of "@user" or "@org/team"
|
||||
mentionPattern = regexp.MustCompile(`(?:\s|^|\(|\[)(@[-\w][-.\w]*?|@[-\w][-.\w]*?/[-\w][-.\w]*?)(?:\s|$|[:,;.?!](\s|$)|'|\)|\])`)
|
||||
// issueNumericPattern matches string that references to a numeric issue, e.g. #1287
|
||||
issueNumericPattern = regexp.MustCompile(`(?:\s|^|\(|\[|\'|\")([#!][0-9]+)(?:\s|$|\)|\]|\'|\"|[:;,.?!]\s|[:;,.?!]$)`)
|
||||
// issueAlphanumericPattern matches string that references to an alphanumeric issue, e.g. ABC-1234
|
||||
issueAlphanumericPattern = regexp.MustCompile(`(?:\s|^|\(|\[|\"|\')([A-Z]{1,10}-[1-9][0-9]*)(?:\s|$|\)|\]|:|\.(\s|$)|\"|\'|,)`)
|
||||
// crossReferenceIssueNumericPattern matches string that references a numeric issue in a different repository
|
||||
// e.g. org/repo#12345
|
||||
crossReferenceIssueNumericPattern = regexp.MustCompile(`(?:\s|^|\(|\[)([0-9a-zA-Z-_\.]+/[0-9a-zA-Z-_\.]+[#!][0-9]+)(?:\s|$|\)|\]|[:;,.?!]\s|[:;,.?!]$)`)
|
||||
// crossReferenceCommitPattern matches a string that references a commit in a different repository
|
||||
// e.g. go-gitea/gitea@d8a994ef, go-gitea/gitea@d8a994ef243349f321568f9e36d5c3f444b99cae (7-40 characters)
|
||||
crossReferenceCommitPattern = regexp.MustCompile(`(?:\s|^|\(|\[)([0-9a-zA-Z-_\.]+)/([0-9a-zA-Z-_\.]+)@([0-9a-f]{7,64})(?:\s|$|\)|\]|[:;,.?!]\s|[:;,.?!]$)`)
|
||||
// spaceTrimmedPattern let's find the trailing space
|
||||
spaceTrimmedPattern = regexp.MustCompile(`(?:.*[0-9a-zA-Z-_])\s`)
|
||||
// timeLogPattern matches string for time tracking
|
||||
timeLogPattern = regexp.MustCompile(`(?:\s|^|\(|\[)(@([0-9]+([\.,][0-9]+)?(w|d|m|h))+)(?:\s|$|\)|\]|[:;,.?!]\s|[:;,.?!]$)`)
|
||||
|
||||
issueCloseKeywordsPat, issueReopenKeywordsPat *regexp.Regexp
|
||||
issueKeywordsOnce sync.Once
|
||||
|
||||
giteaHostInit sync.Once
|
||||
giteaHost string
|
||||
giteaIssuePullPattern *regexp.Regexp
|
||||
|
||||
actionStrings = []string{
|
||||
"none",
|
||||
"closes",
|
||||
"reopens",
|
||||
"neutered",
|
||||
}
|
||||
)
|
||||
|
||||
// XRefAction represents the kind of effect a cross reference has once is resolved
|
||||
type XRefAction int64
|
||||
|
||||
const (
|
||||
// XRefActionNone means the cross-reference is simply a comment
|
||||
XRefActionNone XRefAction = iota // 0
|
||||
// XRefActionCloses means the cross-reference should close an issue if it is resolved
|
||||
XRefActionCloses // 1
|
||||
// XRefActionReopens means the cross-reference should reopen an issue if it is resolved
|
||||
XRefActionReopens // 2
|
||||
// XRefActionNeutered means the cross-reference will no longer affect the source
|
||||
XRefActionNeutered // 3
|
||||
)
|
||||
|
||||
func (a XRefAction) String() string {
|
||||
return actionStrings[a]
|
||||
}
|
||||
|
||||
// IssueReference contains an unverified cross-reference to a local issue or pull request
|
||||
type IssueReference struct {
|
||||
Index int64
|
||||
Owner string
|
||||
Name string
|
||||
Action XRefAction
|
||||
TimeLog string
|
||||
}
|
||||
|
||||
// RenderizableReference contains an unverified cross-reference to with rendering information
|
||||
// The IsPull member means that a `!num` reference was used instead of `#num`.
|
||||
// This kind of reference is used to make pulls available when an external issue tracker
|
||||
// is used. Otherwise, `#` and `!` are completely interchangeable.
|
||||
type RenderizableReference struct {
|
||||
Issue string
|
||||
Owner string
|
||||
Name string
|
||||
CommitSha string
|
||||
IsPull bool
|
||||
RefLocation *RefSpan
|
||||
Action XRefAction
|
||||
ActionLocation *RefSpan
|
||||
}
|
||||
|
||||
type rawReference struct {
|
||||
index int64
|
||||
owner string
|
||||
name string
|
||||
isPull bool
|
||||
action XRefAction
|
||||
issue string
|
||||
refLocation *RefSpan
|
||||
actionLocation *RefSpan
|
||||
timeLog string
|
||||
}
|
||||
|
||||
func rawToIssueReferenceList(reflist []*rawReference) []IssueReference {
|
||||
refarr := make([]IssueReference, len(reflist))
|
||||
for i, r := range reflist {
|
||||
refarr[i] = IssueReference{
|
||||
Index: r.index,
|
||||
Owner: r.owner,
|
||||
Name: r.name,
|
||||
Action: r.action,
|
||||
TimeLog: r.timeLog,
|
||||
}
|
||||
}
|
||||
return refarr
|
||||
}
|
||||
|
||||
// RefSpan is the position where the reference was found within the parsed text
|
||||
type RefSpan struct {
|
||||
Start int
|
||||
End int
|
||||
}
|
||||
|
||||
func makeKeywordsPat(words []string) *regexp.Regexp {
|
||||
acceptedWords := parseKeywords(words)
|
||||
if len(acceptedWords) == 0 {
|
||||
// Never match
|
||||
return nil
|
||||
}
|
||||
return regexp.MustCompile(`(?i)(?:\s|^|\(|\[)(` + strings.Join(acceptedWords, `|`) + `):? $`)
|
||||
}
|
||||
|
||||
func parseKeywords(words []string) []string {
|
||||
acceptedWords := make([]string, 0, 5)
|
||||
wordPat := regexp.MustCompile(`^[\pL]+$`)
|
||||
for _, word := range words {
|
||||
word = strings.ToLower(strings.TrimSpace(word))
|
||||
// Accept Unicode letter class runes (a-z, á, à, ä, )
|
||||
if wordPat.MatchString(word) {
|
||||
acceptedWords = append(acceptedWords, word)
|
||||
} else {
|
||||
log.Info("Invalid keyword: %s", word)
|
||||
}
|
||||
}
|
||||
return acceptedWords
|
||||
}
|
||||
|
||||
func newKeywords() {
|
||||
issueKeywordsOnce.Do(func() {
|
||||
// Delay initialization until after the settings module is initialized
|
||||
doNewKeywords(setting.Repository.PullRequest.CloseKeywords, setting.Repository.PullRequest.ReopenKeywords)
|
||||
})
|
||||
}
|
||||
|
||||
func doNewKeywords(closeKeywords, reopenKeywords []string) {
|
||||
issueCloseKeywordsPat = makeKeywordsPat(closeKeywords)
|
||||
issueReopenKeywordsPat = makeKeywordsPat(reopenKeywords)
|
||||
}
|
||||
|
||||
// getGiteaHostName returns a normalized string with the local host name, with no scheme or port information
|
||||
func getGiteaHostName() string {
|
||||
giteaHostInit.Do(func() {
|
||||
if uapp, err := url.Parse(setting.AppURL); err == nil {
|
||||
giteaHost = strings.ToLower(uapp.Host)
|
||||
giteaIssuePullPattern = regexp.MustCompile(
|
||||
`(\s|^|\(|\[)` +
|
||||
regexp.QuoteMeta(strings.TrimSpace(setting.AppURL)) +
|
||||
`([0-9a-zA-Z-_\.]+/[0-9a-zA-Z-_\.]+)/` +
|
||||
`((?:issues)|(?:pulls))/([0-9]+)(?:\s|$|\)|\]|[:;,.?!]\s|[:;,.?!]$)`)
|
||||
} else {
|
||||
giteaHost = ""
|
||||
giteaIssuePullPattern = nil
|
||||
}
|
||||
})
|
||||
return giteaHost
|
||||
}
|
||||
|
||||
// getGiteaIssuePullPattern
|
||||
func getGiteaIssuePullPattern() *regexp.Regexp {
|
||||
getGiteaHostName()
|
||||
return giteaIssuePullPattern
|
||||
}
|
||||
|
||||
// FindAllMentionsMarkdown matches mention patterns in given content and
|
||||
// returns a list of found unvalidated user names **not including** the @ prefix.
|
||||
func FindAllMentionsMarkdown(content string) []string {
|
||||
bcontent, _ := mdstripper.StripMarkdownBytes([]byte(content))
|
||||
locations := FindAllMentionsBytes(bcontent)
|
||||
mentions := make([]string, len(locations))
|
||||
for i, val := range locations {
|
||||
mentions[i] = string(bcontent[val.Start+1 : val.End])
|
||||
}
|
||||
return mentions
|
||||
}
|
||||
|
||||
// FindAllMentionsBytes matches mention patterns in given content
|
||||
// and returns a list of locations for the unvalidated user names, including the @ prefix.
|
||||
func FindAllMentionsBytes(content []byte) []RefSpan {
|
||||
// Sadly we can't use FindAllSubmatchIndex because our pattern checks for starting and
|
||||
// trailing spaces (\s@mention,\s), so if we get two consecutive references, the space
|
||||
// from the second reference will be "eaten" by the first one:
|
||||
// ...\s@mention1\s@mention2\s... --> ...`\s@mention1\s`, (not) `@mention2,\s...`
|
||||
ret := make([]RefSpan, 0, 5)
|
||||
pos := 0
|
||||
for {
|
||||
match := mentionPattern.FindSubmatchIndex(content[pos:])
|
||||
if match == nil {
|
||||
break
|
||||
}
|
||||
ret = append(ret, RefSpan{Start: match[2] + pos, End: match[3] + pos})
|
||||
notrail := spaceTrimmedPattern.FindSubmatchIndex(content[match[2]+pos : match[3]+pos])
|
||||
if notrail == nil {
|
||||
pos = match[3] + pos
|
||||
} else {
|
||||
pos = match[3] + pos + notrail[1] - notrail[3]
|
||||
}
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
// FindFirstMentionBytes matches the first mention in then given content
|
||||
// and returns the location of the unvalidated user name, including the @ prefix.
|
||||
func FindFirstMentionBytes(content []byte) (bool, RefSpan) {
|
||||
mention := mentionPattern.FindSubmatchIndex(content)
|
||||
if mention == nil {
|
||||
return false, RefSpan{}
|
||||
}
|
||||
return true, RefSpan{Start: mention[2], End: mention[3]}
|
||||
}
|
||||
|
||||
// FindAllIssueReferencesMarkdown strips content from markdown markup
|
||||
// and returns a list of unvalidated references found in it.
|
||||
func FindAllIssueReferencesMarkdown(content string) []IssueReference {
|
||||
return rawToIssueReferenceList(findAllIssueReferencesMarkdown(content))
|
||||
}
|
||||
|
||||
func findAllIssueReferencesMarkdown(content string) []*rawReference {
|
||||
bcontent, links := mdstripper.StripMarkdownBytes([]byte(content))
|
||||
return findAllIssueReferencesBytes(bcontent, links, []byte(content))
|
||||
}
|
||||
|
||||
func convertFullHTMLReferencesToShortRefs(re *regexp.Regexp, contentBytes *[]byte) {
|
||||
// We will iterate through the content, rewrite and simplify full references.
|
||||
//
|
||||
// We want to transform something like:
|
||||
//
|
||||
// this is a https://ourgitea.com/git/owner/repo/issues/123456789, foo
|
||||
// https://ourgitea.com/git/owner/repo/pulls/123456789
|
||||
//
|
||||
// Into something like:
|
||||
//
|
||||
// this is a #123456789, foo
|
||||
// !123456789
|
||||
|
||||
pos := 0
|
||||
for {
|
||||
// re looks for something like: (\s|^|\(|\[)https://ourgitea.com/git/(owner/repo)/(issues)/(123456789)(?:\s|$|\)|\]|[:;,.?!]\s|[:;,.?!]$)
|
||||
match := re.FindSubmatchIndex((*contentBytes)[pos:])
|
||||
if match == nil {
|
||||
break
|
||||
}
|
||||
// match is a bunch of indices into the content from pos onwards so
|
||||
// to simplify things let's just add pos to all of the indices in match
|
||||
for i := range match {
|
||||
match[i] += pos
|
||||
}
|
||||
|
||||
// match[0]-match[1] is whole string
|
||||
// match[2]-match[3] is preamble
|
||||
|
||||
// move the position to the end of the preamble
|
||||
pos = match[3]
|
||||
|
||||
// match[4]-match[5] is owner/repo
|
||||
// now copy the owner/repo to end of the preamble
|
||||
endPos := pos + match[5] - match[4]
|
||||
copy((*contentBytes)[pos:endPos], (*contentBytes)[match[4]:match[5]])
|
||||
|
||||
// move the current position to the end of the newly copied owner/repo
|
||||
pos = endPos
|
||||
|
||||
// Now set the issue/pull marker:
|
||||
//
|
||||
// match[6]-match[7] == 'issues'
|
||||
(*contentBytes)[pos] = '#'
|
||||
if string((*contentBytes)[match[6]:match[7]]) == "pulls" {
|
||||
(*contentBytes)[pos] = '!'
|
||||
}
|
||||
pos++
|
||||
|
||||
// Then add the issue/pull number
|
||||
//
|
||||
// match[8]-match[9] is the number
|
||||
endPos = pos + match[9] - match[8]
|
||||
copy((*contentBytes)[pos:endPos], (*contentBytes)[match[8]:match[9]])
|
||||
|
||||
// Now copy what's left at the end of the string to the new end position
|
||||
copy((*contentBytes)[endPos:], (*contentBytes)[match[9]:])
|
||||
// now we reset the length
|
||||
|
||||
// our new section has length endPos - match[3]
|
||||
// our old section has length match[9] - match[3]
|
||||
*contentBytes = (*contentBytes)[:len(*contentBytes)-match[9]+endPos]
|
||||
pos = endPos
|
||||
}
|
||||
}
|
||||
|
||||
// FindAllIssueReferences returns a list of unvalidated references found in a string.
|
||||
func FindAllIssueReferences(content string) []IssueReference {
|
||||
// Need to convert fully qualified html references to local system to #/! short codes
|
||||
contentBytes := []byte(content)
|
||||
if re := getGiteaIssuePullPattern(); re != nil {
|
||||
convertFullHTMLReferencesToShortRefs(re, &contentBytes)
|
||||
} else {
|
||||
log.Debug("No GiteaIssuePullPattern pattern")
|
||||
}
|
||||
return rawToIssueReferenceList(findAllIssueReferencesBytes(contentBytes, []string{}, nil))
|
||||
}
|
||||
|
||||
// FindRenderizableReferenceNumeric returns the first unvalidated reference found in a string.
|
||||
func FindRenderizableReferenceNumeric(content string, prOnly, crossLinkOnly bool) *RenderizableReference {
|
||||
var match []int
|
||||
if !crossLinkOnly {
|
||||
match = issueNumericPattern.FindStringSubmatchIndex(content)
|
||||
}
|
||||
if match == nil {
|
||||
if match = crossReferenceIssueNumericPattern.FindStringSubmatchIndex(content); match == nil {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
r := getCrossReference(util.UnsafeStringToBytes(content), match[2], match[3], false, prOnly)
|
||||
if r == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return &RenderizableReference{
|
||||
Issue: r.issue,
|
||||
Owner: r.owner,
|
||||
Name: r.name,
|
||||
IsPull: r.isPull,
|
||||
RefLocation: r.refLocation,
|
||||
Action: r.action,
|
||||
ActionLocation: r.actionLocation,
|
||||
}
|
||||
}
|
||||
|
||||
// FindRenderizableCommitCrossReference returns the first unvalidated commit cross reference found in a string.
|
||||
func FindRenderizableCommitCrossReference(content string) (bool, *RenderizableReference) {
|
||||
m := crossReferenceCommitPattern.FindStringSubmatchIndex(content)
|
||||
if len(m) < 8 {
|
||||
return false, nil
|
||||
}
|
||||
|
||||
return true, &RenderizableReference{
|
||||
Owner: content[m[2]:m[3]],
|
||||
Name: content[m[4]:m[5]],
|
||||
CommitSha: content[m[6]:m[7]],
|
||||
RefLocation: &RefSpan{Start: m[2], End: m[7]},
|
||||
}
|
||||
}
|
||||
|
||||
// FindRenderizableReferenceRegexp returns the first regexp unvalidated references found in a string.
|
||||
func FindRenderizableReferenceRegexp(content string, pattern *regexp.Regexp) *RenderizableReference {
|
||||
match := pattern.FindStringSubmatchIndex(content)
|
||||
if len(match) < 4 {
|
||||
return nil
|
||||
}
|
||||
|
||||
action, location := findActionKeywords([]byte(content), match[2])
|
||||
return &RenderizableReference{
|
||||
Issue: content[match[2]:match[3]],
|
||||
RefLocation: &RefSpan{Start: match[0], End: match[1]},
|
||||
Action: action,
|
||||
ActionLocation: location,
|
||||
IsPull: false,
|
||||
}
|
||||
}
|
||||
|
||||
// FindRenderizableReferenceAlphanumeric returns the first alphanumeric unvalidated references found in a string.
|
||||
func FindRenderizableReferenceAlphanumeric(content string) *RenderizableReference {
|
||||
match := issueAlphanumericPattern.FindStringSubmatchIndex(content)
|
||||
if match == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
action, location := findActionKeywords([]byte(content), match[2])
|
||||
return &RenderizableReference{
|
||||
Issue: content[match[2]:match[3]],
|
||||
RefLocation: &RefSpan{Start: match[2], End: match[3]},
|
||||
Action: action,
|
||||
ActionLocation: location,
|
||||
IsPull: false,
|
||||
}
|
||||
}
|
||||
|
||||
// FindAllIssueReferencesBytes returns a list of unvalidated references found in a byte slice.
|
||||
// originalContent is optional and used to detect closing/reopening keywords for URL references.
|
||||
func findAllIssueReferencesBytes(content []byte, links []string, originalContent []byte) []*rawReference {
|
||||
ret := make([]*rawReference, 0, 10)
|
||||
pos := 0
|
||||
|
||||
// Sadly we can't use FindAllSubmatchIndex because our pattern checks for starting and
|
||||
// trailing spaces (\s#ref,\s), so if we get two consecutive references, the space
|
||||
// from the second reference will be "eaten" by the first one:
|
||||
// ...\s#ref1\s#ref2\s... --> ...`\s#ref1\s`, (not) `#ref2,\s...`
|
||||
for {
|
||||
match := issueNumericPattern.FindSubmatchIndex(content[pos:])
|
||||
if match == nil {
|
||||
break
|
||||
}
|
||||
if ref := getCrossReference(content, match[2]+pos, match[3]+pos, false, false); ref != nil {
|
||||
ret = append(ret, ref)
|
||||
}
|
||||
notrail := spaceTrimmedPattern.FindSubmatchIndex(content[match[2]+pos : match[3]+pos])
|
||||
if notrail == nil {
|
||||
pos = match[3] + pos
|
||||
} else {
|
||||
pos = match[3] + pos + notrail[1] - notrail[3]
|
||||
}
|
||||
}
|
||||
|
||||
pos = 0
|
||||
|
||||
for {
|
||||
match := crossReferenceIssueNumericPattern.FindSubmatchIndex(content[pos:])
|
||||
if match == nil {
|
||||
break
|
||||
}
|
||||
if ref := getCrossReference(content, match[2]+pos, match[3]+pos, false, false); ref != nil {
|
||||
ret = append(ret, ref)
|
||||
}
|
||||
notrail := spaceTrimmedPattern.FindSubmatchIndex(content[match[2]+pos : match[3]+pos])
|
||||
if notrail == nil {
|
||||
pos = match[3] + pos
|
||||
} else {
|
||||
pos = match[3] + pos + notrail[1] - notrail[3]
|
||||
}
|
||||
}
|
||||
|
||||
localhost := getGiteaHostName()
|
||||
for _, link := range links {
|
||||
if u, err := url.Parse(link); err == nil {
|
||||
// Note: we're not attempting to match the URL scheme (http/https)
|
||||
host := strings.ToLower(u.Host)
|
||||
if host != "" && host != localhost {
|
||||
continue
|
||||
}
|
||||
parts := strings.Split(u.EscapedPath(), "/")
|
||||
// /user/repo/issues/3
|
||||
if len(parts) != 5 || parts[0] != "" {
|
||||
continue
|
||||
}
|
||||
var sep string
|
||||
switch parts[3] {
|
||||
case "issues":
|
||||
sep = "#"
|
||||
case "pulls":
|
||||
sep = "!"
|
||||
default:
|
||||
continue
|
||||
}
|
||||
refBytes := []byte(parts[1] + "/" + parts[2] + sep + parts[4])
|
||||
if ref := getCrossReference(refBytes, 0, len(refBytes), true, false); ref != nil {
|
||||
ref.refLocation = nil
|
||||
// Detect closing/reopening keywords by finding the URL position in original content
|
||||
if originalContent != nil {
|
||||
if idx := bytes.Index(originalContent, []byte(link)); idx > 0 {
|
||||
// For markdown links [text](url), find the opening bracket before the URL
|
||||
// to properly detect keywords like "closes [text](url)"
|
||||
searchStart := idx
|
||||
if idx >= 2 && originalContent[idx-1] == '(' {
|
||||
// Find the matching '[' for this markdown link
|
||||
bracketIdx := bytes.LastIndex(originalContent[:idx-1], []byte{'['})
|
||||
if bracketIdx >= 0 {
|
||||
searchStart = bracketIdx
|
||||
}
|
||||
}
|
||||
action, location := findActionKeywords(originalContent, searchStart)
|
||||
ref.action = action
|
||||
ref.actionLocation = location
|
||||
}
|
||||
}
|
||||
ret = append(ret, ref)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if len(ret) == 0 {
|
||||
return ret
|
||||
}
|
||||
|
||||
pos = 0
|
||||
|
||||
for {
|
||||
match := timeLogPattern.FindSubmatchIndex(content[pos:])
|
||||
if match == nil {
|
||||
break
|
||||
}
|
||||
|
||||
timeLogEntry := string(content[match[2]+pos+1 : match[3]+pos])
|
||||
|
||||
var f *rawReference
|
||||
for _, ref := range ret {
|
||||
if ref.refLocation != nil && ref.refLocation.End < match[2]+pos && (f == nil || f.refLocation.End < ref.refLocation.End) {
|
||||
f = ref
|
||||
}
|
||||
}
|
||||
|
||||
pos = match[1] + pos
|
||||
|
||||
if f == nil {
|
||||
f = ret[0]
|
||||
}
|
||||
|
||||
if len(f.timeLog) == 0 {
|
||||
f.timeLog = timeLogEntry
|
||||
}
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
|
||||
func getCrossReference(content []byte, start, end int, fromLink, prOnly bool) *rawReference {
|
||||
sep := bytes.IndexAny(content[start:end], "#!")
|
||||
if sep < 0 {
|
||||
return nil
|
||||
}
|
||||
isPull := content[start+sep] == '!'
|
||||
if prOnly && !isPull {
|
||||
return nil
|
||||
}
|
||||
repo := string(content[start : start+sep])
|
||||
issue := string(content[start+sep+1 : end])
|
||||
index, err := strconv.ParseInt(issue, 10, 64)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
if repo == "" {
|
||||
if fromLink {
|
||||
// Markdown links must specify owner/repo
|
||||
return nil
|
||||
}
|
||||
action, location := findActionKeywords(content, start)
|
||||
return &rawReference{
|
||||
index: index,
|
||||
action: action,
|
||||
issue: issue,
|
||||
isPull: isPull,
|
||||
refLocation: &RefSpan{Start: start, End: end},
|
||||
actionLocation: location,
|
||||
}
|
||||
}
|
||||
parts := strings.Split(strings.ToLower(repo), "/")
|
||||
if len(parts) != 2 {
|
||||
return nil
|
||||
}
|
||||
owner, name := parts[0], parts[1]
|
||||
if !validNamePattern.MatchString(owner) || !validNamePattern.MatchString(name) {
|
||||
return nil
|
||||
}
|
||||
action, location := findActionKeywords(content, start)
|
||||
return &rawReference{
|
||||
index: index,
|
||||
owner: owner,
|
||||
name: name,
|
||||
action: action,
|
||||
issue: issue,
|
||||
isPull: isPull,
|
||||
refLocation: &RefSpan{Start: start, End: end},
|
||||
actionLocation: location,
|
||||
}
|
||||
}
|
||||
|
||||
func findActionKeywords(content []byte, start int) (XRefAction, *RefSpan) {
|
||||
newKeywords()
|
||||
var m []int
|
||||
if issueCloseKeywordsPat != nil {
|
||||
m = issueCloseKeywordsPat.FindSubmatchIndex(content[:start])
|
||||
if m != nil {
|
||||
return XRefActionCloses, &RefSpan{Start: m[2], End: m[3]}
|
||||
}
|
||||
}
|
||||
if issueReopenKeywordsPat != nil {
|
||||
m = issueReopenKeywordsPat.FindSubmatchIndex(content[:start])
|
||||
if m != nil {
|
||||
return XRefActionReopens, &RefSpan{Start: m[2], End: m[3]}
|
||||
}
|
||||
}
|
||||
return XRefActionNone, nil
|
||||
}
|
||||
|
||||
// IsXrefActionable returns true if the xref action is actionable (i.e. produces a result when resolved)
|
||||
func IsXrefActionable(ref *RenderizableReference, extTracker bool) bool {
|
||||
if extTracker {
|
||||
// External issues cannot be automatically closed
|
||||
return false
|
||||
}
|
||||
return ref.Action == XRefActionCloses || ref.Action == XRefActionReopens
|
||||
}
|
||||
@@ -0,0 +1,616 @@
|
||||
// Copyright 2019 The Gitea Authors. All rights reserved.
|
||||
// SPDX-License-Identifier: MIT
|
||||
|
||||
package references
|
||||
|
||||
import (
|
||||
"regexp"
|
||||
"testing"
|
||||
|
||||
"gitea.dev/modules/setting"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
type testFixture struct {
|
||||
input string
|
||||
expected []testResult
|
||||
}
|
||||
|
||||
type testResult struct {
|
||||
Index int64
|
||||
Owner string
|
||||
Name string
|
||||
Issue string
|
||||
IsPull bool
|
||||
Action XRefAction
|
||||
RefLocation *RefSpan
|
||||
ActionLocation *RefSpan
|
||||
TimeLog string
|
||||
}
|
||||
|
||||
func TestConvertFullHTMLReferencesToShortRefs(t *testing.T) {
|
||||
re := regexp.MustCompile(`(\s|^|\(|\[)` +
|
||||
regexp.QuoteMeta("https://ourgitea.com/git/") +
|
||||
`([0-9a-zA-Z-_\.]+/[0-9a-zA-Z-_\.]+)/` +
|
||||
`((?:issues)|(?:pulls))/([0-9]+)(?:\s|$|\)|\]|[:;,.?!]\s|[:;,.?!]$)`)
|
||||
test := `this is a https://ourgitea.com/git/owner/repo/issues/123456789, foo
|
||||
https://ourgitea.com/git/owner/repo/pulls/123456789
|
||||
And https://ourgitea.com/git/owner/repo/pulls/123
|
||||
`
|
||||
expect := `this is a owner/repo#123456789, foo
|
||||
owner/repo!123456789
|
||||
And owner/repo!123
|
||||
`
|
||||
|
||||
contentBytes := []byte(test)
|
||||
convertFullHTMLReferencesToShortRefs(re, &contentBytes)
|
||||
result := string(contentBytes)
|
||||
assert.Equal(t, expect, result)
|
||||
}
|
||||
|
||||
func TestFindAllIssueReferences(t *testing.T) {
|
||||
fixtures := []testFixture{
|
||||
{
|
||||
"Simply closes: #29 yes",
|
||||
[]testResult{
|
||||
{29, "", "", "29", false, XRefActionCloses, &RefSpan{Start: 15, End: 18}, &RefSpan{Start: 7, End: 13}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"Simply closes: !29 yes",
|
||||
[]testResult{
|
||||
{29, "", "", "29", true, XRefActionCloses, &RefSpan{Start: 15, End: 18}, &RefSpan{Start: 7, End: 13}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
" #124 yes, this is a reference.",
|
||||
[]testResult{
|
||||
{124, "", "", "124", false, XRefActionNone, &RefSpan{Start: 0, End: 4}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"```\nThis is a code block.\n#723 no, it's a code block.```",
|
||||
[]testResult{},
|
||||
},
|
||||
{
|
||||
"This `#724` no, it's inline code.",
|
||||
[]testResult{},
|
||||
},
|
||||
{
|
||||
"This org3/repo4#200 yes.",
|
||||
[]testResult{
|
||||
{200, "org3", "repo4", "200", false, XRefActionNone, &RefSpan{Start: 5, End: 19}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This org3/repo4!200 yes.",
|
||||
[]testResult{
|
||||
{200, "org3", "repo4", "200", true, XRefActionNone, &RefSpan{Start: 5, End: 19}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This [one](#919) no, this is a URL fragment.",
|
||||
[]testResult{},
|
||||
},
|
||||
{
|
||||
"This [two](/user2/repo1/issues/921) yes.",
|
||||
[]testResult{
|
||||
{921, "user2", "repo1", "921", false, XRefActionNone, nil, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This [three](/user2/repo1/pulls/922) yes.",
|
||||
[]testResult{
|
||||
{922, "user2", "repo1", "922", true, XRefActionNone, nil, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This [four](http://gitea.com:3000/org3/repo4/issues/203) yes.",
|
||||
[]testResult{
|
||||
{203, "org3", "repo4", "203", false, XRefActionNone, nil, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This [five](http://github.com/org3/repo4/issues/204) no.",
|
||||
[]testResult{},
|
||||
},
|
||||
{
|
||||
"This http://gitea.com:3000/user4/repo5/201 no, bad URL.",
|
||||
[]testResult{},
|
||||
},
|
||||
{
|
||||
"This http://gitea.com:3000/user4/repo5/pulls/202 yes.",
|
||||
[]testResult{
|
||||
{202, "user4", "repo5", "202", true, XRefActionNone, nil, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This http://gitea.com:3000/user4/repo5/pulls/202 yes. http://gitea.com:3000/user4/repo5/pulls/203 no",
|
||||
[]testResult{
|
||||
{202, "user4", "repo5", "202", true, XRefActionNone, nil, nil, ""},
|
||||
{203, "user4", "repo5", "203", true, XRefActionNone, nil, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This http://GiTeA.COM:3000/user4/repo6/pulls/205 yes.",
|
||||
[]testResult{
|
||||
{205, "user4", "repo6", "205", true, XRefActionNone, nil, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"Reopens #15 yes",
|
||||
[]testResult{
|
||||
{15, "", "", "15", false, XRefActionReopens, &RefSpan{Start: 8, End: 11}, &RefSpan{Start: 0, End: 7}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This closes #20 for you yes",
|
||||
[]testResult{
|
||||
{20, "", "", "20", false, XRefActionCloses, &RefSpan{Start: 12, End: 15}, &RefSpan{Start: 5, End: 11}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"Do you fix org6/repo6#300 ? yes",
|
||||
[]testResult{
|
||||
{300, "org6", "repo6", "300", false, XRefActionCloses, &RefSpan{Start: 11, End: 25}, &RefSpan{Start: 7, End: 10}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"For 999 #1235 no keyword, but yes",
|
||||
[]testResult{
|
||||
{1235, "", "", "1235", false, XRefActionNone, &RefSpan{Start: 8, End: 13}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"For [!123] yes",
|
||||
[]testResult{
|
||||
{123, "", "", "123", true, XRefActionNone, &RefSpan{Start: 5, End: 9}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"For (#345) yes",
|
||||
[]testResult{
|
||||
{345, "", "", "345", false, XRefActionNone, &RefSpan{Start: 5, End: 9}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"For #22,#23 no, neither #28:#29 or !30!31#32;33 should",
|
||||
[]testResult{},
|
||||
},
|
||||
{
|
||||
"For #24, and #25. yes; also #26; #27? #28! and #29: should",
|
||||
[]testResult{
|
||||
{24, "", "", "24", false, XRefActionNone, &RefSpan{Start: 4, End: 7}, nil, ""},
|
||||
{25, "", "", "25", false, XRefActionNone, &RefSpan{Start: 13, End: 16}, nil, ""},
|
||||
{26, "", "", "26", false, XRefActionNone, &RefSpan{Start: 28, End: 31}, nil, ""},
|
||||
{27, "", "", "27", false, XRefActionNone, &RefSpan{Start: 33, End: 36}, nil, ""},
|
||||
{28, "", "", "28", false, XRefActionNone, &RefSpan{Start: 38, End: 41}, nil, ""},
|
||||
{29, "", "", "29", false, XRefActionNone, &RefSpan{Start: 47, End: 50}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This org3/repo4#200, yes.",
|
||||
[]testResult{
|
||||
{200, "org3", "repo4", "200", false, XRefActionNone, &RefSpan{Start: 5, End: 19}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"Merge pull request '#12345 My fix for a bug' (!1337) from feature-branch into main",
|
||||
[]testResult{
|
||||
{12345, "", "", "12345", false, XRefActionNone, &RefSpan{Start: 20, End: 26}, nil, ""},
|
||||
{1337, "", "", "1337", true, XRefActionNone, &RefSpan{Start: 46, End: 51}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"Which abc. #9434 same as above",
|
||||
[]testResult{
|
||||
{9434, "", "", "9434", false, XRefActionNone, &RefSpan{Start: 11, End: 16}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This closes #600 and reopens #599",
|
||||
[]testResult{
|
||||
{600, "", "", "600", false, XRefActionCloses, &RefSpan{Start: 12, End: 16}, &RefSpan{Start: 5, End: 11}, ""},
|
||||
{599, "", "", "599", false, XRefActionReopens, &RefSpan{Start: 29, End: 33}, &RefSpan{Start: 21, End: 28}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This fixes #100 spent @40m and reopens #101, also fixes #102 spent @4h15m",
|
||||
[]testResult{
|
||||
{100, "", "", "100", false, XRefActionCloses, &RefSpan{Start: 11, End: 15}, &RefSpan{Start: 5, End: 10}, "40m"},
|
||||
{101, "", "", "101", false, XRefActionReopens, &RefSpan{Start: 39, End: 43}, &RefSpan{Start: 31, End: 38}, ""},
|
||||
{102, "", "", "102", false, XRefActionCloses, &RefSpan{Start: 56, End: 60}, &RefSpan{Start: 50, End: 55}, "4h15m"},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
testFixtures(t, fixtures, "default")
|
||||
|
||||
// Test closing/reopening keywords with URLs (issue #27549)
|
||||
// Uses the same AppURL as testFixtures (https://gitea.com:3000/)
|
||||
urlFixtures := []testFixture{
|
||||
{
|
||||
"Closes [this issue](https://gitea.com:3000/user/repo/issues/123)",
|
||||
[]testResult{
|
||||
{123, "user", "repo", "123", false, XRefActionCloses, nil, &RefSpan{Start: 0, End: 6}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"This fixes [#456](https://gitea.com:3000/org/project/issues/456)",
|
||||
[]testResult{
|
||||
{456, "org", "project", "456", false, XRefActionCloses, nil, &RefSpan{Start: 5, End: 10}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"Reopens [PR](https://gitea.com:3000/owner/repo/pulls/789)",
|
||||
[]testResult{
|
||||
{789, "owner", "repo", "789", true, XRefActionReopens, nil, &RefSpan{Start: 0, End: 7}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"See [issue](https://gitea.com:3000/user/repo/issues/100) but closes [another](https://gitea.com:3000/user/repo/issues/200)",
|
||||
[]testResult{
|
||||
{100, "user", "repo", "100", false, XRefActionNone, nil, nil, ""},
|
||||
{200, "user", "repo", "200", false, XRefActionCloses, nil, &RefSpan{Start: 61, End: 67}, ""},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
testFixtures(t, urlFixtures, "url-keywords")
|
||||
|
||||
// Test bare URLs (not markdown links) with closing keywords
|
||||
// These use FindAllIssueReferences (non-markdown) which converts full URLs to short refs first
|
||||
setting.AppURL = "https://gitea.com:3000/"
|
||||
bareURLTests := []struct {
|
||||
name string
|
||||
input string
|
||||
expected XRefAction
|
||||
}{
|
||||
{"Fixes bare URL", "Fixes https://gitea.com:3000/org/project/issues/456", XRefActionCloses},
|
||||
{"Fixes with colon", "Fixes: https://gitea.com:3000/org/project/issues/456", XRefActionCloses},
|
||||
{"Closes bare URL", "Closes https://gitea.com:3000/user/repo/issues/123", XRefActionCloses},
|
||||
{"Closes with colon", "Closes: https://gitea.com:3000/user/repo/issues/123", XRefActionCloses},
|
||||
}
|
||||
|
||||
for _, tt := range bareURLTests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
refs := FindAllIssueReferences(tt.input)
|
||||
assert.Len(t, refs, 1, "Expected 1 reference for: %s", tt.input)
|
||||
if len(refs) > 0 {
|
||||
assert.Equal(t, tt.expected, refs[0].Action, "Expected action %v for: %s", tt.expected, tt.input)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
type alnumFixture struct {
|
||||
input string
|
||||
issue string
|
||||
refLocation *RefSpan
|
||||
action XRefAction
|
||||
actionLocation *RefSpan
|
||||
}
|
||||
|
||||
alnumFixtures := []alnumFixture{
|
||||
{
|
||||
"This ref ABC-123 is alphanumeric",
|
||||
"ABC-123", &RefSpan{Start: 9, End: 16},
|
||||
XRefActionNone, nil,
|
||||
},
|
||||
{
|
||||
"This closes ABCD-1234 alphanumeric",
|
||||
"ABCD-1234", &RefSpan{Start: 12, End: 21},
|
||||
XRefActionCloses, &RefSpan{Start: 5, End: 11},
|
||||
},
|
||||
}
|
||||
|
||||
for _, fixture := range alnumFixtures {
|
||||
ref := FindRenderizableReferenceAlphanumeric(fixture.input)
|
||||
if fixture.issue == "" {
|
||||
assert.Nil(t, ref, "Failed to parse: {%s}", fixture.input)
|
||||
} else {
|
||||
assert.Equal(t, fixture.issue, ref.Issue, "Failed to parse: {%s}", fixture.input)
|
||||
assert.Equal(t, fixture.refLocation, ref.RefLocation, "Failed to parse: {%s}", fixture.input)
|
||||
assert.Equal(t, fixture.action, ref.Action, "Failed to parse: {%s}", fixture.input)
|
||||
assert.Equal(t, fixture.actionLocation, ref.ActionLocation, "Failed to parse: {%s}", fixture.input)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testFixtures(t *testing.T, fixtures []testFixture, context string) {
|
||||
// Save original value for other tests that may rely on it
|
||||
prevURL := setting.AppURL
|
||||
setting.AppURL = "https://gitea.com:3000/"
|
||||
|
||||
for _, fixture := range fixtures {
|
||||
expraw := make([]*rawReference, len(fixture.expected))
|
||||
for i, e := range fixture.expected {
|
||||
expraw[i] = &rawReference{
|
||||
index: e.Index,
|
||||
owner: e.Owner,
|
||||
name: e.Name,
|
||||
isPull: e.IsPull,
|
||||
action: e.Action,
|
||||
issue: e.Issue,
|
||||
refLocation: e.RefLocation,
|
||||
actionLocation: e.ActionLocation,
|
||||
timeLog: e.TimeLog,
|
||||
}
|
||||
}
|
||||
expref := rawToIssueReferenceList(expraw)
|
||||
refs := FindAllIssueReferencesMarkdown(fixture.input)
|
||||
assert.Equal(t, expref, refs, "[%s] Failed to parse: {%s}", context, fixture.input)
|
||||
rawrefs := findAllIssueReferencesMarkdown(fixture.input)
|
||||
assert.Equal(t, expraw, rawrefs, "[%s] Failed to parse: {%s}", context, fixture.input)
|
||||
}
|
||||
|
||||
// Restore for other tests that may rely on the original value
|
||||
setting.AppURL = prevURL
|
||||
}
|
||||
|
||||
func TestFindAllMentions(t *testing.T) {
|
||||
res := FindAllMentionsBytes([]byte("@tasha, @mike; @lucy: @john"))
|
||||
assert.Equal(t, []RefSpan{
|
||||
{Start: 0, End: 6},
|
||||
{Start: 8, End: 13},
|
||||
{Start: 15, End: 20},
|
||||
{Start: 22, End: 27},
|
||||
}, res)
|
||||
}
|
||||
|
||||
func TestFindRenderizableCommitCrossReference(t *testing.T) {
|
||||
cases := []struct {
|
||||
Input string
|
||||
Expected *RenderizableReference
|
||||
}{
|
||||
{
|
||||
Input: "",
|
||||
Expected: nil,
|
||||
},
|
||||
{
|
||||
Input: "test",
|
||||
Expected: nil,
|
||||
},
|
||||
{
|
||||
Input: "go-gitea/gitea@test",
|
||||
Expected: nil,
|
||||
},
|
||||
{
|
||||
Input: "go-gitea/gitea@ab1234",
|
||||
Expected: nil,
|
||||
},
|
||||
{
|
||||
Input: "go-gitea/gitea@abcd1234",
|
||||
Expected: &RenderizableReference{
|
||||
Owner: "go-gitea",
|
||||
Name: "gitea",
|
||||
CommitSha: "abcd1234",
|
||||
RefLocation: &RefSpan{Start: 0, End: 23},
|
||||
},
|
||||
},
|
||||
{
|
||||
Input: "go-gitea/gitea@abcd1234abcd1234abcd1234abcd1234abcd1234",
|
||||
Expected: &RenderizableReference{
|
||||
Owner: "go-gitea",
|
||||
Name: "gitea",
|
||||
CommitSha: "abcd1234abcd1234abcd1234abcd1234abcd1234",
|
||||
RefLocation: &RefSpan{Start: 0, End: 55},
|
||||
},
|
||||
},
|
||||
{
|
||||
Input: "go-gitea/gitea@abcd1234abcd1234abcd1234abcd1234abcd12341234512345123451234512345", // longer than 64 characters
|
||||
Expected: nil,
|
||||
},
|
||||
{
|
||||
Input: "test go-gitea/gitea@abcd1234 test",
|
||||
Expected: &RenderizableReference{
|
||||
Owner: "go-gitea",
|
||||
Name: "gitea",
|
||||
CommitSha: "abcd1234",
|
||||
RefLocation: &RefSpan{Start: 5, End: 28},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, c := range cases {
|
||||
found, ref := FindRenderizableCommitCrossReference(c.Input)
|
||||
assert.Equal(t, ref != nil, found)
|
||||
assert.Equal(t, c.Expected, ref)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegExp_mentionPattern(t *testing.T) {
|
||||
trueTestCases := []struct {
|
||||
pat string
|
||||
exp string
|
||||
}{
|
||||
{"@User", "@User"},
|
||||
{"@ANT_123", "@ANT_123"},
|
||||
{"@xxx-DiN0-z-A..uru..s-xxx", "@xxx-DiN0-z-A..uru..s-xxx"},
|
||||
{" @lol ", "@lol"},
|
||||
{" @Te-st", "@Te-st"},
|
||||
{"(@gitea)", "@gitea"},
|
||||
{"[@gitea]", "@gitea"},
|
||||
{"@gitea! this", "@gitea"},
|
||||
{"@gitea? this", "@gitea"},
|
||||
{"@gitea. this", "@gitea"},
|
||||
{"@gitea, this", "@gitea"},
|
||||
{"@gitea; this", "@gitea"},
|
||||
{"@gitea!\nthis", "@gitea"},
|
||||
{"\n@gitea?\nthis", "@gitea"},
|
||||
{"\t@gitea.\nthis", "@gitea"},
|
||||
{"@gitea,\nthis", "@gitea"},
|
||||
{"@gitea;\nthis", "@gitea"},
|
||||
{"@gitea!", "@gitea"},
|
||||
{"@gitea?", "@gitea"},
|
||||
{"@gitea.", "@gitea"},
|
||||
{"@gitea,", "@gitea"},
|
||||
{"@gitea;", "@gitea"},
|
||||
{"@gitea/team1;", "@gitea/team1"},
|
||||
{"@user's idea", "@user"},
|
||||
}
|
||||
falseTestCases := []string{
|
||||
"@ 0",
|
||||
"@ ",
|
||||
"@",
|
||||
"",
|
||||
"ABC",
|
||||
"@.ABC",
|
||||
"/home/gitea/@gitea",
|
||||
"\"@gitea\"",
|
||||
"@@gitea",
|
||||
"@gitea!this",
|
||||
"@gitea?this",
|
||||
"@gitea,this",
|
||||
"@gitea;this",
|
||||
"@gitea/team1/more",
|
||||
}
|
||||
|
||||
for _, testCase := range trueTestCases {
|
||||
found := mentionPattern.FindStringSubmatch(testCase.pat)
|
||||
assert.Equal(t, testCase.exp, found[1])
|
||||
}
|
||||
for _, testCase := range falseTestCases {
|
||||
res := mentionPattern.MatchString(testCase)
|
||||
assert.False(t, res, "[%s] should be false", testCase)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegExp_issueNumericPattern(t *testing.T) {
|
||||
trueTestCases := []string{
|
||||
"#1234",
|
||||
"#0",
|
||||
"#1234567890987654321",
|
||||
" #12",
|
||||
"#12:",
|
||||
"ref: #12: msg",
|
||||
"\"#1234\"",
|
||||
"'#1234'",
|
||||
}
|
||||
falseTestCases := []string{
|
||||
"# 1234",
|
||||
"# 0",
|
||||
"# ",
|
||||
"#",
|
||||
"#ABC",
|
||||
"#1A2B",
|
||||
"",
|
||||
"ABC",
|
||||
}
|
||||
|
||||
for _, testCase := range trueTestCases {
|
||||
assert.True(t, issueNumericPattern.MatchString(testCase))
|
||||
}
|
||||
for _, testCase := range falseTestCases {
|
||||
assert.False(t, issueNumericPattern.MatchString(testCase))
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegExp_issueAlphanumericPattern(t *testing.T) {
|
||||
trueTestCases := []string{
|
||||
"ABC-1234",
|
||||
"A-1",
|
||||
"RC-80",
|
||||
"ABCDEFGHIJ-1234567890987654321234567890",
|
||||
"ABC-123.",
|
||||
"(ABC-123)",
|
||||
"[ABC-123]",
|
||||
"ABC-123:",
|
||||
"\"ABC-123\"",
|
||||
"'ABC-123'",
|
||||
"ABC-123, unknown PR",
|
||||
}
|
||||
falseTestCases := []string{
|
||||
"RC-08",
|
||||
"PR-0",
|
||||
"ABCDEFGHIJK-1",
|
||||
"PR_1",
|
||||
"",
|
||||
"#ABC",
|
||||
"",
|
||||
"ABC",
|
||||
"GG-",
|
||||
"rm-1",
|
||||
"/home/gitea/ABC-1234",
|
||||
"MY-STRING-ABC-123",
|
||||
}
|
||||
|
||||
for _, testCase := range trueTestCases {
|
||||
assert.True(t, issueAlphanumericPattern.MatchString(testCase))
|
||||
}
|
||||
for _, testCase := range falseTestCases {
|
||||
assert.False(t, issueAlphanumericPattern.MatchString(testCase))
|
||||
}
|
||||
}
|
||||
|
||||
func TestCustomizeCloseKeywords(t *testing.T) {
|
||||
fixtures := []testFixture{
|
||||
{
|
||||
"Simplemente cierra: #29 yes",
|
||||
[]testResult{
|
||||
{29, "", "", "29", false, XRefActionCloses, &RefSpan{Start: 20, End: 23}, &RefSpan{Start: 12, End: 18}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"Closes: #123 no, this English.",
|
||||
[]testResult{
|
||||
{123, "", "", "123", false, XRefActionNone, &RefSpan{Start: 8, End: 12}, nil, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"Cerró org6/repo6#300 yes",
|
||||
[]testResult{
|
||||
{300, "org6", "repo6", "300", false, XRefActionCloses, &RefSpan{Start: 7, End: 21}, &RefSpan{Start: 0, End: 6}, ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
"Reabre org3/repo4#200 yes",
|
||||
[]testResult{
|
||||
{200, "org3", "repo4", "200", false, XRefActionReopens, &RefSpan{Start: 7, End: 21}, &RefSpan{Start: 0, End: 6}, ""},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
issueKeywordsOnce.Do(func() {})
|
||||
|
||||
doNewKeywords([]string{"cierra", "cerró"}, []string{"reabre"})
|
||||
testFixtures(t, fixtures, "spanish")
|
||||
|
||||
// Restore default settings
|
||||
doNewKeywords(setting.Repository.PullRequest.CloseKeywords, setting.Repository.PullRequest.ReopenKeywords)
|
||||
}
|
||||
|
||||
func TestParseCloseKeywords(t *testing.T) {
|
||||
// Test parsing of CloseKeywords and ReopenKeywords
|
||||
assert.Empty(t, parseKeywords([]string{""}))
|
||||
assert.Len(t, parseKeywords([]string{" aa ", " bb ", "99", "#", "", "this is", "cc"}), 3)
|
||||
|
||||
for _, test := range []struct {
|
||||
pattern string
|
||||
match string
|
||||
expected string
|
||||
}{
|
||||
{"close", "This PR will close ", "close"},
|
||||
{"cerró", "cerró ", "cerró"},
|
||||
{"cerró", "AQUÍ SE CERRÓ: ", "CERRÓ"},
|
||||
{"закрывается", "закрывается ", "закрывается"},
|
||||
{"κλείνει", "κλείνει: ", "κλείνει"},
|
||||
{"关闭", "关闭 ", "关闭"},
|
||||
{"閉じます", "閉じます ", "閉じます"},
|
||||
{",$!", "", ""},
|
||||
{"1234", "", ""},
|
||||
} {
|
||||
// The pattern only needs to match the part that precedes the reference.
|
||||
// getCrossReference() takes care of finding the reference itself.
|
||||
pat := makeKeywordsPat([]string{test.pattern})
|
||||
if test.expected == "" {
|
||||
assert.Nil(t, pat)
|
||||
} else {
|
||||
assert.NotNil(t, pat)
|
||||
res := pat.FindAllStringSubmatch(test.match, -1)
|
||||
assert.Len(t, res, 1)
|
||||
assert.Len(t, res[0], 2)
|
||||
assert.Equal(t, test.expected, res[0][1])
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user