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
108
109
110
111
112
113
114
115
116
|
// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package engine
import (
"fmt"
"os"
"github.com/google/yamlfmt"
"github.com/google/yamlfmt/internal/logger"
)
// Engine that will process each file one by one consecutively.
type ConsecutiveEngine struct {
LineSepCharacter string
Formatter yamlfmt.Formatter
ContinueOnError bool
OutputFormat EngineOutputFormat
Quiet bool
Verbose bool
}
func (e *ConsecutiveEngine) FormatContent(content []byte) ([]byte, error) {
return e.Formatter.Format(content)
}
func (e *ConsecutiveEngine) Format(paths []string) (fmt.Stringer, error) {
formatDiffs, formatErrs := e.formatAll(paths)
// Debug format diff output.
logger.Debug(
logger.DebugCodeDiffs,
fmt.Sprintf("The following files were modified:\n%s", formatDiffs.StrOutput()),
)
if len(formatErrs) > 0 {
if e.ContinueOnError {
fmt.Print(formatErrs)
fmt.Println("Continuing...")
} else {
return nil, formatErrs
}
}
applyErr := formatDiffs.ApplyAll()
if applyErr != nil {
return nil, applyErr
}
return getEngineOutput(e.OutputFormat, yamlfmt.OperationFormat, formatDiffs, e.Quiet, e.Verbose)
}
func (e *ConsecutiveEngine) Lint(paths []string) (fmt.Stringer, error) {
formatDiffs, formatErrs := e.formatAll(paths)
if len(formatErrs) > 0 {
return nil, formatErrs
}
if formatDiffs.ChangedCount() == 0 {
return nil, nil
}
return getEngineOutput(e.OutputFormat, yamlfmt.OperationLint, formatDiffs, e.Quiet, e.Verbose)
}
func (e *ConsecutiveEngine) DryRun(paths []string) (fmt.Stringer, error) {
formatDiffs, formatErrs := e.formatAll(paths)
if len(formatErrs) > 0 {
return nil, formatErrs
}
if formatDiffs.ChangedCount() == 0 {
return nil, nil
}
return getEngineOutput(e.OutputFormat, yamlfmt.OperationDry, formatDiffs, e.Quiet, e.Verbose)
}
func (e *ConsecutiveEngine) formatAll(paths []string) (yamlfmt.FileDiffs, FormatErrors) {
formatDiffs := yamlfmt.FileDiffs{}
formatErrs := FormatErrors{}
for _, path := range paths {
fileDiff, err := e.formatFileContent(path)
if err != nil {
formatErrs = append(formatErrs, wrapFormatError(path, err))
continue
}
formatDiffs.Add(fileDiff)
}
return formatDiffs, formatErrs
}
func (e *ConsecutiveEngine) formatFileContent(path string) (*yamlfmt.FileDiff, error) {
content, err := os.ReadFile(path)
if err != nil {
return nil, err
}
formatted, err := e.FormatContent(content)
if err != nil {
return nil, err
}
return &yamlfmt.FileDiff{
Path: path,
Diff: &yamlfmt.FormatDiff{
Original: string(content),
Formatted: string(formatted),
LineSep: e.LineSepCharacter,
},
}, nil
}
|
