Class: Bundler::Thor

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 535

def banner(command, namespace = nil, subcommand = false)
  command.formatted_usage(self, $thor_runner, subcommand).split("\n").map do |formatted_usage|
    "#{basename} #{formatted_usage}"
  end.join("\n")
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 541

def baseclass #:nodoc:
  Bundler::Thor
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 350

def check_unknown_options!(options = {})
  @check_unknown_options ||= {}
  options.each do |key, value|
    if value
      @check_unknown_options[key] = Array(value)
    else
      @check_unknown_options.delete(key)
    end
  end
  @check_unknown_options
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 363

def check_unknown_options?(config) #:nodoc:
  options = check_unknown_options
  return false unless options

  command = config[:current_command]
  return true unless command

  name = command.name

  if subcommands.include?(name)
    false
  elsif options[:except]
    !options[:except].include?(name.to_sym)
  elsif options[:only]
    options[:only].include?(name.to_sym)
  else
    true
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 258

def command_help(shell, command_name)
  meth = normalize_command_name(command_name)
  command = all_commands[meth]
  handle_no_command_error(meth) unless command

  shell.say "Usage:"
  shell.say "  #{banner(command).split("\n").join("\n  ")}"
  shell.say
  class_options_help(shell, nil => command.options.values)
  print_exclusive_options(shell, command)
  print_at_least_one_required_options(shell, command)

  if command.long_description
    shell.say "Description:"
    if command.wrap_long_description
      shell.print_wrapped(command.long_description, indent: 2)
    else
      shell.say command.long_description
    end
  else
    shell.say command.description
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 549

def create_command(meth) #:nodoc:
  @usage ||= nil
  @desc ||= nil
  @long_desc ||= nil
  @long_desc_wrap ||= nil
  @hide ||= nil

  if @usage && @desc
    base_class = @hide ? Bundler::Thor::HiddenCommand : Bundler::Thor::Command
    relations = {exclusive_option_names: method_exclusive_option_names,
      at_least_one_option_names: method_at_least_one_option_names}
    commands[meth] = base_class.new(meth, @desc, @long_desc, @long_desc_wrap, @usage, method_options, relations)
    @usage, @desc, @long_desc, @long_desc_wrap, @method_options, @hide = nil
    @method_exclusive_option_names, @method_at_least_one_option_names = nil
    true
  elsif all_commands[meth] || meth == "method_missing"
    true
  else
    puts "[WARNING] Attempted to create command #{meth.inspect} without usage or description. " \
         "Call desc if you want this method to be available as command or declare it inside a " \
         "no_commands{} block. Invoked from #{caller[1].inspect}."
    false
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 573

alias_method :create_task, :create_command

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 21

def default_command(meth = nil)
  if meth
    @default_command = meth == :none ? "help" : meth.to_s
  else
    @default_command ||= from_superclass(:default_command, "help")
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 28

alias_method :default_task, :default_command

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 26

def deprecation_warning(message) #:nodoc:
  unless ENV["THOR_SILENCE_DEPRECATION"]
    warn "Deprecation warning: #{message}\n" +
      "You can silence deprecations warning by setting the environment variable THOR_SILENCE_DEPRECATION."
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 54

def desc(usage, description, options = {})
  if options[:for]
    command = find_and_refresh_command(options[:for])
    command.usage = usage             if usage
    command.description = description if description
  else
    @usage = usage
    @desc = description
    @hide = options[:hide] || false
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 467

def disable_required_check #:nodoc:
  @disable_required_check ||= [:help]
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 434

def disable_required_check!(*command_names)
  @disable_required_check = disable_required_check | command_names
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 438

def disable_required_check?(command) #:nodoc:
  command && disable_required_check.include?(command.name.to_sym)
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 494

def dispatch(meth, given_args, given_opts, config) #:nodoc:
  meth ||= retrieve_command_name(given_args)
  command = all_commands[normalize_command_name(meth)]

  if !command && config[:invoked_via_subcommand]
    # We're a subcommand and our first argument didn't match any of our
    # commands. So we put it back and call our default command.
    given_args.unshift(meth)
    command = all_commands[normalize_command_name(default_command)]
  end

  if command
    args, opts = Bundler::Thor::Options.split(given_args)
    if stop_on_unknown_option?(command) && !args.empty?
      # given_args starts with a non-option, so we treat everything as
      # ordinary arguments
      args.concat opts
      opts.clear
    end
  else
    args = given_args
    opts = nil
    command = dynamic_command_class.new(meth)
  end

  opts = given_opts || opts || []
  config[:current_command] = command
  config[:command_options] = command.options

  instance = new(args, opts, config)
  yield instance if block_given?
  args = instance.args
  trailing = args[Range.new(arguments.size, -1)]
  instance.invoke_command(command, trailing || [])
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 545

def dynamic_command_class #:nodoc:
  Bundler::Thor::DynamicCommand
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 207

alias_method :exclusive, :method_exclusive

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 615

def find_command_possibilities(meth)
  len = meth.to_s.length
  possibilities = all_commands.merge(map).keys.select { |n| meth == n[0, len] }.sort
  unique_possibilities = possibilities.map { |k| map[k] || k }.uniq

  if possibilities.include?(meth)
    [meth]
  elsif unique_possibilities.size == 1
    unique_possibilities
  else
    possibilities
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 628

alias_method :find_task_possibilities, :find_command_possibilities

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 288

def help(shell, subcommand = false)
  list = printable_commands(true, subcommand)
  Bundler::Thor::Util.thor_classes_in(self).each do |klass|
    list += klass.printable_commands(false)
  end
  sort_commands!(list)

  if defined?(@package_name) && @package_name
    shell.say "#{@package_name} commands:"
  else
    shell.say "Commands:"
  end

  shell.print_table(list, indent: 2, truncate: true)
  shell.say
  class_options_help(shell)
  print_exclusive_options(shell)
  print_at_least_one_required_options(shell)
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 575

def initialize_added #:nodoc:
  class_options.merge!(method_options)
  @method_options = nil
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 78

def long_desc(long_description, options = {})
  if options[:for]
    command = find_and_refresh_command(options[:for])
    command.long_description = long_description if long_description
  else
    @long_desc = long_description
    @long_desc_wrap = options[:wrap] != false
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 101

def map(mappings = nil, **kw)
  @map ||= from_superclass(:map, {})

  if mappings && !kw.empty?
    mappings = kw.merge!(mappings)
  else
    mappings ||= kw
  end
  if mappings
    mappings.each do |key, value|
      if key.respond_to?(:each)
        key.each { |subkey| @map[subkey] = value }
      else
        @map[key] = value
      end
    end
  end

  @map
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 246

def method_at_least_one(*args, &block)
  register_options_relation_for(:method_options,
                                :method_at_least_one_option_names, *args, &block)
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 458

def method_at_least_one_option_names #:nodoc:
  @method_at_least_one_option_names ||= []
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 203

def method_exclusive(*args, &block)
  register_options_relation_for(:method_options,
                                :method_exclusive_option_names, *args, &block)
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 449

def method_exclusive_option_names #:nodoc:
  @method_exclusive_option_names ||= []
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 163

def method_option(name, options = {})
  unless [ Symbol, String ].any? { |klass| name.is_a?(klass) }
    raise ArgumentError, "Expected a Symbol or String, got #{name.inspect}"
  end
  scope = if options[:for]
    find_and_refresh_command(options[:for]).options
  else
    method_options
  end

  build_option(name, options, scope)
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 129

def method_options(options = nil)
  @method_options ||= {}
  build_options(options, @method_options) if options
  @method_options
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 594

def normalize_command_name(meth) #:nodoc:
  return default_command.to_s.tr("-", "_") unless meth

  possibilities = find_command_possibilities(meth)
  raise AmbiguousTaskError, "Ambiguous command #{meth} matches [#{possibilities.join(', ')}]" if possibilities.size > 1

  if possibilities.empty?
    meth ||= default_command
  elsif map[meth]
    meth = map[meth]
  else
    meth = possibilities.first
  end

  meth.to_s.tr("-", "_") # treat foo-bar as foo_bar
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 610

alias_method :normalize_task_name, :normalize_command_name

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 175

alias_method :option, :method_option

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 135

alias_method :options, :method_options

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 12

def package_name(name, _ = {})
  @package_name = name.nil? || name == "" ? nil : name
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 482

def print_at_least_one_required_options(shell, command = nil) # :nodoc:
  opts = []
  opts = command.method_at_least_one_option_names unless command.nil?
  opts += class_at_least_one_option_names
  unless opts.empty?
    shell.say "Required At Least One:"
    shell.print_table(opts.map{ |ex| ex.map{ |e| "--#{e}"}}, indent: 2 )
    shell.say
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 471

def print_exclusive_options(shell, command = nil) # :nodoc:
  opts = []
  opts  = command.method_exclusive_option_names unless command.nil?
  opts += class_exclusive_option_names
  unless opts.empty?
    shell.say "Exclusive Options:"
    shell.print_table(opts.map{ |ex| ex.map{ |e| "--#{e}"}}, indent: 2 )
    shell.say
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 309

def printable_commands(all = true, subcommand = false)
  (all ? all_commands : commands).map do |_, command|
    next if command.hidden?
    item = []
    item << banner(command, false, subcommand)
    item << (command.description ? "# #{command.description.gsub(/\s+/m, ' ')}" : "")
    item
  end.compact
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 318

alias_method :printable_tasks, :printable_commands

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 37

def register(klass, subcommand_name, usage, description, options = {})
  if klass <= Bundler::Thor::Group
    desc usage, description, options
    define_method(subcommand_name) { |*args| invoke(klass, args) }
  else
    desc usage, description, options
    subcommand subcommand_name, klass
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 581

def retrieve_command_name(args) #:nodoc:
  meth = args.first.to_s unless args.empty?
  args.shift if meth && (map[meth] || meth !~ /^\-/)
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 585

alias_method :retrieve_task_name, :retrieve_command_name

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 642

def sort_commands!(list)
  list.sort! { |a, b| a[0] <=> b[0] }
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 462

def stop_on_unknown_option #:nodoc:
  @stop_on_unknown_option ||= []
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 420

def stop_on_unknown_option!(*command_names)
  @stop_on_unknown_option = stop_on_unknown_option | command_names
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 424

def stop_on_unknown_option?(command) #:nodoc:
  command && stop_on_unknown_option.include?(command.name.to_sym)
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 329

def subcommand(subcommand, subcommand_class)
  subcommands << subcommand.to_s
  subcommand_class.subcommand_help subcommand
  subcommand_classes[subcommand.to_s] = subcommand_class

  define_method(subcommand) do |*args|
    args, opts = Bundler::Thor::Arguments.split(args)
    invoke_args = [args, opts, {invoked_via_subcommand: true, class_options: options}]
    invoke_args.unshift "help" if opts.delete("--help") || opts.delete("-h")
    invoke subcommand_class, *invoke_args
  end
  subcommand_class.commands.each do |_meth, command|
    command.ancestor_name = subcommand
  end
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 325

def subcommand_classes
  @subcommand_classes ||= {}
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 630

def subcommand_help(cmd)
  desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
  class_eval "
    def help(command = nil, subcommand = true); super; end
"
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 320

def subcommands
  @subcommands ||= from_superclass(:subcommands, [])
end

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 344

alias_method :subtask, :subcommand

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 636

alias_method :subtask_help, :subcommand_help

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 323

alias_method :subtasks, :subcommands

# File 'lib/bundler/vendor/thor/lib/thor.rb', line 281

alias_method :task_help, :command_help