593 lines
25 KiB
TypeScript
593 lines
25 KiB
TypeScript
import type { IterationFacts, Node } from '../contract'
|
||
import type { Outline } from '../testSupport'
|
||
import { describe, expect, it } from 'vitest'
|
||
import { factsByLine, nodeFacts, nodesToText, outline, readFixture, runtime, walk, WASM_DIR, withBlocks } from '../testSupport'
|
||
import { createPythonAdapter } from './python'
|
||
|
||
const adapter = createPythonAdapter(WASM_DIR)
|
||
|
||
function tree(source: string): Promise<Outline[]> {
|
||
return withBlocks(adapter, 'python', source, outline)
|
||
}
|
||
|
||
function facts(source: string): Promise<Record<number, unknown>> {
|
||
return withBlocks(adapter, 'python', source, factsByLine)
|
||
}
|
||
|
||
// fixtures/sample.py：行号 1 起
|
||
const SAMPLE: Outline[] = [
|
||
{ at: 1, kind: 'comment' },
|
||
{ at: 3, kind: 'import' },
|
||
{ at: 4, kind: 'import' },
|
||
{ at: 6, kind: 'const' },
|
||
{ at: 7, kind: 'variable' },
|
||
{ at: [10, 11], kind: 'function', kids: [
|
||
{ at: 13, kind: 'variable', notes: [12] },
|
||
{ at: 14, kind: 'if', kids: [{ at: 15, kind: 'return' }] },
|
||
{ at: 16, kind: 'else', kids: [{ at: 17, kind: 'variable' }] },
|
||
{ at: 18, kind: 'else', kids: [{ at: 19, kind: 'statement' }] },
|
||
{ at: 20, kind: 'loop', kids: [
|
||
{ at: 21, kind: 'if', kids: [{ at: 22, kind: 'statement' }] },
|
||
] },
|
||
{ at: 23, kind: 'try', kids: [
|
||
{ at: 24, kind: 'statement', kids: [{ at: 25, kind: 'statement' }] },
|
||
] },
|
||
{ at: 26, kind: 'catch', kids: [{ at: 27, kind: 'statement' }] },
|
||
{ at: 28, kind: 'finally', kids: [{ at: 29, kind: 'statement' }] },
|
||
{ at: 30, kind: 'return' },
|
||
] },
|
||
{ at: 33, kind: 'class', kids: [
|
||
{ at: 34, kind: 'field' },
|
||
{ at: 35, kind: 'field' },
|
||
{ at: 36, kind: 'field' },
|
||
{ at: 37, kind: 'variable' },
|
||
{ at: 39, kind: 'function', kids: [{ at: 40, kind: 'return' }] },
|
||
] },
|
||
]
|
||
|
||
describe('python 代码块树', () => {
|
||
it('样例覆盖 import / def / docstring / if-elif-else / for / try-except-finally / with / 推导式 / class 字段', async () => {
|
||
expect(await tree(readFixture('sample.py'))).toEqual(SAMPLE)
|
||
})
|
||
|
||
it('装饰器算进头部；冒号后、主体前的注释挂到主体第一条语句上；循环的 else 是兄弟块；match 的 case 是子块 if', async () => {
|
||
const source = [
|
||
'@cache',
|
||
'def load(key):',
|
||
' # 先查缓存',
|
||
' while key:',
|
||
' key = key[1:]',
|
||
' else:',
|
||
' pass',
|
||
' match key:',
|
||
' case \'a\':',
|
||
' return 1',
|
||
' case _:',
|
||
' return 2',
|
||
].join('\n')
|
||
expect(await tree(source)).toEqual([
|
||
{ at: [1, 2], kind: 'function', kids: [
|
||
{ at: 4, kind: 'loop', notes: [3], kids: [{ at: 5, kind: 'variable' }] },
|
||
{ at: 6, kind: 'else', kids: [{ at: 7, kind: 'statement' }] },
|
||
{ at: 8, kind: 'if', kids: [
|
||
{ at: 9, kind: 'if', kids: [{ at: 10, kind: 'return' }] },
|
||
{ at: 11, kind: 'if', kids: [{ at: 12, kind: 'return' }] },
|
||
] },
|
||
] },
|
||
])
|
||
})
|
||
|
||
it('docstring 只认主体开头；不是开头、也没挂到赋值上的字符串是注释，挂到后面那条语句上，f-string、字节串照旧是语句', async () => {
|
||
const source = [
|
||
'def f():',
|
||
' x = 1',
|
||
' """not a docstring"""',
|
||
' "a" \'b\'',
|
||
' f"{x}"',
|
||
' b"x"',
|
||
' "a" f"b"',
|
||
].join('\n')
|
||
expect(await tree(source)).toEqual([
|
||
{ at: 1, kind: 'function', kids: [
|
||
{ at: 2, kind: 'variable' },
|
||
{ at: 5, kind: 'statement', notes: [3, 4] },
|
||
{ at: 6, kind: 'statement' },
|
||
{ at: 7, kind: 'statement' },
|
||
] },
|
||
])
|
||
expect(await tree('def f(): f"not a docstring"')).toEqual([{ at: 1, kind: 'function', kids: [{ at: 1, kind: 'statement' }] }])
|
||
})
|
||
})
|
||
|
||
describe('python 属性 docstring', () => {
|
||
/** 字段（一行译文的块）的说明，按 header 起始行（1 起）索引。 */
|
||
function fieldDocs(source: string): Promise<Record<number, unknown>> {
|
||
return withBlocks(adapter, 'python', source, (blocks) => {
|
||
const byLine: Record<number, unknown> = {}
|
||
walk(blocks, (block) => {
|
||
if (block.kind === 'field' && block.doc)
|
||
byLine[block.header.startRow + 1] = nodesToText(block.doc)
|
||
})
|
||
return byLine
|
||
})
|
||
}
|
||
|
||
it('attributeDocs.py：模块、类主体里紧跟在赋值后面的字符串并进那块，头部延到字符串结尾；隔着注释、不跟在赋值后面的是注释，挂到讲的块上', async () => {
|
||
expect(await tree(readFixture('attributeDocs.py'))).toEqual([
|
||
{ at: 1, kind: 'comment' },
|
||
{ at: [3, 4], kind: 'const' },
|
||
{ at: [6, 8], kind: 'variable' },
|
||
{ at: [11, 12], kind: 'class', kids: [
|
||
{ at: [14, 15], kind: 'variable' },
|
||
{ at: [17, 19], kind: 'field', notes: [21, 22] },
|
||
] },
|
||
{ at: 25, kind: 'function', kids: [
|
||
{ at: 26, kind: 'variable' },
|
||
{ at: 31, kind: 'statement', notes: [[27, 30]] },
|
||
{ at: 32, kind: 'statement' },
|
||
{ at: 33, kind: 'return' },
|
||
] },
|
||
])
|
||
})
|
||
|
||
it('进常量、变量的 facts.doc 和字段的 doc，是那个字符串节点；函数体里的赋值没有', async () => {
|
||
const source = readFixture('attributeDocs.py')
|
||
const found = await facts(source)
|
||
expect(found[3]).toMatchObject({ doc: '"""一 deployment 一案例的唯一约束名; 入库侧按它认"重复入库", 故与建表同源。"""' })
|
||
expect(found[6]).toMatchObject({ doc: '"""隔着空行、赋值行尾有注释也算。"""' })
|
||
expect(found[14]).toMatchObject({ doc: '"""正在分析源 deployment."""' })
|
||
expect(found[26]).not.toHaveProperty('doc')
|
||
expect(await fieldDocs(source)).toEqual({ 17: '"""案例标题,\n 用户可编辑."""' })
|
||
})
|
||
|
||
it('只挂到紧跟着的下一条语句：两个字符串只有第一个是说明；没有值的注解、拼接的字符串也算；条件分支里的赋值不算', async () => {
|
||
const source = [
|
||
'class K:',
|
||
' a: int',
|
||
' "A" "B"',
|
||
' "又一个"',
|
||
'if DEBUG:',
|
||
' X = 1',
|
||
' """不算"""',
|
||
].join('\n')
|
||
expect(await tree(source)).toEqual([
|
||
{ at: 1, kind: 'class', kids: [{ at: [2, 3], kind: 'field', notes: [4] }] },
|
||
{ at: 5, kind: 'if', kids: [{ at: 6, kind: 'variable', notes: [7] }] },
|
||
])
|
||
expect(await fieldDocs(source)).toEqual({ 2: '"A" "B"' })
|
||
})
|
||
})
|
||
|
||
describe('python 函数、类的 docstring', () => {
|
||
const source = [
|
||
'class K:',
|
||
' """类说明"""',
|
||
' def run(self): # 行尾',
|
||
' # 先说一句',
|
||
' """跑一遍。',
|
||
'',
|
||
' 细节。',
|
||
' """ # 行尾',
|
||
' # 真正的注释',
|
||
' return 1',
|
||
'def g(): "单行"',
|
||
].join('\n')
|
||
|
||
it('算进函数、类头部、不单独成块，它前面的注释也在头部里；后面的注释挂到后面那条语句上', async () => {
|
||
expect(await tree(source)).toEqual([
|
||
{ at: [1, 2], kind: 'class', kids: [
|
||
{ at: [3, 8], kind: 'function', kids: [
|
||
{ at: 10, kind: 'return', notes: [9] },
|
||
] },
|
||
] },
|
||
{ at: 11, kind: 'function' },
|
||
])
|
||
})
|
||
|
||
it('进 facts.doc：是那个字符串节点；没有 docstring 的函数没有；模块开头的 docstring 照旧是注释块', async () => {
|
||
const found = await facts(source)
|
||
expect(found[1]).toMatchObject({ name: 'K', doc: '"""类说明"""' })
|
||
expect(found[3]).toMatchObject({ name: 'run', doc: '"""跑一遍。\n\n 细节。\n """' })
|
||
expect(await tree('"""模块说明"""\nclass K:\n pass')).toEqual([{ at: 1, kind: 'comment' }, { at: 2, kind: 'class', kids: [{ at: 3, kind: 'statement' }] }])
|
||
expect(found[11]).toMatchObject({ name: 'g', doc: '"单行"' })
|
||
expect(await facts('def f():\n x = 1\n """not a docstring"""')).not.toHaveProperty('1.doc')
|
||
})
|
||
})
|
||
|
||
describe('python 属性表信息（facts）', () => {
|
||
it('sample.py：import / from import、模块和类里的赋值、函数和方法', async () => {
|
||
const sample = await facts(readFixture('sample.py'))
|
||
expect(sample[3]).toEqual({ sources: ['os'], items: [{ kind: 'module', module: 'os' }] })
|
||
expect(sample[4]).toEqual({ sources: ['pathlib'], items: [{ kind: 'named', name: 'Path', alias: 'P' }] })
|
||
expect(sample[6]).toEqual({ access: 'public', declarators: [{ name: 'MAX_DEPTH', value: '8' }] })
|
||
expect(sample[10]).toEqual({
|
||
name: 'find_env_files',
|
||
doc: '"""Return every .env file under root."""',
|
||
access: 'public',
|
||
async: false,
|
||
decorators: [],
|
||
parameters: [{ name: 'root', optional: false, type: 'str' }],
|
||
returnType: 'list[str]',
|
||
})
|
||
expect(sample[17]).toEqual({ declarators: [{ name: 'found', value: 'found[:MAX_DEPTH]' }] })
|
||
expect(sample[37]).toEqual({ access: 'public', declarators: [{ name: 'label', value: '\'env\'' }] })
|
||
expect(sample[39]).toMatchObject({
|
||
name: 'summary',
|
||
access: 'public',
|
||
parameters: [{ name: 'self', optional: false }, { name: 'verbose', optional: false, type: 'bool', default: 'False' }],
|
||
returnType: 'str',
|
||
})
|
||
})
|
||
|
||
it('routes.py：future 导入、多行括号导入、带装饰器的 async def、await 赋值', async () => {
|
||
const routes = await facts(readFixture('routes.py'))
|
||
expect(routes[6]).toEqual({ sources: ['__future__'], items: [{ kind: 'named', name: 'annotations' }] })
|
||
expect(routes[19]).toEqual({
|
||
sources: ['.schemas'],
|
||
items: [
|
||
{ kind: 'named', name: 'UserAvatarUploadResponse' },
|
||
{ kind: 'named', name: 'UserDetailResponse' },
|
||
{ kind: 'named', name: 'UserUpdateRequest' },
|
||
],
|
||
})
|
||
expect(routes[29]).toEqual({
|
||
name: 'get_user',
|
||
doc: '"""获取用户详情。\n\n 管理员可查看任意用户，普通用户只能查看自己。\n """',
|
||
access: 'public',
|
||
async: true,
|
||
decorators: ['@router.get("/{user_id}", response_model=UserDetailResponse)'],
|
||
parameters: [
|
||
{ name: 'user_id', optional: false, type: 'Int4Path' },
|
||
{ name: 'db', optional: false, type: 'AsyncSession', default: 'Depends(get_db)' },
|
||
{ name: 'current_user', optional: false, type: 'User', default: 'Depends(get_current_user)' },
|
||
],
|
||
returnType: 'UserDetailResponse',
|
||
})
|
||
expect(routes[118]).toEqual({ declarators: [{ name: 'payload', value: 'await file.read()' }] })
|
||
})
|
||
|
||
it('导入：import a.b as c, d 每个模块一个来源；from . import、from m import *', async () => {
|
||
const source = [
|
||
'import os.path as osp, sys',
|
||
'from . import x',
|
||
'from m import *',
|
||
].join('\n')
|
||
expect(await facts(source)).toEqual({
|
||
1: { sources: ['os.path', 'sys'], items: [{ kind: 'module', module: 'os.path', alias: 'osp' }, { kind: 'module', module: 'sys' }] },
|
||
2: { sources: ['.'], items: [{ kind: 'named', name: 'x' }] },
|
||
3: { sources: ['m'], items: [{ kind: 'namespace' }] },
|
||
})
|
||
})
|
||
|
||
it('形参：*args / **kwargs 带前缀，* 和 / 分隔符不算参数', async () => {
|
||
const found = await facts('async def f(a, /, b: int, *args: int, c=1, d: str = \'x\', **kw) -> None:\n pass')
|
||
expect(found[1]).toEqual({
|
||
name: 'f',
|
||
access: 'public',
|
||
async: true,
|
||
decorators: [],
|
||
parameters: [
|
||
{ name: 'a', optional: false },
|
||
{ name: 'b', optional: false, type: 'int' },
|
||
{ name: '*args', optional: false, type: 'int' },
|
||
{ name: 'c', optional: false, default: '1' },
|
||
{ name: 'd', optional: false, type: 'str', default: '\'x\'' },
|
||
{ name: '**kw', optional: false },
|
||
],
|
||
returnType: 'None',
|
||
})
|
||
})
|
||
|
||
it('访问级别：单下划线开头私有、__dunder__ 公共；解构全是私有名才私有；函数体里的没有', async () => {
|
||
const source = [
|
||
'_cache = {}',
|
||
'__all__ = [\'f\']',
|
||
'a, _b = 1, 2',
|
||
'_c, _d = 1, 2',
|
||
'total: int',
|
||
'class K:',
|
||
' def __init__(self):',
|
||
' self.x = 1',
|
||
' def _helper(self):',
|
||
' def inner():',
|
||
' pass',
|
||
].join('\n')
|
||
const found = await facts(source)
|
||
expect(found[1]).toMatchObject({ access: 'private' })
|
||
expect(found[2]).toMatchObject({ access: 'public' })
|
||
expect(found[3]).toEqual({ access: 'public', declarators: [{ name: 'a, _b', value: '1, 2' }] })
|
||
expect(found[4]).toMatchObject({ access: 'private' })
|
||
expect(found[5]).toEqual({ access: 'public', declarators: [{ name: 'total', type: 'int' }] })
|
||
expect(found[7]).toMatchObject({ name: '__init__', access: 'public' })
|
||
expect(found[8]).toEqual({ declarators: [{ name: 'self.x', value: '1' }] })
|
||
expect(found[9]).toMatchObject({ name: '_helper', access: 'private' })
|
||
expect(found[10]).not.toHaveProperty('access')
|
||
})
|
||
|
||
it('声明的值照源码给，字面量的各项不在 facts 里（见 LanguageAdapter.collection）', async () => {
|
||
const found = await facts('EMPTY = {}\nITEMS = [1]\nclass K:\n labels = {"x": 1}')
|
||
expect(found[1]).toEqual({ access: 'public', declarators: [{ name: 'EMPTY', value: '{}' }] })
|
||
expect(found[2]).toEqual({ access: 'public', declarators: [{ name: 'ITEMS', value: '[1]' }] })
|
||
expect(found[4]).toEqual({ access: 'public', declarators: [{ name: 'labels', value: '{"x": 1}' }] })
|
||
})
|
||
})
|
||
|
||
describe('python 字面量的各项', () => {
|
||
const collections = (source: string): Promise<unknown[]> => nodeFacts(adapter, 'python', source, node => adapter.collection?.(node))
|
||
|
||
it('字典：字符串键、名字键、**展开，注释不算一项；值里的字典另有自己的各项，空字典没有项', async () => {
|
||
const source = [
|
||
'_KEYS = {',
|
||
' "published": "contests:publish",',
|
||
' key: 1,',
|
||
' # 注释不算一项',
|
||
' "nested": {"a": {}},',
|
||
' **other,',
|
||
'}',
|
||
].join('\n')
|
||
expect(await collections(source)).toEqual([
|
||
{ kind: 'map', entries: [
|
||
{ kind: 'pair', key: '"published"', value: '"contests:publish"' },
|
||
{ kind: 'pair', key: 'key', value: '1' },
|
||
{ kind: 'pair', key: '"nested"', value: '{"a": {}}' },
|
||
{ kind: 'spread', value: 'other' },
|
||
] },
|
||
{ kind: 'map', entries: [{ kind: 'pair', key: '"a"', value: '{}' }] },
|
||
{ kind: 'map', entries: [] },
|
||
])
|
||
})
|
||
|
||
it('列表、元组、集合：各项照源码顺序，*x 是展开，注释不算一项；值里的字面量另有自己的各项，空列表没有项', async () => {
|
||
const source = [
|
||
'filters = [',
|
||
' Filter(field="user_id"),',
|
||
' # 注释不算一项',
|
||
' *rest,',
|
||
' (a, b),',
|
||
' {1},',
|
||
' [],',
|
||
']',
|
||
].join('\n')
|
||
expect(await collections(source)).toEqual([
|
||
{ kind: 'sequence', elements: [
|
||
{ kind: 'item', value: 'Filter(field="user_id")' },
|
||
{ kind: 'spread', value: 'rest' },
|
||
{ kind: 'item', value: '(a, b)' },
|
||
{ kind: 'item', value: '{1}' },
|
||
{ kind: 'item', value: '[]' },
|
||
] },
|
||
{ kind: 'sequence', elements: [{ kind: 'item', value: 'a' }, { kind: 'item', value: 'b' }] },
|
||
{ kind: 'sequence', elements: [{ kind: 'item', value: '1' }] },
|
||
{ kind: 'sequence', elements: [] },
|
||
])
|
||
})
|
||
|
||
it('推导式、括号里的一个式子、调用的实参列表、别的值不是', async () => {
|
||
expect(await collections('x = [a for a in b]\ny = (a)\nf(a, b)\nz = a, b')).toEqual([])
|
||
})
|
||
})
|
||
|
||
describe('python 类', () => {
|
||
it('classes.py：docstring（连同它前面的注释）算进类头部，类里的类、函数里的类照常成块', async () => {
|
||
expect(await tree(readFixture('classes.py'))).toEqual([
|
||
{ at: 1, kind: 'comment' },
|
||
{ at: 3, kind: 'import' },
|
||
{ at: [6, 10], kind: 'class', kids: [
|
||
{ at: 12, kind: 'field' },
|
||
{ at: 14, kind: 'function', kids: [{ at: 15, kind: 'variable' }] },
|
||
] },
|
||
{ at: [18, 20], kind: 'class', kids: [{ at: 21, kind: 'variable' }] },
|
||
{ at: [24, 25], kind: 'class', kids: [
|
||
{ at: 26, kind: 'class', kids: [{ at: 27, kind: 'variable' }] },
|
||
{ at: 29, kind: 'class', kids: [{ at: 30, kind: 'statement' }] },
|
||
] },
|
||
{ at: 33, kind: 'class', kids: [{ at: 34, kind: 'statement' }] },
|
||
{ at: 37, kind: 'function', kids: [
|
||
{ at: [38, 39], kind: 'class' },
|
||
{ at: 40, kind: 'return' },
|
||
] },
|
||
])
|
||
})
|
||
|
||
it('classes.py：名称、说明、访问级别（同函数的下划线规则，类里的类也按它，函数里的没有）、装饰器、父类（参数列表照写的顺序，关键字参数也算）', async () => {
|
||
const found = await facts(readFixture('classes.py'))
|
||
expect(found[6]).toEqual({
|
||
name: 'AppResponse',
|
||
doc: '"""应用响应的基类。\n\n 带上 HTTP 状态码。\n """',
|
||
access: 'public',
|
||
decorators: [],
|
||
typeParameters: [],
|
||
bases: [{ value: 'BaseModel' }],
|
||
implements: [],
|
||
})
|
||
expect(found[18]).toMatchObject({ name: 'NotFound', doc: '"""找不到资源。"""', bases: [{ value: 'AppResponse' }] })
|
||
expect(found[24]).toEqual({
|
||
name: 'Meta',
|
||
access: 'public',
|
||
decorators: ['@dataclass(frozen=True)'],
|
||
typeParameters: [],
|
||
bases: [{ value: 'Base' }, { value: 'metaclass=ABCMeta' }],
|
||
implements: [],
|
||
})
|
||
expect(found[26]).toMatchObject({ name: 'Config', access: 'public', bases: [] })
|
||
expect(found[29]).toMatchObject({ name: '_Hidden', access: 'private' })
|
||
expect(found[33]).toMatchObject({ name: '_Private', access: 'private' })
|
||
expect(found[38]).toEqual({ name: 'Local', doc: '"""局部类。"""', decorators: [], typeParameters: [], bases: [], implements: [] })
|
||
})
|
||
|
||
it('没有「抽象」这个概念；Python 3.12 的泛型参数进 typeParameters；*bases、**kw 也是父类里的一项', async () => {
|
||
expect((await facts('class G[T](Generic[T], *mixins, **kw):\n pass'))[1]).toEqual({
|
||
name: 'G',
|
||
access: 'public',
|
||
decorators: [],
|
||
typeParameters: ['T'],
|
||
bases: [{ value: 'Generic[T]' }, { value: '*mixins' }, { value: '**kw' }],
|
||
implements: [],
|
||
})
|
||
})
|
||
})
|
||
|
||
describe('python 写在表达式里的遍历（推导式）', () => {
|
||
/** 源码里每个认得出的遍历（外层在前），节点换成源码。 */
|
||
async function iterations(source: string): Promise<unknown[]> {
|
||
const tree = await runtime.parse(adapter, 'python', source)
|
||
try {
|
||
const found: IterationFacts[] = []
|
||
const visit = (node: Node): void => {
|
||
const facts = adapter.iteration?.(node)
|
||
if (facts)
|
||
found.push(facts)
|
||
for (const child of node.children) {
|
||
if (child)
|
||
visit(child)
|
||
}
|
||
}
|
||
visit(tree.rootNode)
|
||
return found.map(nodesToText)
|
||
}
|
||
finally {
|
||
tree.delete()
|
||
}
|
||
}
|
||
|
||
it('调用唯一的参数是生成器：那对括号是调用的，记在 sharedParentheses；参数不止一个时生成器自己带括号，没有', async () => {
|
||
expect(await iterations('"".join(secrets.choice(ALPHABET) for _ in range(length))')).toEqual([{
|
||
result: 'generator',
|
||
clauses: [{ kind: 'for', variables: '_', source: 'range(length)', async: false }],
|
||
value: 'secrets.choice(ALPHABET)',
|
||
sharedParentheses: { open: '(', close: ')' },
|
||
}])
|
||
const source = 'f(a, (x for x in y))'
|
||
expect(await iterations(source)).toEqual([{
|
||
result: 'generator',
|
||
clauses: [{ kind: 'for', variables: 'x', source: 'y', async: false }],
|
||
value: 'x',
|
||
}])
|
||
})
|
||
|
||
it('列表带条件、字典分出键和值、集合的变量是解构', async () => {
|
||
expect(await iterations('[u.id for u in users if u.is_active]')).toEqual([{
|
||
result: 'list',
|
||
clauses: [{ kind: 'for', variables: 'u', source: 'users', async: false }, { kind: 'if', condition: 'u.is_active' }],
|
||
value: 'u.id',
|
||
}])
|
||
expect(await iterations('{u.id: u for u in users}')).toEqual([{
|
||
result: 'dict',
|
||
clauses: [{ kind: 'for', variables: 'u', source: 'users', async: false }],
|
||
key: 'u.id',
|
||
value: 'u',
|
||
}])
|
||
expect(await iterations('{n for n, _ in pairs}')).toEqual([{
|
||
result: 'set',
|
||
clauses: [{ kind: 'for', variables: 'n, _', source: 'pairs', async: false }],
|
||
value: 'n',
|
||
}])
|
||
})
|
||
|
||
it('几节 for、if 照源码顺序；async for 标出异步', async () => {
|
||
expect(await iterations('[c for row in grid if row for c in row if c]')).toEqual([{
|
||
result: 'list',
|
||
clauses: [
|
||
{ kind: 'for', variables: 'row', source: 'grid', async: false },
|
||
{ kind: 'if', condition: 'row' },
|
||
{ kind: 'for', variables: 'c', source: 'row', async: false },
|
||
{ kind: 'if', condition: 'c' },
|
||
],
|
||
value: 'c',
|
||
}])
|
||
expect(await iterations('[v async for v in stream() if v]')).toEqual([{
|
||
result: 'list',
|
||
clauses: [{ kind: 'for', variables: 'v', source: 'stream()', async: true }, { kind: 'if', condition: 'v' }],
|
||
value: 'v',
|
||
}])
|
||
})
|
||
|
||
it('套着的遍历各自认，外层取的值就是里层整个遍历', async () => {
|
||
expect(await iterations('[[y for y in row] for row in grid]')).toEqual([
|
||
{ result: 'list', clauses: [{ kind: 'for', variables: 'row', source: 'grid', async: false }], value: '[y for y in row]' },
|
||
{ result: 'list', clauses: [{ kind: 'for', variables: 'y', source: 'row', async: false }], value: 'y' },
|
||
])
|
||
})
|
||
|
||
it('列表、字典、元组字面量和 for 语句不是', async () => {
|
||
expect(await iterations('x = [1, 2]\ny = {"a": 1}\nz = (a, b)\nfor x in y:\n pass')).toEqual([])
|
||
})
|
||
})
|
||
|
||
describe('python 调用', () => {
|
||
const calls = (source: string): Promise<unknown[]> => nodeFacts(adapter, 'python', source, node => adapter.call?.(node))
|
||
|
||
it('实参照源码顺序：按位置、按名字、*x、**x；新建对象和调用写法一样，不给 construct；点分名字取最后一节', async () => {
|
||
const source = 'user_service.update_user(\n db, # 会话\n user_id=user_id,\n *rest,\n **options,\n)'
|
||
expect(await calls(source)).toEqual([{
|
||
callee: 'user_service.update_user',
|
||
name: 'update_user',
|
||
argumentList: '(\n db, # 会话\n user_id=user_id,\n *rest,\n **options,\n)',
|
||
arguments: [
|
||
{ kind: 'positional', value: 'db' },
|
||
{ kind: 'keyword', name: 'user_id', value: 'user_id' },
|
||
{ kind: 'spread', value: 'rest' },
|
||
{ kind: 'keywordSpread', value: 'options' },
|
||
],
|
||
}])
|
||
})
|
||
|
||
it('唯一的实参是生成器表达式时就是它；被调用的不是名字时没有 name；装饰器、父类列表不是调用', async () => {
|
||
expect(await calls('sum(x for x in xs)')).toEqual([{ callee: 'sum', name: 'sum', argumentList: '(x for x in xs)', arguments: [{ kind: 'positional', value: '(x for x in xs)' }] }])
|
||
expect(await calls('handlers[k]()')).toEqual([{ callee: 'handlers[k]', argumentList: '()', arguments: [] }])
|
||
expect(await calls('@cache\nclass A(Base):\n pass')).toEqual([])
|
||
})
|
||
})
|
||
|
||
describe('python 注释挂到它讲的块上', () => {
|
||
it('同一层后面最近的那块（隔着空行也算）；主体最后的挂到前面那块；主体里只有注释时挂到父块；文件最后的挂到最后一块', async () => {
|
||
const source = [
|
||
'"""模块说明。"""',
|
||
'',
|
||
'import os',
|
||
'',
|
||
'',
|
||
'# 讲 load：隔着空行',
|
||
'def load(path):',
|
||
' """读出来。"""',
|
||
' # 先检查',
|
||
' if not path:',
|
||
' return None',
|
||
' return path',
|
||
' # 函数体最后的注释',
|
||
'',
|
||
'',
|
||
'class Empty:',
|
||
' """只有说明。"""',
|
||
' # 只有注释的主体',
|
||
'',
|
||
'',
|
||
'# 文件最后的注释',
|
||
].join('\n')
|
||
expect(await tree(source)).toEqual([
|
||
{ at: 1, kind: 'comment' },
|
||
{ at: 3, kind: 'import' },
|
||
{ at: [7, 8], kind: 'function', notes: [6], kids: [
|
||
{ at: 10, kind: 'if', notes: [9], kids: [{ at: 11, kind: 'return' }] },
|
||
{ at: 12, kind: 'return', notes: [13] },
|
||
] },
|
||
{ at: [16, 17], kind: 'class', notes: [18, 21] },
|
||
])
|
||
})
|
||
|
||
it('文件开头的注释和第一块代码隔着空行是文件的说明，紧挨着就挂到它上面；#! 和写编码的那行总是文件的', async () => {
|
||
expect(await tree('# 文件的说明\n\nimport os\n')).toEqual([{ at: 1, kind: 'comment' }, { at: 3, kind: 'import' }])
|
||
expect(await tree('# 讲导入\nimport os\n')).toEqual([{ at: 2, kind: 'import', notes: [1] }])
|
||
expect(await tree('#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n# 讲导入\nimport os\n')).toEqual([
|
||
{ at: [1, 2], kind: 'comment' },
|
||
{ at: 4, kind: 'import', notes: [3] },
|
||
])
|
||
})
|
||
|
||
it('luffy 的 acquisition/repository.py：导入后面隔着两个空行的注释挂到类上，是类卡片的「注释」一行，类的编辑范围连着这几行', async () => {
|
||
const source = readFixture('acquisitionRepository.py')
|
||
const [klass] = (await tree(source)).filter(block => block.kind === 'class')
|
||
expect(klass).toMatchObject({ at: [19, 21], notes: [[13, 16]] })
|
||
})
|
||
})
|