go ruleguard
v0.4.2
Analysebasierte GO-Linter, die dynamisch geladene Regeln ausführt.
Sie schreiben die Regeln ruleguard überprüft, ob sie zufrieden sind.
ruleguard hat einige Ähnlichkeiten mit Github Codesql, aber es ist nur bestrebt, nur zu gehen.
Merkmale:
Es kann auch leicht in andere statische Analysatoren eingebettet werden. Go-Critic kann als Beispiel verwendet werden.
Es wird empfohlen, dass Sie aus der neuesten Veröffentlichung {Linux/AMD64, Linux/ARM64, Darwin/AMD64, Darwin/ARM64, Windows/AMD64, Windows/ARM64} erhalten.
Wenn Sie den RulleGuard von Quelle installieren möchten, ist es so einfach:
# Installs a `ruleguard` binary under your `$(go env GOPATH)/bin`
$ go install -v github.com/quasilyte/go-ruleguard/cmd/ruleguard@latest
# Get the DSL package (needed to execute the ruleguard files)
$ go get -v -u github.com/quasilyte/go-ruleguard/dsl@latestWenn Sie im GO -Modul im GO -Modul sind, wird das
dsl-Paket für das aktuelle Modul installiert. Andernfalls wird das Paket in den $ gopath installiert und ist weltweit verfügbar.
Wenn $GOPATH/bin unter Ihrem System $PATH ist, sollte der Befehl ruleguard danach verfügbar sein:
$ ruleguard -help
ruleguard: execute dynamic gogrep-based rules
Usage: ruleguard [-flag] [package]
Flags:
-rules string
comma-separated list of ruleguard file paths
-e string
execute a single rule from a given string
-fix
apply all suggested fixes
-c int
display offending line with this many lines of context (default -1)
-json
emit JSON output Erstellen Sie eine rules.go -Datei:
//go:build ruleguard
// +build ruleguard
package gorules
import "github.com/quasilyte/go-ruleguard/dsl"
func dupSubExpr ( m dsl. Matcher ) {
m . Match ( `$x || $x` ,
`$x && $x` ,
`$x | $x` ,
`$x & $x` ).
Where ( m [ "x" ]. Pure ).
Report ( `suspicious identical LHS and RHS` )
}
func boolExprSimplify ( m dsl. Matcher ) {
m . Match ( `!($x != $y)` ). Suggest ( `$x == $y` )
m . Match ( `!($x == $y)` ). Suggest ( `$x != $y` )
}
func exposedMutex ( m dsl. Matcher ) {
isExported := func ( v dsl. Var ) bool {
return v . Text . Matches ( `^p{Lu}` )
}
m . Match ( `type $name struct { $*_; sync.Mutex; $*_ }` ).
Where ( isExported ( m [ "name" ])).
Report ( "do not embed sync.Mutex" )
m . Match ( `type $name struct { $*_; sync.RWMutex; $*_ }` ).
Where ( isExported ( m [ "name" ])).
Report ( "do not embed sync.RWMutex" )
} Erstellen Sie ein Testbeispiel. GO example.go :
package main
import "sync"
type EmbedsMutex struct {
key int
sync. Mutex
}
func main () {
var v1 , v2 int
println ( ! ( v1 != v2 ))
println ( ! ( v1 == v2 ))
if v1 == 0 && v1 == 0 {
println ( "hello, world!" )
}
} Führen Sie ruleguard in dieser Zieldatei aus:
$ ruleguard -rules rules.go -fix example.go
example.go:5:1: exposedMutex: do not embed sync.Mutex (rules.go:24)
example.go:12:10: boolExprSimplify: suggestion: v1 == v2 (rules.go:15)
example.go:13:10: boolExprSimplify: suggestion: v1 ! = v2 (rules.go:16)
example.go:14:5: dupSubExpr: suspicious identical LHS and RHS (rules.go:7) Da wir ruleguard mit -fix -Argument betrieben haben, werden beide vorgeschlagenen Änderungen auf example.go angewendet.go.
Es gibt auch einen -e -Modus, der während des Muster -Debuggens nützlich ist:
$ ruleguard -e ' m.Match(`!($x != $y)`) ' example.go
example.go:12:10: ! (v1 ! = v2) Es fügt automatisch Report("$$") in das angegebene Muster ein.
Sie können mit -debug-group <name> -Flag verwenden, um Erklärungen zu sehen, warum einige Regeln die Übereinstimmung abgelehnt haben (z. B. Where() Bedingung fehlgeschlagen ist).
-e generierte Regel hat e Namen, sodass es auch debugged werden kann.
Zunächst spricht es RulleGuard -Dateien (z. B. rules.go ) während des Starts zum Laden des Regelsatzes.
Anschließend werden geladene Regeln verwendet, um die angegebenen Ziele (GO -Dateien, Pakete) zu überprüfen.
Die Datei " rules.go " ist in Bezug auf dsl -API geschrieben. RuleGuard -Dateien enthalten eine Reihe von Funktionen, die in der Regelgruppen dienen. Jede solche Funktion akzeptiert ein einzelnes dsl.Matcher -Argument, mit dem dann Regeln in der Gruppe definiert und konfiguriert werden.
Eine Regeldefinition beginnt immer mit Match(patterns...) Methodenaufruf und endet mit Report(message) Methodenaufruf.
Zwischen diesen beiden können zusätzliche Anrufe geben. Beispielsweise wendet ein Aufruf Where(cond) Einschränkungen auf eine Übereinstimmung an, um zu entscheiden, ob er akzeptiert oder abgelehnt wird. Selbst wenn ein Muster übereinstimmt, wird keine Berichtsnachricht erzeugt, es sei denn, es erfüllt einen Bedingung Where() .
Damit RuleGuard arbeitet, muss das dsl -Paket zur Laufzeit verfügbar sein. Wenn dies nicht der Fall ist, sehen Sie einen Fehler wie:
$ ruleguard -rules rules.go .
ruleguard: load rules: parse rules file: typechecker error: rules.go:6:8: could not import github.com/quasilyte/go-ruleguard/dsl (can't find import: "github.com/quasilyte/go-ruleguard/dsl")
Dies wird behoben, indem das DSL -Paket zum Modul hinzugefügt wird:
$ ruleguard-test go get github.com/quasilyte/go-ruleguard/dsl
go: downloading github.com/quasilyte/go-ruleguard v0.3.18
go: downloading github.com/quasilyte/go-ruleguard/dsl v0.3.21
go: added github.com/quasilyte/go-ruleguard/dsl v0.3.21
$ ruleguard-test ruleguard -rules rules.go .
.../test.go:6:5: boolExprSimplify: suggestion: 1 == 0 (rules.go:9)
Wenn Sie einen früheren Rat befolgt haben, eine Build -Einschränkung in der Datei der Regeln.go wie folgt zu verwenden:
$ ruleguard-test head -4 rules.go
//go:build ignore
// +build ignore
package gorules
Sie werden feststellen, dass die Datei go.mod die DSL als indirekte Abhängigkeit listet:
$ grep dsl go.mod
require github.com/quasilyte/go-ruleguard/dsl v0.3.21 // indirect
Wenn Sie jetzt go mod tidy ausführen, werden Sie bemerken, dass das DSL -Paket aus der go.mod -Datei verschwindet:
$ go mod tidy
$ grep dsl go.mod
$
Dies liegt daran, dass go mod tidy sich so verhält, als wären alle Build -Einschränkungen in Kraft, mit Ausnahme von ignore . Dies ist auf der GO -Website dokumentiert.
Dies wird durch die Verwendung einer anderen Build -Einschränkung wie ruleguard oder rules festgelegt.
HINWEIS: go-critic UND go-perfguard einbetten die Regeln mit der IR-Vorkompilierung ein.
