handle linting stdin by Linter.LintStdin instead of Command

Author: rhysd

command.go

@@ -102,15 +102,7 @@ func (cmd *Command) runLinter(args []string, opts *LinterOptions, initConfig boo
 	}
 
 	if len(args) == 1 && args[0] == "-" {
-		b, err := io.ReadAll(cmd.Stdin)
-		if err != nil {
-			return nil, fmt.Errorf("could not read stdin: %w", err)
-		}
-		n := "<stdin>"
-		if opts.StdinFileName != "" {
-			n = opts.StdinFileName
-		}
-		return l.Lint(n, b, nil)
+		return l.LintStdin(cmd.Stdin)
 	}
 
 	return l.LintFiles(args, nil)
@@ -151,7 +143,7 @@ func (cmd *Command) Main(args []string) int {
 	flags.BoolVar(&opts.Verbose, "verbose", false, "Enable verbose output")
 	flags.BoolVar(&opts.Debug, "debug", false, "Enable debug output (for development)")
 	flags.BoolVar(&ver, "version", false, "Show version and how this binary was installed")
-	flags.StringVar(&opts.StdinFileName, "stdin-filename", "", "File name when reading input from stdin")
+	flags.StringVar(&opts.StdinFileName, "stdin-filename", "<stdin>", "File name when reading input from stdin")
 	flags.Usage = func() {
 		printUsageHeader(cmd.Stderr)
 		flags.PrintDefaults()

linter.go

@@ -103,6 +103,7 @@ type Linter struct {
 	shellcheck     string
 	pyflakes       string
 	ignorePats     []*regexp.Regexp
+	stdin          string
 	defaultConfig  *Config
 	errFmt         *ErrorFormatter
 	cwd            string
@@ -172,6 +173,11 @@ func NewLinter(out io.Writer, opts *LinterOptions) (*Linter, error) {
 		}
 	}
 
+	stdin := "<stdin>"
+	if opts.StdinFileName != "" {
+		stdin = opts.StdinFileName
+	}
+
 	return &Linter{
 		NewProjects(),
 		out,
@@ -181,6 +187,7 @@ func NewLinter(out io.Writer, opts *LinterOptions) (*Linter, error) {
 		opts.Shellcheck,
 		opts.Pyflakes,
 		ignore,
+		stdin,
 		cfg,
 		formatter,
 		cwd,
@@ -443,9 +450,20 @@ func (l *Linter) LintFile(path string, project *Project) ([]*Error, error) {
 	return errs, err
 }
 
+// LintStdin lints the content read from STDIN. The stdin parameter is a reader to read from STDIN,
+// which is usually os.Stdin. The file name is determined by LinterOptions.StdinFileName. When the
+// option is empty, "<stdin>" is the default value.
+func (l *Linter) LintStdin(stdin io.Reader) ([]*Error, error) {
+	l.log("Reading the input from stdin")
+	b, err := io.ReadAll(stdin)
+	if err != nil {
+		return nil, fmt.Errorf("could not read stdin: %w", err)
+	}
+	return l.Lint(l.stdin, b, nil)
+}
+
 // Lint lints YAML workflow file content given as byte slice. The path parameter is used as file
-// path where the content came from. Setting "<stdin>" to path parameter indicates the output came
-// from STDIN.
+// path where the content came from.
 // When nil is passed to the project parameter, it tries to find the project from the path parameter.
 func (l *Linter) Lint(path string, content []byte, project *Project) ([]*Error, error) {
 	if project == nil && path != "<stdin>" {

linter_test.go

@@ -2,7 +2,9 @@ package actionlint
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -17,6 +19,12 @@ import (
 	"golang.org/x/sys/execabs"
 )
 
+type testErrorReader struct{}
+
+func (r testErrorReader) Read(p []byte) (int, error) {
+	return 0, errors.New("dummy read error")
+}
+
 func TestLinterLintOK(t *testing.T) {
 	dir := filepath.Join("testdata", "ok")
 
@@ -432,7 +440,7 @@ func TestLinterFormatErrorMessageInSARIF(t *testing.T) {
 
 	var have interface{}
 	if err := json.Unmarshal([]byte(out), &have); err != nil {
-		t.Fatalf("Output is not JSON: %v: %q", err, out)
+		t.Fatalf("output is not JSON: %v: %q", err, out)
 	}
 
 	bytes, err = os.ReadFile(filepath.Join(dir, "test.sarif"))
@@ -449,6 +457,53 @@ func TestLinterFormatErrorMessageInSARIF(t *testing.T) {
 	}
 }
 
+func TestLinterLintStdinOK(t *testing.T) {
+	for _, f := range []string{"", "foo.yaml"} {
+		l, err := NewLinter(io.Discard, &LinterOptions{StdinFileName: f})
+		if err != nil {
+			t.Fatalf("creating Linter object with stdin file name %q caused error: %v", f, err)
+		}
+
+		in := []byte(`on: push
+jobs:
+  job:
+    runs-on: foo
+	steps:
+	  - run: echo`)
+		errs, err := l.LintStdin(bytes.NewReader(in))
+		if err != nil {
+			t.Fatalf("linting input with stdin file name %q caused error: %v", f, err)
+		}
+		if len(errs) != 1 {
+			t.Fatalf("unexpected number of errors with stdin file name %q: %v", f, errs)
+		}
+
+		want := f
+		if want == "" {
+			want = "<stdin>"
+		}
+		if errs[0].Filepath != want {
+			t.Fatalf("file path in the error with stdin file name %q should be %q but got %q", f, want, errs[0].Filepath)
+		}
+	}
+}
+
+func TestLinterLintStdinReadError(t *testing.T) {
+	l, err := NewLinter(io.Discard, &LinterOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = l.LintStdin(testErrorReader{})
+	if err == nil {
+		t.Fatal("error did not occur")
+	}
+	want := "could not read stdin: dummy read error"
+	have := err.Error()
+	if want != have {
+		t.Fatalf("wanted error message %q but have %q", want, have)
+	}
+}
+
 func TestLinterPathsNotFound(t *testing.T) {
 	l, err := NewLinter(io.Discard, &LinterOptions{})
 	if err != nil {