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