mirror of
https://github.com/johnkerl/miller.git
synced 2026-07-17 16:38:54 +00:00
91eaff1341
* refine the plan
* Fix all staticcheck lint findings (uncapped)
golangci-lint's default max-same-issues=3 was hiding most of the backlog:
the true pre-fix count was 69 staticcheck findings, not 34. This fixes all
of them, driving staticcheck to zero:
- ST1023/QF1011 (37): omit explicit types inferred from the RHS
- S1009/S1031 (15): drop redundant nil checks before len()/range
- SA9003 (9): remove comment-only empty branches, keeping the comments
- QF1007 (3): merge conditional assignment into declaration
- QF1006 (3): lift break conditions into loop conditions
- QF1001 (3): apply De Morgan's law / name the negated predicate
Also updates plans/lintfixes.md with the cap discovery and the corrected
errcheck picture (1202 uncapped, ~949 of them fmt.Fprint*).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* Drive errcheck to zero: config for bulk categories, propagate real errors
Adds .golangci.yml with errcheck exclude-functions for fmt.Fprint* (usage
printers), (*bufio.Writer).Write/WriteString (sticky errors, surfaced at the
now-checked final Flush), and (*strings.Builder).WriteString; pins
max-issues-per-linter/max-same-issues to 0 so CI reports true counts.
Real error paths now propagate instead of being dropped:
- Finalize{Reader,Writer}Options in join/put/filter/split/tee and the
repl/script entry points: 'mlr join -i badformat' now errors instead of
silently using wrong separators
- final output-stream Flush in pkg/stream: write failure no longer exits 0
- DSL emit/print/dump redirect writes, matching their sibling branches
- CSV writer WriteCSVRecordMaybeColorized, close-time Flush in file output
handlers, ENV[...] Setenv, REPL record-write and redirect-close errors
- termcvt write-side Close before rename (had "TODO: check return status")
The rest are deliberate ignores, marked with _ = and a comment where the
reason isn't obvious: unset-of-missing-path no-ops, read-side closes,
mid-stream FlushOnEveryRecord, init-time strftime registrations, in-memory
usage-capture pipes, and regtest-harness env/temp-file teardown.
golangci-lint now reports 0 issues on ./cmd/mlr ./pkg/... with all caps off.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
94 lines
2.5 KiB
Go
94 lines
2.5 KiB
Go
package lib
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
|
|
"github.com/johnkerl/miller/v6/pkg/platform"
|
|
)
|
|
|
|
// OpenOutboundHalfPipe returns a handle to a process. Writing to that handle
|
|
// writes to the process' stdin. The process' stdout and stderr are the current
|
|
// process' stdout and stderr.
|
|
//
|
|
// This is for pipe-output-redirection in the Miller put/filter DSL.
|
|
//
|
|
// Note I am not using os.exec.Cmd which is billed as being simpler than using
|
|
// os.StartProcess. It may indeed be simpler when you want to handle the
|
|
// subprocess' stdin/stdout/stderr all three within the parent process. Here I
|
|
// found it much easier to use os.StartProcess to let the stdout/stderr run
|
|
// free.
|
|
|
|
func OpenOutboundHalfPipe(commandString string) (*os.File, error) {
|
|
readPipe, writePipe, err := os.Pipe()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var procAttr os.ProcAttr
|
|
procAttr.Files = []*os.File{
|
|
readPipe,
|
|
os.Stdout,
|
|
os.Stderr,
|
|
}
|
|
|
|
// /bin/sh -c "..." or cmd /c "..."
|
|
shellRunArray := platform.GetShellRunArray(commandString)
|
|
|
|
process, err := os.StartProcess(shellRunArray[0], shellRunArray, &procAttr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
go func() { _, _ = process.Wait() }()
|
|
|
|
return writePipe, nil
|
|
}
|
|
|
|
// OpenInboundHalfPipe returns a handle to a process. Reading from that handle
|
|
// reads from the process' stdout. The process' stdin and stderr are the
|
|
// current process' stdin and stderr.
|
|
//
|
|
// This is for the Miller prepipe feature.
|
|
//
|
|
// Note I am not using os.exec.Cmd which is billed as being simpler than using
|
|
// os.StartProcess. It may indeed be simpler when you want to handle the
|
|
// subprocess' stdin/stdout/stderr all three within the parent process. Here I
|
|
// found it much easier to use os.StartProcess to let the stdin/stderr run
|
|
// free.
|
|
|
|
func OpenInboundHalfPipe(commandString string) (*os.File, error) {
|
|
readPipe, writePipe, err := os.Pipe()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var procAttr os.ProcAttr
|
|
procAttr.Files = []*os.File{
|
|
os.Stdin,
|
|
writePipe,
|
|
os.Stderr,
|
|
}
|
|
|
|
// /bin/sh -c "..." or cmd /c "..."
|
|
shellRunArray := platform.GetShellRunArray(commandString)
|
|
|
|
process, err := os.StartProcess(shellRunArray[0], shellRunArray, &procAttr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// TODO comment somewhere
|
|
// https://stackoverflow.com/questions/47486128/why-does-io-pipe-continue-to-block-even-when-eof-is-reached
|
|
|
|
// TODO comment
|
|
go func(process *os.Process, readPipe *os.File) {
|
|
_, err := process.Wait()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "mlr: %v\n", err)
|
|
}
|
|
_ = readPipe.Close()
|
|
}(process, readPipe)
|
|
|
|
return readPipe, nil
|
|
}
|