defaultCommandMetadata = MetadataLoader.loadCommand(defaultCommand); List<CommandMetadata> defaultCommandGroup = Lists.newArrayList(MetadataLoader.loadCommands(defaultGroupCommands)); MetadataLoader.loadCommandsIntoGroupsByAnnotation(allCommands,commandGroups, defaultCommandGroup); this.metadata = MetadataLoader.loadGlobal(name, description, defaultCommandMetadata, ImmutableList.copyOf(defaultCommandGroup), ImmutableList.copyOf(commandGroups));
public CommandGroupMetadata apply(GroupBuilder<C> group) { CommandMetadata groupDefault = MetadataLoader.loadCommand(group.defaultCommand); List<CommandMetadata> groupCommands = MetadataLoader.loadCommands(group.commands); // currentlly the default command is required to be in the commands list. If that changes, we'll need to add it here and add checks for existence allCommands.addAll(groupCommands); return MetadataLoader.loadCommandGroup(group.name, group.description, groupDefault, groupCommands); } }));
public static InjectionMetadata loadInjectionMetadata(Class<?> type) { InjectionMetadata injectionMetadata = new InjectionMetadata(); loadInjectionMetadata(type, injectionMetadata, ImmutableList.<Field>of()); injectionMetadata.compact(); return injectionMetadata; }
createGroupsFromAnnotations(allCommands,newCommands,commandGroups,defaultCommandGroup); CommandGroupMetadata newGroup = loadCommandGroup(groupName,"",null, Collections.singletonList(command)); commandGroups.add(newGroup); added = true;
if(null == defaultCommand) defaultCommand = loadCommand(defaultCommandClass); newCommands.add(defaultCommand); if(null == groupCommand) groupCommand = loadCommand(commandClass); newCommands.add(groupCommand); groupCommands.add(groupCommand); if(null == groupMetadata) groupMetadata = loadCommandGroup(groupAnno.name(),groupAnno.description(),defaultCommand, groupCommands); commandGroups.add(groupMetadata);
for (Field field : cls.getDeclaredFields()) { field.setAccessible(true); ImmutableList<Field> path = concat(fields, field); injectionMetadata.metadataInjections.add(new Accessor(path)); } else { loadInjectionMetadata(field.getType(), injectionMetadata, path);
public static CommandGroupMetadata loadCommandGroup(String name, String description, CommandMetadata defaultCommand, Iterable<CommandMetadata> commands) { ImmutableList.Builder<OptionMetadata> groupOptionsBuilder = ImmutableList.builder(); if (defaultCommand != null) { groupOptionsBuilder.addAll(defaultCommand.getGroupOptions()); } for (CommandMetadata command : commands) { groupOptionsBuilder.addAll(command.getGroupOptions()); } List<OptionMetadata> groupOptions = mergeOptionSet(groupOptionsBuilder.build()); return new CommandGroupMetadata(name, description, groupOptions, defaultCommand, commands); }
public CommandMetadata apply(Class<?> commandType) { return loadCommand(commandType); } }));
@VisibleForTesting public Iterable<String> generateSuggestions() { Parser parser = new Parser(metadata); ParseState state = parser.parse(arguments); Class<? extends Suggester> suggesterClass = BUILTIN_SUGGESTERS.get(state.getLocation()); if (suggesterClass != null) { SuggesterMetadata suggesterMetadata = MetadataLoader.loadSuggester(suggesterClass); if (suggesterMetadata != null) { ImmutableMap.Builder<Class<?>, Object> bindings = ImmutableMap.<Class<?>, Object>builder() .put(GlobalMetadata.class, metadata); if (state.getGroup() != null) { bindings.put(CommandGroupMetadata.class, state.getGroup()); } if (state.getCommand() != null) { bindings.put(CommandMetadata.class, state.getCommand()); } Suggester suggester = createInstance(suggesterMetadata.getSuggesterClass(), ImmutableList.<OptionMetadata>of(), null, null, null, suggesterMetadata.getMetadataInjections(), bindings.build()); return suggester.suggest(); } } return ImmutableList.of(); }
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); }
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; }
public static SuggesterMetadata loadSuggester(Class<? extends Suggester> suggesterClass) { InjectionMetadata injectionMetadata = loadInjectionMetadata(suggesterClass); return new SuggesterMetadata(suggesterClass, injectionMetadata.metadataInjections); }
InjectionMetadata injectionMetadata = loadInjectionMetadata(commandType);