cli/analyzer/parser.test.js

import { describe, it, expect } from 'vitest';
import { parseTypeScript } from './parser';
describe('parseTypeScript', () => {
    describe('function declarations', () => {
        it('extracts a regular function declaration', () => {
            const content = `function greet(name) {

  return 'hello ' + name;

}`;
            const result = parseTypeScript(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('greet');
            expect(result.functions[0].params).toEqual(['name']);
            expect(result.functions[0].isExported).toBe(false);
            expect(result.functions[0].startLine).toBe(1);
            expect(result.functions[0].endLine).toBe(3);
        });
        it('extracts an async function declaration', () => {
            const content = `async function fetchData(url, options) {

  const res = await fetch(url, options);

  return res.json();

}`;
            const result = parseTypeScript(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('fetchData');
            expect(result.functions[0].params).toEqual(['url', 'options']);
            expect(result.functions[0].isExported).toBe(false);
        });
        it('extracts an exported function declaration', () => {
            const content = `export function calculate(a, b) {

  return a + b;

}`;
            const result = parseTypeScript(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('calculate');
            expect(result.functions[0].isExported).toBe(true);
            expect(result.exports).toContain('calculate');
        });
        it('extracts an export default function', () => {
            const content = `export default function main() {

  console.log('hello');

}`;
            const result = parseTypeScript(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('main');
            expect(result.functions[0].isExported).toBe(true);
        });
        it('extracts a generator function', () => {
            const content = `function* generate(items) {

  for (const item of items) {

    yield item;

  }

}`;
            const result = parseTypeScript(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('generate');
            expect(result.functions[0].params).toEqual(['items']);
        });
    });
    describe('arrow functions', () => {
        it('extracts a const arrow function', () => {
            const content = `const add = (a, b) => {

  return a + b;

}`;
            const result = parseTypeScript(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('add');
            expect(result.functions[0].params).toEqual(['a', 'b']);
            expect(result.functions[0].isExported).toBe(false);
        });
        it('extracts an exported arrow function', () => {
            const content = `export const multiply = (x, y) => {

  return x * y;

}`;
            const result = parseTypeScript(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('multiply');
            expect(result.functions[0].isExported).toBe(true);
            expect(result.exports).toContain('multiply');
        });
        it('extracts an async arrow function', () => {
            const content = `const loadData = async (id) => {

  const res = await fetch('/api/' + id);

  return res.json();

}`;
            const result = parseTypeScript(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('loadData');
            expect(result.functions[0].params).toEqual(['id']);
        });
        it('extracts an arrow function with no params', () => {
            const content = `const noop = () => {

  // do nothing

}`;
            const result = parseTypeScript(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('noop');
            expect(result.functions[0].params).toEqual([]);
        });
        it('extracts arrow function with TypeScript type annotations', () => {
            const content = `export const process = (input: string, count: number): boolean => {

  return input.length > count;

}`;
            const result = parseTypeScript(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('process');
            expect(result.functions[0].params).toEqual(['input', 'count']);
        });
    });
    describe('class declarations', () => {
        it('extracts a class with methods', () => {
            const content = `class UserService {

  constructor(db) {

    this.db = db;

  }



  getUser(id) {

    return this.db.find(id);

  }



  async createUser(data) {

    return this.db.insert(data);

  }

}`;
            const result = parseTypeScript(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('UserService');
            expect(result.classes[0].isExported).toBe(false);
            expect(result.classes[0].methods).toContain('constructor');
            expect(result.classes[0].methods).toContain('getUser');
            expect(result.classes[0].methods).toContain('createUser');
            expect(result.classes[0].startLine).toBe(1);
        });
        it('extracts an exported class', () => {
            const content = `export class ApiClient {

  fetch(url) {

    return fetch(url);

  }

}`;
            const result = parseTypeScript(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('ApiClient');
            expect(result.classes[0].isExported).toBe(true);
            expect(result.classes[0].methods).toContain('fetch');
            expect(result.exports).toContain('ApiClient');
        });
        it('extracts an export default class', () => {
            const content = `export default class App {

  run() {

    console.log('running');

  }

}`;
            const result = parseTypeScript(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('App');
            expect(result.classes[0].isExported).toBe(true);
        });
        it('extracts an abstract class', () => {
            const content = `abstract class BaseRepository {

  abstract find(id);

  

  save(entity) {

    return this.persist(entity);

  }

}`;
            const result = parseTypeScript(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('BaseRepository');
            expect(result.classes[0].methods).toContain('find');
            expect(result.classes[0].methods).toContain('save');
        });
        it('extracts getter and setter methods', () => {
            const content = `class Config {

  get value() {

    return this._value;

  }



  set value(v) {

    this._value = v;

  }

}`;
            const result = parseTypeScript(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].methods).toContain('value');
        });
    });
    describe('import statements', () => {
        it('extracts named imports', () => {
            const content = `import { readFile, writeFile } from 'fs';`;
            const result = parseTypeScript(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('fs');
            expect(result.imports[0].names).toEqual(['readFile', 'writeFile']);
        });
        it('extracts default imports', () => {
            const content = `import express from 'express';`;
            const result = parseTypeScript(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('express');
            expect(result.imports[0].names).toEqual(['express']);
        });
        it('extracts namespace imports', () => {
            const content = `import * as path from 'path';`;
            const result = parseTypeScript(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('path');
            expect(result.imports[0].names).toEqual(['path']);
        });
        it('extracts side-effect imports', () => {
            const content = `import './styles.css';`;
            const result = parseTypeScript(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('./styles.css');
            expect(result.imports[0].names).toEqual([]);
        });
        it('extracts require calls', () => {
            const content = `const fs = require('fs');`;
            const result = parseTypeScript(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('fs');
            expect(result.imports[0].names).toEqual(['fs']);
        });
        it('extracts destructured require calls', () => {
            const content = `const { join, resolve } = require('path');`;
            const result = parseTypeScript(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('path');
            expect(result.imports[0].names).toEqual(['join', 'resolve']);
        });
        it('extracts import with alias', () => {
            const content = `import { readFile as read, writeFile as write } from 'fs';`;
            const result = parseTypeScript(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('fs');
            expect(result.imports[0].names).toEqual(['read', 'write']);
        });
        it('extracts mixed default and named imports', () => {
            const content = `import React, { useState, useEffect } from 'react';`;
            const result = parseTypeScript(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('react');
            expect(result.imports[0].names).toContain('React');
            expect(result.imports[0].names).toContain('useState');
            expect(result.imports[0].names).toContain('useEffect');
        });
    });
    describe('export statements', () => {
        it('extracts named exports', () => {
            const content = `const a = 1;

const b = 2;

export { a, b };`;
            const result = parseTypeScript(content);
            expect(result.exports).toContain('a');
            expect(result.exports).toContain('b');
        });
        it('extracts export default identifier', () => {
            const content = `const config = {};

export default config;`;
            const result = parseTypeScript(content);
            expect(result.exports).toContain('config');
        });
        it('extracts export const/let/var', () => {
            const content = `export const API_URL = 'http://localhost';

export let counter = 0;

export var legacy = true;`;
            const result = parseTypeScript(content);
            expect(result.exports).toContain('API_URL');
            expect(result.exports).toContain('counter');
            expect(result.exports).toContain('legacy');
        });
        it('extracts re-exports with alias', () => {
            const content = `export { default as MyComponent } from './component';`;
            const result = parseTypeScript(content);
            expect(result.exports).toContain('MyComponent');
        });
    });
    describe('mixed content', () => {
        it('handles a file with multiple declarations', () => {
            const content = `import { readFileSync } from 'fs';

import path from 'path';



export interface Config {

  name: string;

}



export function loadConfig(filePath) {

  const content = readFileSync(filePath, 'utf-8');

  return JSON.parse(content);

}



const DEFAULT_PATH = './config.json';



export const getDefaultConfig = () => {

  return loadConfig(DEFAULT_PATH);

}



export class ConfigManager {

  constructor(config) {

    this.config = config;

  }



  get(key) {

    return this.config[key];

  }



  set(key, value) {

    this.config[key] = value;

  }

}



export default ConfigManager;`;
            const result = parseTypeScript(content);
            // Imports
            expect(result.imports).toHaveLength(2);
            expect(result.imports[0].source).toBe('fs');
            expect(result.imports[1].source).toBe('path');
            // Functions
            expect(result.functions.length).toBeGreaterThanOrEqual(2);
            const loadConfigFn = result.functions.find((f) => f.name === 'loadConfig');
            expect(loadConfigFn).toBeDefined();
            expect(loadConfigFn.isExported).toBe(true);
            const getDefaultFn = result.functions.find((f) => f.name === 'getDefaultConfig');
            expect(getDefaultFn).toBeDefined();
            expect(getDefaultFn.isExported).toBe(true);
            // Classes
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('ConfigManager');
            expect(result.classes[0].isExported).toBe(true);
            expect(result.classes[0].methods).toContain('constructor');
            expect(result.classes[0].methods).toContain('get');
            expect(result.classes[0].methods).toContain('set');
            // Exports
            expect(result.exports).toContain('loadConfig');
            expect(result.exports).toContain('getDefaultConfig');
            expect(result.exports).toContain('ConfigManager');
        });
        it('handles empty content', () => {
            const result = parseTypeScript('');
            expect(result.functions).toEqual([]);
            expect(result.classes).toEqual([]);
            expect(result.imports).toEqual([]);
            expect(result.exports).toEqual([]);
        });
        it('handles content with only comments', () => {
            const content = `// This is a comment

/* Multi-line

   comment */

// Another comment`;
            const result = parseTypeScript(content);
            expect(result.functions).toEqual([]);
            expect(result.classes).toEqual([]);
            expect(result.imports).toEqual([]);
            expect(result.exports).toEqual([]);
        });
    });
});
import { parsePython } from './parser';
describe('parsePython', () => {
    describe('function definitions', () => {
        it('extracts a regular function definition', () => {
            const content = `def greet(name):

    return 'hello ' + name

`;
            const result = parsePython(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('greet');
            expect(result.functions[0].params).toEqual(['name']);
            expect(result.functions[0].isExported).toBe(true);
            expect(result.functions[0].startLine).toBe(1);
            expect(result.functions[0].endLine).toBe(2);
        });
        it('extracts an async function definition', () => {
            const content = `async def fetch_data(url, timeout=30):

    response = await aiohttp.get(url, timeout=timeout)

    return response.json()

`;
            const result = parsePython(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('fetch_data');
            expect(result.functions[0].params).toEqual(['url', 'timeout']);
            expect(result.functions[0].isExported).toBe(true);
        });
        it('extracts function with type annotations', () => {
            const content = `def process(input: str, count: int = 0) -> bool:

    return len(input) > count

`;
            const result = parsePython(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('process');
            expect(result.functions[0].params).toEqual(['input', 'count']);
        });
        it('marks private functions (underscore prefix) as not exported', () => {
            const content = `def _helper(x):

    return x * 2



def public_func(y):

    return _helper(y)

`;
            const result = parsePython(content);
            expect(result.functions).toHaveLength(2);
            const helper = result.functions.find((f) => f.name === '_helper');
            expect(helper).toBeDefined();
            expect(helper.isExported).toBe(false);
            const pub = result.functions.find((f) => f.name === 'public_func');
            expect(pub).toBeDefined();
            expect(pub.isExported).toBe(true);
        });
        it('extracts function with *args and **kwargs', () => {
            const content = `def variadic(a, *args, **kwargs):

    pass

`;
            const result = parsePython(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].params).toEqual(['a', 'args', 'kwargs']);
        });
        it('handles multiple functions', () => {
            const content = `def first():

    pass



def second(x):

    return x

`;
            const result = parsePython(content);
            expect(result.functions).toHaveLength(2);
            expect(result.functions[0].name).toBe('first');
            expect(result.functions[1].name).toBe('second');
        });
    });
    describe('class definitions', () => {
        it('extracts a class with methods', () => {
            const content = `class UserService:

    def __init__(self, db):

        self.db = db



    def get_user(self, user_id):

        return self.db.find(user_id)



    async def create_user(self, data):

        return await self.db.insert(data)

`;
            const result = parsePython(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('UserService');
            expect(result.classes[0].isExported).toBe(true);
            expect(result.classes[0].methods).toContain('__init__');
            expect(result.classes[0].methods).toContain('get_user');
            expect(result.classes[0].methods).toContain('create_user');
            expect(result.classes[0].startLine).toBe(1);
        });
        it('extracts a class with inheritance', () => {
            const content = `class ApiClient(BaseClient):

    def fetch(self, url):

        return self.session.get(url)

`;
            const result = parsePython(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('ApiClient');
            expect(result.classes[0].isExported).toBe(true);
            expect(result.classes[0].methods).toContain('fetch');
        });
        it('marks private classes as not exported', () => {
            const content = `class _InternalHelper:

    def do_work(self):

        pass



class PublicApi:

    def run(self):

        pass

`;
            const result = parsePython(content);
            expect(result.classes).toHaveLength(2);
            const internal = result.classes.find((c) => c.name === '_InternalHelper');
            expect(internal).toBeDefined();
            expect(internal.isExported).toBe(false);
            const pub = result.classes.find((c) => c.name === 'PublicApi');
            expect(pub).toBeDefined();
            expect(pub.isExported).toBe(true);
        });
        it('extracts class with multiple base classes', () => {
            const content = `class MyView(View, Mixin):

    def get(self, request):

        pass

`;
            const result = parsePython(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('MyView');
            expect(result.classes[0].methods).toContain('get');
        });
    });
    describe('import statements', () => {
        it('extracts simple import', () => {
            const content = `import os`;
            const result = parsePython(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('os');
            expect(result.imports[0].names).toEqual(['os']);
        });
        it('extracts import with alias', () => {
            const content = `import numpy as np`;
            const result = parsePython(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('numpy');
            expect(result.imports[0].names).toEqual(['np']);
        });
        it('extracts from...import', () => {
            const content = `from os.path import join, dirname`;
            const result = parsePython(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('os.path');
            expect(result.imports[0].names).toEqual(['join', 'dirname']);
        });
        it('extracts from...import with alias', () => {
            const content = `from collections import OrderedDict as OD`;
            const result = parsePython(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('collections');
            expect(result.imports[0].names).toEqual(['OD']);
        });
        it('extracts from...import wildcard', () => {
            const content = `from module import *`;
            const result = parsePython(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('module');
            expect(result.imports[0].names).toEqual(['*']);
        });
        it('extracts multi-line from...import with parentheses', () => {
            const content = `from flask import (

    Flask,

    request,

    jsonify

)`;
            const result = parsePython(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('flask');
            expect(result.imports[0].names).toEqual(['Flask', 'request', 'jsonify']);
        });
        it('extracts multiple comma-separated imports', () => {
            const content = `import os, sys`;
            const result = parsePython(content);
            expect(result.imports).toHaveLength(2);
            expect(result.imports[0].source).toBe('os');
            expect(result.imports[0].names).toEqual(['os']);
            expect(result.imports[1].source).toBe('sys');
            expect(result.imports[1].names).toEqual(['sys']);
        });
    });
    describe('indentation-based end detection', () => {
        it('detects function end based on indentation', () => {
            const content = `def first():

    x = 1

    return x



def second():

    return 2

`;
            const result = parsePython(content);
            expect(result.functions).toHaveLength(2);
            expect(result.functions[0].name).toBe('first');
            expect(result.functions[0].startLine).toBe(1);
            expect(result.functions[0].endLine).toBe(3);
            expect(result.functions[1].name).toBe('second');
            expect(result.functions[1].startLine).toBe(5);
            expect(result.functions[1].endLine).toBe(6);
        });
        it('detects class end based on indentation', () => {
            const content = `class MyClass:

    def method_a(self):

        return 1



    def method_b(self):

        return 2



def standalone():

    pass

`;
            const result = parsePython(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].startLine).toBe(1);
            expect(result.classes[0].endLine).toBe(6);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('standalone');
        });
        it('handles function at end of file without trailing newline', () => {
            const content = `def last_func():

    return 42`;
            const result = parsePython(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].endLine).toBe(2);
        });
    });
    describe('exports and __all__', () => {
        it('collects public names as exports by default', () => {
            const content = `def public_one():

    pass



def _private():

    pass



class PublicClass:

    pass



class _PrivateClass:

    pass

`;
            const result = parsePython(content);
            expect(result.exports).toContain('public_one');
            expect(result.exports).toContain('PublicClass');
            expect(result.exports).not.toContain('_private');
            expect(result.exports).not.toContain('_PrivateClass');
        });
        it('uses __all__ when defined', () => {
            const content = `__all__ = ['exported_func', 'ExportedClass']



def exported_func():

    pass



def other_func():

    pass



class ExportedClass:

    pass

`;
            const result = parsePython(content);
            expect(result.exports).toEqual(['exported_func', 'ExportedClass']);
        });
    });
    describe('mixed content', () => {
        it('handles a typical Python module', () => {
            const content = `import os

from pathlib import Path



class Config:

    def __init__(self, path: str):

        self.path = path



    def load(self):

        return Path(self.path).read_text()



def create_config(path: str) -> Config:

    return Config(path)



def _validate(data):

    return bool(data)

`;
            const result = parsePython(content);
            // Imports
            expect(result.imports).toHaveLength(2);
            expect(result.imports[0].source).toBe('os');
            expect(result.imports[1].source).toBe('pathlib');
            expect(result.imports[1].names).toEqual(['Path']);
            // Classes
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('Config');
            expect(result.classes[0].methods).toContain('__init__');
            expect(result.classes[0].methods).toContain('load');
            // Functions (only top-level, not class methods)
            const topFuncs = result.functions;
            expect(topFuncs).toHaveLength(2);
            expect(topFuncs[0].name).toBe('create_config');
            expect(topFuncs[1].name).toBe('_validate');
            // Exports
            expect(result.exports).toContain('Config');
            expect(result.exports).toContain('create_config');
            expect(result.exports).not.toContain('_validate');
        });
        it('handles empty content', () => {
            const result = parsePython('');
            expect(result.functions).toEqual([]);
            expect(result.classes).toEqual([]);
            expect(result.imports).toEqual([]);
            expect(result.exports).toEqual([]);
        });
        it('handles content with only comments', () => {
            const content = `# This is a comment

# Another comment

"""

Module docstring

"""`;
            const result = parsePython(content);
            expect(result.functions).toEqual([]);
            expect(result.classes).toEqual([]);
            expect(result.imports).toEqual([]);
            expect(result.exports).toEqual([]);
        });
    });
});
import { parseGo, parseRust, parseJava, parseGeneric } from './parser';
describe('parseGo', () => {
    describe('function declarations', () => {
        it('extracts a regular function', () => {
            const content = `func main() {

	fmt.Println("hello")

}`;
            const result = parseGo(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('main');
            expect(result.functions[0].params).toEqual([]);
            expect(result.functions[0].startLine).toBe(1);
            expect(result.functions[0].endLine).toBe(3);
        });
        it('extracts a function with parameters', () => {
            const content = `func Add(a int, b int) int {

	return a + b

}`;
            const result = parseGo(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('Add');
            expect(result.functions[0].params).toEqual(['a', 'b']);
            expect(result.functions[0].isExported).toBe(true);
        });
        it('extracts a method with receiver', () => {
            const content = `func (s *Server) Start(port int) error {

	return s.listen(port)

}`;
            const result = parseGo(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('Start');
            expect(result.functions[0].params).toEqual(['port']);
            expect(result.functions[0].isExported).toBe(true);
        });
        it('marks lowercase functions as unexported', () => {
            const content = `func helper(x int) int {

	return x * 2

}`;
            const result = parseGo(content);
            expect(result.functions[0].isExported).toBe(false);
            expect(result.exports).not.toContain('helper');
        });
        it('marks uppercase functions as exported', () => {
            const content = `func HandleRequest(w http.ResponseWriter, r *http.Request) {

	w.Write([]byte("ok"))

}`;
            const result = parseGo(content);
            expect(result.functions[0].isExported).toBe(true);
            expect(result.exports).toContain('HandleRequest');
        });
    });
    describe('type declarations', () => {
        it('extracts a struct type', () => {
            const content = `type Server struct {

	host string

	port int

}`;
            const result = parseGo(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('Server');
            expect(result.classes[0].isExported).toBe(true);
            expect(result.classes[0].startLine).toBe(1);
            expect(result.classes[0].endLine).toBe(4);
        });
        it('extracts an interface type with methods', () => {
            const content = `type Reader interface {

	Read(p []byte) (int, error)

	Close() error

}`;
            const result = parseGo(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('Reader');
            expect(result.classes[0].isExported).toBe(true);
            expect(result.classes[0].methods).toContain('Read');
            expect(result.classes[0].methods).toContain('Close');
        });
        it('marks lowercase types as unexported', () => {
            const content = `type config struct {

	name string

}`;
            const result = parseGo(content);
            expect(result.classes[0].isExported).toBe(false);
            expect(result.exports).not.toContain('config');
        });
    });
    describe('import statements', () => {
        it('extracts a single import', () => {
            const content = `import "fmt"`;
            const result = parseGo(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('fmt');
            expect(result.imports[0].names).toEqual(['fmt']);
        });
        it('extracts a block import', () => {
            const content = `import (

	"fmt"

	"net/http"

	"os"

)`;
            const result = parseGo(content);
            expect(result.imports).toHaveLength(3);
            expect(result.imports[0].source).toBe('fmt');
            expect(result.imports[1].source).toBe('net/http');
            expect(result.imports[1].names).toEqual(['http']);
            expect(result.imports[2].source).toBe('os');
        });
        it('extracts aliased imports', () => {
            const content = `import (

	mux "github.com/gorilla/mux"

)`;
            const result = parseGo(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('github.com/gorilla/mux');
            expect(result.imports[0].names).toEqual(['mux']);
        });
    });
    describe('empty content', () => {
        it('handles empty content', () => {
            const result = parseGo('');
            expect(result.functions).toEqual([]);
            expect(result.classes).toEqual([]);
            expect(result.imports).toEqual([]);
            expect(result.exports).toEqual([]);
        });
    });
});
describe('parseRust', () => {
    describe('function declarations', () => {
        it('extracts a public function', () => {
            const content = `pub fn add(a: i32, b: i32) -> i32 {

    a + b

}`;
            const result = parseRust(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('add');
            expect(result.functions[0].params).toEqual(['a', 'b']);
            expect(result.functions[0].isExported).toBe(true);
            expect(result.functions[0].startLine).toBe(1);
            expect(result.functions[0].endLine).toBe(3);
        });
        it('extracts a private function', () => {
            const content = `fn helper(x: u32) -> u32 {

    x * 2

}`;
            const result = parseRust(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('helper');
            expect(result.functions[0].isExported).toBe(false);
        });
        it('extracts an async function', () => {
            const content = `pub async fn fetch_data(url: &str) -> Result<String, Error> {

    reqwest::get(url).await?.text().await

}`;
            const result = parseRust(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('fetch_data');
            expect(result.functions[0].params).toEqual(['url']);
            expect(result.functions[0].isExported).toBe(true);
        });
    });
    describe('struct and enum declarations', () => {
        it('extracts a public struct', () => {
            const content = `pub struct Config {

    pub name: String,

    pub port: u16,

}`;
            const result = parseRust(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('Config');
            expect(result.classes[0].isExported).toBe(true);
            expect(result.exports).toContain('Config');
        });
        it('extracts an enum', () => {
            const content = `pub enum Status {

    Active,

    Inactive,

    Pending,

}`;
            const result = parseRust(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('Status');
            expect(result.classes[0].isExported).toBe(true);
        });
        it('extracts a private struct', () => {
            const content = `struct Internal {

    data: Vec<u8>,

}`;
            const result = parseRust(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('Internal');
            expect(result.classes[0].isExported).toBe(false);
        });
    });
    describe('impl blocks', () => {
        it('extracts methods from impl block', () => {
            const content = `pub struct Server {

    port: u16,

}



impl Server {

    pub fn new(port: u16) -> Self {

        Server { port }

    }



    pub fn start(&self) {

        println!("Starting on port {}", self.port);

    }



    fn internal_helper(&self) {

        // private

    }

}`;
            const result = parseRust(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('Server');
            expect(result.classes[0].methods).toContain('new');
            expect(result.classes[0].methods).toContain('start');
            expect(result.classes[0].methods).toContain('internal_helper');
        });
    });
    describe('use statements', () => {
        it('extracts a simple use statement', () => {
            const content = `use std::collections::HashMap;`;
            const result = parseRust(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('std::collections::HashMap');
            expect(result.imports[0].names).toEqual(['HashMap']);
        });
        it('extracts grouped use statements', () => {
            const content = `use std::collections::{HashMap, HashSet};`;
            const result = parseRust(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('std::collections');
            expect(result.imports[0].names).toEqual(['HashMap', 'HashSet']);
        });
        it('extracts crate use statements', () => {
            const content = `use crate::config::Settings;`;
            const result = parseRust(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('crate::config::Settings');
            expect(result.imports[0].names).toEqual(['Settings']);
        });
    });
    describe('empty content', () => {
        it('handles empty content', () => {
            const result = parseRust('');
            expect(result.functions).toEqual([]);
            expect(result.classes).toEqual([]);
            expect(result.imports).toEqual([]);
            expect(result.exports).toEqual([]);
        });
    });
});
describe('parseJava', () => {
    describe('class declarations', () => {
        it('extracts a public class with methods', () => {
            const content = `public class UserService {

    public User getUser(int id) {

        return db.find(id);

    }



    private void validate(User user) {

        // validation logic

    }

}`;
            const result = parseJava(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('UserService');
            expect(result.classes[0].isExported).toBe(true);
            expect(result.classes[0].methods).toContain('getUser');
            expect(result.classes[0].methods).toContain('validate');
        });
        it('extracts an interface', () => {
            const content = `public interface Repository {

    Object find(int id);

    void save(Object entity);

}`;
            const result = parseJava(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('Repository');
            expect(result.classes[0].isExported).toBe(true);
        });
        it('extracts a private class', () => {
            const content = `class InternalHelper {

    void doWork() {

        // work

    }

}`;
            const result = parseJava(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('InternalHelper');
            expect(result.classes[0].isExported).toBe(false);
        });
    });
    describe('method extraction', () => {
        it('extracts public methods as exported functions', () => {
            const content = `public class Api {

    public String getData(String key) {

        return map.get(key);

    }



    public void setData(String key, String value) {

        map.put(key, value);

    }

}`;
            const result = parseJava(content);
            const getDataFn = result.functions.find((f) => f.name === 'getData');
            expect(getDataFn).toBeDefined();
            expect(getDataFn.isExported).toBe(true);
            expect(getDataFn.params).toEqual(['key']);
            const setDataFn = result.functions.find((f) => f.name === 'setData');
            expect(setDataFn).toBeDefined();
            expect(setDataFn.params).toEqual(['key', 'value']);
        });
    });
    describe('import statements', () => {
        it('extracts import statements', () => {
            const content = `import java.util.List;

import java.util.Map;

import com.example.service.UserService;`;
            const result = parseJava(content);
            expect(result.imports).toHaveLength(3);
            expect(result.imports[0].source).toBe('java.util.List');
            expect(result.imports[0].names).toEqual(['List']);
            expect(result.imports[1].source).toBe('java.util.Map');
            expect(result.imports[1].names).toEqual(['Map']);
            expect(result.imports[2].source).toBe('com.example.service.UserService');
            expect(result.imports[2].names).toEqual(['UserService']);
        });
        it('extracts static imports', () => {
            const content = `import static org.junit.Assert.assertEquals;`;
            const result = parseJava(content);
            expect(result.imports).toHaveLength(1);
            expect(result.imports[0].source).toBe('org.junit.Assert.assertEquals');
            expect(result.imports[0].names).toEqual(['assertEquals']);
        });
    });
    describe('empty content', () => {
        it('handles empty content', () => {
            const result = parseJava('');
            expect(result.functions).toEqual([]);
            expect(result.classes).toEqual([]);
            expect(result.imports).toEqual([]);
            expect(result.exports).toEqual([]);
        });
    });
});
describe('parseGeneric', () => {
    describe('PHP patterns', () => {
        it('extracts PHP functions', () => {
            const content = `<?php

function calculateTotal($items, $tax) {

    $sum = 0;

    foreach ($items as $item) {

        $sum += $item;

    }

    return $sum * (1 + $tax);

}`;
            const result = parseGeneric(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('calculateTotal');
            expect(result.functions[0].params).toEqual(['items', 'tax']);
        });
        it('extracts PHP classes', () => {
            const content = `<?php

class UserController {

    public function index() {

        return view('users.index');

    }



    public function store($request) {

        // store logic

    }

}`;
            const result = parseGeneric(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('UserController');
            expect(result.classes[0].methods).toContain('index');
            expect(result.classes[0].methods).toContain('store');
        });
        it('extracts PHP use statements', () => {
            const content = `<?php

use App\\Models\\User;

use Illuminate\\Http\\Request;`;
            const result = parseGeneric(content);
            expect(result.imports).toHaveLength(2);
            expect(result.imports[0].names).toEqual(['User']);
            expect(result.imports[1].names).toEqual(['Request']);
        });
    });
    describe('Ruby patterns', () => {
        it('extracts Ruby methods', () => {
            const content = `def calculate(x, y)

  x + y

end`;
            const result = parseGeneric(content);
            expect(result.functions).toHaveLength(1);
            expect(result.functions[0].name).toBe('calculate');
            expect(result.functions[0].params).toEqual(['x', 'y']);
        });
        it('extracts Ruby classes', () => {
            const content = `class UserService

  def initialize(db)

    @db = db

  end



  def find_user(id)

    @db.find(id)

  end

end`;
            const result = parseGeneric(content);
            expect(result.classes).toHaveLength(1);
            expect(result.classes[0].name).toBe('UserService');
            expect(result.classes[0].methods).toContain('initialize');
            expect(result.classes[0].methods).toContain('find_user');
        });
        it('extracts Ruby require statements', () => {
            const content = `require 'json'

require_relative 'helpers/utils'`;
            const result = parseGeneric(content);
            expect(result.imports).toHaveLength(2);
            expect(result.imports[0].source).toBe('json');
            expect(result.imports[0].names).toEqual(['json']);
            expect(result.imports[1].source).toBe('helpers/utils');
            expect(result.imports[1].names).toEqual(['utils']);
        });
    });
    describe('fallback behavior', () => {
        it('returns empty result for unrecognized content', () => {
            const content = `-- This is some SQL or unknown language

SELECT * FROM users WHERE id = 1;`;
            const result = parseGeneric(content);
            expect(result.functions).toEqual([]);
            expect(result.classes).toEqual([]);
            expect(result.imports).toEqual([]);
            expect(result.exports).toEqual([]);
        });
        it('handles empty content', () => {
            const result = parseGeneric('');
            expect(result.functions).toEqual([]);
            expect(result.classes).toEqual([]);
            expect(result.imports).toEqual([]);
            expect(result.exports).toEqual([]);
        });
    });
});