Skip to content

Commit 43af36f

Browse files
HichemTab-techHichemTab-tech
committed
Integrate gitignore support into directory tree building
Enhanced the `buildTreeNode` function to account for `.gitignore` patterns when generating directory trees. This ensures files and directories that match gitignore rules are excluded or marked as unchecked. - Added `collectDirectoryGitignorePatterns` and `shouldExcludeByGitignore` utility functions. - Updated `buildTreeNode` to handle gitignore patterns and pass them recursively. - Adjusted logic to mark files/folders as unchecked if excluded by gitignore rules.
1 parent 5b6aff8 commit 43af36f

File tree

2 files changed

+221
-5
lines changed

2 files changed

+221
-5
lines changed

‎src/extension.ts‎

Lines changed: 31 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ import * as vscode from 'vscode';
22
import * as fs from 'fs';
33
import * as path from 'path';
44
import { JetTreeMarkViewProvider } from './JetTreeMarkViewProvider';
5+
import { collectDirectoryGitignorePatterns, shouldExcludeByGitignore, GitignorePattern } from './gitignore-utils';
56

67
// noinspection JSUnusedGlobalSymbols
78
export function activate(ctx: vscode.ExtensionContext) {
@@ -43,9 +44,20 @@ interface TreeNodeType {
4344

4445
/**
4546
* Build a TreeNodeType *for* the directory itself, including its contents.
47+
* @param dir Directory path
48+
* @param parentPatterns Optional gitignore patterns from parent directories
49+
* @param forceUncheck
50+
* @returns TreeNodeType representing the directory
4651
*/
47-
export function buildTreeNode(dir: string): TreeNodeType {
52+
export function buildTreeNode(dir: string, parentPatterns: GitignorePattern[] = [], forceUncheck: boolean = false): TreeNodeType {
4853
const name = path.basename(dir) || dir;
54+
55+
// Collect gitignore patterns for this directory
56+
const directoryPatterns = collectDirectoryGitignorePatterns(dir);
57+
58+
// Combine with parent patterns (parent patterns take precedence)
59+
const allPatterns = [...directoryPatterns, ...parentPatterns];
60+
4961
const node: TreeNodeType = {
5062
id: dir,
5163
name,
@@ -61,17 +73,31 @@ export function buildTreeNode(dir: string): TreeNodeType {
6173

6274
for (const entry of entries) {
6375
const fullPath = path.join(dir, entry.name);
64-
if (entry.isDirectory()) {
65-
node.children!.push(buildTreeNode(fullPath));
76+
const isDirectory = entry.isDirectory();
77+
78+
// Check if this file/folder should be excluded based on gitignore patterns
79+
const shouldExclude = shouldExcludeByGitignore(fullPath, dir, allPatterns, isDirectory);
80+
81+
if (isDirectory) {
82+
// Process subdirectory, passing down the combined patterns
83+
const childNode = buildTreeNode(fullPath, allPatterns, shouldExclude || forceUncheck);
84+
85+
// If the directory itself matches gitignore patterns, mark it as unchecked
86+
if (shouldExclude || forceUncheck) {
87+
childNode.checked = false;
88+
}
89+
90+
node.children!.push(childNode);
6691
} else {
92+
// Add file node
6793
node.children!.push({
6894
id: fullPath,
6995
name: entry.name,
7096
type: 'file',
71-
checked: true
97+
checked: !shouldExclude && !forceUncheck // Set checked to false if it matches gitignore patterns
7298
});
7399
}
74100
}
75101

76102
return node;
77-
}
103+
}

‎src/gitignore-utils.ts‎

Lines changed: 190 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,190 @@
1+
import * as fs from 'fs';
2+
import * as path from 'path';
3+
4+
/**
5+
* Represents a parsed gitignore pattern
6+
*/
7+
export interface GitignorePattern {
8+
pattern: string;
9+
isNegated: boolean;
10+
isDirectory: boolean;
11+
isAbsolute: boolean;
12+
}
13+
14+
/**
15+
* Parses a .gitignore file and returns an array of patterns
16+
* @param gitignorePath Path to the .gitignore file
17+
* @returns Array of parsed gitignore patterns
18+
*/
19+
export function parseGitignoreFile(gitignorePath: string): GitignorePattern[] {
20+
if (!fs.existsSync(gitignorePath)) {
21+
return [];
22+
}
23+
24+
const content = fs.readFileSync(gitignorePath, 'utf8');
25+
return parseGitignoreContent(content);
26+
}
27+
28+
/**
29+
* Parses gitignore content and returns an array of patterns
30+
* @param content Content of the .gitignore file
31+
* @returns Array of parsed gitignore patterns
32+
*/
33+
export function parseGitignoreContent(content: string): GitignorePattern[] {
34+
return content
35+
.split('\n')
36+
.map(line => line.trim())
37+
.filter(line => line && !line.startsWith('#')) // Remove empty lines and comments
38+
.map(line => {
39+
const isNegated = line.startsWith('!');
40+
const pattern = isNegated ? line.substring(1) : line;
41+
const isDirectory = pattern.endsWith('/');
42+
const isAbsolute = pattern.startsWith('/') || pattern.startsWith('./');
43+
44+
return {
45+
pattern: isAbsolute ? pattern.substring(pattern.startsWith('./') ? 2 : 1) : pattern,
46+
isNegated,
47+
isDirectory,
48+
isAbsolute
49+
};
50+
});
51+
}
52+
53+
/**
54+
* Checks if a file or directory matches any of the gitignore patterns
55+
* @param filePath Path to the file or directory (relative to the directory containing the .gitignore)
56+
* @param patterns Array of gitignore patterns
57+
* @param isDirectory Whether the path is a directory
58+
* @returns True if the file or directory should be ignored
59+
*/
60+
export function matchesGitignorePatterns(
61+
filePath: string,
62+
patterns: GitignorePattern[],
63+
isDirectory: boolean
64+
): boolean {
65+
// Normalize path for matching
66+
const normalizedPath = filePath.replace(/\\/g, '/');
67+
68+
// Start with not ignored, then apply patterns in order
69+
let ignored = false;
70+
71+
for (const pattern of patterns) {
72+
// Skip directory-only patterns if this is a file
73+
if (pattern.isDirectory && !isDirectory) {
74+
continue;
75+
}
76+
77+
if (matchesPattern(normalizedPath, pattern, isDirectory)) {
78+
// If pattern matches, set ignored based on whether it's negated
79+
ignored = !pattern.isNegated;
80+
}
81+
}
82+
83+
return ignored;
84+
}
85+
86+
/**
87+
* Checks if a path matches a gitignore pattern
88+
* @param normalizedPath Normalized path to check
89+
* @param pattern Gitignore pattern
90+
* @param isDirectory Whether the path is a directory
91+
* @returns True if the path matches the pattern
92+
*/
93+
function matchesPattern(
94+
normalizedPath: string,
95+
pattern: GitignorePattern,
96+
isDirectory: boolean
97+
): boolean {
98+
const patternStr = pattern.pattern.replace(/\\/g, '/');
99+
100+
// Handle exact matches
101+
if (!patternStr.includes('*')) {
102+
if (pattern.isAbsolute) {
103+
// For absolute patterns, match from the beginning
104+
return normalizedPath === patternStr ||
105+
(isDirectory && normalizedPath.startsWith(patternStr + '/'));
106+
} else {
107+
// For relative patterns, match anywhere in the path
108+
return normalizedPath === patternStr ||
109+
normalizedPath.endsWith('/' + patternStr) ||
110+
normalizedPath.includes('/' + patternStr + '/') ||
111+
(isDirectory && (
112+
normalizedPath.endsWith('/' + patternStr) ||
113+
normalizedPath.includes('/' + patternStr + '/')
114+
));
115+
}
116+
}
117+
118+
// Handle wildcard patterns
119+
const regexPattern = patternStr
120+
.replace(/\./g, '\\.') // Escape dots
121+
.replace(/\*/g, '.*') // Convert * to .*
122+
.replace(/\?/g, '.'); // Convert ? to .
123+
124+
const regex = pattern.isAbsolute
125+
? new RegExp(`^${regexPattern}$`)
126+
: new RegExp(`(^|/)${regexPattern}$`);
127+
128+
return regex.test(normalizedPath);
129+
}
130+
131+
/**
132+
* Collects gitignore patterns from a specific directory
133+
* @param dirPath Path to the directory
134+
* @returns Array of gitignore patterns from this directory
135+
*/
136+
export function collectDirectoryGitignorePatterns(dirPath: string): GitignorePattern[] {
137+
const gitignorePath = path.join(dirPath, '.gitignore');
138+
if (fs.existsSync(gitignorePath)) {
139+
return parseGitignoreFile(gitignorePath);
140+
}
141+
return [];
142+
}
143+
144+
/**
145+
* Collects all gitignore patterns that apply to a given directory
146+
* @param dirPath Path to the directory
147+
* @returns Array of gitignore patterns that apply to the directory
148+
*/
149+
export function collectGitignorePatterns(dirPath: string): GitignorePattern[] {
150+
const patterns: GitignorePattern[] = [];
151+
let currentDir = dirPath;
152+
153+
// Collect patterns from all parent directories up to the root
154+
while (true) {
155+
const gitignorePath = path.join(currentDir, '.gitignore');
156+
if (fs.existsSync(gitignorePath)) {
157+
const dirPatterns = parseGitignoreFile(gitignorePath);
158+
patterns.push(...dirPatterns);
159+
}
160+
161+
const parentDir = path.dirname(currentDir);
162+
if (parentDir === currentDir) {
163+
break; // Reached the root
164+
}
165+
currentDir = parentDir;
166+
}
167+
168+
return patterns;
169+
}
170+
171+
/**
172+
* Determines if a file or directory should be excluded based on gitignore patterns
173+
* @param fullPath Full path to the file or directory
174+
* @param baseDir Base directory for relative path calculation
175+
* @param patterns Gitignore patterns to check against
176+
* @param isDirectory Whether the path is a directory
177+
* @returns True if the file or directory should be excluded
178+
*/
179+
export function shouldExcludeByGitignore(
180+
fullPath: string,
181+
baseDir: string,
182+
patterns: GitignorePattern[],
183+
isDirectory: boolean
184+
): boolean {
185+
// Calculate path relative to the base directory
186+
const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
187+
188+
// Check if the path matches any gitignore pattern
189+
return matchesGitignorePatterns(relativePath, patterns, isDirectory);
190+
}

0 commit comments

Comments
 (0)