module Bundler::Thor::Base::ClassMethods

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 370
def all_commands
  @all_commands ||= from_superclass(:all_commands, Bundler::Thor::CoreExt::OrderedHash.new)
  @all_commands.merge!(commands)
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 232
def argument(name, options = {})
  is_thor_reserved_word?(name, :argument)
  no_commands { attr_accessor name }

  required = if options.key?(:optional)
    !options[:optional]
  elsif options.key?(:required)
    options[:required]
  else
    options[:default].nil?
  end

  remove_argument name

  if required
    arguments.each do |argument|
      next if argument.required?
      raise ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after " \
                          "the non-required argument #{argument.human_name.inspect}."
    end
  end

  options[:required] = required

  arguments << Bundler::Thor::Argument.new(name, options)
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 264
def arguments
  @arguments ||= from_superclass(:arguments, [])
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 157
def check_default_type!
  @check_default_type = true
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 142
def check_unknown_options!
  @check_unknown_options = true
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 299
def class_option(name, options = {})
  build_option(name, options, class_options)
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 277
def class_options(options = nil)
  @class_options ||= from_superclass(:class_options, {})
  build_options(options, @class_options) if options
  @class_options
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 359
def commands
  @commands ||= Bundler::Thor::CoreExt::OrderedHash.new
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 345
def group(name = nil)
  if name
    @group = name.to_s
  else
    @group ||= from_superclass(:group, "standard")
  end
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 448
def namespace(name = nil)
  if name
    @namespace = name.to_s
  else
    @namespace ||= Bundler::Thor::Util.namespace_from_thor_class(self)
  end
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 418
def no_commands
  @no_commands = true
  yield
ensure
  @no_commands = false
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 488
def public_command(*names)
  names.each do |name|
    class_eval "def #{name}(*); super end"
  end
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 314
def remove_argument(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}

  names.each do |name|
    arguments.delete_if { |a| a.name == name.to_s }
    undef_method name, "#{name}=" if options[:undefine]
  end
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 333
def remove_class_option(*names)
  names.each do |name|
    class_options.delete(name)
  end
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 388
def remove_command(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}

  names.each do |name|
    commands.delete(name.to_s)
    all_commands.delete(name.to_s)
    undef_method name if options[:undefine]
  end
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 464
def start(given_args = ARGV, config = {})
  config[:shell] ||= Bundler::Thor::Base.shell.new
  dispatch(nil, given_args.dup, nil, config)
rescue Bundler::Thor::Error => e
  config[:debug] || ENV["THOR_DEBUG"] == "1" ? (raise e) : config[:shell].error(e.message)
  exit(1) if exit_on_failure?
rescue Errno::EPIPE
  # This happens if a thor command is piped to something like `head`,
  # which closes the pipe when it's done reading. This will also
  # mean that if the pipe is closed, further unnecessary
  # computation will not occur.
  exit(0)
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 185
def strict_args_position!
  @strict_args_position = true
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 653
def basename
  File.basename($PROGRAM_NAME).split(" ").first
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 646
def exit_on_failure?
  false
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 626
def from_superclass(method, default = nil)
  if self == baseclass || !superclass.respond_to?(method, true)
    default
  else
    value = superclass.send(method)

    # Ruby implements `dup` on Object, but raises a `TypeError`
    # if the method is called on immediates. As a result, we
    # don't have a good way to check whether dup will succeed
    # without calling it and rescuing the TypeError.
    begin
      value.dup
    rescue TypeError
      value
    end

  end
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 599
def inherited(klass)
  Bundler::Thor::Base.register_klass_file(klass)
  klass.instance_variable_set(:@no_commands, false)
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 606
def method_added(meth)
  meth = meth.to_s

  if meth == "initialize"
    initialize_added
    return
  end

  # Return if it's not a public instance method
  return unless public_method_defined?(meth.to_sym)

  @no_commands ||= false
  return if @no_commands || !create_command(meth)

  is_thor_reserved_word?(meth, :command)
  Bundler::Thor::Base.register_klass_file(self)
end

# File lib/bundler/vendor/thor/lib/thor/base.rb, line 533
def print_options(shell, options, group_name = nil)
  return if options.empty?

  list = []
  padding = options.map { |o| o.aliases.size }.max.to_i * 4

  options.each do |option|
    next if option.hide
    item = [option.usage(padding)]
    item.push(option.description ? "# #{option.description}" : "")

    list << item
    list << ["", "# Default: #{option.default}"] if option.show_default?
    list << ["", "# Possible values: #{option.enum.join(', ')}"] if option.enum
  end

  shell.say(group_name ? "#{group_name} options:" : "Options:")
  shell.print_table(list, :indent => 2)
  shell.say ""
end