feature: Respect the file information for languages from the API CF-1742

Author: machadoit

cmd/analyze.go

@@ -41,6 +41,7 @@ type LanguagesConfig struct {
 		Name       string   `yaml:"name" json:"name"`
 		Languages  []string `yaml:"languages" json:"languages"`
 		Extensions []string `yaml:"extensions" json:"extensions"`
+		Files      []string `yaml:"files" json:"files"`
 	} `yaml:"tools" json:"tools"`
 }
 
@@ -90,18 +91,15 @@ func GetFileExtension(filePath string) string {
 	return strings.ToLower(filepath.Ext(filePath))
 }
 
-// IsToolSupportedForFile checks if a tool supports a given file based on its extension
+// IsToolSupportedForFile checks if a tool supports a given file based on its extension or filename
 func IsToolSupportedForFile(toolName string, filePath string, langConfig *LanguagesConfig) bool {
 	if langConfig == nil {
 		// If no language config is available, assume all tools are supported
 		return true
 	}
 
 	fileExt := GetFileExtension(filePath)
-	if fileExt == "" {
-		// If file has no extension, assume tool is supported
-		return true
-	}
+	fileName := filepath.Base(filePath)
 
 	for _, tool := range langConfig.Tools {
 		if tool.Name == toolName {
@@ -117,6 +115,13 @@ func IsToolSupportedForFile(toolName string, filePath string, langConfig *Langua
 				}
 			}
 
+			// Check if filename is supported by this tool (exact match)
+			for _, file := range tool.Files {
+				if strings.EqualFold(file, fileName) {
+					return true
+				}
+			}
+
 			// Extension not found in tool's supported extensions
 			return false
 		}

cmd/analyze_test.go

@@ -62,21 +62,31 @@ func TestIsToolSupportedForFile(t *testing.T) {
 			Name       string   `yaml:"name" json:"name"`
 			Languages  []string `yaml:"languages" json:"languages"`
 			Extensions []string `yaml:"extensions" json:"extensions"`
+			Files      []string `yaml:"files" json:"files"`
 		}{
 			{
 				Name:       "pylint",
 				Languages:  []string{"Python"},
 				Extensions: []string{".py"},
+				Files:      []string{},
+			},
+			{
+				Name:       "eslint",
+				Languages:  []string{"JavaScript", "TypeScript"},
+				Extensions: []string{},
+				Files:      []string{},
 			},
 			{
 				Name:       "cppcheck",
 				Languages:  []string{"C", "CPP"},
 				Extensions: []string{".c", ".cpp", ".h", ".hpp"},
+				Files:      []string{},
 			},
 			{
 				Name:       "trivy",
 				Languages:  []string{"Multiple"},
-				Extensions: []string{},
+				Extensions: []string{".yaml", ".yml"},
+				Files:      []string{"requirements.txt"},
 			},
 		},
 	}
@@ -111,7 +121,7 @@ func TestIsToolSupportedForFile(t *testing.T) {
 		},
 		{
 			name:     "Tool with no extensions specified",
-			toolName: "trivy",
+			toolName: "eslint",
 			filePath: "any.file",
 			config:   langConfig,
 			want:     true,
@@ -130,6 +140,13 @@ func TestIsToolSupportedForFile(t *testing.T) {
 			config:   nil,
 			want:     true,
 		},
+		{
+			name:     "Trivy with requirements.txt",
+			toolName: "trivy",
+			filePath: "requirements.txt",
+			config:   langConfig,
+			want:     true,
+		},
 	}
 
 	for _, tt := range tests {

codacy-client/client.go

@@ -253,7 +253,7 @@ func GetToolsVersions() ([]domain.Tool, error) {
 }
 
 // GetRepositoryLanguages fetches the languages for a repository
-func GetRepositoryLanguages(initFlags domain.InitFlags) ([]domain.Language, error) {
+func GetRepositoryLanguages(initFlags domain.InitFlags) ([]domain.RepositoryLanguage, error) {
 	baseURL := fmt.Sprintf("%s/api/v3/organizations/%s/%s/repositories/%s/settings/languages",
 		CodacyApiBase,
 		initFlags.Provider,

domain/language.go

@@ -1,23 +1,32 @@
 package domain
 
-// Language represents a language in the Codacy API
-type Language struct {
+// RepositoryLanguage represents a language in the Codacy API
+type RepositoryLanguage struct {
 	Name           string   `json:"name"`
 	CodacyDefaults []string `json:"codacyDefaults"`
 	Extensions     []string `json:"extensions"`
+	DefaultFiles   []string `json:"defaultFiles"`
 	Enabled        bool     `json:"enabled"`
 	Detected       bool     `json:"detected"`
 }
 
 // LanguagesResponse represents the structure of the languages response
 type LanguagesResponse struct {
-	Languages []Language `json:"languages"`
+	Languages []RepositoryLanguage `json:"languages"`
+}
+
+// Language represents a processed language with combined extensions and files
+type Language struct {
+	Name       string
+	Extensions []string
+	Files      []string
 }
 
 // LanguageTool represents a language tool with its file extensions from the API
 type LanguageTool struct {
 	Name           string   `json:"name"`
 	FileExtensions []string `json:"fileExtensions"`
+	Files          []string `json:"files"`
 }
 
 // LanguageToolsResponse represents the structure of the language tools API response
@@ -30,6 +39,7 @@ type ToolLanguageInfo struct {
 	Name       string   `yaml:"name"`
 	Languages  []string `yaml:"languages,flow"`
 	Extensions []string `yaml:"extensions,flow"`
+	Files      []string `yaml:"files,flow"`
 }
 
 // LanguagesConfig represents the structure of the languages configuration file

tools/language_config.go

@@ -44,6 +44,12 @@ func buildToolLanguageInfoFromAPI() (map[string]domain.ToolLanguageInfo, error)
 		languageExtensionsMap[strings.ToLower(langTool.Name)] = langTool.FileExtensions
 	}
 
+	// Create map of language name to files
+	languageFilesMap := make(map[string][]string)
+	for _, langTool := range languageTools {
+		languageFilesMap[strings.ToLower(langTool.Name)] = langTool.Files
+	}
+
 	// Build tool language configurations from API data
 	result := make(map[string]domain.ToolLanguageInfo)
 	supportedToolNames := make(map[string]bool)
@@ -72,22 +78,33 @@ func buildToolLanguageInfoFromAPI() (map[string]domain.ToolLanguageInfo, error)
 			Extensions: []string{},
 		}
 
-		// Build extensions from API language data
+		// Build extensions and files from API language data
 		extensionsSet := make(map[string]struct{})
+		filesSet := make(map[string]struct{})
+
 		for _, apiLang := range tool.Languages {
 			lowerLang := strings.ToLower(apiLang)
 			if extensions, exists := languageExtensionsMap[lowerLang]; exists {
 				for _, ext := range extensions {
 					extensionsSet[ext] = struct{}{}
 				}
 			}
+			if files, exists := languageFilesMap[lowerLang]; exists {
+				for _, file := range files {
+					filesSet[file] = struct{}{}
+				}
+			}
 		}
 
-		// Convert set to sorted slice
+		// Convert sets to sorted slices
 		for ext := range extensionsSet {
 			configTool.Extensions = append(configTool.Extensions, ext)
 		}
 		slices.Sort(configTool.Extensions)
+		for file := range filesSet {
+			configTool.Files = append(configTool.Files, file)
+		}
+		slices.Sort(configTool.Files)
 
 		// Sort languages alphabetically
 		slices.Sort(configTool.Languages)
@@ -201,18 +218,6 @@ func CreateLanguagesConfigFile(apiTools []domain.Tool, toolsConfigDir string, to
 
 // buildRemoteModeLanguagesConfig builds the languages config for remote mode using repository languages as source of truth
 func buildRemoteModeLanguagesConfig(apiTools []domain.Tool, toolIDMap map[string]string, initFlags domain.InitFlags) ([]domain.ToolLanguageInfo, error) {
-	// Get language file extensions from API
-	languageTools, err := codacyclient.GetLanguageTools()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get language tools from API: %w", err)
-	}
-
-	// Create map of language name to file extensions
-	languageExtensionsMap := make(map[string][]string)
-	for _, langTool := range languageTools {
-		languageExtensionsMap[strings.ToLower(langTool.Name)] = langTool.FileExtensions
-	}
-
 	// Get repository languages - this is the single source of truth for remote mode
 	repositoryLanguages, err := getRepositoryLanguages(initFlags)
 	if err != nil {
@@ -232,18 +237,36 @@ func buildRemoteModeLanguagesConfig(apiTools []domain.Tool, toolIDMap map[string
 			Name:       shortName,
 			Languages:  []string{},
 			Extensions: []string{},
+			Files:      []string{},
 		}
 
 		// Use only languages that exist in the repository
 		extensionsSet := make(map[string]struct{})
+		filesSet := make(map[string]struct{})
 
 		for _, lang := range tool.Languages {
 			lowerLang := strings.ToLower(lang)
-			if repoExts, exists := repositoryLanguages[lowerLang]; exists && len(repoExts) > 0 {
-				configTool.Languages = append(configTool.Languages, lang)
-				// Add repository-specific extensions
-				for _, ext := range repoExts {
-					extensionsSet[ext] = struct{}{}
+			if repoLang, exists := repositoryLanguages[lowerLang]; exists {
+				// Check if this language has either extensions or files
+				hasExtensions := len(repoLang.Extensions) > 0
+				hasFiles := len(repoLang.Files) > 0
+
+				if hasExtensions || hasFiles {
+					configTool.Languages = append(configTool.Languages, lang)
+
+					// Add repository-specific extensions if they exist
+					if hasExtensions {
+						for _, ext := range repoLang.Extensions {
+							extensionsSet[ext] = struct{}{}
+						}
+					}
+
+					// Add repository-specific files if they exist
+					if hasFiles {
+						for _, file := range repoLang.Files {
+							filesSet[file] = struct{}{}
+						}
+					}
 				}
 			}
 		}
@@ -254,6 +277,12 @@ func buildRemoteModeLanguagesConfig(apiTools []domain.Tool, toolIDMap map[string
 		}
 		slices.Sort(configTool.Extensions)
 
+		// Convert files set to sorted slice
+		for file := range filesSet {
+			configTool.Files = append(configTool.Files, file)
+		}
+		slices.Sort(configTool.Files)
+
 		// Sort languages alphabetically
 		slices.Sort(configTool.Languages)
 
@@ -264,14 +293,14 @@ func buildRemoteModeLanguagesConfig(apiTools []domain.Tool, toolIDMap map[string
 	return configTools, nil
 }
 
-func getRepositoryLanguages(initFlags domain.InitFlags) (map[string][]string, error) {
+func getRepositoryLanguages(initFlags domain.InitFlags) (map[string]domain.Language, error) {
 	response, err := codacyclient.GetRepositoryLanguages(initFlags)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get repository languages: %w", err)
 	}
 
-	// Create map to store language name -> combined extensions
-	result := make(map[string][]string)
+	// Create map to store language name -> Language struct
+	result := make(map[string]domain.Language)
 
 	// Filter and process languages
 	for _, lang := range response {
@@ -285,17 +314,32 @@ func getRepositoryLanguages(initFlags domain.InitFlags) (map[string][]string, er
 				extensions[ext] = struct{}{}
 			}
 
-			// Convert map to slice
+			// Combine and deduplicate files
+			files := make(map[string]struct{})
+			for _, file := range lang.DefaultFiles {
+				files[file] = struct{}{}
+			}
+
+			// Convert extension map to slice
 			extSlice := make([]string, 0, len(extensions))
 			for ext := range extensions {
 				extSlice = append(extSlice, ext)
 			}
-
-			// Sort extensions for consistent ordering in the config file
 			slices.Sort(extSlice)
 
+			// Convert files map to slice
+			fileSlice := make([]string, 0, len(files))
+			for file := range files {
+				fileSlice = append(fileSlice, file)
+			}
+			slices.Sort(fileSlice)
+
 			// Add to result map with lowercase key for case-insensitive matching
-			result[strings.ToLower(lang.Name)] = extSlice
+			result[strings.ToLower(lang.Name)] = domain.Language{
+				Name:       lang.Name,
+				Extensions: extSlice,
+				Files:      fileSlice,
+			}
 		}
 	}