forked from open-policy-agent/opa
-
Notifications
You must be signed in to change notification settings - Fork 0
/
check.go
107 lines (86 loc) · 2.26 KB
/
check.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
// Copyright 2017 The OPA Authors. All rights reserved.
// Use of this source code is governed by an Apache2
// license that can be found in the LICENSE file.
package cmd
import (
"encoding/json"
"fmt"
"os"
"github.com/open-policy-agent/opa/ast"
"github.com/open-policy-agent/opa/loader"
"github.com/open-policy-agent/opa/util"
"github.com/spf13/cobra"
)
var checkParams = struct {
format *util.EnumFlag
errLimit int
ignore []string
}{
format: util.NewEnumFlag(checkFormatPretty, []string{
checkFormatPretty, checkFormatJSON,
}),
}
const (
checkFormatPretty = "pretty"
checkFormatJSON = "json"
)
var checkCommand = &cobra.Command{
Use: "check <path> [path [...]]",
Short: "Check Rego source files",
Long: `Check Rego source files for parse and compilation errors.
If the 'check' command succeeds in parsing and compiling the source file(s), no output
is produced. If the parsing or compiling fails, 'check' will output the errors
and exit with a non-zero exit code.`,
PreRunE: func(Cmd *cobra.Command, args []string) error {
if len(args) == 0 {
return fmt.Errorf("specify at least one file")
}
return nil
},
Run: func(cmd *cobra.Command, args []string) {
os.Exit(checkModules(args))
},
}
func checkModules(args []string) int {
f := loaderFilter{
Ignore: checkParams.ignore,
}
result, err := loader.Filtered(args, f.Apply)
if err != nil {
outputErrors(err)
return 1
}
modules := map[string]*ast.Module{}
for _, m := range result.Modules {
modules[m.Name] = m.Parsed
}
compiler := ast.NewCompiler().SetErrorLimit(checkParams.errLimit)
compiler.Compile(modules)
if !compiler.Failed() {
return 0
}
outputErrors(compiler.Errors)
return 1
}
func outputErrors(err error) {
switch checkParams.format.String() {
case checkFormatJSON:
result := map[string]error{
"errors": err,
}
bs, err := json.MarshalIndent(result, "", " ")
if err != nil {
fmt.Fprintln(os.Stderr, err)
} else {
fmt.Fprintln(os.Stdout, string(bs))
}
default:
fmt.Fprintln(os.Stdout, err)
}
}
func init() {
setMaxErrors(checkCommand.Flags(), &checkParams.errLimit)
setIgnore(checkCommand.Flags(), &checkParams.ignore)
checkCommand.Flags().VarP(checkParams.format, "format", "f", "set output format")
RootCommand.AddCommand(checkCommand)
}