Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

👍 implement options method with class #266

Merged
merged 3 commits into from
Aug 29, 2024
Merged

👍 implement options method with class #266

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
62d490e
:+1: implement options method with class
Milly Aug 28, 2024
894a291
:muscle: use defaultValue of internal methods
Milly Aug 28, 2024
9a141c3
:+1: regenerate `option`
Milly Aug 28, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
135 changes: 18 additions & 117 deletions .scripts/gen-option/format.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,45 +1,12 @@
import type { Option, OptionScope, OptionType } from "./types.ts";

const denops = "@denops/core";

const translate: Record<string, string> = {
"default": "defaultValue",
"delete": "delete_",
"eval": "eval_",
"function": "function_",
};

function defaultValue(type: OptionType): string {
switch (type) {
case "string":
return `""`;
case "number":
return `0`;
case "boolean":
return `false`;
default: {
const unknownType: never = type;
throw new Error(`Unknown type ${unknownType}`);
}
}
}

function coerceValue(expr: string, type: OptionType): string {
switch (type) {
case "string":
return `(${expr}) as string`;
case "number":
return `(${expr}) as number`;
case "boolean":
// Vim returns (0 | 1) so coerce to boolean.
return `Boolean(${expr})`;
default: {
const unknownType: never = type;
throw new Error(`Unknown type ${unknownType}`);
}
}
}

export function formatDocs(docs: string): string[] {
const lines = docs.replaceAll(/\*\//g, "* /").split("\n");
const normalizedLines = lines.map((v) => ` * ${v}`.trimEnd());
Expand All @@ -51,13 +18,9 @@ function formatOption(option: Option): string[] {
const name = translate[option.name] ?? option.name;
const lines = [
...formatDocs(docs),
`export const ${name}: ${getOptionTypeName(scope, type)} = {`,
...formatOptionBody(name, type),
...(scope.includes("global") ? formatGlobalOptionBody(name, type) : []),
...(scope.includes("local") ? formatLocalOptionBody(name, type) : []),
...(scope.includes("local") ? formatBufferOptionBody(name, type) : []),
...(scope.includes("local") ? formatWindowOptionBody(name, type) : []),
`};`,
`export const ${name}: ${getOptionTypeName(scope, type)} = ${
getOptionConstructor(name, type)
};`,
Comment on lines +21 to +23
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Refactor to use dynamic option instantiation.

The refactoring to use getOptionConstructor for creating option instances simplifies the code by removing multiple conditional checks and function calls that were previously used for this purpose. This change should enhance maintainability and clarity as it centralizes the instantiation logic.

However, as noted in the PR comments, this change introduces a breaking change by altering how options are accessed and instantiated. It is crucial to ensure that this new method does not lead to TypeError when properties are accessed on undefined, which has been a concern with the new implementation.

Ensure thorough testing and documentation are provided to guide developers on the new usage patterns to prevent runtime errors.

"",
];
return lines;
Expand All @@ -73,90 +36,28 @@ function getOptionTypeName(scope: OptionScope[], type: OptionType): string {
}
}

function formatOptionBody(name: string, type: OptionType): string[] {
const lines = [
` async get(denops: Denops): Promise<${type}> {`,
` const result = await options.get(denops, "${name}");`,
` return ${coerceValue(`result ?? ${defaultValue(type)}`, type)};`,
` },`,
` set(denops: Denops, value: ${type}): Promise<void> {`,
` return options.set(denops, "${name}", value);`,
` },`,
` reset(denops: Denops): Promise<void> {`,
` return options.remove(denops, "${name}");`,
` },`,
];
return lines;
}

function formatGlobalOptionBody(name: string, type: OptionType): string[] {
const lines = [
` async getGlobal(denops: Denops): Promise<${type}> {`,
` const result = await globalOptions.get(denops, "${name}");`,
` return ${coerceValue(`result ?? ${defaultValue(type)}`, type)};`,
` },`,
` setGlobal(denops: Denops, value: ${type}): Promise<void> {`,
` return globalOptions.set(denops, "${name}", value);`,
` },`,
` resetGlobal(denops: Denops): Promise<void> {`,
` return globalOptions.remove(denops, "${name}");`,
` },`,
];
return lines;
}

function formatLocalOptionBody(name: string, type: OptionType): string[] {
const lines = [
` async getLocal(denops: Denops): Promise<${type}> {`,
` const result = await localOptions.get(denops, "${name}");`,
` return ${coerceValue(`result ?? ${defaultValue(type)}`, type)};`,
` },`,
` setLocal(denops: Denops, value: ${type}): Promise<void> {`,
` return localOptions.set(denops, "${name}", value);`,
` },`,
` resetLocal(denops: Denops): Promise<void> {`,
` return localOptions.remove(denops, "${name}");`,
` },`,
];
return lines;
}

function formatBufferOptionBody(name: string, type: OptionType): string[] {
const lines = [
` async getBuffer(denops: Denops, bufnr: number): Promise<${type}> {`,
` const result = await getbufvar(denops, bufnr, "&${name}");`,
` return ${coerceValue(`result ?? ${defaultValue(type)}`, type)};`,
` },`,
` setBuffer(denops: Denops, bufnr: number, value: ${type}): Promise<void> {`,
` return setbufvar(denops, bufnr, "&${name}", value);`,
` },`,
];
return lines;
}

function formatWindowOptionBody(name: string, type: OptionType): string[] {
const lines = [
` async getWindow(denops: Denops, winnr: number): Promise<${type}> {`,
` const result = await getwinvar(denops, winnr, "&${name}");`,
` return ${coerceValue(`result ?? ${defaultValue(type)}`, type)};`,
` },`,
` setWindow(denops: Denops, winnr: number, value: ${type}): Promise<void> {`,
` return setwinvar(denops, winnr, "&${name}", value);`,
` },`,
];
return lines;
function getOptionConstructor(name: string, type: OptionType): string {
switch (type) {
case "string":
return `new StringOption("${name}")`;
case "number":
return `new NumberOption("${name}")`;
case "boolean":
return `new BooleanOption("${name}")`;
default: {
const unknownType: never = type;
throw new Error(`Unknown type ${unknownType}`);
}
}
}

export function format(options: Option[], root: string): string[] {
const fn = `${root}/../function/mod.ts`;
const variable = `${root}/../variable/mod.ts`;
const types = `${root}/types.ts`;
const utils = `${root}/_utils.ts`;
const lines = [
"// NOTE: This file is generated. Do NOT modify it manually.",
`import type { Denops } from "${denops}";`,
`import { getbufvar, setbufvar, getwinvar, setwinvar } from "${fn}";`,
`import { globalOptions, localOptions, options } from "${variable}";`,
`import type { GlobalOption, GlobalOrLocalOption, LocalOption } from "${types}";`,
`import { BooleanOption, NumberOption, StringOption } from "${utils}";`,
"",
...options.map(formatOption),
];
Expand Down
Loading