270 lines
13 KiB
TypeScript
270 lines
13 KiB
TypeScript
import type { BlockView, RuleRun } from './blockView'
|
|
import type { CodeBlock, LibraryRule, RuleBlock, RuleLocation, RuleWorkspace, Segment } from './contract'
|
|
import { describe, expect, it } from 'vitest'
|
|
import { fileAttributes } from './attributes'
|
|
import { toBlockViews } from './blockView'
|
|
import { replaceLines } from './editText'
|
|
import { createPythonAdapter } from './languages/python'
|
|
import { activeRules, fromLibrary, importsIn, resolveReference } from './libraryRules'
|
|
import { propertyLines, WASM_DIR, withBlocks } from './testSupport'
|
|
import { pythonZhTranslator } from './translators/pythonZh'
|
|
|
|
const py = createPythonAdapter(WASM_DIR)
|
|
|
|
const MODEL = [
|
|
'from sqlalchemy.orm import mapped_column',
|
|
'',
|
|
'class User(Base):',
|
|
' __tablename__ = "users"',
|
|
' # 基本信息',
|
|
' name = mapped_column(String)',
|
|
'',
|
|
' def greet(self) -> str:',
|
|
' return self.name',
|
|
'',
|
|
].join('\n')
|
|
|
|
/** 认领每个类块的假规则：并进它的前两个子块。 */
|
|
function cardRule(id: string, overrides: Partial<RuleBlock> = {}): LibraryRule {
|
|
return {
|
|
id,
|
|
label: id,
|
|
languageIds: ['python'],
|
|
libraries: ['sqlalchemy'],
|
|
claim: block => block.kind === 'class'
|
|
? { kind: `${id}.card`, badge: { label: `${id} 卡片`, color: { dark: '#fff', light: '#000' } }, rows: [], absorbs: block.children.slice(0, 1), ...overrides }
|
|
: undefined,
|
|
}
|
|
}
|
|
|
|
const throwing: LibraryRule = {
|
|
id: 'throwing',
|
|
label: '抛错',
|
|
languageIds: ['python'],
|
|
libraries: ['sqlalchemy'],
|
|
claim: () => {
|
|
throw new Error('坏了')
|
|
},
|
|
}
|
|
|
|
async function views(source: string, rules: LibraryRule[], reports: string[] = []): Promise<BlockView[]> {
|
|
const run: RuleRun = { rules, report: message => reports.push(message) }
|
|
return withBlocks(py, 'python', source, blocks => toBlockViews(blocks, { source, language: py, markers: [] }, pythonZhTranslator, run))
|
|
}
|
|
|
|
function flatten(list: BlockView[]): BlockView[] {
|
|
return list.flatMap(view => [view, ...flatten(view.children)])
|
|
}
|
|
|
|
/** 语法树用完即释放，节点要在里面读完。 */
|
|
function activates(source: string, rule: LibraryRule): Promise<boolean> {
|
|
return withBlocks(py, 'python', source, blocks => activeRules([rule], importsIn(blocks)).length > 0)
|
|
}
|
|
|
|
describe('库规则：启用', () => {
|
|
it('来源等于库名、或是它的子模块才算导入了这个库', () => {
|
|
expect(fromLibrary('sqlalchemy', 'sqlalchemy')).toBe(true)
|
|
expect(fromLibrary('sqlalchemy.orm', 'sqlalchemy')).toBe(true)
|
|
expect(fromLibrary('drizzle-orm/pg-core', 'drizzle-orm')).toBe(true)
|
|
expect(fromLibrary('sqlalchemy_utils', 'sqlalchemy')).toBe(false)
|
|
expect(fromLibrary('.sqlalchemy', 'sqlalchemy')).toBe(false)
|
|
})
|
|
|
|
it.each([
|
|
['from sqlalchemy.orm import Mapped, mapped_column', true],
|
|
['import sqlalchemy as sa', true],
|
|
['import os, sqlalchemy', true],
|
|
['def f():\n from sqlalchemy import select\n', true],
|
|
['from sqlalchemy_utils import UUIDType', false],
|
|
['from .sqlalchemy import Base', false],
|
|
['import os', false],
|
|
])('%s → %s', async (source, active) => {
|
|
expect(await activates(source, cardRule('sqlalchemy'))).toBe(active)
|
|
})
|
|
|
|
it('没导入库的文件不问规则', async () => {
|
|
const reports: string[] = []
|
|
const list = await views(MODEL.replace('sqlalchemy.orm', 'other'), [throwing], reports)
|
|
expect(list.map(view => view.kind)).toEqual(['import', 'class'])
|
|
expect(reports).toEqual([])
|
|
})
|
|
})
|
|
|
|
describe('库规则：认领', () => {
|
|
it('认领的块换成替身：种类、标签、编辑范围是整个类；规则没并进来的子块（夹在中间的注释、方法）照源码顺序留下', async () => {
|
|
const rule: LibraryRule = {
|
|
...cardRule('orm'),
|
|
claim: (block) => {
|
|
if (block.kind !== 'class')
|
|
return undefined
|
|
const [table, , column] = block.children
|
|
return { kind: 'orm.card', badge: { label: '卡片', color: { dark: '#fff', light: '#000' } }, rows: [{ label: '名称', value: [{ text: 'User', role: 'type' }] }], absorbs: [table, column] }
|
|
},
|
|
}
|
|
const [, card] = await views(MODEL, [rule])
|
|
expect(card).toMatchObject({
|
|
kind: 'orm.card',
|
|
badge: { label: '卡片' },
|
|
startLine: 2,
|
|
endLine: 8,
|
|
code: 'class User(Base):\n __tablename__ = "users"\n # 基本信息\n name = mapped_column(String)\n\n def greet(self) -> str:\n return self.name',
|
|
attributes: { kind: 'orm.card', access: 'public' },
|
|
properties: [{ label: '名称' }],
|
|
})
|
|
expect(card.children.map(child => [child.id, child.kind, child.startLine])).toEqual([['1.0', 'comment', 4], ['1.1', 'function', 7]])
|
|
})
|
|
|
|
it('两个字段中间写着的方法：预览里照常是卡片的子块；卡片「编辑」写回整个类', async () => {
|
|
const source = [
|
|
'from sqlalchemy.orm import mapped_column',
|
|
'',
|
|
'class User(Base):',
|
|
' id = mapped_column(Integer)',
|
|
'',
|
|
' def greet(self) -> str:',
|
|
' return self.name',
|
|
'',
|
|
' name = mapped_column(String)',
|
|
'',
|
|
].join('\n')
|
|
const fields: LibraryRule = { ...cardRule('orm'), claim: block => block.kind === 'class'
|
|
? { kind: 'orm.card', badge: { label: '卡片', color: { dark: '#fff', light: '#000' } }, rows: [], absorbs: block.children.filter(child => child.kind === 'variable') }
|
|
: undefined }
|
|
const [, card] = await views(source, [fields])
|
|
expect(card.children.map(child => [child.kind, child.startLine, child.endLine])).toEqual([['function', 5, 5]])
|
|
expect([card.startLine, card.endLine]).toEqual([2, 8])
|
|
expect(replaceLines(source, card.startLine, card.endLine, card.code)).toBe(source)
|
|
const edited = replaceLines(source, card.startLine, card.endLine, card.code.replace('greet', 'hello').replace('String', 'Text'))
|
|
expect(edited).toBe(source.replace('greet', 'hello').replace('String', 'Text'))
|
|
})
|
|
|
|
it('能编辑的范围只在块和它的子孙之间重叠：卡片盖住的是它自己留下的子块，别的块互不重叠', async () => {
|
|
const list = flatten(await views(MODEL, [cardRule('orm', {})]))
|
|
const related = (a: string, b: string): boolean => a.startsWith(`${b}.`) || b.startsWith(`${a}.`)
|
|
for (const a of list) {
|
|
for (const b of list.filter(other => other !== a && !related(a.id, other.id)))
|
|
expect(a.startLine > b.endLine || b.startLine > a.endLine, `${a.id} / ${b.id}`).toBe(true)
|
|
}
|
|
expect(list.filter(view => view.id.startsWith('1.')).every(view => view.startLine >= list[1].startLine && view.endLine <= list[1].endLine)).toBe(true)
|
|
})
|
|
|
|
it('几个规则都认同一块时先注册的算', async () => {
|
|
expect((await views(MODEL, [cardRule('first'), cardRule('second')]))[1].kind).toBe('first.card')
|
|
expect((await views(MODEL, [cardRule('second'), cardRule('first')]))[1].kind).toBe('second.card')
|
|
})
|
|
|
|
it('规则抛错：记下来，接着问下一个规则；都没认就照常显示', async () => {
|
|
const reports: string[] = []
|
|
expect((await views(MODEL, [throwing, cardRule('second')], reports))[1].kind).toBe('second.card')
|
|
expect(reports[1]).toBe('库规则 throwing 看第 3 行的 class 块时出错，这块照常显示：坏了')
|
|
|
|
const alone = await views(MODEL, [throwing])
|
|
expect(alone[1]).toMatchObject({ kind: 'class', startLine: 2, endLine: 2 })
|
|
expect(alone[1].children.map(child => child.kind)).toEqual(['variable', 'comment', 'variable', 'function'])
|
|
})
|
|
|
|
it('替身不合约定（种类 id 没带规则 id、并进来的不是子块）：记下来，照常显示', async () => {
|
|
const reports: string[] = []
|
|
const stranger: CodeBlock[] = []
|
|
await withBlocks(py, 'python', 'x = 1', (blocks) => {
|
|
stranger.push(...blocks)
|
|
})
|
|
const list = await views(MODEL, [cardRule('bad', { kind: 'card' }), cardRule('worse', { absorbs: stranger })], reports)
|
|
expect(list[1].kind).toBe('class')
|
|
expect(reports).toEqual([
|
|
'库规则 bad 给第 3 行的 class 块的替身不合约定，这块照常显示：种类 id「card」没以「bad.」开头',
|
|
'库规则 worse 给第 3 行的 class 块的替身不合约定，这块照常显示：要并进来的块不是这块的子块',
|
|
])
|
|
})
|
|
|
|
it('认成契约里现成的属性表块：种类、属性表、筛选属性照语言插件报的这种块，编辑范围是整个类；并进来的不是子块时照常显示', async () => {
|
|
const asEnum = (absorbs: (block: CodeBlock) => CodeBlock[]): LibraryRule => ({
|
|
...cardRule('lib'),
|
|
claim: block => block.kind === 'class' && block.facts.name
|
|
? { as: { kind: 'enum', facts: { name: block.facts.name, access: block.facts.access, decorators: [], bases: [], members: [] } }, absorbs: absorbs(block) }
|
|
: undefined,
|
|
})
|
|
const [, recognized] = await views(MODEL, [asEnum(block => block.children.slice(0, 1))])
|
|
expect(recognized).toMatchObject({ kind: 'enum', startLine: 2, endLine: 8, attributes: { kind: 'enum', access: 'public' } })
|
|
expect(recognized.badge).toBeUndefined()
|
|
expect(propertyLines('properties' in recognized ? recognized.properties : [])).toEqual(['名称: User', '访问级别: 公共', '成员: 无'])
|
|
expect(recognized.children.map(child => child.kind)).toEqual(['comment', 'variable', 'function'])
|
|
|
|
const reports: string[] = []
|
|
const stranger: CodeBlock[] = []
|
|
await withBlocks(py, 'python', 'x = 1', blocks => stranger.push(...blocks))
|
|
const [, shown] = await views(MODEL, [asEnum(() => stranger)], reports)
|
|
expect(shown.kind).toBe('class')
|
|
expect(reports).toEqual(['库规则 lib 给第 3 行的 class 块的替身不合约定，这块照常显示：要并进来的块不是这块的子块'])
|
|
})
|
|
|
|
it('筛选：规则的种类和别的种类一样计数，名字取规则给的标签', async () => {
|
|
const list = await views(MODEL, [cardRule('orm')])
|
|
expect(fileAttributes(list, pythonZhTranslator.attributeNames).find(attribute => attribute.id === 'kind')?.values).toEqual([
|
|
{ id: 'import', name: '导入', count: 1 },
|
|
{ id: 'orm.card', name: 'orm 卡片', count: 1 },
|
|
{ id: 'comment', name: '注释', count: 1 },
|
|
{ id: 'variable', name: '变量', count: 1 },
|
|
{ id: 'function', name: '函数', count: 1 },
|
|
{ id: 'return', name: '返回', count: 1 },
|
|
])
|
|
})
|
|
})
|
|
|
|
describe('库规则：自己查定义的引用', () => {
|
|
const workspace: RuleWorkspace = { lookup: async () => [] }
|
|
const found: RuleLocation[] = [{ uri: 'file:///w/tasks.py', start: { line: 3, character: 4 }, end: { line: 3, character: 8 } }]
|
|
|
|
/** 认领类块、在名称那一行标一个引用的规则。 */
|
|
function referencing(id: string, reference: Segment, resolve?: LibraryRule['resolve']): LibraryRule {
|
|
return {
|
|
...cardRule(id, { rows: [{ label: '名称', value: [reference] }] }),
|
|
...(resolve && { resolve }),
|
|
}
|
|
}
|
|
|
|
it('引用要标自己的规则、规则要给 resolve、段要带下标，不然这块照常显示', async () => {
|
|
const reports: string[] = []
|
|
const resolve = async (): Promise<RuleLocation[]> => found
|
|
const list = await views(MODEL, [
|
|
referencing('other', { text: 'x', role: 'string', offset: 20, reference: { rule: 'celery', key: 'x' } }, resolve),
|
|
referencing('lazy', { text: 'x', role: 'string', offset: 20, reference: { rule: 'lazy', key: 'x' } }),
|
|
referencing('loose', { text: 'x', role: 'string', reference: { rule: 'loose', key: 'x' } }, resolve),
|
|
], reports)
|
|
expect(list[1].kind).toBe('class')
|
|
expect(reports.map(report => report.replace(/^.*照常显示：/, ''))).toEqual([
|
|
'引用「x」标的规则是「celery」，不是自己',
|
|
'标了引用「x」却没给 resolve',
|
|
'引用「x」没带源码下标',
|
|
])
|
|
|
|
const good = await views(MODEL, [referencing('good', { text: 'x', role: 'string', offset: 20, reference: { rule: 'good', key: 'x' } }, resolve)])
|
|
expect(good[1].kind).toBe('good.card')
|
|
})
|
|
|
|
it('查引用交给标它的规则；规则不在、没给 resolve、出错时当作没有定义并记下来', async () => {
|
|
const reports: string[] = []
|
|
const asked: [string, RuleWorkspace][] = []
|
|
const rule = referencing('good', { text: 'x', role: 'string', offset: 20 }, async (key, given) => {
|
|
asked.push([key, given])
|
|
return found
|
|
})
|
|
const broken = referencing('broken', { text: 'x', role: 'string', offset: 20 }, async () => {
|
|
throw new Error('索引坏了')
|
|
})
|
|
const rules = [rule, broken, cardRule('plain')]
|
|
const report = (message: string): number => reports.push(message)
|
|
|
|
expect(await resolveReference({ rule: 'good', key: 'a.b' }, rules, workspace, report)).toEqual(found)
|
|
expect(asked).toEqual([['a.b', workspace]])
|
|
expect(await resolveReference({ rule: 'broken', key: 'a.b' }, rules, workspace, report)).toEqual([])
|
|
expect(await resolveReference({ rule: 'plain', key: 'a.b' }, rules, workspace, report)).toEqual([])
|
|
expect(await resolveReference({ rule: 'gone', key: 'a.b' }, rules, workspace, report)).toEqual([])
|
|
expect(reports).toEqual([
|
|
'库规则 broken 查「a.b」的定义时出错：索引坏了',
|
|
'没有能查引用「a.b」的库规则 plain',
|
|
'没有能查引用「a.b」的库规则 gone',
|
|
])
|
|
})
|
|
})
|