func TestRSTComment(t *testing.T) {
tests := []struct {
comment string
expected bool
}{
{"//+rst", true},
{"// +rst", true},
{"// +rst\n", true},
{"/*+rst*/", true},
{"/* +rst */", true},
{"/* +rst */", true},
{"/*\n+rst */", true},
{"/* +rst\nfoo */", true},
{"/* foo\n+rst */", false},
{"// rst", false},
}
for i, test := range tests {
var c ast.Comment
c.Text = test.comment
cgrp := &ast.CommentGroup{List: []*ast.Comment{&c}}
_, ok := rstComment(cgrp)
if ok != test.expected {
t.Fatalf("Iteration %d: Expected %t, got %t: %q", i, test.expected, ok, test.comment)
}
}
}
func ascg(txt string) *ast.CommentGroup {
var cg ast.CommentGroup
for _, line := range strings.Split(txt, "\n") {
var cmt ast.Comment
cmt.Text = "// " + line
cg.List = append(cg.List, &cmt)
}
return &cg
}
// Rewrite rewrites files to the local path.
func (ctx *Context) rewrite() error {
if !ctx.rewriteImports {
return nil
}
if ctx.dirty {
ctx.loadPackage()
}
ctx.dirty = true
fileImports := make(map[string]map[string]*File) // map[ImportPath]map[FilePath]File
for _, pkg := range ctx.Package {
for _, f := range pkg.Files {
for _, imp := range f.Imports {
fileList := fileImports[imp]
if fileList == nil {
fileList = make(map[string]*File, 1)
fileImports[imp] = fileList
}
fileList[f.Path] = f
}
}
}
filePaths := make(map[string]*File, len(ctx.RewriteRule))
for from := range ctx.RewriteRule {
for _, f := range fileImports[from] {
filePaths[f.Path] = f
}
}
/*
RULE: co2/internal/co3/pk3 -> co1/internal/co3/pk3
i co1/internal/co2/pk2 [co2/pk2] < ["co1/pk1"]
i co1/internal/co3/pk3 [co3/pk3] < ["co1/pk1"]
e co2/internal/co3/pk3 [co3/pk3] < ["co1/internal/co2/pk2"]
l co1/pk1 < []
s strings < ["co1/internal/co3/pk3" "co2/internal/co3/pk3"]
Rewrite the package "co1/internal/co2/pk2" because it references a package with a rewrite.from package.
*/
ctx.updatePackageReferences()
for from := range ctx.RewriteRule {
pkg := ctx.Package[from]
if pkg == nil {
continue
}
for _, ref := range pkg.referenced {
for _, f := range ref.Files {
dprintf("REF RW %s\n", f.Path)
filePaths[f.Path] = f
}
}
}
defer func() {
ctx.RewriteRule = make(map[string]string, 3)
}()
if len(ctx.RewriteRule) == 0 {
return nil
}
goprint := &printer.Config{
Mode: printer.TabIndent | printer.UseSpaces,
Tabwidth: 8,
}
for _, fileInfo := range filePaths {
if pathos.FileHasPrefix(fileInfo.Path, ctx.RootDir) == false {
continue
}
// Read the file into AST, modify the AST.
fileset := token.NewFileSet()
f, err := parser.ParseFile(fileset, fileInfo.Path, nil, parser.ParseComments)
if err != nil {
return err
}
dprintf("RW:: File: %s\n", fileInfo.Path)
for _, impNode := range f.Imports {
imp, err := strconv.Unquote(impNode.Path.Value)
if err != nil {
return err
}
for from, to := range ctx.RewriteRule {
if imp != from {
continue
}
impNode.Path.Value = strconv.Quote(to)
for i, metaImport := range fileInfo.Imports {
if from == metaImport {
dprintf("\tImport: %s -> %s\n", from, to)
fileInfo.Imports[i] = to
}
}
break
}
}
// Remove import comment.
st := fileInfo.Package.Status
if st == StatusVendor || st == StatusUnused {
var ic *ast.Comment
if f.Name != nil {
pos := f.Name.Pos()
big:
// Find the next comment after the package name.
for _, cblock := range f.Comments {
for _, c := range cblock.List {
if c.Pos() > pos {
ic = c
break big
}
}
}
}
if ic != nil {
// If it starts with the import text, assume it is the import comment and remove.
if index := strings.Index(ic.Text, " import "); index > 0 && index < 5 {
ic.Text = strings.Repeat(" ", len(ic.Text))
}
}
}
// Don't sort or modify the imports to minimize diffs.
// Write the AST back to disk.
fi, err := os.Stat(fileInfo.Path)
if err != nil {
return err
}
w, err := safefile.Create(fileInfo.Path, fi.Mode())
if err != nil {
return err
}
err = goprint.Fprint(w, fileset, f)
if err != nil {
w.Close()
return err
}
err = w.Commit()
if err != nil {
return err
}
}
return nil
}
func (rp *routesParser) Parse(gofile *ast.File, target interface{}) error {
tgt := target.(*spec.Paths)
for _, comsec := range gofile.Comments {
// check if this is a route comment section
var method, path, id string
var tags []string
var remaining *ast.CommentGroup
var justMatched bool
for _, cmt := range comsec.List {
for _, line := range strings.Split(cmt.Text, "\n") {
matches := rxRoute.FindStringSubmatch(line)
if len(matches) > 3 && len(matches[3]) > 0 {
method, path, id = matches[1], matches[2], matches[len(matches)-1]
tags = rxSpace.Split(matches[3], -1)
justMatched = true
} else if method != "" {
if remaining == nil {
remaining = new(ast.CommentGroup)
}
if !justMatched || strings.TrimSpace(rxStripComments.ReplaceAllString(line, "")) != "" {
cc := new(ast.Comment)
cc.Slash = cmt.Slash
cc.Text = line
remaining.List = append(remaining.List, cc)
justMatched = false
}
}
}
}
if method == "" {
continue // it's not, next!
}
pthObj := tgt.Paths[path]
op := rp.operations[id]
if op == nil {
op = new(spec.Operation)
op.ID = id
}
switch strings.ToUpper(method) {
case "GET":
if pthObj.Get != nil {
if id == pthObj.Get.ID {
op = pthObj.Get
} else {
pthObj.Get = op
}
} else {
pthObj.Get = op
}
case "POST":
if pthObj.Post != nil {
if id == pthObj.Post.ID {
op = pthObj.Post
} else {
pthObj.Post = op
}
} else {
pthObj.Post = op
}
case "PUT":
if pthObj.Put != nil {
if id == pthObj.Put.ID {
op = pthObj.Put
} else {
pthObj.Put = op
}
} else {
pthObj.Put = op
}
case "PATCH":
if pthObj.Patch != nil {
if id == pthObj.Patch.ID {
op = pthObj.Patch
} else {
pthObj.Patch = op
}
} else {
pthObj.Patch = op
}
case "HEAD":
if pthObj.Head != nil {
if id == pthObj.Head.ID {
op = pthObj.Head
} else {
pthObj.Head = op
}
} else {
pthObj.Head = op
}
case "DELETE":
if pthObj.Delete != nil {
if id == pthObj.Delete.ID {
op = pthObj.Delete
} else {
pthObj.Delete = op
}
} else {
pthObj.Delete = op
}
case "OPTIONS":
if pthObj.Options != nil {
if id == pthObj.Options.ID {
op = pthObj.Options
} else {
pthObj.Options = op
}
} else {
pthObj.Options = op
}
}
op.Tags = tags
sp := new(sectionedParser)
sp.setTitle = func(lines []string) { op.Summary = joinDropLast(lines) }
sp.setDescription = func(lines []string) { op.Description = joinDropLast(lines) }
sr := newSetResponses(rp.definitions, rp.responses, opResponsesSetter(op))
sp.taggers = []tagParser{
newMultiLineTagParser("Consumes", newMultilineDropEmptyParser(rxConsumes, opConsumesSetter(op))),
newMultiLineTagParser("Produces", newMultilineDropEmptyParser(rxProduces, opProducesSetter(op))),
newSingleLineTagParser("Schemes", newSetSchemes(opSchemeSetter(op))),
newMultiLineTagParser("Security", newSetSecurityDefinitions(rxSecuritySchemes, opSecurityDefsSetter(op))),
newMultiLineTagParser("Responses", sr),
}
if err := sp.Parse(remaining); err != nil {
return fmt.Errorf("operation (%s): %v", op.ID, err)
}
if tgt.Paths == nil {
tgt.Paths = make(map[string]spec.PathItem)
}
tgt.Paths[path] = pthObj
}
return nil
}
