thor-completion 0.0.0

data/lib/thor/completion/bash.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+class Thor
+  module Completion
+    class Bash
+      include SchemaValidator
+
+      attr_reader :output, :schema, :name, :commands, :global_options
+
+      def initialize(schema)
+        validate_schema!(schema)
+
+        @schema = schema
+        @name = schema[:name]
+        @commands = schema[:commands] || []
+        @global_options = schema[:globalOptions] || []
+        @output = []
+      end
+
+      def call
+        generate_main_function
+        generate_subcommand_functions
+
+        output << ""
+        output << "complete -F _#{name} #{name}"
+
+        output.join("\n")
+      end
+
+      private def generate_main_function
+        output << "_#{name}() {"
+        output << "  local cur prev words cword"
+        output << "  if type _init_completion &>/dev/null; then"
+        output << "    _init_completion || return"
+        output << "  else"
+        output << "    # Fallback initialization if bash-completion is not available"
+        output << "    COMPREPLY=()"
+        output << "    _get_comp_words_by_ref -n : cur prev words cword 2>/dev/null || {"
+        output << "      cur=\"${COMP_WORDS[COMP_CWORD]}\""
+        output << "      prev=\"${COMP_WORDS[COMP_CWORD-1]}\""
+        output << "      words=(\"${COMP_WORDS[@]}\")"
+        output << "      cword=$COMP_CWORD"
+        output << "    }"
+        output << "  fi"
+        output << ""
+        output << "  local commands=\"#{commands.reject {|c| c[:hidden] }.map {|c| c[:name] }.join(' ')}\""
+        output << "  local options=\"#{format_options(global_options)}\""
+        output << ""
+        output << "  if [[ $cword -eq 1 ]]; then"
+        output << "    COMPREPLY=($(compgen -W \"$commands $options\" -- \"$cur\"))"
+        output << "    return"
+        output << "  fi"
+        output << ""
+        output << "  local command=\"${words[1]}\""
+        output << "  case \"$command\" in"
+
+        commands.each do |cmd|
+          next if cmd[:hidden]
+
+          cmd_name = cmd[:name]
+
+          next unless cmd[:subcommands]&.any? || cmd[:options]&.any? || cmd[:arguments]&.any?
+
+          output << "    #{cmd_name})"
+          output << "      _#{name}_#{sanitize_name(cmd_name)}"
+          output << "      ;;"
+        end
+
+        output << "    *)"
+        output << "      COMPREPLY=()"
+        output << "      ;;"
+        output << "  esac"
+        output << "}"
+        output << ""
+      end
+
+      private def generate_subcommand_functions
+        commands.each do |cmd|
+          next if cmd[:hidden]
+          next unless cmd[:subcommands]&.any? || cmd[:options]&.any? || cmd[:arguments]&.any?
+
+          generate_command_function(cmd, [])
+        end
+      end
+
+      private def generate_command_function(cmd, parent_names)
+        cmd_name = cmd[:name]
+        func_name = "_#{name}_#{(parent_names + [sanitize_name(cmd_name)]).join('_')}"
+
+        output << "#{func_name}() {"
+
+        if cmd[:subcommands]&.any?
+          subcommands = cmd[:subcommands].reject {|c| c[:hidden] }.map {|c| c[:name] }.join(" ")
+          output << "  local subcommands=\"#{subcommands}\""
+        end
+
+        output << "  local options=\"#{format_options(cmd[:options])}\"" if cmd[:options]&.any?
+
+        # Calculate the position where we are in the command
+        depth = parent_names.length + 2 # +2 for program name and command name
+
+        if cmd[:subcommands]&.any?
+          output << ""
+          output << "  if [[ $cword -eq #{depth} ]]; then"
+          output << if cmd[:options]&.any?
+                      "    COMPREPLY=($(compgen -W \"$subcommands $options\" -- \"$cur\"))"
+                    else
+                      "    COMPREPLY=($(compgen -W \"$subcommands\" -- \"$cur\"))"
+                    end
+          output << "    return"
+          output << "  fi"
+          output << ""
+          output << "  local subcommand=\"${words[#{depth}]}\""
+          output << "  case \"$subcommand\" in"
+
+          cmd[:subcommands].each do |subcmd|
+            next if subcmd[:hidden]
+
+            subcmd_name = subcmd[:name]
+
+            next unless subcmd[:subcommands]&.any? || subcmd[:options]&.any? || subcmd[:arguments]&.any?
+
+            subcmd_func_name = "_#{name}_#{(parent_names + [sanitize_name(cmd_name), sanitize_name(subcmd_name)]).join('_')}"
+            output << "    #{subcmd_name})"
+            output << "      #{subcmd_func_name}"
+            output << "      ;;"
+          end
+
+          output << "    *)"
+          output << if cmd[:options]&.any?
+                      "      COMPREPLY=($(compgen -W \"$options\" -- \"$cur\"))"
+                    else
+                      "      COMPREPLY=()"
+                    end
+          output << "      ;;"
+          output << "  esac"
+        elsif cmd[:arguments]&.any?
+          # Handle positional arguments
+          arg = cmd[:arguments].first
+          output << ""
+          output << "  case \"$prev\" in"
+
+          # Handle options that take values
+          if cmd[:options]&.any?
+            cmd[:options].reject {|opt| opt[:type] == "boolean" }.each do |opt|
+              opt_names = ["--#{opt[:name]}"]
+              opt_names << "-#{opt[:short]}" if opt[:short]
+
+              output << "    #{opt_names.join('|')})"
+              output << if opt[:enum]&.any?
+                          "      COMPREPLY=($(compgen -W \"#{opt[:enum].join(' ')}\" -- \"$cur\"))"
+                        elsif opt[:completion]
+                          "      #{format_completion_bash(opt[:completion])}"
+                        else
+                          "      COMPREPLY=($(compgen -f -- \"$cur\"))"
+                        end
+              output << "      return"
+              output << "      ;;"
+            end
+          end
+
+          output << "  esac"
+          output << ""
+
+          if cmd[:options]&.any?
+            output << "  if [[ $cur == -* ]]; then"
+            output << "    COMPREPLY=($(compgen -W \"$options\" -- \"$cur\"))"
+            output << "    return"
+            output << "  fi"
+            output << ""
+          end
+
+          # Default to file completion for arguments
+          output << if arg[:completion]
+                      "  #{format_completion_bash(arg[:completion])}"
+                    else
+                      "  COMPREPLY=($(compgen -f -- \"$cur\"))"
+                    end
+        elsif cmd[:options]&.any?
+          # Only options, no arguments or subcommands
+          output << ""
+          output << "  case \"$prev\" in"
+
+          cmd[:options].reject {|opt| opt[:type] == "boolean" }.each do |opt|
+            opt_names = ["--#{opt[:name]}"]
+            opt_names << "-#{opt[:short]}" if opt[:short]
+
+            output << "    #{opt_names.join('|')})"
+            output << if opt[:enum]&.any?
+                        "      COMPREPLY=($(compgen -W \"#{opt[:enum].join(' ')}\" -- \"$cur\"))"
+                      elsif opt[:completion]
+                        "      #{format_completion_bash(opt[:completion])}"
+                      else
+                        "      COMPREPLY=($(compgen -f -- \"$cur\"))"
+                      end
+            output << "      return"
+            output << "      ;;"
+          end
+
+          output << "  esac"
+          output << ""
+          output << "  COMPREPLY=($(compgen -W \"$options\" -- \"$cur\"))"
+        end
+
+        output << "}"
+        output << ""
+
+        # Recursively generate functions for subcommands
+        return unless cmd[:subcommands]&.any?
+
+        cmd[:subcommands].each do |subcmd|
+          next if subcmd[:hidden]
+          next unless subcmd[:subcommands]&.any? || subcmd[:options]&.any? || subcmd[:arguments]&.any?
+
+          generate_command_function(subcmd, parent_names + [sanitize_name(cmd_name)])
+        end
+      end
+
+      private def format_options(options)
+        options.reject {|opt| opt[:hidden] }
+               .map {|opt| format_option_name(opt) }
+               .flatten
+               .join(" ")
+      end
+
+      private def format_option_name(opt)
+        names = []
+        Array(opt[:short]).each {|s| names << "-#{s}" } if opt[:short]
+        names << "--#{opt[:name]}" if opt[:name]
+        names
+      end
+
+      private def format_completion_bash(completion)
+        case completion[:type]
+        when "directory"
+          "COMPREPLY=($(compgen -d -- \"$cur\"))"
+        when "static"
+          values = completion[:values].join(" ")
+          "COMPREPLY=($(compgen -W \"#{values}\" -- \"$cur\"))"
+        when "command", "dynamic"
+          cmd = completion[:command]
+          "COMPREPLY=($(compgen -W \"$(#{cmd})\" -- \"$cur\"))"
+        else
+          # Default to file completion for "file" type and unknown types
+          "COMPREPLY=($(compgen -f -- \"$cur\"))"
+        end
+      end
+
+      private def sanitize_name(name)
+        name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
+      end
+    end
+  end
+end

data/lib/thor/completion/builder.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+class Thor
+  module Completion
+    class Builder
+      extend SchemaValidator
+
+      def self.call(name:, description:, version:, cli:)
+        schema = {
+          name:,
+          description:,
+          version:,
+          commands: [],
+          subcommands: [],
+          globalOptions: []
+        }
+
+        build_command(cli, schema)
+
+        cli.class_options.each_value do |option|
+          schema[:globalOptions] += build_option(option)
+        end
+
+        schema
+      end
+
+      def self.build_command(cli, parent)
+        cli.options.each_value do |option|
+          parent[:options] += build_option(option)
+        end
+
+        cli.all_commands.each_value do |command|
+          cmd_schema = {
+            name: command.name,
+            description: command.description || "",
+            options: command.options.each_value.flat_map { build_option(it) }
+          }
+
+          # Extract positional arguments from method parameters
+          if cli.instance_methods(false).include?(command.name.to_sym)
+            method = cli.instance_method(command.name.to_sym)
+            arguments = extract_arguments(method)
+            cmd_schema[:arguments] = arguments if arguments.any?
+          end
+
+          # Check if this command has subcommands
+          subcommand_class = cli.subcommand_classes[command.name]
+          if subcommand_class
+            cmd_schema[:subcommands] = []
+
+            # Recursively build subcommands
+            build_subcommands(subcommand_class, cmd_schema)
+          end
+
+          parent[:commands] << cmd_schema
+        end
+      end
+
+      def self.resolve_completion(value)
+        value = value.to_s
+
+        return "file" if value == "file" || value.end_with?("_file")
+        return "directory" if value == "dir" || value.match?(/_dir(ectory)?$/)
+        return "directory" if value == "folder" || value.end_with?("_folder")
+
+        nil
+      end
+
+      def self.build_subcommands(cli, parent)
+        cli.all_commands.each_value do |command|
+          subcmd_schema = {
+            name: command.name,
+            description: command.description || "",
+            options: command.options.each_value.flat_map { build_option(it) }
+          }
+
+          # Extract positional arguments from method parameters
+          if cli.instance_methods(false).include?(command.name.to_sym)
+            method = cli.instance_method(command.name.to_sym)
+            arguments = extract_arguments(method)
+            subcmd_schema[:arguments] = arguments if arguments.any?
+          end
+
+          # Check if this subcommand has its own subcommands
+          subcommand_class = cli.subcommand_classes[command.name]
+          if subcommand_class
+            subcmd_schema[:subcommands] = []
+
+            # Recursively build nested subcommands
+            build_subcommands(subcommand_class, subcmd_schema)
+          end
+
+          parent[:subcommands] << subcmd_schema
+        end
+      end
+
+      def self.extract_arguments(method)
+        values = method
+                 .parameters
+                 .select {|type, _| %i[req opt rest].include?(type) } # rubocop:disable Style/HashSlice
+
+        values.map do |type, name|
+          arg_hash = {
+            name: name.to_s,
+            description: name.to_s.tr("_", " ").capitalize,
+            required: type == :req,
+            variadic: type == :rest
+          }
+
+          # Add completion hint if available
+          completion = resolve_completion(name)
+          arg_hash[:completion] = {type: completion} if completion
+
+          arg_hash
+        end
+      end
+
+      def self.build_option(option)
+        dasherize = proc { it.to_s.tr("_", "-") }
+        name = dasherize.call(option.name)
+
+        [].tap do |list|
+          short_opts = option.aliases.map { dasherize.call(it.gsub(/^-+/, "")) }
+          opt_hash = {
+            name:,
+            type: option.type.to_s,
+            description: option.description || "",
+            required: option.required,
+            repeatable: option.repeatable || false,
+            default: option.default,
+            enum: Array(option.enum),
+            hidden: option.hide || false
+          }
+
+          if (completion = resolve_completion(option.name))
+            opt_hash[:completion] = completion
+          end
+
+          # Only add short if there are aliases
+          if short_opts.any?
+            opt_hash[:short] =
+              short_opts.length == 1 ? short_opts.first : short_opts
+          end
+
+          list << opt_hash
+
+          if option.type == :boolean
+            list << {
+              name: "no-#{name}",
+              type: option.type.to_s,
+              description: "",
+              required: false,
+              repeatable: option.repeatable || false,
+              hidden: option.hide || false
+            }
+
+            list << {
+              name: "skip-#{name}",
+              type: option.type.to_s,
+              description: "",
+              required: false,
+              repeatable: option.repeatable || false,
+              hidden: option.hide || false
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thor/completion/fish.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+class Thor
+  module Completion
+    class Fish
+      include SchemaValidator
+
+      attr_reader :output, :schema, :name, :commands, :global_options
+
+      def initialize(schema)
+        validate_schema!(schema)
+
+        @schema = schema
+        @name = schema[:name]
+        @commands = schema[:commands] || []
+        @global_options = schema[:globalOptions] || []
+        @output = []
+      end
+
+      def call
+        # Add a description comment for the command itself
+        output << "# #{name} - #{schema[:description]}" if schema[:description]
+        output << ""
+
+        generate_completions
+
+        output.join("\n")
+      end
+
+      private def generate_completions
+        # Generate completions for main commands
+        commands.reject {|c| c[:hidden] }.each do |cmd|
+          cmd_name = cmd[:name]
+          cmd_desc = escape_fish(cmd[:description] || "")
+
+          output << "complete -c #{name} -n \"__fish_use_subcommand\" -a #{cmd_name} -d #{quote_fish(cmd_desc)}"
+        end
+
+        # Generate global options
+        global_options.reject {|opt| opt[:hidden] }.each do |opt|
+          generate_option_completion(opt, "__fish_use_subcommand")
+        end
+
+        # Generate completions for subcommands
+        commands.each do |cmd|
+          next if cmd[:hidden]
+
+          generate_command_completions(cmd, [cmd[:name]])
+        end
+      end
+
+      private def generate_command_completions(cmd, path)
+        condition = build_condition(path)
+
+        # Generate subcommands
+        if cmd[:subcommands]&.any?
+          cmd[:subcommands].reject {|c| c[:hidden] }.each do |subcmd|
+            subcmd_name = subcmd[:name]
+            subcmd_desc = escape_fish(subcmd[:description] || "")
+
+            output << "complete -c #{name} -n #{quote_fish(condition)} -a #{subcmd_name} -d #{quote_fish(subcmd_desc)}"
+          end
+        end
+
+        # Generate options
+        if cmd[:options]&.any?
+          cmd[:options].reject {|opt| opt[:hidden] }.each do |opt|
+            generate_option_completion(opt, condition)
+          end
+        end
+
+        # Generate argument completions
+        if cmd[:arguments]&.any?
+          arg = cmd[:arguments].first
+          if arg[:completion]
+            case arg[:completion][:type]
+            when "directory"
+              output << "complete -c #{name} -n #{quote_fish(condition)} -x -a '(__fish_complete_directories)'"
+              # For "file" type or others, Fish will provide file completion by default
+            end
+          end
+          # Fish provides file completion by default, so we don't need to add -F
+        end
+
+        # Recursively generate completions for subcommands
+        return unless cmd[:subcommands]&.any?
+
+        cmd[:subcommands].each do |subcmd|
+          next if subcmd[:hidden]
+
+          generate_command_completions(subcmd, path + [subcmd[:name]])
+        end
+      end
+
+      private def generate_option_completion(opt, condition)
+        opt_desc = escape_fish(opt[:description] || "")
+
+        # Build the base completion command
+        base_cmd = "complete -c #{name} -n #{quote_fish(condition)}"
+
+        # Add short and long options
+        if opt[:short]
+          shorts = Array(opt[:short])
+
+          shorts.each do |short|
+            parts = [base_cmd, "-s #{short}"]
+            parts << "-l #{opt[:name]}" if opt[:name]
+            parts << "-d #{quote_fish(opt_desc)}" if opt_desc && !opt_desc.empty?
+
+            # Add value requirements for non-boolean options
+            if opt[:type] != "boolean"
+              parts << "-r" # require argument
+
+              if opt[:enum]&.any?
+                # Add enum values as completions
+                values = opt[:enum].map {|v| escape_fish(v) }.join(" ")
+                parts << "-a #{quote_fish(values)}"
+              end
+            end
+
+            output << parts.join(" ")
+          end
+
+          # If there's also a long option and multiple shorts, add long-only completion
+          if opt[:name] && shorts.any?
+            parts = [base_cmd, "-l #{opt[:name]}"]
+            parts << "-d #{quote_fish(opt_desc)}" if opt_desc && !opt_desc.empty?
+
+            if opt[:type] != "boolean"
+              parts << "-r"
+              if opt[:enum]&.any?
+                values = opt[:enum].map {|v| escape_fish(v) }.join(" ")
+                parts << "-a #{quote_fish(values)}"
+              end
+            end
+
+            output << parts.join(" ")
+          end
+        elsif opt[:name]
+          # Long option only
+          parts = [base_cmd, "-l #{opt[:name]}"]
+          parts << "-d #{quote_fish(opt_desc)}" if opt_desc && !opt_desc.empty?
+
+          if opt[:type] != "boolean"
+            parts << "-r"
+            if opt[:enum]&.any?
+              values = opt[:enum].map {|v| escape_fish(v) }.join(" ")
+              parts << "-a #{quote_fish(values)}"
+            end
+          end
+
+          output << parts.join(" ")
+        end
+      end
+
+      private def build_condition(path)
+        # Build a Fish condition that checks if we're in the right subcommand context
+        # For example: "__fish_seen_subcommand_from utils; and __fish_seen_subcommand_from nested"
+        conditions = path.map do |cmd|
+          "__fish_seen_subcommand_from #{cmd}"
+        end
+
+        if conditions.length > 1
+          # For nested commands, we need to ensure we're in the right context
+          conditions.join("; and ")
+        else
+          conditions.first
+        end
+      end
+
+      private def quote_fish(str)
+        # Fish uses single quotes, escape single quotes by ending the string,
+        # adding an escaped quote, and starting a new string
+        "'#{str.to_s.gsub("'", "'\\''")}'"
+      end
+
+      private def escape_fish(str)
+        str.to_s.gsub("'", "\\'")
+      end
+
+      private def sanitize_name(name)
+        name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
+      end
+    end
+  end
+end