zsh.c File Reference

Zsh shell completion script generator with category grouping. More...

Go to the source code of this file.

Functions
	__attribute__ ((unused))
asciichat_error_t	completions_generate_zsh (FILE *output)
	Generate zsh completion script.

Detailed Description

Zsh shell completion script generator with category grouping.

Definition in file zsh.c.

Function Documentation

__attribute__()

__attribute__

(

(unused)

)

Write options grouped by category using _describe for proper group headers

Definition at line 172 of file zsh.c.

                                                                                                     {
  if (!opts || count == 0)
    return;
 
  size_t group_count = 0;
  const char **groups = zsh_collect_groups(opts, count, &group_count);
 
  // First pass: declare arrays for each group
  for (size_t g = 0; g < group_count; g++) {
    const char *group = groups[g];
    fprintf(output, "  local -a %s_%s_opts=(\n", func_prefix, group);
 
    // Write all options in this group (long options only to avoid "corrections" duplicates)
    for (size_t i = 0; i < count; i++) {
      if (!opts[i].group || strcmp(opts[i].group, group) != 0)
        continue;
 
      // Long option only (short options are less discoverable via TAB)
      fprintf(output, "    '--%s:", opts[i].long_name);
      zsh_escape_desc(output, opts[i].help_text);
      fprintf(output, "'\n");
    }
 
    fprintf(output, "  )\n");
  }
 
  // Second pass: call _describe for each group (with lowercase display)
  for (size_t g = 0; g < group_count; g++) {
    const char *group = groups[g];
    fprintf(output, "  _describe -t %s '", group);
    utf8_write_lowercase(output, group);
    fprintf(output, " options' %s_%s_opts\n", func_prefix, group);
  }
 
  SAFE_FREE(groups);
}

References SAFE_FREE, and utf8_write_lowercase().

completions_generate_zsh()

asciichat_error_t completions_generate_zsh

(

FILE *

output

)

Generate zsh completion script.

Definition at line 210 of file zsh.c.

                                                         {
  if (!output) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Output stream cannot be NULL");
  }
 
  /* Load binary-level and discovery options for binary-level completion.
   * Binary-level completion (options before mode name like --color-mode) uses
   * _arguments with -n -S flags to establish proper zsh completion context.
   * Without _arguments, completion functions fail with "can only be called from
   * completion function" error, causing zsh to display "corrections (errors: N)"
   * messages. The -n flag disables defaults and -S disables short option
   * processing, allowing safe context establishment. */
  size_t binary_count = 0;
  const option_descriptor_t *binary_opts = options_registry_get_for_display(MODE_DISCOVERY, true, &binary_count);
 
  size_t discovery_count = 0;
  const option_descriptor_t *discovery_opts = options_registry_get_for_display(MODE_DISCOVERY, false, &discovery_count);
 
  fprintf(output, "# Zsh completion script for ascii-chat\n"
                  "# Generated from options registry - DO NOT EDIT MANUALLY\n"
                  "\n"
                  "# Configure completion for ascii-chat\n"
                  "# Use only _complete (no corrections or approximate matching)\n"
                  "zstyle ':completion:*:ascii-chat:*' completer _complete\n"
                  "\n"
                  "# Device index completion helpers\n"
                  "_ascii_chat_webcam_indices() {\n"
                  "  local -a indices\n"
                  "  local output\n"
                  "  output=$(\"${words[1]}\" --list-webcams 2>/dev/null) || return\n"
                  "  while IFS= read -r line; do\n"
                  "    [[ \"$line\" =~ ^[[:space:]]*([0-9]+)[[:space:]]+(.+)$ ]] && \\\n"
                  "      indices+=(\"${match[1]}:${match[2]}\")\n"
                  "  done <<< \"$output\"\n"
                  "  _describe 'webcam' indices\n"
                  "}\n"
                  "\n"
                  "_ascii_chat_microphone_indices() {\n"
                  "  local -a indices\n"
                  "  local output\n"
                  "  output=$(\"${words[1]}\" --list-microphones 2>/dev/null) || return\n"
                  "  while IFS= read -r line; do\n"
                  "    [[ \"$line\" =~ ^[[:space:]]*([0-9-]+)[[:space:]]+(.+)$ ]] && \\\n"
                  "      indices+=(\"${match[1]}:${match[2]}\")\n"
                  "  done <<< \"$output\"\n"
                  "  _describe 'microphone' indices\n"
                  "}\n"
                  "\n"
                  "_ascii_chat_speakers_indices() {\n"
                  "  local -a indices\n"
                  "  local output\n"
                  "  output=$(\"${words[1]}\" --list-speakers 2>/dev/null) || return\n"
                  "  while IFS= read -r line; do\n"
                  "    [[ \"$line\" =~ ^[[:space:]]*([0-9-]+)[[:space:]]+(.+)$ ]] && \\\n"
                  "      indices+=(\"${match[1]}:${match[2]}\")\n"
                  "  done <<< \"$output\"\n"
                  "  _describe 'speakers' indices\n"
                  "}\n"
                  "\n"
                  "_ascii_chat_binary() {\n"
                  "  local -a binary_opts=(\n");
 
  /* Add discovery options to binary-level completion */
  if (discovery_opts) {
    for (size_t i = 0; i < discovery_count; i++) {
      fprintf(output, "    '--%s:", discovery_opts[i].long_name);
      zsh_escape_desc(output, discovery_opts[i].help_text);
      fprintf(output, "'\n");
    }
  }
 
  fprintf(output, "  )\n"
                  "  _values 'option' \"${binary_opts[@]}\"\n"
                  "}\n"
                  "\n"
                  "_ascii_chat_binary_grouped() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Write binary-level options in grouped format */
  if (binary_opts) {
    zsh_write_combined_args(output, binary_opts, binary_count);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "_ascii_chat() {\n"
                  "  if [[ ${words[2]} == -* ]]; then\n"
                  "    # Binary-level options: show both binary and discovery mode options\n"
                  "    # (since discovery is the default mode that runs at binary level)\n"
                  "    _ascii_chat_binary_grouped\n"
                  "    _ascii_chat_discovery\n"
                  "    return\n"
                  "  fi\n"
                  "\n"
                  "  # Mode routing: check words[2] to determine which mode function to call\n"
                  "  case $words[2] in\n"
                  "    # Server-like modes\n"
                  "    server)\n"
                  "      _ascii_chat_server\n"
                  "      return\n"
                  "      ;;\n"
                  "    discovery-service)\n"
                  "      _ascii_chat_discovery_service\n"
                  "      return\n"
                  "      ;;\n"
                  "\n"
                  "    # Client-like modes\n"
                  "    client)\n"
                  "      _ascii_chat_client\n"
                  "      return\n"
                  "      ;;\n"
                  "    mirror)\n"
                  "      _ascii_chat_mirror\n"
                  "      return\n"
                  "      ;;\n"
                  "    # Default/unknown input - show mode selection only if truly empty, otherwise discovery\n"
                  "    *)\n"
                  "      # If words[2] is empty AND we're at position 2, show mode selection\n"
                  "      # Otherwise (even for partial input like 'disc'), use discovery mode (the default)\n"
                  "      if [[ -z \"${words[2]}\" && $CURRENT -eq 2 ]]; then\n"
                  "        # Completing the mode name itself - show available modes\n"
                  "        local -a server_modes client_modes\n"
                  "        server_modes=(\n");
 
  /* Generate server-like modes from registry */
  size_t mode_server_count = 0;
  const mode_descriptor_t *mode_server_descs = get_modes_by_group("server-like", &mode_server_count);
  if (mode_server_descs) {
    for (size_t i = 0; i < mode_server_count; i++) {
      fprintf(output, "          '%s:%s'\n", mode_server_descs[i].name, mode_server_descs[i].description);
    }
    SAFE_FREE(mode_server_descs);
  }
 
  fprintf(output, "        )\n"
                  "        client_modes=(\n");
 
  /* Generate client-like modes from registry (exclude discovery since it's the default mode) */
  size_t mode_client_count = 0;
  const mode_descriptor_t *mode_client_descs = get_modes_by_group("client-like", &mode_client_count);
  if (mode_client_descs) {
    for (size_t i = 0; i < mode_client_count; i++) {
      /* Skip discovery mode - it's the default when no mode is specified */
      if (strcmp(mode_client_descs[i].name, "discovery") == 0) {
        continue;
      }
      fprintf(output, "          '%s:%s'\n", mode_client_descs[i].name, mode_client_descs[i].description);
    }
    SAFE_FREE(mode_client_descs);
  }
 
  fprintf(output, "        )\n"
                  "        _describe -t server-modes 'server-like modes' server_modes\n"
                  "        _describe -t client-modes 'client-like modes' client_modes\n"
                  "      else\n"
                  "        # Default mode (discovery) - complete its options\n"
                  "        _ascii_chat_discovery\n"
                  "      fi\n"
                  "      ;;\n"
                  "  esac\n"
                  "}\n"
                  "\n"
                  "# Server-like modes: handle incoming connections and stream management\n"
                  "_ascii_chat_server() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Server options - grouped by category */
  size_t server_count = 0;
  const option_descriptor_t *server_opts = options_registry_get_for_display(MODE_SERVER, false, &server_count);
 
  if (server_opts) {
    zsh_write_combined_args(output, server_opts, server_count);
    SAFE_FREE(server_opts);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "_ascii_chat_discovery_service() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Discovery-service options - grouped by category */
  size_t discovery_svc_count = 0;
  const option_descriptor_t *discovery_svc_opts =
      options_registry_get_for_display(MODE_DISCOVERY_SERVICE, false, &discovery_svc_count);
 
  if (discovery_svc_opts) {
    zsh_write_combined_args(output, discovery_svc_opts, discovery_svc_count);
    SAFE_FREE(discovery_svc_opts);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "# Client-like modes: connect to servers or render local media\n"
                  "_ascii_chat_client() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Client options - grouped by category */
  size_t client_count = 0;
  const option_descriptor_t *client_opts = options_registry_get_for_display(MODE_CLIENT, false, &client_count);
 
  if (client_opts) {
    zsh_write_combined_args(output, client_opts, client_count);
    SAFE_FREE(client_opts);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "_ascii_chat_mirror() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Mirror options - grouped by category */
  size_t mirror_count = 0;
  const option_descriptor_t *mirror_opts = options_registry_get_for_display(MODE_MIRROR, false, &mirror_count);
 
  if (mirror_opts) {
    zsh_write_combined_args(output, mirror_opts, mirror_count);
    SAFE_FREE(mirror_opts);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "# Discovery mode: find sessions via discovery service (default mode when no mode specified)\n"
                  "_ascii_chat_discovery() {\n"
                  "  local curcontext=$curcontext\n"
                  "  local -a context line state state_descr args\n"
                  "  local -A opt_args\n\n");
 
  /* Discovery options - grouped by category (reuse already-loaded options) */
  if (discovery_opts) {
    zsh_write_combined_args(output, discovery_opts, discovery_count);
  }
 
  fprintf(output, "}\n"
                  "\n"
                  "# Register completion functions (must come after definitions)\n"
                  "compdef _ascii_chat ascii-chat\n"
                  "compdef _ascii_chat 'build/bin/ascii-chat'\n");
 
  SAFE_FREE(binary_opts);
  SAFE_FREE(discovery_opts);
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, get_modes_by_group(), MODE_CLIENT, MODE_DISCOVERY, MODE_DISCOVERY_SERVICE, MODE_MIRROR, MODE_SERVER, options_registry_get_for_display(), SAFE_FREE, and SET_ERRNO.

Referenced by completions_generate_for_shell().