How to use

CommandMetadata

in

io.airlift.command.model

  public Class<?> apply(CommandMetadata input)
  {
    return input.getType();
  }
};

  @Override
  public String apply(CommandMetadata input)
  {
    return "[" + input.getName() + "] " + input.getDescription();
  }
});

  @Override
  public boolean apply(CommandMetadata input)
  {
    return !input.isHidden();
  }
});

  @Override
  public Iterable<String> suggest()
  {
    ImmutableList.Builder<String> suggestions = ImmutableList.<String>builder()
        .addAll(concat(transform(command.getCommandOptions(), OptionMetadata.optionsGetter())));

    if (command.getArguments() != null) {
      suggestions.add("--");
    }

    return suggestions.build();
  }
}

if(!command.isHidden())
      synopsis.appendWords(UsageHelper.toSynopsisUsage(command.getGlobalOptions()));
  synopsis.append(group.getName()).appendWords(UsageHelper.toSynopsisUsage(command.getGroupOptions()));
  synopsis.newline();
if(!command.isHidden())
      synopsis.appendWords(UsageHelper.toSynopsisUsage(command.getGlobalOptions()));
  synopsis.append(group.getName()).appendWords(UsageHelper.toSynopsisUsage(command.getGroupOptions()));
  synopsis.append(command.getName()).appendWords(UsageHelper.toSynopsisUsage(command.getCommandOptions()));
  synopsis.newline();
if (group.getDefaultCommand() != null && group.getDefaultCommand().getDescription() != null && !group.getDefaultCommand().isHidden()) {
  commandPrinter.append("With no arguments,")
      .append(group.getDefaultCommand().getDescription())
      .newline()
      .newline();
  if(!command.isHidden())
    commandPrinter.append(command.getName()).newline();
    UsagePrinter descriptionPrinter = commandPrinter.newIndentedPrinter(4);
    descriptionPrinter.append(command.getDescription()).newline().newline();
    for (OptionMetadata option : command.getCommandOptions()) {

  private void printCommandDescription(UsagePrinter commandPrinter, @Nullable CommandGroupMetadata group, CommandMetadata command)
  {
    if(!command.isHidden())
    {
      if (group != null) {
        commandPrinter.append(group.getName());
      }
      commandPrinter.append(command.getName()).newline();
      if (command.getDescription() != null) {
        commandPrinter.newIndentedPrinter(4).append(command.getDescription()).newline();
      }
      commandPrinter.newline();
    }
  }
}

    .append(programName)
    .append(groupName)
    .append(command.getName())
    .append("-")
    .append(command.getDescription())
    .newline()
    .newline();
List<OptionMetadata> options = newArrayList();
if (programName != null) {
  synopsis.append(programName).appendWords(toSynopsisUsage(sortOptions(command.getGlobalOptions())));
  options.addAll(command.getGlobalOptions());
  synopsis.append(groupName).appendWords(toSynopsisUsage(sortOptions(command.getGroupOptions())));
  options.addAll(command.getGroupOptions());
synopsis.append(command.getName()).appendWords(toSynopsisUsage(sortOptions(command.getCommandOptions())));
options.addAll(command.getCommandOptions());
ArgumentsMetadata arguments = command.getArguments();
if (arguments != null) {
  synopsis.append("[--]")

return createInstance(command.getType(),
    command.getAllOptions(),
    state.getParsedOptions(),
    command.getArguments(),
    state.getParsedArguments(),
    command.getMetadataInjections(),
    bindings.build(),
    commandFactory);

  public String apply(CommandMetadata input)
  {
    return input.getName();
  }
};

public C parse(C commandInstance, String... args)
{
  Preconditions.checkNotNull(args, "args is null");
  
  Parser parser = new Parser(metadata);
  ParseState state = parser.parse(args);
  CommandMetadata command = MetadataLoader.loadCommand(commandInstance.getClass());
  state = state.withCommand(command);
  validate(state);
  ImmutableMap.Builder<Class<?>, Object> bindings = ImmutableMap.<Class<?>, Object>builder().put(GlobalMetadata.class, metadata);
  if (state.getGroup() != null) {
    bindings.put(CommandGroupMetadata.class, state.getGroup());
  }
  bindings.put(CommandMetadata.class, command);
  C c = (C) ParserUtil.injectOptions(commandInstance,
    command.getAllOptions(),
    state.getParsedOptions(),
    command.getArguments(),
    state.getParsedArguments(),
    command.getMetadataInjections(),
    bindings.build());
  
  return c;
}

CommandMetadata command = find(expectedCommands, compose(equalTo(tokens.peek()), CommandMetadata.nameGetter()), null);
if (command == null) {
  while (tokens.hasNext()) {
    state = parseOptions(tokens, state, command.getCommandOptions());
    state = parseArgs(state, tokens, command.getArguments());

private void validate(ParseState state)
{
  CommandMetadata command = state.getCommand();
  if (command == null) {
    List<String> unparsedInput = state.getUnparsedInput();
    if (unparsedInput.isEmpty()) {
      throw new ParseCommandMissingException();
    }
    else {
      throw new ParseCommandUnrecognizedException(unparsedInput);
    }
  }
  ArgumentsMetadata arguments = command.getArguments();
  if (state.getParsedArguments().isEmpty() && arguments != null && arguments.isRequired()) {
    throw new ParseArgumentsMissingException(arguments.getTitle());
  }
  
  if (!state.getUnparsedInput().isEmpty()) {
    throw new ParseArgumentsUnexpectedException(state.getUnparsedInput());
  }
  if (state.getLocation() == Context.OPTION) {
    throw new ParseOptionMissingValueException(state.getCurrentOption().getTitle());
  }
  for (OptionMetadata option : command.getAllOptions()) {
    if (option.isRequired() && !state.getParsedOptions().containsKey(option)) {
      throw new ParseOptionMissingException(option.getOptions().iterator().next());
    }
  }
}

public static GlobalMetadata loadGlobal(String name,
    String description,
    CommandMetadata defaultCommand,
    Iterable<CommandMetadata> defaultGroupCommands,
    Iterable<CommandGroupMetadata> groups)
{
  ImmutableList.Builder<OptionMetadata> globalOptionsBuilder = ImmutableList.builder();
  if (defaultCommand != null) {
    globalOptionsBuilder.addAll(defaultCommand.getGlobalOptions());
  }
  for (CommandMetadata command : defaultGroupCommands) {
    globalOptionsBuilder.addAll(command.getGlobalOptions());
  }
  for (CommandGroupMetadata group : groups) {
    for (CommandMetadata command : group.getCommands()) {
      globalOptionsBuilder.addAll(command.getGlobalOptions());
    }
  }
  List<OptionMetadata> globalOptions = mergeOptionSet(globalOptionsBuilder.build());
  return new GlobalMetadata(name, description, globalOptions, defaultCommand, defaultGroupCommands, groups);
}

CommandMetadata commandMetadata = new CommandMetadata(
    name,
    description,

if (!commandMetadata.isHidden()) {
  commands.put(commandMetadata.getName(), commandMetadata.getDescription());

  @Override
  public String apply(CommandMetadata input)
  {
    return input.getName();
  }
});

private static CommandMetadata findCommandMetadata(CommandMetadata result, CommandMetadata command, Class<? extends PrideCommand> type) {
  if (result != null) {
    return result;
  }
  if (command.getType().equals(type)) {
    return command;
  }
  return null;
}

  @Override
  public String apply(CommandMetadata input)
  {
    return input.getName();
  }
});

  @Override
  public boolean apply(CommandMetadata input)
  {
    return !input.isHidden();
  }
});

@Override
public void run() throws Ap3Exception
{
  if(null != groupMetadata)
  {
    CommandMetadata metadata = promptForApp(groupMetadata.getCommands());
    Ap3Command command = cli.getParsedCommand(metadata.getType());
    if(null != command)
    {
      command.run();
    }
  }
}