Skip to content

Commit 5ab42dc

Browse files
franciscoovazevedofranciscoovazevedo
committed
updated to use the ight v2 endpoint
1 parent 5d06a3a commit 5ab42dc

File tree

9 files changed

+643
-800
lines changed

9 files changed

+643
-800
lines changed

‎cmd/init.go‎

Lines changed: 38 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,8 @@ package cmd
33
import (
44
"codacy/cli-v2/config"
55
"codacy/cli-v2/tools"
6+
"codacy/cli-v2/tools/pylint"
7+
"codacy/cli-v2/tools/types"
68
"encoding/json"
79
"errors"
810
"fmt"
@@ -154,7 +156,7 @@ func buildRepositoryConfigurationFiles(token string) error {
154156
var objmap map[string]json.RawMessage
155157
_ = json.Unmarshal(body, &objmap)
156158

157-
var apiToolConfigurations []CodacyToolConfiguration
159+
var apiToolConfigurations []types.ToolConfiguration
158160
err = json.Unmarshal(objmap["toolConfiguration"], &apiToolConfigurations)
159161

160162
eslintApiConfiguration := extractESLintConfiguration(apiToolConfigurations)
@@ -192,19 +194,29 @@ func buildRepositoryConfigurationFiles(token string) error {
192194
fmt.Println("Default Trivy configuration created")
193195
}
194196

197+
pylintApiConfiguration := extractPylintConfiguration(apiToolConfigurations)
198+
199+
if pylintApiConfiguration != nil {
200+
err = createPylintConfigFile(*pylintApiConfiguration)
201+
if err != nil {
202+
log.Fatal(err)
203+
}
204+
fmt.Println("Pylint configuration created based on Codacy settings")
205+
}
206+
195207
return nil
196208
}
197209

198-
func convertAPIToolConfigurationToDomain(config CodacyToolConfiguration) tools.ToolConfiguration {
210+
func convertAPIToolConfigurationToDomain(config types.ToolConfiguration) tools.ToolConfiguration {
199211
var patterns []tools.PatternConfiguration
200212

201213
for _, pattern := range config.Patterns {
202214
var parameters []tools.PatternParameterConfiguration
203215

204216
for _, parameter := range pattern.Parameters {
205217
parameters = append(parameters, tools.PatternParameterConfiguration{
206-
Name: parameter.name,
207-
Value: parameter.value,
218+
Name: parameter.Name,
219+
Value: parameter.Value,
208220
})
209221
}
210222

@@ -222,13 +234,13 @@ func convertAPIToolConfigurationToDomain(config CodacyToolConfiguration) tools.T
222234
}
223235
}
224236

225-
func extractESLintConfiguration(toolConfigurations []CodacyToolConfiguration) *CodacyToolConfiguration {
237+
func extractESLintConfiguration(toolConfigurations []types.ToolConfiguration) *types.ToolConfiguration {
226238

227239
//ESLInt internal codacy uuid, to filter ot not ESLint tools
228-
//"f8b29663-2cb2-498d-b923-a10c6a8c05cd"
240+
const ESLintUUID = "f8b29663-2cb2-498d-b923-a10c6a8c05cd"
229241

230242
for _, toolConfiguration := range toolConfigurations {
231-
if toolConfiguration.Uuid == "f8b29663-2cb2-498d-b923-a10c6a8c05cd" {
243+
if toolConfiguration.Uuid == ESLintUUID {
232244
return &toolConfiguration
233245
}
234246
}
@@ -237,7 +249,7 @@ func extractESLintConfiguration(toolConfigurations []CodacyToolConfiguration) *C
237249
}
238250

239251
// extractTrivyConfiguration extracts Trivy configuration from the Codacy API response
240-
func extractTrivyConfiguration(toolConfigurations []CodacyToolConfiguration) *CodacyToolConfiguration {
252+
func extractTrivyConfiguration(toolConfigurations []types.ToolConfiguration) *types.ToolConfiguration {
241253
// Trivy internal codacy uuid
242254
const TrivyUUID = "2fd7fbe0-33f9-4ab3-ab73-e9b62404e2cb"
243255

@@ -250,25 +262,28 @@ func extractTrivyConfiguration(toolConfigurations []CodacyToolConfiguration) *Co
250262
return nil
251263
}
252264

253-
type CodacyToolConfiguration struct {
254-
Uuid string `json:"uuid"`
255-
IsEnabled bool `json:"isEnabled"`
256-
Patterns []PatternConfiguration `json:"patterns"`
257-
}
265+
func extractPylintConfiguration(toolConfigurations []types.ToolConfiguration) *types.ToolConfiguration {
266+
const PylintUUID = "31677b6d-4ae0-4f56-8041-606a8d7a8e61"
258267

259-
type PatternConfiguration struct {
260-
InternalId string `json:"internalId"`
261-
Parameters []ParameterConfiguration `json:"parameters"`
268+
for _, toolConfiguration := range toolConfigurations {
269+
if toolConfiguration.Uuid == PylintUUID {
270+
return &toolConfiguration
271+
}
272+
}
273+
return nil
262274
}
263275

264-
type ParameterConfiguration struct {
265-
name string `json:"name"`
266-
value string `json:"value"`
276+
func createPylintConfigFile(config types.ToolConfiguration) error {
277+
if config.IsEnabled {
278+
pylintConfigurationString := pylint.GeneratePylintRC(config)
279+
return os.WriteFile(".pylintrc", []byte(pylintConfigurationString), 0644)
280+
}
281+
return nil
267282
}
268283

269284
// createTrivyConfigFile creates a trivy.yaml configuration file based on the API configuration
270-
func createTrivyConfigFile(config CodacyToolConfiguration) error {
271-
// Convert CodacyToolConfiguration to tools.ToolConfiguration
285+
func createTrivyConfigFile(config types.ToolConfiguration) error {
286+
// Convert ToolConfiguration to tools.ToolConfiguration
272287
trivyDomainConfiguration := convertAPIToolConfigurationForTrivy(config)
273288

274289
// Use the shared CreateTrivyConfig function to generate the config content
@@ -279,7 +294,7 @@ func createTrivyConfigFile(config CodacyToolConfiguration) error {
279294
}
280295

281296
// convertAPIToolConfigurationForTrivy converts API tool configuration to domain model for Trivy
282-
func convertAPIToolConfigurationForTrivy(config CodacyToolConfiguration) tools.ToolConfiguration {
297+
func convertAPIToolConfigurationForTrivy(config types.ToolConfiguration) tools.ToolConfiguration {
283298
var patterns []tools.PatternConfiguration
284299

285300
// Only process if tool is enabled
@@ -292,7 +307,7 @@ func convertAPIToolConfigurationForTrivy(config CodacyToolConfiguration) tools.T
292307

293308
// Check if there's an explicit enabled parameter
294309
for _, param := range pattern.Parameters {
295-
if param.name == "enabled" && param.value == "false" {
310+
if param.Name == "enabled" && param.Value == "false" {
296311
patternEnabled = false
297312
}
298313
}

‎tools/pylint/pylintConfigParser.go‎

Lines changed: 127 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,127 @@
1+
package pylint
2+
3+
import (
4+
"codacy/cli-v2/tools/types"
5+
"fmt"
6+
"log"
7+
"strings"
8+
)
9+
10+
// GeneratePylintRC generates a pylintrc file content with the specified patterns enabled
11+
func GeneratePylintRC(config types.ToolConfiguration) string {
12+
var rcContent strings.Builder
13+
14+
// Write header
15+
rcContent.WriteString("[MASTER]\n")
16+
rcContent.WriteString("ignore=CVS\n")
17+
rcContent.WriteString("persistent=yes\n")
18+
rcContent.WriteString("load-plugins=\n\n")
19+
20+
// Disable all patterns by default
21+
rcContent.WriteString("[MESSAGES CONTROL]\n")
22+
rcContent.WriteString("disable=all\n")
23+
24+
// Collect all enabled pattern IDs and their parameters
25+
var enabledPatternsIds []string
26+
patternParams := make(map[string]map[string]string)
27+
28+
// Only process patterns if the tool is enabled
29+
if config.IsEnabled {
30+
for _, pattern := range config.Patterns {
31+
patternID := extractPatternId(pattern.InternalId)
32+
enabledPatternsIds = append(enabledPatternsIds, patternID)
33+
34+
// Store parameters for this pattern
35+
params := make(map[string]string)
36+
for _, param := range pattern.Parameters {
37+
params[param.Name] = param.Value
38+
}
39+
patternParams[patternID] = params
40+
}
41+
}
42+
43+
// Write all enabled patterns in a single line
44+
if len(enabledPatternsIds) > 0 {
45+
rcContent.WriteString(fmt.Sprintf("enable=%s\n", strings.Join(enabledPatternsIds, ",")))
46+
}
47+
rcContent.WriteString("\n")
48+
49+
// Group parameters by section
50+
groupedParams := groupParametersBySection(config)
51+
52+
// Write parameters for each section
53+
for sectionName, params := range groupedParams {
54+
rcContent.WriteString(fmt.Sprintf("[%s]\n", sectionName))
55+
for _, param := range params {
56+
value := param.Value
57+
if value == "" {
58+
// If no value is set, use default from PatternDefaultParameters
59+
if defaultParams, ok := PatternDefaultParameters[extractPatternId(param.Name)]; ok {
60+
for _, defaultParam := range defaultParams {
61+
if defaultParam.Name == param.Name {
62+
value = defaultParam.Value
63+
break
64+
}
65+
}
66+
}
67+
}
68+
rcContent.WriteString(fmt.Sprintf("%s=%s\n", param.Name, value))
69+
}
70+
rcContent.WriteString("\n")
71+
}
72+
73+
return rcContent.String()
74+
}
75+
76+
// groupParametersBySection groups parameters by their section name
77+
func groupParametersBySection(config types.ToolConfiguration) map[string][]types.PylintPatternParameterConfiguration {
78+
// Initialize the result map
79+
groupedParams := make(map[string][]types.PylintPatternParameterConfiguration)
80+
81+
// Iterate through each pattern
82+
for _, pattern := range config.Patterns {
83+
// Get parameters to process - either from the pattern or from defaults
84+
if len(pattern.Parameters) == 0 {
85+
// If no parameters, check defaults
86+
patternID := extractPatternId(pattern.InternalId)
87+
pattern.Parameters = PatternDefaultParameters[patternID]
88+
}
89+
90+
// Convert pattern parameters to PylintPatternParameterConfiguration
91+
parameters := make([]types.PylintPatternParameterConfiguration, len(pattern.Parameters))
92+
for i, param := range pattern.Parameters {
93+
parameters[i] = types.PylintPatternParameterConfiguration{
94+
Name: param.Name,
95+
Value: param.Value,
96+
SectionName: GetParameterSection(param.Name),
97+
}
98+
}
99+
100+
// Process all parameters (either from pattern or defaults)
101+
for _, param := range parameters {
102+
// Skip parameters without a section name
103+
if param.SectionName == nil {
104+
log.Printf("Parameter %s has no section name", param.Name)
105+
continue
106+
}
107+
108+
// Get the section name
109+
sectionName := *param.SectionName
110+
111+
// Add the parameter to the appropriate section
112+
groupedParams[sectionName] = append(groupedParams[sectionName], param)
113+
}
114+
}
115+
116+
return groupedParams
117+
}
118+
119+
// extractPatternId returns the part of the pattern ID after the underscore
120+
// For example: "PyLintPython3_C0301" -> "C0301"
121+
func extractPatternId(fullID string) string {
122+
parts := strings.Split(fullID, "_")
123+
if len(parts) > 1 {
124+
return parts[1]
125+
}
126+
return fullID
127+
}

‎tools/pylint/pylintDefaults.go‎

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
1+
package pylint
2+
3+
import "codacy/cli-v2/tools/types"
4+
5+
// PatternDefaultParameters contains the default parameters for Pylint patterns
6+
var PatternDefaultParameters = map[string][]types.ParameterConfiguration{
7+
"R0914": {
8+
{
9+
Name: "max-locals",
10+
Value: "15",
11+
},
12+
},
13+
"C0301": {
14+
{
15+
Name: "max-line-length",
16+
Value: "120",
17+
},
18+
},
19+
"C0102": {
20+
{
21+
Name: "bad-names",
22+
Value: "foo,bar,baz,toto,tutu,tata",
23+
},
24+
},
25+
"C0103": {
26+
{
27+
Name: "argument-rgx",
28+
Value: "[a-z_][a-z0-9_]{2,30}$",
29+
},
30+
{
31+
Name: "attr-rgx",
32+
Value: "[a-z_][a-z0-9_]{2,30}$",
33+
},
34+
{
35+
Name: "class-rgx",
36+
Value: "[A-Z_][a-zA-Z0-9]+$",
37+
},
38+
{
39+
Name: "const-rgx",
40+
Value: "(([A-Z_][A-Z0-9_]*)|(__.*__))$",
41+
},
42+
{
43+
Name: "function-rgx",
44+
Value: "[a-z_][a-z0-9_]{2,30}$",
45+
},
46+
{
47+
Name: "method-rgx",
48+
Value: "[a-z_][a-z0-9_]{2,30}$",
49+
},
50+
{
51+
Name: "module-rgx",
52+
Value: "(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$",
53+
},
54+
{
55+
Name: "variable-rgx",
56+
Value: "[a-z_][a-z0-9_]{2,30}$",
57+
},
58+
{
59+
Name: "inlinevar-rgx",
60+
Value: "[A-Za-z_][A-Za-z0-9_]*$",
61+
},
62+
{
63+
Name: "class-attribute-rgx",
64+
Value: "([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$",
65+
},
66+
},
67+
}

0 commit comments

Comments
 (0)