blob: cf44153bd3ba77c922cb9d236789875b8073d010 [file] [log] [blame]
// Copyright 2019 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package gerritfmt
import (
"bytes"
"fmt"
"io"
"io/ioutil"
"log"
"os"
"os/exec"
"path/filepath"
"regexp"
"sort"
"strings"
)
// Formatter is a definition of a formatting engine
type Formatter interface {
// Format returns the files but formatted. All files are
// assumed to have the same language.
Format(in []File, outSink io.Writer) (out []FormattedFile, err error)
}
// FormatterConfig defines the mapping configurable
type FormatterConfig struct {
// Regex is the typical filename regexp to use
Regex *regexp.Regexp
// Query is used to filter inside Gerrit
Query string
// The formatter
Formatter Formatter
}
// Formatters holds all the formatters supported
var Formatters = map[string]*FormatterConfig{
"commitmsg": {
Regex: regexp.MustCompile(`^/COMMIT_MSG$`),
Formatter: &commitMsgFormatter{},
},
}
func init() {
gjf, err := exec.LookPath("google-java-format")
if err == nil {
Formatters["java"] = &FormatterConfig{
Regex: regexp.MustCompile(`\.java$`),
Query: "ext:java",
Formatter: &toolFormatter{
bin: "java",
args: []string{"-jar", gjf, "-i"},
},
}
} else {
log.Printf("LookPath google-java-format: %v", err, os.Getenv("PATH"))
}
bzl, err := exec.LookPath("buildifier")
if err == nil {
Formatters["bzl"] = &FormatterConfig{
Regex: regexp.MustCompile(`(\.bzl|/BUILD|^BUILD)$`),
Query: "(ext:bzl OR file:BUILD OR file:WORKSPACE)",
Formatter: &toolFormatter{
bin: bzl,
args: []string{"-mode=fix"},
},
}
} else {
log.Printf("LookPath buildifier: %v, %s", err, os.Getenv("PATH"))
}
gofmt, err := exec.LookPath("gofmt")
if err == nil {
Formatters["go"] = &FormatterConfig{
Regex: regexp.MustCompile(`\.go$`),
Query: "ext:go",
Formatter: &toolFormatter{
bin: gofmt,
args: []string{"-w"},
},
}
} else {
log.Printf("LookPath gofmt: %v, %s", err, os.Getenv("PATH"))
}
}
// IsSupported returns if the given language is supported.
func IsSupported(lang string) bool {
_, ok := Formatters[lang]
return ok
}
// SupportedLanguages returns a list of languages.
func SupportedLanguages() []string {
var r []string
for l := range Formatters {
r = append(r, l)
}
sort.Strings(r)
return r
}
func splitByLang(in []File) map[string][]File {
res := map[string][]File{}
for _, f := range in {
res[f.Language] = append(res[f.Language], f)
}
return res
}
// Format formats all the files in the request for which a formatter exists.
func Format(req *FormatRequest, rep *FormatReply) error {
for _, f := range req.Files {
if f.Language == "" {
return fmt.Errorf("file %q has empty language", f.Name)
}
}
for language, fs := range splitByLang(req.Files) {
var buf bytes.Buffer
entry := Formatters[language]
log.Println("init", Formatters)
out, err := entry.Formatter.Format(fs, &buf)
if err != nil {
return err
}
if len(out) > 0 && out[0].Message == "" {
out[0].Message = buf.String()
}
rep.Files = append(rep.Files, out...)
}
return nil
}
type commitMsgFormatter struct{}
func (f *commitMsgFormatter) Format(in []File, outSink io.Writer) (out []FormattedFile, err error) {
complaint := checkCommitMessage(string(in[0].Content))
ff := FormattedFile{}
ff.Name = in[0].Name
if complaint != "" {
ff.Message = complaint
} else {
ff.Content = in[0].Content
}
out = append(out, ff)
return out, nil
}
func checkCommitMessage(msg string) (complaint string) {
lines := strings.Split(msg, "\n")
if len(lines) < 2 {
return "must have multiple lines"
}
if len(lines[1]) > 1 {
return "subject and body must be separated by blank line"
}
if len(lines[0]) > 70 {
return "subject must be less than 70 chars"
}
if strings.HasSuffix(lines[0], ".") {
return "subject must not end in '.'"
}
return ""
}
type toolFormatter struct {
bin string
args []string
}
func (f *toolFormatter) Format(in []File, outSink io.Writer) (out []FormattedFile, err error) {
cmd := exec.Command(f.bin, f.args...)
tmpDir, err := ioutil.TempDir("", "gerritfmt")
if err != nil {
return nil, err
}
defer os.RemoveAll(tmpDir)
for _, f := range in {
dir, base := filepath.Split(f.Name)
dir = filepath.Join(tmpDir, dir)
if err := os.MkdirAll(dir, 0755); err != nil {
return nil, err
}
if err := ioutil.WriteFile(filepath.Join(dir, base), f.Content, 0644); err != nil {
return nil, err
}
cmd.Args = append(cmd.Args, f.Name)
}
cmd.Dir = tmpDir
var errBuf, outBuf bytes.Buffer
cmd.Stdout = &outBuf
cmd.Stderr = &errBuf
log.Println("running", cmd.Args, "in", tmpDir)
if err := cmd.Run(); err != nil {
log.Printf("error %v, stderr %s, stdout %s", err, errBuf.String(),
outBuf.String())
return nil, err
}
for _, f := range in {
c, err := ioutil.ReadFile(filepath.Join(tmpDir, f.Name))
if err != nil {
return nil, err
}
out = append(out, FormattedFile{
File: File{
Name: f.Name,
Content: c,
},
})
}
return out, nil
}