commit 7670174930643ad04a9a66d7fe2519f790f9e15a · knotbin.com/doggo

+19 -15

core.ts

···

       434
       434
        
         return null;

     

       435
       435
        
       }

     

       436
       436
        
       

     

       437
       437
       +
       function escapeRegExp(str: string): string {

     

       438
       438
       +
         return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

     

       439
       439
       +
       }

     

       440
       440
       +
       

     

       437
       441
        
       async function findSymbolInFile(

     

       438
       442
        
         filePath: string,

     

       439
       443
        
         symbolName: string,

     
···

       456
       460
        
             // Also check for non-exported declarations (class, function, interface, type, enum, const)

     

       457
       461
        
             // that might be exported later with export { ... }

     

       458
       462
        
             const patterns = [

     

       459
       459
       -
               new RegExp(`^(?:async\\s+)?function\\s+${symbolName}\\b`),

     

       460
       460
       -
               new RegExp(`^class\\s+${symbolName}\\b`),

     

       461
       461
       -
               new RegExp(`^interface\\s+${symbolName}\\b`),

     

       462
       462
       -
               new RegExp(`^type\\s+${symbolName}\\b`),

     

       463
       463
       -
               new RegExp(`^enum\\s+${symbolName}\\b`),

     

       464
       464
       -
               new RegExp(`^(?:const|let|var)\\s+${symbolName}\\b`),

     

       463
       463
       +
               new RegExp(`^(?:async\\s+)?function\\s+${escapeRegExp(symbolName)}\\b`),

     

       464
       464
       +
               new RegExp(`^class\\s+${escapeRegExp(symbolName)}\\b`),

     

       465
       465
       +
               new RegExp(`^interface\\s+${escapeRegExp(symbolName)}\\b`),

     

       466
       466
       +
               new RegExp(`^type\\s+${escapeRegExp(symbolName)}\\b`),

     

       467
       467
       +
               new RegExp(`^enum\\s+${escapeRegExp(symbolName)}\\b`),

     

       468
       468
       +
               new RegExp(`^(?:const|let|var)\\s+${escapeRegExp(symbolName)}\\b`),

     

       465
       469
        
             ];

     

       466
       470
        
       

     

       467
       471
        
             for (const pattern of patterns) {

     
···

       669
       673
        
                 // Check for non-exported declarations that match symbols in sourceExports

     

       670
       674
        
                 for (const exp of sourceExports) {

     

       671
       675
        
                   const patterns = [

     

       672
       672
       -
                     `class ${exp.originalName}`,

     

       673
       673
       -
                     `function ${exp.originalName}`,

     

       674
       674
       -
                     `const ${exp.originalName}`,

     

       675
       675
       -
                     `let ${exp.originalName}`,

     

       676
       676
       -
                     `var ${exp.originalName}`,

     

       677
       677
       -
                     `interface ${exp.originalName}`,

     

       678
       678
       -
                     `type ${exp.originalName}`,

     

       679
       679
       -
                     `enum ${exp.originalName}`,

     

       676
       676
       +
                     new RegExp(`^class\\s+${escapeRegExp(exp.originalName)}\\b`),

     

       677
       677
       +
                     new RegExp(`^(?:async\\s+)?function\\s+${escapeRegExp(exp.originalName)}\\b`),

     

       678
       678
       +
                     new RegExp(`^const\\s+${escapeRegExp(exp.originalName)}\\b`),

     

       679
       679
       +
                     new RegExp(`^let\\s+${escapeRegExp(exp.originalName)}\\b`),

     

       680
       680
       +
                     new RegExp(`^var\\s+${escapeRegExp(exp.originalName)}\\b`),

     

       681
       681
       +
                     new RegExp(`^interface\\s+${escapeRegExp(exp.originalName)}\\b`),

     

       682
       682
       +
                     new RegExp(`^type\\s+${escapeRegExp(exp.originalName)}\\b`),

     

       683
       683
       +
                     new RegExp(`^enum\\s+${escapeRegExp(exp.originalName)}\\b`),

     

       680
       684
        
                   ];

     

       681
       685
        
       

     

       682
       686
        
                   for (const pattern of patterns) {

     

       683
       683
       -
                     if (trimmed.startsWith(pattern)) {

     

       687
       687
       +
                     if (pattern.test(trimmed)) {

     

       684
       688
        
                       let fullDeclaration = trimmed;

     

       685
       689
        
                       const declarationStartLine = i;

     

       686
       690

+1 -1

deno.json

···

       1
       1
        
       {

     

       2
       2
        
         "name": "@knotbin/doggo",

     

       3
       3
       -
         "version": "0.1.1",

     

       3
       3
       +
         "version": "0.1.2",

     

       4
       4
        
         "exports": "./mod.ts",

     

       5
       5
        
         "imports": {

     

       6
       6
        
           "@std/assert": "jsr:@std/assert@^1.0.15",

+22

tests/core_test.ts

···

       144
       144
        
         assertEquals(byType["interface"]?.total, 1);

     

       145
       145
        
         assertEquals(byType["const"]?.total, 1);

     

       146
       146
        
       });

     

       147
       147
       +
       

     

       148
       148
       +
       Deno.test("analyzeDirectory - correctly matches symbols with prefix names", async () => {

     

       149
       149
       +
         const fixturesPath = join(

     

       150
       150
       +
           Deno.cwd(),

     

       151
       151
       +
           "tests",

     

       152
       152
       +
           "fixtures",

     

       153
       153
       +
           "prefix_bug",

     

       154
       154
       +
           "types.ts",

     

       155
       155
       +
         );

     

       156
       156
       +
       

     

       157
       157
       +
         const result = await analyzeDirectory(fixturesPath);

     

       158
       158
       +
       

     

       159
       159
       +
         assertEquals(result.symbols.length, 2);

     

       160
       160
       +
       

     

       161
       161
       +
         const serverSymbol = result.symbols.find((s) => s.name === "Server");

     

       162
       162
       +
         assertEquals(serverSymbol?.type, "type");

     

       163
       163
       +
         assertEquals(serverSymbol?.line, 6);

     

       164
       164
       +
       

     

       165
       165
       +
         const serverRateLimitSymbol = result.symbols.find((s) => s.name === "ServerRateLimitDescription");

     

       166
       166
       +
         assertEquals(serverRateLimitSymbol?.type, "type");

     

       167
       167
       +
         assertEquals(serverRateLimitSymbol?.line, 1);

     

       168
       168
       +
       });

+9

tests/fixtures/prefix_bug/types.ts

···

       1
       1
       +
       export type ServerRateLimitDescription = {

     

       2
       2
       +
         name: string;

     

       3
       3
       +
         duration: number;

     

       4
       4
       +
       };

     

       5
       5
       +
       

     

       6
       6
       +
       export type Server = {

     

       7
       7
       +
         host: string;

     

       8
       8
       +
         port: number;

     

       9
       9
       +
       };