Refactor loadRequiredLanguageParsers

src/AnalyzeProject/index.ts

@@ -1,7 +1,7 @@
 import * as fs from "fs/promises"
 import { globby } from "globby"
 import * as path from "path"
-import { LanguageParser, loadAllLanguages } from "./languageParser"
+import { LanguageParser, loadRequiredLanguageParsers } from "./languageParser"
 
 async function analyzeProject(dirPath: string): Promise<string> {
 	let result = ""
@@ -13,7 +13,7 @@ async function analyzeProject(dirPath: string): Promise<string> {
 	const { filesToParse, remainingFiles } = separateFiles(allFiles)
 
 	// Load only the necessary language parsers
-	const languageParsers = await loadAllLanguages(filesToParse)
+	const languageParsers = await loadRequiredLanguageParsers(filesToParse)
 
 	// Parse specific files and generate result
 	result += "Files parsed with ASTs:\n"

src/AnalyzeProject/languageParser.ts

@@ -46,100 +46,75 @@ Sources:
 - https://github.com/tree-sitter/node-tree-sitter/issues/168
 - https://github.com/Gregoor/tree-sitter-wasms/blob/main/README.md
 */
-export async function loadAllLanguages(filesToParse: string[]): Promise<LanguageParser> {
+export async function loadRequiredLanguageParsers(filesToParse: string[]): Promise<LanguageParser> {
 	await Parser.init()
-
 	const extensionsToLoad = new Set(filesToParse.map((file) => path.extname(file).toLowerCase().slice(1)))
-
-	const languageMap: { [key: string]: string } = {
-		js: "javascript",
-		jsx: "javascript",
-		ts: "typescript",
-		tsx: "tsx",
-		py: "python",
-		rs: "rust",
-		go: "go",
-		cpp: "cpp",
-		hpp: "cpp",
-		c: "c",
-		h: "c",
-		cs: "c_sharp",
-		rb: "ruby",
-		java: "java",
-		php: "php",
-		swift: "swift",
-	}
-
-	const languages: { [key: string]: Parser.Language } = {}
-
-	for (const ext of extensionsToLoad) {
-		if (ext in languageMap) {
-			const langName = languageMap[ext as keyof typeof languageMap]
-			if (!languages[langName]) {
-				languages[langName] = await loadLanguage(langName)
-			}
-		}
-	}
-
 	const parsers: LanguageParser = {}
-
 	for (const ext of extensionsToLoad) {
-		if (ext in languageMap) {
+		let language: Parser.Language
-			const langName = languageMap[ext as keyof typeof languageMap]
+		let query: Parser.Query
-			const lang = languages[langName]
+		switch (ext) {
-
+			case "js":
-			const parser = new Parser()
+			case "jsx":
-			parser.setLanguage(lang)
+				language = await loadLanguage("javascript")
-			let query: Parser.Query
+				query = language.query(javascriptQuery)
-
+				break
-			switch (ext) {
+			case "ts":
-				case "js":
+				language = await loadLanguage("typescript")
-				case "jsx":
+				query = language.query(typescriptQuery)
-					query = lang.query(javascriptQuery)
+				break
-					break
+			case "tsx":
-				case "ts":
+				language = await loadLanguage("tsx")
-				case "tsx":
+				query = language.query(typescriptQuery)
-					query = lang.query(typescriptQuery)
+				break
-					break
+			case "py":
-				case "py":
+				language = await loadLanguage("python")
-					query = lang.query(pythonQuery)
+				query = language.query(pythonQuery)
-					break
+				break
-				case "rs":
+			case "rs":
-					query = lang.query(rustQuery)
+				language = await loadLanguage("rust")
-					break
+				query = language.query(rustQuery)
-				case "go":
+				break
-					query = lang.query(goQuery)
+			case "go":
-					break
+				language = await loadLanguage("go")
-				case "cpp":
+				query = language.query(goQuery)
-				case "hpp":
+				break
-					query = lang.query(cppQuery)
+			case "cpp":
-					break
+			case "hpp":
-				case "c":
+				language = await loadLanguage("cpp")
-				case "h":
+				query = language.query(cppQuery)
-					query = lang.query(cQuery)
+				break
-					break
+			case "c":
-				case "cs":
+			case "h":
-					query = lang.query(csharpQuery)
+				language = await loadLanguage("c")
-					break
+				query = language.query(cQuery)
-				case "rb":
+				break
-					query = lang.query(rubyQuery)
+			case "cs":
-					break
+				language = await loadLanguage("c_sharp")
-				case "java":
+				query = language.query(csharpQuery)
-					query = lang.query(javaQuery)
+				break
-					break
+			case "rb":
-				case "php":
+				language = await loadLanguage("ruby")
-					query = lang.query(phpQuery)
+				query = language.query(rubyQuery)
-					break
+				break
-				case "swift":
+			case "java":
-					query = lang.query(swiftQuery)
+				language = await loadLanguage("java")
-					break
+				query = language.query(javaQuery)
-				default:
+				break
-					throw new Error(`Unsupported language: ${ext}`)
+			case "php":
-			}
+				language = await loadLanguage("php")
-
+				query = language.query(phpQuery)
-			parsers[ext] = { parser, query }
+				break
+			case "swift":
+				language = await loadLanguage("swift")
+				query = language.query(swiftQuery)
+				break
+			default:
+				throw new Error(`Unsupported language: ${ext}`)
 		}
+		const parser = new Parser()
+		parser.setLanguage(language)
+		parsers[ext] = { parser, query }
 	}
-
 	return parsers
 }