@param OutputInterface $output

@return bool
180460
protected function clearSymfonyCache(OutputInterface $output)
    {
        $command   = $this->getApplication()->find('cache:clear');
        $arguments = [
            'command' => 'cache:clear',
        ];

        return $command->run(new ArrayInput($arguments), $output) === 0;
    }
239355
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->requireConfig();

        $output->writeln('Starting <fg=blue>Magallanes</>');
        $output->writeln('');

        $output->writeln(sprintf('<comment>%s</comment>', var_export($this->runtime->getConfiguration(), true)));

        $output->writeln('');
        $output->writeln('Finished <fg=blue>Magallanes</>');

        return 0;
    }
321991
protected function setOutput(OutputInterface $output)
    {
        switch (Config::get('lumos.terminal')) {
            case 'bash':
                $op = new bashOutput($output);
                break;
            case 'cmd':
                $op = new cmdOutput($output);
                break;
            default:
                $op = new bashOutput($output);
                break;
        }
        //
        $this->console = $op;
        $this->output = $op->output;
    }
685298
protected function process(OutputInterface $output, $class)
    {
        $reflection = new \ReflectionClass($class);
        if ($reflection->isAbstract()) {
            $output->writeln(sprintf(
                '<language>%s</language> is abstract, skipping...',
                $reflection->name
            ), OutputInterface::VERBOSITY_VERBOSE);
            return false;
        }

        if (!$reflection->isSubclassOf(Language::class)) {
            $output->writeln(sprintf(
                '<language>%s</language> is not Language, skipping...',
                $reflection->name
            ), OutputInterface::VERBOSITY_VERBOSE);
            return false;
        }

        if ($reflection->getMethod('getMetadata')->getDeclaringClass()->name !== $reflection->name) {
            $output->writeln(sprintf(
                '<language>%s</language>::<info>getAliases</info> is not declared, skipping...',
                $reflection->name
            ), OutputInterface::VERBOSITY_VERBOSE);
            return false;
        }

        $result = array_merge(
            [$reflection->name], // Class name
            array_replace(Language::getMetadata(), call_user_func([$reflection->name, 'getMetadata'])) // metadata with default values
        );
        $output->writeln(var_export($result, true), OutputInterface::VERBOSITY_VERBOSE);

        return $result;
    }
492864
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $organizationName = $input->getOption('organization');
        if (!$organizationName = $this->resolveOrganizationName($organizationName, $output)) {
            return -1;
        }

        $userid = $input->getArgument('user_id');

        $client = $this->clientProvider->getUserClient();
        $membership = $client->getMembership($userid, $organizationName);

        $output->writeln('Membership');
        $this->formatterHelper->outputOrganizationMembershipInfo($membership, $output);

        return 0;
    }
1313910
protected function isUpdateNeeded(InputInterface $input, OutputInterface $output)
    {
        if ('@warning_time@' !== Tenside::WARNING_TIME) {
            $commandName = '';
            if ($name = $this->getCommandName($input)) {
                try {
                    $commandName = $this->find($name)->getName();
                } catch (\InvalidArgumentException $e) {
                    // Swallow the exception.
                }
            }
            if ($commandName !== 'self-update' && $commandName !== 'selfupdate') {
                if (time() > Tenside::WARNING_TIME) {
                    $output->writeln(
                        sprintf(
                            '<warning>Warning: This development build is over 30 days old. ' .
                            'It is recommended to update it by running "%s self-update" to get the latest version.' .
                            '</warning>',
                            $_SERVER['PHP_SELF']
                        )
                    );

                    return true;
                }
            }
        }

        return false;
    }
1137936
protected function outputSkip(OutputInterface $output, $message = null)
    {
        $message = $message ?: 'No relevant files found to process, free pass!';
        $output->writeln('<info>'.$message.'</info>');

        return 0;
    }
437015
protected function set_cache( string $output ) : bool {
		return set_transient( $this->cache_key(), $output, $this->args['cache'] );
	}
584800
protected function execute(InputInterface $input, OutputInterface $output)
  {
    $results = Cache::flush();

    if ($results) return $output->writeln('<info>Cleared cache!</info>');

    return $output->writeln('Nothing to clear');
  }
491684
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->output = $output;
        $method = $this->method;
        $this->setHelperSet($this->getApplication()->getHelperSet());
        if ($this->argument != null) {
            $argument = $input->getArgument($this->argument);
            $this->$method($argument);

            return;
        }

        $this->$method($input,$output);
    }
1161057
protected function execute(Input $input, Output $output) {
        return $this->cmd->execute($input,$output,$this);
    }
274368
protected function hasOutput($output)
    {
        if (!empty($output)) {
            return true;
        }

        // Check for type first to avoid errors with objects/arrays/etc
        return ((is_string($output) || is_numeric($output)) && strlen($output) > 0);
    }
294624
public function run(InputInterface $input, OutputInterface $output): int
    {
        return $this->console->run($input, $output);
    }
42020
protected function reconcileInitialConfig(OutputInterface $output)
    {
        $this->step(++$this->step, 'Basic configuration');
        $settings = $this->displayConfigTable();
        $confirm = $this->io->confirm('Would you like to edit these now?', false);
        if ($confirm === false) {
            return true;
        }
        $command = $this->getApplication()->find('config:set');
        $buffer = $this->getBufferedOutput($output, OutputInterface::VERBOSITY_NORMAL);

        $siteName = $this->io->ask('Site name:', $settings['sitename']);
        $sitePayoff = $this->io->ask('Site payoff tag-line:', $settings['payoff']);
        $theme = $this->io->ask('Theme name:', $settings['theme'], function ($v) use ($settings) {
            $fs = $this->app['filesystem']->getFilesystem('themes');
            if ($fs->has($v)) {
                return $v;
            }
            $this->io->warning(sprintf('The theme directory "%s" was not found, reverting to "%s"', $v, $settings['theme']));

            return $settings['theme'];
        });
        $debug = $this->io->confirm('Enable debugging:', $settings['debug']);
        $settings = [
            'sitename' => $siteName,
            'payoff'   => $sitePayoff,
            'theme'    => $theme,
            'debug'    => $debug,
        ];
        foreach ($settings as $key => $value) {
            $input = new ArrayInput([
                '--no-interaction' => true,
                'key'              => $key,
                'value'            => $value,
            ]);

            $result = $command->run($input, $buffer);
            $this->writeBufferedOutput($buffer, $result);
        }

        $this->io->success('Settings updated!');
        $this->displayConfigTable();
        if ($debug) {
            $this->io->block('Do not forget to disable debugging for production', 'REMINDER', 'fg=yellow', ' ! ');
        }

        return true;
    }
1264419
public function execute(InputInterface $input, OutputInterface $output)
    {
        $filesystem = new Filesystem();
        $discouraged = RootDirectories::getDiscouraged();
        $found = [];

        foreach ($discouraged as $directory => $comment) {
            if ($filesystem->exists($directory) && is_dir($directory)) {
                $found[] = [$directory, $comment];
            }
        }

        if (count($found) == 0) {
            $output->writeln('<fg=green>No issues found.</fg=green>');

            return 0;
        }

        $output->writeln('The following issues where found:');

        $table = new Table($output);

        $table->setHeaders(['Directory', 'Comment']);
        $table->setRows($found);
        $table->render();

        return 1;
    }
1340384
protected function outputFixMessage(OutputInterface $output)
    {
        $output->writeln('');
        $output->writeln("<error>    Oh dear \xF0\x9F\x98\xA2     </error>");
        $output->writeln('');
        $output->writeln("<info>Sadly, not all checks went well</info>");
        $output->writeln('<info>But this is no reason to give up!</info>');
        $output->writeln('<info>Remember: This check was to verifiy if Gerrie is working to avoid unnecessary problems.</info>');
        $output->writeln("<info>So get up, grab a \xE2\x98\x95  and try to fix the failing checks.</info>");
        $output->writeln('');
        $output->writeln('<info>If you don`t know how to solve this "problem(s)":</info>');
        $output->writeln('<info>  * have a look at the documentation</info>');
        $output->writeln('<info>  * or open an issue on GitHub</info>');
        $output->writeln('');
        $output->writeln('<info>Do not be afraid. You can execute this check whenever you want.</info>');
        $output->writeln('<info>It is for free and breaks nothing :)</info>');
        $output->writeln("<info>So keep \xF0\x9F\x8E\xB8  and cu next time \xF0\x9F\x91\x8B</info>");
        $output->writeln('');
    }
608343
public function execute(InputInterface $input, OutputInterface $output)
    {
        if (empty($path = $input->getArgument('path'))) {
            $this->render($input, $output);
        } else {
            $this->test($input->getArgument('method'), $path, $input, $output);
        }

        return 0;
    }