👍 Add functions in textprop.txt on Vim

Author: lambdalisue

denops_std/function/vim/_generated.ts

@@ -1332,3 +1332,291 @@ export function typename(denops: Denops, expr: unknown): Promise<unknown>;
 export function typename(denops: Denops, ...args: unknown[]): Promise<unknown> {
   return denops.call("typename", ...args);
 }
+
+/**
+ * Attach a text property at position {lnum}, {col}.  {col} is
+ * counted in bytes, use one for the first column.
+ * If {lnum} is invalid an error is given.
+ * If {col} is invalid an error is given.
+ * {props} is a dictionary with these fields:
+ *    length	length of text in bytes, can only be used
+ * 		for a property that does not continue in
+ * 		another line; can be zero
+ *    end_lnum	line number for the end of text (inclusive)
+ *    end_col	column just after the text; not used when
+ * 		"length" is present; when {col} and "end_col"
+ * 		are equal, and "end_lnum" is omitted or equal
+ * 		to {lnum}, this is a zero-width text property
+ *    bufnr	buffer to add the property to; when omitted
+ * 		the current buffer is used
+ *    id		user defined ID for the property; must be a
+ * 		number; when omitted zero is used
+ *    type		name of the text property type
+ * All fields except "type" are optional.
+ * It is an error when both "length" and "end_lnum" or "end_col"
+ * are given.  Either use "length" or "end_col" for a property
+ * within one line, or use "end_lnum" and "end_col" for a
+ * property that spans more than one line.
+ * When neither "length" nor "end_col" are given the property
+ * will be zero-width.  That means it will move with the text, as
+ * a kind of mark.  One character will be highlighted, if the
+ * type specifies highlighting.
+ * The property can end exactly at the last character of the
+ * text, or just after it.  In the last case, if text is appended
+ * to the line, the text property size will increase, also when
+ * the property type does not have "end_incl" set.
+ * "type" will first be looked up in the buffer the property is
+ * added to. When not found, the global property types are used.
+ * If not found an error is given.
+ * Can also be used as a |method|:
+ * 	GetLnum()->prop_add(col, props)
+ */
+export function prop_add(
+  denops: Denops,
+  lnum: unknown,
+  col: unknown,
+  props: unknown,
+): Promise<unknown>;
+export function prop_add(denops: Denops, ...args: unknown[]): Promise<unknown> {
+  return denops.call("prop_add", ...args);
+}
+
+/**
+ * Remove all text properties from line {lnum}.
+ * When {lnum-end} is given, remove all text properties from line
+ * {lnum} to {lnum-end} (inclusive).
+ * When {props} contains a "bufnr" item use this buffer,
+ * otherwise use the current buffer.
+ * Can also be used as a |method|:
+ * 	GetLnum()->prop_clear()
+ */
+export function prop_clear(
+  denops: Denops,
+  lnum: unknown,
+  lnum_end?: unknown,
+  props?: unknown,
+): Promise<unknown>;
+export function prop_clear(
+  denops: Denops,
+  ...args: unknown[]
+): Promise<unknown> {
+  return denops.call("prop_clear", ...args);
+}
+
+/**
+ * Search for a text property as specified with {props}:
+ *    id		property with this ID
+ *    type		property with this type name
+ *    both		"id" and "type" must both match
+ *    bufnr	buffer to search in; when present a
+ * 		start position with "lnum" and "col"
+ * 		must be given; when omitted the
+ * 		current buffer is used
+ *    lnum		start in this line (when omitted start
+ * 		at the cursor)
+ *    col		start at this column (when omitted
+ * 		and "lnum" is given: use column 1,
+ * 		otherwise start at the cursor)
+ *    skipstart	do not look for a match at the start
+ * 		position
+ * A property matches when either "id" or "type" matches.
+ * {direction} can be "f" for forward and "b" for backward.  When
+ * omitted forward search is performed.
+ * If a match is found then a Dict is returned with the entries
+ * as with prop_list(), and additionally an "lnum" entry.
+ * If no match is found then an empty Dict is returned.
+ */
+export function prop_find(
+  denops: Denops,
+  props: unknown,
+  direction?: unknown,
+): Promise<unknown>;
+export function prop_find(
+  denops: Denops,
+  ...args: unknown[]
+): Promise<unknown> {
+  return denops.call("prop_find", ...args);
+}
+
+/**
+ * Return a List with all text properties in line {lnum}.
+ * When {props} contains a "bufnr" item, use this buffer instead
+ * of the current buffer.
+ * The properties are ordered by starting column and priority.
+ * Each property is a Dict with these entries:
+ *    col		starting column
+ *    length	length in bytes, one more if line break is
+ * 		included
+ *    id		property ID
+ *    type		name of the property type, omitted if
+ * 		the type was deleted
+ *    start	when TRUE property starts in this line
+ *    end		when TRUE property ends in this line
+ * When "start" is zero the property started in a previous line,
+ * the current one is a continuation.
+ * When "end" is zero the property continues in the next line.
+ * The line break after this line is included.
+ * Can also be used as a |method|:
+ * 	GetLnum()->prop_list()
+ */
+export function prop_list(
+  denops: Denops,
+  lnum: unknown,
+  props?: unknown,
+): Promise<unknown>;
+export function prop_list(
+  denops: Denops,
+  ...args: unknown[]
+): Promise<unknown> {
+  return denops.call("prop_list", ...args);
+}
+
+/**
+ * Remove a matching text property from line {lnum}.  When
+ * {lnum-end} is given, remove matching text properties from line
+ * {lnum} to {lnum-end} (inclusive).
+ * When {lnum} is omitted remove matching text properties from
+ * all lines (this requires going over all lines, thus will be a
+ * bit slow for a buffer with many lines).
+ * {props} is a dictionary with these fields:
+ *    id		remove text properties with this ID
+ *    type		remove text properties with this type name
+ *    both		"id" and "type" must both match
+ *    bufnr	use this buffer instead of the current one
+ *    all		when TRUE remove all matching text properties,
+ * 		not just the first one
+ * A property matches when either "id" or "type" matches.
+ * If buffer "bufnr" does not exist you get an error message.
+ * If buffer "bufnr" is not loaded then nothing happens.
+ * Returns the number of properties that were removed.
+ * Can also be used as a |method|:
+ * 	GetProps()->prop_remove()
+ */
+export function prop_remove(
+  denops: Denops,
+  props: unknown,
+  lnum?: unknown,
+  lnum_end?: unknown,
+): Promise<unknown>;
+export function prop_remove(
+  denops: Denops,
+  ...args: unknown[]
+): Promise<unknown> {
+  return denops.call("prop_remove", ...args);
+}
+
+/**
+ * Add a text property type {name}.  If a property type with this
+ * name already exists an error is given.  Nothing is returned.
+ * {props} is a dictionary with these optional fields:
+ *    bufnr	define the property only for this buffer; this
+ * 		avoids name collisions and automatically
+ * 		clears the property types when the buffer is
+ * 		deleted.
+ *    highlight	name of highlight group to use
+ *    priority	when a character has multiple text
+ * 		properties the one with the highest priority
+ * 		will be used; negative values can be used, the
+ * 		default priority is zero
+ *    combine	when omitted or TRUE combine the highlight
+ * 		with any syntax highlight; when FALSE syntax
+ * 		highlight will not be used
+ *    start_incl	when TRUE inserts at the start position will
+ * 		be included in the text property
+ *    end_incl	when TRUE inserts at the end position will be
+ * 		included in the text property
+ * Can also be used as a |method|:
+ * 	GetPropName()->prop_type_add(props)
+ */
+export function prop_type_add(
+  denops: Denops,
+  name: unknown,
+  props: unknown,
+): Promise<unknown>;
+export function prop_type_add(
+  denops: Denops,
+  ...args: unknown[]
+): Promise<unknown> {
+  return denops.call("prop_type_add", ...args);
+}
+
+/**
+ * Change properties of an existing text property type.  If a
+ * property with this name does not exist an error is given.
+ * The {props} argument is just like |prop_type_add()|.
+ * Can also be used as a |method|:
+ * 	GetPropName()->prop_type_change(props)
+ */
+export function prop_type_change(
+  denops: Denops,
+  name: unknown,
+  props: unknown,
+): Promise<unknown>;
+export function prop_type_change(
+  denops: Denops,
+  ...args: unknown[]
+): Promise<unknown> {
+  return denops.call("prop_type_change", ...args);
+}
+
+/**
+ * Remove the text property type {name}.  When text properties
+ * using the type {name} are still in place, they will not have
+ * an effect and can no longer be removed by name.
+ * {props} can contain a "bufnr" item.  When it is given, delete
+ * a property type from this buffer instead of from the global
+ * property types.
+ * When text property type {name} is not found there is no error.
+ * Can also be used as a |method|:
+ * 	GetPropName()->prop_type_delete()
+ */
+export function prop_type_delete(
+  denops: Denops,
+  name: unknown,
+  props?: unknown,
+): Promise<unknown>;
+export function prop_type_delete(
+  denops: Denops,
+  ...args: unknown[]
+): Promise<unknown> {
+  return denops.call("prop_type_delete", ...args);
+}
+
+/**
+ * Returns the properties of property type {name}.  This is a
+ * dictionary with the same fields as was given to
+ * prop_type_add().
+ * When the property type {name} does not exist, an empty
+ * dictionary is returned.
+ * {props} can contain a "bufnr" item.  When it is given, use
+ * this buffer instead of the global property types.
+ * Can also be used as a |method|:
+ * 	GetPropName()->prop_type_get()
+ */
+export function prop_type_get(
+  denops: Denops,
+  name: unknown,
+  props?: unknown,
+): Promise<unknown>;
+export function prop_type_get(
+  denops: Denops,
+  ...args: unknown[]
+): Promise<unknown> {
+  return denops.call("prop_type_get", ...args);
+}
+
+/**
+ * Returns a list with all property type names.
+ * {props} can contain a "bufnr" item.  When it is given, use
+ * this buffer instead of the global property types.
+ */
+export function prop_type_list(
+  denops: Denops,
+  props?: unknown,
+): Promise<unknown>;
+export function prop_type_list(
+  denops: Denops,
+  ...args: unknown[]
+): Promise<unknown> {
+  return denops.call("prop_type_list", ...args);
+}

scripts/gen-function/format.ts

@@ -5,6 +5,7 @@ const translate: Record<string, string> = {
   "delete": "delete_",
   "eval": "eval_",
   "function": "function_",
+  "lnum-end": "lnum_end",
 };
 
 function formatDocs(docs: string): string[] {

scripts/gen-function/gen-function.ts

@@ -21,6 +21,7 @@ const manualFnSet = new Set([
 
 const vimHelps = await Promise.all([
   `https://raw.githubusercontent.com/vim/vim/v${VIM_VERSION}/runtime/doc/eval.txt`,
+  `https://raw.githubusercontent.com/vim/vim/v${VIM_VERSION}/runtime/doc/textprop.txt`,
 ].map(downloadString));
 const vimDefs = vimHelps.map(parse).flat();
 const vimFnSet = difference(new Set(vimDefs.map((def) => def.fn)), manualFnSet);