support diff options

Author: golangcidev

Gopkg.lock

@@ -26,8 +26,8 @@
 
 
 [[constraint]]
-  name = "github.com/bradleyfalzon/revgrep"
-  version = "0.3.0"
+  name = "github.com/golangci/revgrep"
+  branch = "master"
 
 [[constraint]]
   name = "github.com/stretchr/testify"

Gopkg.toml

@@ -83,6 +83,10 @@ func (e *Executor) initRun() {
 	runCmd.Flags().StringSliceVarP(&rc.ExcludePatterns, "exclude", "e", config.DefaultExcludePatterns, "Exclude issue by regexp")
 
 	runCmd.Flags().IntVar(&rc.MaxIssuesPerLinter, "max-issues-per-linter", 50, "Maximum issues count per one linter. Set to 0 to disable")
+
+	runCmd.Flags().BoolVarP(&rc.Diff, "new", "n", false, "Show only new issues: if there are unstaged changes or untracked files, only those changes are shown, else only changes in HEAD~ are shown")
+	runCmd.Flags().StringVar(&rc.DiffFromRevision, "new-from-rev", "", "Show only new issues created after git revision `REV`")
+	runCmd.Flags().StringVar(&rc.DiffPatchFilePath, "new-from-patch", "", "Show only new issues created in git patch with file path `PATH`")
 }
 
 func isFullImportNeeded(linters []pkg.Linter) bool {
@@ -196,10 +200,11 @@ func (e *Executor) runAnalysis(ctx context.Context, args []string) (chan result.
 
 	runner := pkg.SimpleRunner{
 		Processors: []processors.Processor{
-			processors.NewMaxPerFileFromLinter(),
 			processors.NewExclude(fmt.Sprintf("(%s)", strings.Join(e.cfg.Run.ExcludePatterns, "|"))),
 			processors.NewNolint(lintCtx.Program.Fset),
 			processors.NewUniqByLine(),
+			processors.NewDiff(e.cfg.Run.Diff, e.cfg.Run.DiffFromRevision, e.cfg.Run.DiffPatchFilePath),
+			processors.NewMaxPerFileFromLinter(),
 			processors.NewMaxFromLinter(e.cfg.Run.MaxIssuesPerLinter),
 			processors.NewPathPrettifier(),
 		},

internal/commands/run.go

@@ -79,6 +79,10 @@ type Run struct {
 	Deadline time.Duration
 
 	MaxIssuesPerLinter int
+
+	DiffFromRevision  string
+	DiffPatchFilePath string
+	Diff              bool
 }
 
 type Config struct {

pkg/config/config.go

@@ -8,6 +8,14 @@ type Issue struct {
 	HunkPos    int
 }
 
+func (i Issue) FilePath() string {
+	return i.File
+}
+
+func (i Issue) Line() int {
+	return i.LineNumber
+}
+
 func NewIssue(fromLinter, text, file string, lineNumber, hunkPos int) Issue {
 	return Issue{
 		FromLinter: fromLinter,

pkg/result/issue.go

@@ -1,92 +1,66 @@
 package processors
 
 import (
+	"bytes"
 	"fmt"
+	"io"
 	"io/ioutil"
-	"strings"
 
-	"github.com/bradleyfalzon/revgrep"
 	"github.com/golangci/golangci-lint/pkg/result"
+	"github.com/golangci/revgrep"
 )
 
-type DiffProcessor struct {
-	patch string
+type Diff struct {
+	onlyNew       bool
+	fromRev       string
+	patchFilePath string
 }
 
-func NewDiffProcessor(patch string) *DiffProcessor {
-	return &DiffProcessor{
-		patch: patch,
+var _ Processor = Diff{}
+
+func NewDiff(onlyNew bool, fromRev, patchFilePath string) *Diff {
+	return &Diff{
+		onlyNew:       onlyNew,
+		fromRev:       fromRev,
+		patchFilePath: patchFilePath,
 	}
 }
 
-func (p DiffProcessor) Name() string {
+func (p Diff) Name() string {
 	return "diff"
 }
 
-func (p DiffProcessor) processResult(res result.Result) (*result.Result, error) {
-	// Make mapping to restore original issues metadata later
-	fli := makeFilesToLinesToIssuesMap([]result.Result{res})
-
-	rIssues, err := p.runRevgrepOnIssues(res.Issues)
-	if err != nil {
-		return nil, err
-	}
-
-	newIssues := []result.Issue{}
-	for _, ri := range rIssues {
-		if fli[ri.File] == nil {
-			return nil, fmt.Errorf("can't get original issue file for %v", ri)
-		}
-
-		oi := fli[ri.File][ri.LineNo]
-		if len(oi) != 1 {
-			return nil, fmt.Errorf("can't get original issue for %v: %v", ri, oi)
-		}
-
-		i := result.Issue{
-			File:       ri.File,
-			LineNumber: ri.LineNo,
-			Text:       ri.Message,
-			HunkPos:    ri.HunkPos,
-			FromLinter: oi[0].FromLinter,
-		}
-		newIssues = append(newIssues, i)
+func (p Diff) Process(issues []result.Issue) ([]result.Issue, error) {
+	if !p.onlyNew && p.fromRev == "" && p.patchFilePath == "" { // no need to work
+		return issues, nil
 	}
 
-	res.Issues = newIssues
-	return &res, nil
-}
-
-func (p DiffProcessor) Process(results []result.Result) ([]result.Result, error) {
-	retResults := []result.Result{}
-	for _, res := range results {
-		newRes, err := p.processResult(res)
+	var patchReader io.Reader
+	if p.patchFilePath != "" {
+		patch, err := ioutil.ReadFile(p.patchFilePath)
 		if err != nil {
-			return nil, fmt.Errorf("can't filter only new issues for result %+v: %s", res, err)
+			return nil, fmt.Errorf("can't read from pathc file %s: %s", p.patchFilePath, err)
 		}
-		retResults = append(retResults, *newRes)
+		patchReader = bytes.NewReader(patch)
 	}
-
-	return retResults, nil
-}
-
-func (p DiffProcessor) runRevgrepOnIssues(issues []result.Issue) ([]revgrep.Issue, error) {
-	// TODO: change revgrep to accept interface with line number, file name
-	fakeIssuesLines := []string{}
-	for _, i := range issues {
-		line := fmt.Sprintf("%s:%d:%d: %s", i.File, i.LineNumber, 0, i.Text)
-		fakeIssuesLines = append(fakeIssuesLines, line)
+	c := revgrep.Checker{
+		Patch:        patchReader,
+		RevisionFrom: p.fromRev,
 	}
-	fakeIssuesOut := strings.Join(fakeIssuesLines, "\n")
-
-	checker := revgrep.Checker{
-		Patch:  strings.NewReader(p.patch),
-		Regexp: `^([^:]+):(\d+):(\d+)?:?\s*(.*)$`,
-	}
-	rIssues, err := checker.Check(strings.NewReader(fakeIssuesOut), ioutil.Discard)
-	if err != nil {
-		return nil, fmt.Errorf("can't filter only new issues by revgrep: %s", err)
+	if err := c.Prepare(); err != nil {
+		return nil, fmt.Errorf("can't prepare diff by revgrep: %s", err)
 	}
 
-	return rIssues, nil
+	return transformIssues(issues, func(i *result.Issue) *result.Issue {
+		hunkPos, isNew := c.IsNewIssue(i)
+		if !isNew {
+			return nil
+		}
+
+		newI := *i
+		newI.HunkPos = hunkPos
+		return &newI
+	}), nil
 }
+
+func (Diff) Finish() {}

pkg/result/processors/diff.go

@@ -2,23 +2,6 @@ package processors
 
 import "github.com/golangci/golangci-lint/pkg/result"
 
-type linesToIssuesMap map[int][]result.Issue
-type filesToLinesToIssuesMap map[string]linesToIssuesMap
-
-func makeFilesToLinesToIssuesMap(results []result.Result) filesToLinesToIssuesMap {
-	fli := filesToLinesToIssuesMap{}
-	for _, res := range results {
-		for _, i := range res.Issues {
-			if fli[i.File] == nil {
-				fli[i.File] = linesToIssuesMap{}
-			}
-			li := fli[i.File]
-			li[i.LineNumber] = append(li[i.LineNumber], i)
-		}
-	}
-	return fli
-}
-
 func filterIssues(issues []result.Issue, filter func(i *result.Issue) bool) []result.Issue {
 	retIssues := make([]result.Issue, 0, len(issues))
 	for _, i := range issues {