module Thor::Completion::Bash::CommandMixin

Methods mixed in to {Thor::Command}.

Public Instance Methods

bash_complete(request:, index:, klass: logger.trace "ENTERING click to toggle source
# File lib/thor/completion/bash/command_mixin.rb, line 176
def bash_complete request:, index:, klass:
  # logger.level = :trace

  logger.trace "ENTERING #{ self.class }##{ __method__ }",
    request: request,
    index: index,
    index_word: request.words[index]

  # Index we'll increment as we scan past options
  scan_index = index
  arg_count = 0
  
  # Skip over args (for now)
  while scan_index < request.cword &&
        scan_index < request.words.length &&
        !request.words[scan_index].start_with?( '-' )
    scan_index += 1
    arg_count += 1
  end

  if  scan_index == request.cword ||
      ( request.split &&
        scan_index == request.cword - 1 )
    return bash_complete_cur request: request, arg_count: arg_count, klass: klass
  end

  unless scan_index < request.words.length
    # We ran out of words without hitting a command name or ending
    # empty string (for which we would provide all commands as options)
    #
    # TODO  In the future we can deal with half-written class options
    #       I guess? Maybe? But for now we just give up.
    #
    return [].tap { |results|
      logger.trace "No option or empty string found",
        results: []
    }
  end

  # match_word = request.words[scan_index]

  # matching_options = options.values.select { |option|
  #   option.all_switch_tokens.any? { |token| token.start_with? match_word }
  # }

  return [].tap { |results|
    logger.trace "Not implemented",
      results: results
  }
  
end
bash_complete_cur(request:, arg_count:, klass: return bash_complete_cur_split( request: request ) if request.split) click to toggle source
# File lib/thor/completion/bash/command_mixin.rb, line 124
def bash_complete_cur request:, arg_count:, klass:
  return bash_complete_cur_split( request: request ) if request.split
  
  if request.cur == ''
    results = [ '--help' ]

    argument = klass.arguments( command: self )[arg_count]

    if argument
      results += argument.bash_complete( request: request, klass: klass )
    end

    results += options.values.flat_map { |option| option.long_switch_tokens }

    return results.
      tap { |results|
        logger.trace "`request.cur` is ''; returning all long opts",
          results: results
      }
  end

  if request.cur.start_with? '-'
    return options.values.flat_map { |option|
      option.long_switch_names.flat_map { |name|
        if option.boolean?
          [ "--#{ name }", "--no-#{ name }" ]
        else
          "--#{ name }="
        end
      }
    }.
    +( [ '--help' ] ).
    select { |token| token.start_with? request.cur }.
    tap { |results|
      logger.trace "Completing partial switch token",
        results: results
    }
  end

  argument = klass.arguments( command: self )[arg_count]
  if argument
    return argument.
      bash_complete( request: request, klass: klass).
      tap { |results|
        logger.trace "We b here"
      }
  end

  return []
end
bash_complete_cur_split(request:) click to toggle source
# File lib/thor/completion/bash/command_mixin.rb, line 42
def bash_complete_cur_split request:
  # The input was split at a `=`, so we're looking for a value for
  # an option whose name will be at {Request#prev}.

  logger.trace "Processing split Bash complete request...",
    command: self.name,
    request: request

  matching_options = options.values.select { |option|
    option.long_switch_tokens.
      reject { |token| token.end_with? '=' }.
      include? request.prev
  }

  case matching_options.length
  when 0
    return [].tap { |results|
      logger.trace "No matching options found",
        results: results,
        options: options.transform_values { |option|
          {
            tokens: option.all_switch_tokens,
            names: option.all_switch_names,
          }
        }
    }

  when 1
    option = matching_options[0]

    logger.trace "Unique option found for `request.prev`",
      prev: request.prev,
      option: option
    
    if option.enum
      return option.enum.
        select { |value|
          value.to_s.start_with? request.cur
        }.
        tap { |results|
          logger.trace \
            "Matched against enum option #{ option.name }",
            prev: request.prev,
            results: results,
            option: option
        }

    elsif option.complete
      return option.complete.call.
        select { |value|
          value.to_s.start_with? request.cur
        }.
        tap { |results|
          logger.trace \
            "Matched against complete option #{ option.name }",
            prev: request.prev,
            results: results,
            option: option
        }

    else
      return [].tap { |results|
        logger.trace \
          ( "Matched against non-enum option #{ option.name } " +
            "but we don't have any completions to provide" ),
          prev: request.prev,
          results: results,
          option: option
      }
    end

  else
    return [].tap { |results|
      logger.trace "Multiple options found for prev",
        results: results,
        prev: request.prev,
        options: matching_options
    }
  end
end