import { Candidate, Context, DdcCandidate, DdcOptions, FilterOptions, SourceOptions,} from "./types.ts";import { defaultDdcOptions, foldMerge, mergeFilterOptions, mergeFilterParams, mergeSourceOptions, mergeSourceParams,} from "./context.ts";import { BaseSource, defaultSourceOptions, defaultSourceParams, GatherCandidatesArguments,} from "./base/source.ts";import { BaseFilter, defaultFilterOptions, defaultFilterParams, FilterArguments,} from "./base/filter.ts";import { assertEquals, autocmd, deadline, DeadlineError, Denops, fn, op, parse, TimeoutError, toFileUrl,} from "./deps.ts";
type DdcResult = { candidates: Candidate[]; completeStr: string; prevInput: string; lineNr: number;};
export class Ddc { private sources: Record<string, BaseSource> = {}; private filters: Record<string, BaseFilter> = {}; private checkPaths: Record<string, boolean> = {}; private prevResults: Record<string, DdcResult> = {}; private events: string[] = []; private prevRuntimepath = "";
private foundSources(names: string[]): BaseSource[] { return names.map((n) => this.sources[n]).filter((v) => v); } private foundFilters(names: string[]): BaseFilter[] { return names.map((n) => this.filters[n]).filter((v) => v); }
private foundInvalidSources(names: string[]): string[] { return names.filter((n) => !this.sources[n]); } private foundInvalidFilters(names: string[]): string[] { return names.filter((n) => !this.filters[n]); }
async registerAutocmd(denops: Denops, events: string[]) { await autocmd.group(denops, "ddc", (helper: autocmd.GroupHelper) => { for (const event of events) { if (!this.events.includes(event)) { helper.define( event as autocmd.AutocmdEvent, "*", `call denops#notify('${denops.name}','onEvent',["${event}"])`, ); this.events.push(event); } } }); }
async registerSource(denops: Denops, path: string, name: string) { if (path in this.checkPaths) { return; }
this.checkPaths[path] = true;
const mod = await import(toFileUrl(path).href); const source = new mod.Source(); source.name = name; this.sources[source.name] = source; if (source.events && source.events.length != 0) { this.registerAutocmd(denops, source.events); } }
async registerFilter(denops: Denops, path: string, name: string) { if (path in this.checkPaths) { return; }
this.checkPaths[path] = true;
const mod = await import(toFileUrl(path).href); const filter = new mod.Filter(); filter.name = name; filter?.apiVersion ? filter.onInit({ denops }) : filter.onInit(denops); this.filters[filter.name] = filter; if (filter.events && filter.events.length != 0) { this.registerAutocmd(denops, filter.events); } }
async autoload(denops: Denops) { const runtimepath = await op.runtimepath.getGlobal(denops); if (runtimepath == this.prevRuntimepath) { return; }
this.prevRuntimepath = runtimepath;
const sources = await fn.globpath( denops, runtimepath, "denops/ddc-sources/*.ts", 1, 1, ) as string[]; const filters = await fn.globpath( denops, runtimepath, "denops/ddc-filters/*.ts", 1, 1, ) as string[]; await Promise.all(sources.map((path) => { this.registerSource(denops, path, parse(path).name); })); await Promise.all(filters.map((path) => { this.registerFilter(denops, path, parse(path).name); })); }
async checkInvalid( denops: Denops, options: DdcOptions, filterNames: string[], ) { const invalidSources = this.foundInvalidSources(options.sources); if (Object.keys(this.sources).length != 0 && invalidSources.length != 0) { await denops.call( "ddc#util#print_error", "Invalid sources are detected!", ); await denops.call("ddc#util#print_error", invalidSources); }
const invalidFilters = this.foundInvalidFilters([...new Set(filterNames)]); if (Object.keys(this.filters).length != 0 && invalidFilters.length != 0) { await denops.call( "ddc#util#print_error", "Invalid filters are detected!", ); await denops.call("ddc#util#print_error", invalidFilters); } }
async onEvent( denops: Denops, context: Context, options: DdcOptions, ): Promise<void> { let filterNames: string[] = []; for (const source of this.foundSources(options.sources)) { const [sourceOptions, sourceParams] = sourceArgs(options, source); if (source.events?.includes(context.event)) { await callSourceOnEvent( source, denops, context, options, sourceOptions, sourceParams, ); }
filterNames = filterNames.concat( sourceOptions.matchers, sourceOptions.sorters, sourceOptions.converters, ); }
filterNames = [...new Set(filterNames)];
for (const filter of this.foundFilters(filterNames)) { if (filter.events?.includes(context.event)) { const [o, p] = filterArgs( options.filterOptions, options.filterParams, filter, ); await callFilterOnEvent( filter, denops, context, options, o, p, ); } }
if ( Object.keys(this.sources).length != 0 && Object.keys(this.filters).length != 0 ) { await this.checkInvalid(denops, options, filterNames); } }
async gatherResults( denops: Denops, context: Context, options: DdcOptions, ): Promise<[number, DdcCandidate[]]> { const sources = this.foundSources(options.sources) .map((s) => [s, ...sourceArgs(options, s)] as const); const rs = await Promise.all(sources.map(async ([s, o, p]) => { const pos = await callSourceGetCompletePosition( s, denops, context, options, o, p, ); const forceCompletion = o.forceCompletionPattern.length != 0 && context.input.search( new RegExp("(" + o.forceCompletionPattern + ")$"), ) != -1; const completePos = (pos < 0 && forceCompletion) ? context.input.length : (s.isBytePos && pos >= 0) ? byteposToCharpos(context.input, pos) : pos; const completeStr = context.input.slice(completePos); if ( completePos < 0 || (!forceCompletion && context.event != "Manual" && context.event != "ManualRefresh" && (completeStr.length < o.minAutoCompleteLength || completeStr.length > o.maxAutoCompleteLength)) ) { delete this.prevResults[s.name]; return; }
const result = s.name in this.prevResults ? this.prevResults[s.name] : null;
const prevInput = context.input.slice(0, completePos);
if ( !result || prevInput != result.prevInput || !completeStr.startsWith(result.completeStr) || context.lineNr != result.lineNr || context.event == "Manual" || context.event == "AutoRefresh" || context.event == "ManualRefresh" || o.isVolatile ) { const scs = await callSourceGatherCandidates( s, denops, context, options, o, p, completeStr, ); if (!scs.length) { return; }
this.prevResults[s.name] = { candidates: scs.concat(), completeStr: completeStr, prevInput: prevInput, lineNr: context.lineNr, }; }
const fcs = await this.filterCandidates( denops, context, options, o, options.filterOptions, options.filterParams, completeStr, this.prevResults[s.name].candidates, );
const candidates = fcs.map((c) => ( { ...c, abbr: formatAbbr(c.word, c.abbr), source: s.name, dup: o.dup, icase: true, equal: true, menu: formatMenu(o.mark, c.menu), } )); if (!candidates.length) { return; } return [completePos, candidates] as const; }));
const fs = rs.filter(<T>(v?: T): v is T => !!v); if (!fs.length) { return [-1, []]; }
const completePos = Math.min(...fs.map((v) => v[0]));
const candidates = fs.flatMap(([_, cs]) => cs);
const completePosBytes = charposToBytepos(context.input, completePos);
return [completePosBytes, candidates]; }
private async filterCandidates( denops: Denops, context: Context, options: DdcOptions, sourceOptions: SourceOptions, filterOptions: Record<string, Partial<FilterOptions>>, filterParams: Record<string, Partial<Record<string, unknown>>>, completeStr: string, cdd: Candidate[], ): Promise<Candidate[]> { const matchers = this.foundFilters(sourceOptions.matchers); const sorters = this.foundFilters(sourceOptions.sorters); const converters = this.foundFilters(sourceOptions.converters);
async function callFilters(filters: BaseFilter[]): Promise<Candidate[]> { for (const filter of filters) { const [o, p] = filterArgs(filterOptions, filterParams, filter); cdd = await callFilterFilter( filter, denops, context, options, sourceOptions, o, p, completeStr, cdd, ); }
return cdd; }
if (sourceOptions.matcherKey != "") { cdd = cdd.map((c) => ( { ...c, word: c[sourceOptions.matcherKey], __word: c.word, } )); }
cdd = await callFilters(matchers);
if (sourceOptions.matcherKey != "") { cdd = cdd.map((c) => ( { ...c, word: c.__word, } )); }
cdd = await callFilters(sorters);
cdd = cdd.slice(0, sourceOptions.maxCandidates);
cdd = await callFilters(converters);
return cdd; }}
function formatAbbr(word: string, abbr: string | undefined): string { return abbr ? abbr : word;}
function formatMenu(prefix: string, menu: string | undefined): string { menu = menu ? menu : ""; return prefix == "" ? menu : menu == "" ? `[${prefix}]` : `[${prefix}] ${menu}`;}
function byteposToCharpos(input: string, pos: number): number { const bytes = (new TextEncoder()).encode(input); return (new TextDecoder()).decode(bytes.slice(0, pos)).length;}
function charposToBytepos(input: string, pos: number): number { return (new TextEncoder()).encode(input.slice(0, pos)).length;}
function sourceArgs( options: DdcOptions, source: BaseSource,): [SourceOptions, Record<string, unknown>] { const o = foldMerge( mergeSourceOptions, defaultSourceOptions, [options.sourceOptions["_"], options.sourceOptions[source.name]], ); const p = foldMerge(mergeSourceParams, defaultSourceParams, [ source.params(), options.sourceParams[source.name], ]); return [o, p];}
function filterArgs( filterOptions: Record<string, Partial<FilterOptions>>, filterParams: Record<string, Partial<Record<string, unknown>>>, filter: BaseFilter,): [FilterOptions, Record<string, unknown>] { const optionsOf = (filter: BaseFilter) => foldMerge(mergeFilterOptions, defaultFilterOptions, [ filterOptions[filter.name], ]); const paramsOf = (filter: BaseFilter) => foldMerge(mergeFilterParams, defaultFilterParams, [ filter.params(), filterParams[filter.name], ]); return [optionsOf(filter), paramsOf(filter)];}
async function checkSourceOnInit( source: BaseSource, denops: Denops, sourceOptions: SourceOptions, sourceParams: Record<string, unknown>,) { if (source.isInitialized) { return; }
try { (source?.apiVersion) ? await source.onInit({ denops, sourceOptions, sourceParams, }) : await source.onInit( denops, );
source.isInitialized = true; } catch (e: unknown) { if (e instanceof TimeoutError) { } else { console.error( `[ddc.vim] source: ${source.name} "onInit()" is failed`, ); console.error(e); } }}
async function checkFilterOnInit( filter: BaseFilter, denops: Denops, filterOptions: FilterOptions, filterParams: Record<string, unknown>,) { if (filter.isInitialized) { return; }
try { (filter?.apiVersion) ? await filter.onInit({ denops, filterOptions, filterParams, }) : await filter.onInit( denops, );
filter.isInitialized = true; } catch (e: unknown) { if (e instanceof TimeoutError) { } else { console.error( `[ddc.vim] filter: ${filter.name} "onInit()" is failed`, ); console.error(e); } }}
async function callSourceOnEvent( source: BaseSource, denops: Denops, context: Context, options: DdcOptions, sourceOptions: SourceOptions, sourceParams: Record<string, unknown>,) { await checkSourceOnInit(source, denops, sourceOptions, sourceParams);
try { (source?.apiVersion) ? await source.onEvent({ denops, context, options, sourceOptions, sourceParams, }) : await source.onEvent( denops, context, options, sourceOptions, sourceParams, ); } catch (e: unknown) { if (e instanceof TimeoutError) { } else { console.error( `[ddc.vim] source: ${source.name} "onEvent()" is failed`, ); console.error(e); } }}
async function callFilterOnEvent( filter: BaseFilter, denops: Denops, context: Context, options: DdcOptions, filterOptions: FilterOptions, filterParams: Record<string, unknown>,) { await checkFilterOnInit(filter, denops, filterOptions, filterParams);
try { (filter?.apiVersion) ? filter.onEvent({ denops, context, options, filterOptions, filterParams, }) : filter.onEvent( denops, context, options, filterOptions, filterParams, ); } catch (e: unknown) { if (e instanceof TimeoutError) { } else { console.error( `[ddc.vim] filter: ${filter.name} "onEvent()" is failed`, ); console.error(e); } }}
async function callSourceGetCompletePosition( source: BaseSource, denops: Denops, context: Context, options: DdcOptions, sourceOptions: SourceOptions, sourceParams: Record<string, unknown>,): Promise<number> { await checkSourceOnInit(source, denops, sourceOptions, sourceParams);
try { return (source?.apiVersion) ? await source.getCompletePosition({ denops, context, options, sourceOptions, sourceParams, }) : await source.getCompletePosition( denops, context, options, sourceOptions, sourceParams, ); } catch (e: unknown) { if (e instanceof TimeoutError) { } else { console.error( `[ddc.vim] source: ${source.name} "getCompletePoistion()" is failed`, ); console.error(e); }
return -1; }}
async function callSourceGatherCandidates( source: BaseSource, denops: Denops, context: Context, options: DdcOptions, sourceOptions: SourceOptions, sourceParams: Record<string, unknown>, completeStr: string,): Promise<Candidate[]> { await checkSourceOnInit(source, denops, sourceOptions, sourceParams);
try { const promise = (source?.apiVersion) ? source.gatherCandidates({ denops, context, options, sourceOptions, sourceParams, completeStr, }) : source.gatherCandidates( denops, context, options, sourceOptions, sourceParams, completeStr, ); return await deadline(promise, sourceOptions.timeout); } catch (e: unknown) { if (e instanceof TimeoutError || e instanceof DeadlineError) { } else { console.error( `[ddc.vim] source: ${source.name} "gatherCandidates()" is failed`, ); console.error(e); }
return []; }}
async function callFilterFilter( filter: BaseFilter, denops: Denops, context: Context, options: DdcOptions, sourceOptions: SourceOptions, filterOptions: FilterOptions, filterParams: Record<string, unknown>, completeStr: string, candidates: Candidate[],): Promise<Candidate[]> { await checkFilterOnInit(filter, denops, filterOptions, filterParams);
try { return (filter?.apiVersion) ? await filter.filter({ denops, context, options, sourceOptions, filterOptions, filterParams, completeStr, candidates, }) : await filter.filter( denops, context, options, filterOptions, filterParams, completeStr, candidates, ); } catch (e: unknown) { if (e instanceof TimeoutError) { } else { console.error( `[ddc.vim] filter: ${filter.name} "filter()" is failed`, ); console.error(e); }
return []; }}
Deno.test("sourceArgs", () => { const userOptions: DdcOptions = { ...defaultDdcOptions(), sources: ["strength"], sourceOptions: { "_": { mark: "A", matchers: ["matcher_head"], }, "strength": { mark: "S", }, }, sourceParams: { "_": { "by_": "bar", }, "strength": { min: 100, }, }, }; class S extends BaseSource { params() { return { "min": 0, "max": 999, }; } gatherCandidates( _args: GatherCandidatesArguments | Denops, _context?: Context, _options?: DdcOptions, _sourceOptions?: SourceOptions, _sourceParams?: Record<string, unknown>, _completeStr?: string, ): Promise<Candidate[]> { return Promise.resolve([]); } } const source = new S(); source.name = "strength"; const [o, p] = sourceArgs(userOptions, source); assertEquals(o, { ...defaultSourceOptions(), mark: "S", matchers: ["matcher_head"], maxCandidates: 500, converters: [], sorters: [], }); assertEquals(p.by_, undefined); assertEquals(p, { ...defaultSourceParams(), min: 100, max: 999, });});
Deno.test("filterArgs", () => { const userOptions: Record<string, FilterOptions> = { "/dev/null": { placeholder: undefined, }, }; const userParams: Record<string, Record<string, unknown>> = { "/dev/null": { min: 100, }, }; class F extends BaseFilter { params() { return { "min": 0, "max": 999, }; } filter( _args: FilterArguments | Denops, _context?: Context, _options?: DdcOptions, _sourceOptions?: SourceOptions, _filterOptions?: FilterOptions, _filterParams?: Record<string, unknown>, _completeStr?: string, _candidates?: Candidate[], ): Promise<Candidate[]> { return Promise.resolve([]); } } const filter = new F(); filter.name = "/dev/null"; assertEquals(filterArgs(userOptions, userParams, filter), [{ ...defaultFilterOptions(), }, { ...defaultFilterParams(), min: 100, max: 999, }]);});
Deno.test("byteposToCharpos", () => { assertEquals(byteposToCharpos("あ hoge", 4), 2);});
Deno.test("charposToBytepos", () => { assertEquals(charposToBytepos("あ hoge", 2), 4);});