class Slop

# File lib/slop.rb, line 128
def initialize(config = {}, &block)
  @config = DEFAULT_OPTIONS.merge(config)
  @options = []
  @commands = {}
  @trash = []
  @triggered_options = []
  @unknown_options = []
  @callbacks = {}
  @separators = {}
  @runner = nil
  @command = config.delete(:command)

  if block_given?
    block.arity == 1 ? yield(self) : instance_eval(&block)
  end

  if config[:help]
    on('-h', '--help', 'Display this help message.', :tail => true) do
      puts help
      exit
    end
  end
end

# File lib/slop.rb, line 93
def optspec(string, config = {})
  warn "[DEPRECATED] `Slop.optspec` is deprecated and will be removed in version 4"
  config[:banner], optspec = string.split(/^--+$/, 2) if string[/^--+$/]
  lines = optspec.split("\n").reject(&:empty?)
  opts  = Slop.new(config)

  lines.each do |line|
    opt, description = line.split(' ', 2)
    short, long = opt.split(',').map { |s| s.sub(/\A--?/, '') }
    opt = opts.on(short, long, description)

    if long && long.end_with?('=')
      long.sub!(/\=$/, '')
      opt.config[:argument] = true
    end
  end

  opts
end

# File lib/slop.rb, line 53
def parse(items = ARGV, config = {}, &block)
  parse! items.dup, config, &block
end

# File lib/slop.rb, line 62
def parse!(items = ARGV, config = {}, &block)
  config, items = items, ARGV if items.is_a?(Hash) && config.empty?
  slop = new config, &block
  slop.parse! items
  slop
end

# File lib/slop.rb, line 293
def [](key)
  option = fetch_option(key)
  option.value if option
end

# File lib/slop.rb, line 413
def add_callback(label, &block)
  (@callbacks[label] ||= []) << block
end

# File lib/slop.rb, line 171
def banner(banner = nil)
  config[:banner] = banner if banner
  config[:banner]
end

# File lib/slop.rb, line 162
def banner=(banner)
  config[:banner] = banner
end

# File lib/slop.rb, line 199
def command(command, options = {}, &block)
  options = @config.merge(options)
  @commands[command.to_s] = Slop.new(options.merge(:command => command.to_s), &block)
end

# File lib/slop.rb, line 188
def description(desc = nil)
  config[:description] = desc if desc
  config[:description]
end

# File lib/slop.rb, line 179
def description=(desc)
  config[:description] = desc
end

# File lib/slop.rb, line 312
def each(&block)
  options.each(&block)
end

# File lib/slop.rb, line 404
def fetch_command(command)
  @commands[command.to_s]
end

# File lib/slop.rb, line 388
def fetch_option(key)
  options.find { |option| [option.long, option.short].include?(clean(key)) }
end

# File lib/slop.rb, line 372
def missing
  (options - @triggered_options).map(&:key)
end

# File lib/slop.rb, line 276
def on(*objects, &block)
  option = build_option(objects, &block)
  original = options.find do |o|
    o.long and o.long == option.long or o.short and o.short == option.short
  end
  options.delete(original) if original
  options << option
  option
end

# File lib/slop.rb, line 210
def parse(items = ARGV, &block)
  parse! items.dup, &block
  items
end

# File lib/slop.rb, line 223
def parse!(items = ARGV, &block)
  if items.empty? && @callbacks[:empty]
    @callbacks[:empty].each { |cb| cb.call(self) }
    return items
  end

  # reset the trash so it doesn't carry over if you parse multiple
  # times with the same instance
  @trash.clear

  if cmd = @commands[items[0]]
    items.shift
    return cmd.parse! items
  end

  items.each_with_index do |item, index|
    @trash << index && break if item == '--'
    autocreate(items, index) if config[:autocreate]
    process_item(items, index, &block) unless @trash.include?(index)
  end
  items.reject!.with_index { |item, index| @trash.include?(index) }

  missing_options = options.select { |opt| opt.required? && opt.count < 1 }
  if missing_options.any?
    raise MissingOptionError,
    "Missing required option(s): #{missing_options.map(&:key).join(', ')}"
  end

  if @unknown_options.any?
    raise InvalidOptionError, "Unknown options #{@unknown_options.join(', ')}"
  end

  if @triggered_options.empty? && @callbacks[:no_options]
    @callbacks[:no_options].each { |cb| cb.call(self) }
  end

  if @runner.respond_to?(:call)
    @runner.call(self, items) unless config[:help] and present?(:help)
  end

  items
end

# File lib/slop.rb, line 348
def present?(*keys)
  keys.all? { |key| (opt = fetch_option(key)) && opt.count > 0 }
end

# File lib/slop.rb, line 355
def respond_to_missing?(method_name, include_private = false)
  options.any? { |o| o.key == method_name.to_s.chop } || super
end

# File lib/slop.rb, line 332
def run(callable = nil, &block)
  @runner = callable || block
  unless @runner.respond_to?(:call)
    raise ArgumentError, "You must specify a callable object or a block to #run"
  end
end

# File lib/slop.rb, line 420
def separator(text)
  if @separators[options.size]
    @separators[options.size] << "\n#{text}"
  else
    @separators[options.size] = text
  end
end

# File lib/slop.rb, line 155
def strict?
  config[:strict]
end

# File lib/slop.rb, line 302
def to_hash(include_commands = false)
  hash = Hash[options.map { |opt| [opt.key.to_sym, opt.value] }]
  if include_commands
    @commands.each { |cmd, opts| hash.merge!(cmd.to_sym => opts.to_hash) }
  end
  hash
end

# File lib/slop.rb, line 431
def to_s
  heads  = options.reject(&:tail?)
  tails  = (options - heads)
  opts = (heads + tails).select(&:help).map(&:to_s)
  optstr = opts.each_with_index.map { |o, i|
    (str = @separators[i + 1]) ? [o, str].join("\n") : o
  }.join("\n")

  if @commands.any?
    optstr << "\n" if !optstr.empty?
    optstr << "\nAvailable commands:\n\n"
    optstr << commands_to_help
    optstr << "\n\nSee `<command> --help` for more information on a specific command."
  end

  banner = config[:banner]
  if banner.nil?
    banner = "Usage: #{File.basename($0, '.*')}"
    banner << " #{@command}" if @command
    banner << " [command]" if @commands.any?
    banner << " [options]"
  end
  if banner
    "#{banner}\n#{@separators[0] ? "#{@separators[0]}\n" : ''}#{optstr}"
  else
    optstr
  end
end

# File lib/slop.rb, line 615
def autocreate(items, index)
  flag = items[index]
  if !fetch_option(flag) && !@trash.include?(index)
    option = build_option(Array(flag))
    argument = items[index + 1]
    option.config[:argument] = (argument && argument !~ /\A--?/)
    option.config[:autocreated] = true
    options << option
  end
end

# File lib/slop.rb, line 631
def build_option(objects, &block)
  config = {}
  config[:argument] = true if @config[:arguments]
  config[:optional_argument] = true if @config[:optional_arguments]

  if objects.last.is_a?(Hash)
    config.merge!(objects.pop)
  end

  short = extract_short_flag(objects, config)
  long  = extract_long_flag(objects, config)
  desc  = objects.shift if objects[0].respond_to?(:to_str)

  Option.new(self, short, long, desc, config, &block)
end

# File lib/slop.rb, line 675
def clean(object)
  object.to_s.sub(/\A--?/, '')
end

# File lib/slop.rb, line 679
def commands_to_help
  padding = 0
  @commands.each { |c, _| padding = c.size if c.size > padding }
  @commands.map do |cmd, opts|
    "  #{cmd}#{' ' * (padding - cmd.size)}   #{opts.description}"
  end.join("\n")
end

# File lib/slop.rb, line 570
def execute_multiple_switches(option, argument, items, index)
  execute_option(option, nil, index)
  flags = argument.split('')
  flags.each do |key|
    if opt = fetch_option(key)
      opt.count += 1
      if (opt.expects_argument? || opt.accepts_optional_argument?) &&
          (flags[-1] == opt.key) && (val = items[index+1])
        execute_option(opt, val, index, key)
      else
        execute_option(opt, nil, index, key)
      end
    else
      raise InvalidOptionError, "Unknown option -#{key}" if strict?
    end
  end
end

# File lib/slop.rb, line 537
def execute_option(option, argument, index, item = nil)
  if !option
    if config[:multiple_switches] && strict?
      raise InvalidOptionError, "Unknown option -#{item}"
    end
    return
  end

  if argument
    unless item && item.end_with?("=#{argument}")
      @trash << index + 1 unless option.argument_in_value
    end
    option.value = argument
  else
    option.value = option.count > 0
  end

  if option.match? && !argument.match(option.config[:match])
    raise InvalidArgumentError, "#{argument} is an invalid argument"
  end

  option.call(option.value)
end

# File lib/slop.rb, line 660
def extract_long_flag(objects, config)
  flag = objects.first.to_s
  if flag =~ /\A(?:--?)?[a-zA-Z0-9][a-zA-Z0-9_.-]+\=?\??\z/
    config[:argument] ||= true if flag.end_with?('=')
    config[:optional_argument] = true if flag.end_with?('=?')
    objects.shift
    clean(flag).sub(/\=\??\z/, '')
  end
end

# File lib/slop.rb, line 593
def extract_option(flag)
  option = fetch_option(flag)
  option ||= fetch_option(flag.downcase) if config[:ignore_case]
  option ||= fetch_option(flag.gsub(/([^-])-/, '\1_'))

  unless option
    case flag
    when /\A--?([^=]+)=(.+)\z/, /\A-([a-zA-Z])(.+)\z/, /\A--no-(.+)\z/
      option, argument = fetch_option($1), ($2 || false)
      option.argument_in_value = true if option
    end
  end

  [option, argument]
end

# File lib/slop.rb, line 647
def extract_short_flag(objects, config)
  flag = objects[0].to_s
  if flag =~ /\A-?\w=?\z/
    config[:argument] ||= flag.end_with?('=')
    objects.shift
    flag.delete('-=')
  end
end

# File lib/slop.rb, line 473
def method_missing(method, *args, &block)
  meth = method.to_s
  if meth.end_with?('?')
    meth.chop!
    present?(meth) || present?(meth.gsub('_', '-'))
  else
    super
  end
end

# File lib/slop.rb, line 491
def process_item(items, index, &block)
  return unless item = items[index]
  option, argument = extract_option(item) if item.start_with?('-')

  if option
    option.count += 1 unless item.start_with?('--no-')
    option.count += 1 if option.key[0, 3] == "no-"
    @trash << index
    @triggered_options << option

    if option.expects_argument?
      argument ||= items.at(index + 1)

      if !argument || argument =~ /\A--?[a-zA-Z][a-zA-Z0-9_-]*\z/
        raise MissingArgumentError, "#{option.key} expects an argument"
      end

      execute_option(option, argument, index, item)
    elsif option.accepts_optional_argument?
      argument ||= items.at(index + 1)

      if argument && argument =~ /\A([^\-?]|-\d)+/
        execute_option(option, argument, index, item)
      else
        option.call(nil)
      end
    elsif config[:multiple_switches] && argument
      execute_multiple_switches(option, argument, items, index)
    else
      option.value = option.count > 0
      option.call(nil)
    end
  else
    @unknown_options << item if strict? && item =~ /\A--?/
    block.call(item) if block && !@trash.include?(index)
  end
end