Returns all commands in alphabetic order

@return the list of commands
558379
public List<String> commands(boolean sys, boolean app) {
        C.List<String> list = C.newList();
        Act.Mode mode = Act.mode();
        boolean all = !sys && !app;
        for (String s : registry.keySet()) {
            boolean isSysCmd = s.startsWith("act.");
            if (isSysCmd && !sys && !all) {
                continue;
            }
            if (!isSysCmd && !app && !all) {
                continue;
            }
            CliHandler h = registry.get(s);
            if (h.appliedIn(mode)) {
                list.add(s);
            }
        }
        return list.sorted(new $.Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                boolean b1 = (o1.startsWith("act."));
                boolean b2 = (o2.startsWith("act."));
                if (b1 & !b2) {
                    return -1;
                }
                if (!b1 & b2) {
                    return 1;
                }
                return o1.compareTo(o2);
            }
        });
    }
287761
public static Completer lowerCaseCommandCompleter()
    {
        return new StringsCompleter(COMMANDS.stream()
                .map(s -> s.toLowerCase(Locale.ENGLISH))
                .collect(toSet()));
    }
627969
private static String showCommandAliases() {
        final Command[] commands = Command.values();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < commands.length; ++i) {
            if (i != 0) {
                sb.append(", ");
                if (i == commands.length - 1) {
                    sb.append("or ");
                }
            }
            sb.append("`--");
            sb.append(commands[i].getAlias());
            sb.append("`");
        }
        return sb.toString();
    }
1010639
@Override
    public List<Option> getCommandLineOptions() {
        final List<Option> ret = new LinkedList<Option>();

        String help;

        help = TIME_HELP;
        ret.add(new Option(SHORT_OPT_TIME, LONG_OPT_TIME, false, help));

        help = WARNINGS_AS_ERRORS;
        ret.add(new Option(null, LONG_OPT_PEDANTIC, false, help));

        help = SYSTEM_CONFIG_PATH;
        Option o = new Option(SHRT_OPT_SYSCFG, LONG_OPT_SYSCFG, true, help);
        o.setArgName(ARG_SYSCFG);
        ret.add(o);

        return ret;
    }
931592
public String keyList() {
		String separator = "";
		StringBuilder buffer = new StringBuilder();
		String item;

		for (int i = 0; i < names.size(); i++) {
			item = names.get(i);
			buffer.append(separator + item);
			separator = ", ";
		}

		return buffer.toString();
	}
600697
def list_commands(self, ctx):
        """"""
        commands = super(LegitGroup, self).list_commands(ctx)
        return [cmd for cmd in order_manually(commands)]
703374
function getAllCommands() {
    let resourceTypes = [];
    let tables = {};
    Object.keys(manifest).forEach(key => {
        const { [key]: category } = manifest;
        Object.keys(category.operations).forEach((operationKey) => {
            let operation = category.operations[operationKey];
            let opCategory = operation.target[0] || operation.methodAlias;
            if (resourceTypes.indexOf(opCategory) < 0) {
                resourceTypes.push(opCategory);
                tables[opCategory] = [];
            }
            tables[opCategory].push([chalk.cyan.bold(operation.command), operation.description]);
        });
    });

    resourceTypes.sort();

    let sections = [];
    for (let resourceType of resourceTypes) {
        tables[resourceType].sort((a, b) => a[0].localeCompare(b[0]));
        sections.push({
            head: chalk.white.bold(resourceType),
            table: tables[resourceType]
        });
    }

    return sections;
}
1140183
def list_all_commands(self):
        
        commands = [name for name, _ in inspect.getmembers(self, predicate=inspect.isroutine) if not name.startswith('_')]
        return commands
1000315
public java.util.List<CommandInvocation> getCommandInvocations() {
        if (commandInvocations == null) {
            commandInvocations = new com.amazonaws.internal.SdkInternalList<CommandInvocation>();
        }
        return commandInvocations;
    }
91674
protected String[] getPS() {
    ShellCommandExecutor shellExecutor = new ShellCommandExecutor(CMD);
    try {
      shellExecutor.execute();
    }
    catch (IOException e) {
      LOG.error(StringUtils.stringifyException(e));
      return null;
    }
    return shellExecutor.getOutput().split("\n");
  }
867375
def get_visible_commands(self) -> List[str]:
        """"""
        commands = self.get_all_commands()

        # Remove the hidden commands
        for name in self.hidden_commands:
            if name in commands:
                commands.remove(name)

        # Remove the disabled commands
        for name in self.disabled_commands:
            if name in commands:
                commands.remove(name)

        return commands
1284071
public static function commands(){
       $results = [];
       foreach(static::$commands as $name => $cmd){
          $results[] = [
            'name'        => $name,
            'params'      => preg_replace('/:(\w+)/','[$1]',implode(' ',$cmd[0])),
            'description' => $cmd[2],
          ];
       }
       return $results;
    }
611682
protected function getDefaultCommands()
    {
        $commands = parent::getDefaultCommands();
        foreach ($commands as $command) {
            if ('list' === $command->getName()) {
                if (method_exists($commands, 'setHidden')) {
                    $command->setHidden(true);
                } elseif (method_exists($command, 'setPrivate')) {
                    $commands->setPrivate(true);
                }
            }
        }

        return $commands;
    }
1316753
def list_commands(self, ctx):
        """"""
        rv = defaults.list_commands(ctx)
        if self._commands_dir:
            for filename in os.listdir(self._commands_dir):
                if _is_command_file(filename) and filename[:-3] not in rv:
                    rv.append(filename[:-3])
            rv.sort()
        return rv
134127
public static Map<String, Command> loadCommands() {
    return CommandUtils.loadCommands(ExtensionsShell.class.getPackage().getName(), null, null);
  }
662780
private List<String> buildCommand() {
        List<String> command = new ArrayList<String>();
        command.add(cmd);
        command.add("thin");
        command.add("--sourceAppPath=" + getSourceAppPath());
        command.add("--targetLibCachePath=" + getTargetLibCachePath());
        command.add("--targetThinAppPath=" + getTargetThinAppPath());
        if (getParentLibCachePath() != null) {
            command.add("--parentLibCachePath=" + getParentLibCachePath());
        }
        return command;
    }
1027757
public function getCommandsInOrder(): array
    {
        $commands = array_filter($this->commands);

        $order = [];

        $counter = 0;

        while (!empty($commands)) {
            ++$counter;

            if ($counter === 50) {
                throw new ImpossibleWriteOrderException(array_keys($commands));
            }

            foreach ($commands as $definition => $defCommands) {
                $dependencies = $this->hasDependencies($this->definitions[$definition], $commands);

                if (!empty($dependencies)) {
                    continue;
                }

                foreach ($defCommands as $command) {
                    $order[] = $command;
                }

                unset($commands[$definition]);
            }
        }

        return $order;
    }