scip-query 0.1.0

package/tests/symbol-parser.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect } from 'vitest';
+import { parseSymbol, shortenSymbol, leafName } from '../src/symbol-parser.js';
+
+describe('parseSymbol', () => {
+  it('parses a TypeScript class method symbol', () => {
+    const raw = 'scip-typescript npm @vega/api 0.1.3 src/modules/auth/`auth.service.ts`/AuthService#login().';
+    const result = parseSymbol(raw);
+
+    expect(result).not.toHaveProperty('kind');
+    if (!('kind' in result)) {
+      expect(result.scheme).toBe('scip-typescript');
+      expect(result.manager).toBe('npm');
+      expect(result.packageName).toBe('@vega/api');
+      expect(result.version).toBe('0.1.3');
+      // src/ + modules/ + auth/ + `auth.service.ts`/ + AuthService# + login().
+      expect(result.descriptors).toHaveLength(6);
+      expect(result.descriptors[0]).toEqual({ name: 'src', suffix: 'namespace' });
+      expect(result.descriptors[1]).toEqual({ name: 'modules', suffix: 'namespace' });
+      expect(result.descriptors[2]).toEqual({ name: 'auth', suffix: 'namespace' });
+      expect(result.descriptors[3]).toEqual({ name: 'auth.service.ts', suffix: 'namespace' });
+      expect(result.descriptors[4]).toEqual({ name: 'AuthService', suffix: 'type' });
+      expect(result.descriptors[5]).toEqual({ name: 'login', suffix: 'method' });
+    }
+  });
+
+  it('parses a Rust symbol', () => {
+    const raw = 'rust-analyzer cargo my-crate 0.1.0 src/`lib.rs`/MyStruct#new().';
+    const result = parseSymbol(raw);
+
+    if (!('kind' in result)) {
+      expect(result.scheme).toBe('rust-analyzer');
+      expect(result.manager).toBe('cargo');
+      expect(result.packageName).toBe('my-crate');
+      // src/ + `lib.rs`/ + MyStruct# + new().
+      expect(result.descriptors).toHaveLength(4);
+      expect(result.descriptors[0]).toEqual({ name: 'src', suffix: 'namespace' });
+      expect(result.descriptors[1]).toEqual({ name: 'lib.rs', suffix: 'namespace' });
+      expect(result.descriptors[2]).toEqual({ name: 'MyStruct', suffix: 'type' });
+      expect(result.descriptors[3]).toEqual({ name: 'new', suffix: 'method' });
+    }
+  });
+
+  it('parses a Java symbol', () => {
+    const raw = 'scip-java maven com.example/mylib 1.0.0 com/example/MyClass#doStuff().';
+    const result = parseSymbol(raw);
+
+    if (!('kind' in result)) {
+      expect(result.scheme).toBe('scip-java');
+      expect(result.manager).toBe('maven');
+      expect(result.packageName).toBe('com.example/mylib');
+      expect(result.version).toBe('1.0.0');
+    }
+  });
+
+  it('parses a Python symbol', () => {
+    const raw = 'scip-python pip my-package 1.0.0 my_module/`utils.py`/helper_function.';
+    const result = parseSymbol(raw);
+
+    if (!('kind' in result)) {
+      expect(result.scheme).toBe('scip-python');
+      expect(result.manager).toBe('pip');
+      expect(result.packageName).toBe('my-package');
+    }
+  });
+
+  it('parses a local symbol', () => {
+    const raw = 'local 42';
+    const result = parseSymbol(raw);
+
+    expect(result).toHaveProperty('kind', 'local');
+    if ('kind' in result) {
+      expect(result.id).toBe('42');
+    }
+  });
+
+  it('parses a symbol with type parameters', () => {
+    // Type param uses bracket-wrap syntax: [T]
+    const raw = 'scip-typescript npm pkg 1.0.0 `file.ts`/Generic#[T]';
+    const result = parseSymbol(raw);
+
+    if (!('kind' in result)) {
+      const last = result.descriptors[result.descriptors.length - 1];
+      expect(last).toEqual({ name: 'T', suffix: 'type-param' });
+    }
+  });
+
+  it('handles a property/term symbol', () => {
+    const raw = 'scip-typescript npm pkg 1.0.0 `file.ts`/MyClass#myProp.';
+    const result = parseSymbol(raw);
+
+    if (!('kind' in result)) {
+      expect(result.descriptors[result.descriptors.length - 1]).toEqual({
+        name: 'myProp',
+        suffix: 'term',
+      });
+    }
+  });
+
+  it('handles parameter descriptors', () => {
+    // Parameter uses paren-wrap syntax: (paramName)
+    const raw = 'scip-typescript npm pkg 1.0.0 `file.ts`/MyClass#method().(param)';
+    const result = parseSymbol(raw);
+
+    if (!('kind' in result)) {
+      const last = result.descriptors[result.descriptors.length - 1];
+      expect(last).toEqual({ name: 'param', suffix: 'parameter' });
+    }
+  });
+});
+
+describe('shortenSymbol', () => {
+  it('shortens a TypeScript class method', () => {
+    const raw = 'scip-typescript npm @vega/api 0.1.3 src/modules/auth/`auth.service.ts`/AuthService#login().';
+    const short = shortenSymbol(raw);
+    // Each / creates a separate namespace descriptor, file ext gets stripped
+    expect(short).toBe('src:modules:auth:auth.service:AuthService:login()');
+  });
+
+  it('shortens a Rust symbol', () => {
+    const raw = 'rust-analyzer cargo my-crate 0.1.0 src/`lib.rs`/MyStruct#new().';
+    const short = shortenSymbol(raw);
+    expect(short).toBe('src:lib:MyStruct:new()');
+  });
+
+  it('shortens a local symbol', () => {
+    const short = shortenSymbol('local 42');
+    expect(short).toBe('local:42');
+  });
+
+  it('strips file extensions from namespace parts', () => {
+    const raw = 'scip-python pip pkg 1.0.0 my_module/`utils.py`/helper.';
+    const short = shortenSymbol(raw);
+    expect(short).toBe('my_module:utils:helper');
+  });
+
+  it('strips Java file extensions', () => {
+    const raw = 'scip-java maven pkg 1.0.0 com/example/`MyClass.java`/MyClass#doStuff().';
+    const short = shortenSymbol(raw);
+    expect(short).toBe('com:example:MyClass:MyClass:doStuff()');
+  });
+});
+
+describe('leafName', () => {
+  it('extracts the last descriptor name', () => {
+    const raw = 'scip-typescript npm @vega/api 0.1.3 src/modules/auth/`auth.service.ts`/AuthService#login().';
+    expect(leafName(raw)).toBe('login');
+  });
+
+  it('extracts from a simple symbol', () => {
+    const raw = 'scip-typescript npm pkg 1.0.0 `file.ts`/myFunction.';
+    expect(leafName(raw)).toBe('myFunction');
+  });
+
+  it('handles local symbols', () => {
+    expect(leafName('local 42')).toBe('42');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/tsup.config.ts

@@ -0,0 +1,40 @@
+import { readdirSync } from 'node:fs';
+import { defineConfig } from 'tsup';
+
+const queryEntries = Object.fromEntries(
+  readdirSync('src/queries', { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.ts'))
+    .map((entry) => [
+      `queries/${entry.name.replace(/\.ts$/, '')}`,
+      `src/queries/${entry.name}`,
+    ]),
+);
+
+export default defineConfig([
+  {
+    entry: {
+      index: 'src/index.ts',
+      ...queryEntries,
+    },
+    format: ['esm'],
+    dts: true,
+    sourcemap: true,
+    clean: true,
+    target: 'node18',
+  },
+  {
+    entry: { cli: 'src/cli.ts' },
+    format: ['esm'],
+    sourcemap: true,
+    target: 'node18',
+    banner: {
+      js: '#!/usr/bin/env node',
+    },
+  },
+  {
+    entry: { 'reindex-worker': 'src/reindex-worker.ts', postinstall: 'src/postinstall.ts' },
+    format: ['esm'],
+    sourcemap: true,
+    target: 'node18',
+  },
+]);

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+  },
+});