Executes the command.

@param InputInterface  $input
@param OutputInterface $output
13327
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $src = $input->getArgument('src');
        $dst = $input->getArgument('dst');
        $selector = $input->getArgument('selector');
        $append = $input->getOption('append');

        // Create CSS dest object
        $dstCss = new \Sabberworm\CSS\Parser($append && file_exists($dst) ? file_get_contents($dst) : null);
        $dstCssDoc = $dstCss->parse();

        $finder = new Finder();
        $resources = $finder
                    ->files()
                    ->depth(0)
                    ->in($src)
                    ->name($selector.'.css');

        foreach ($resources as $res) {
            $output->writeln('CSS Found: '.$res->getRealPath());
            $css = new \Sabberworm\CSS\Parser(file_get_contents($res->getRealPath()));
            $cssDoc = $css->parse();
            foreach ($cssDoc->getContents() as $block) {
                if ($block instanceof \Sabberworm\CSS\RuleSet\DeclarationBlock) {
                    /* @var $ruleset \Sabberworm\CSS\RuleSet\DeclarationBlock */
                    // Keep only the root CSS (ignore media queries)
                    $keepRules = array();
                    foreach ($block->getRules() as $rule) {
                        /* @var $rule \Sabberworm\CSS\Rule\Rule */
                        $value = $rule->getValue();
                        if (is_object($value)) {
                            // keep only object with size rem
                            $keepValue = false;
                            switch (get_class($value)) {
                                case 'Sabberworm\CSS\Value\Size':
                                    /* @var $value \Sabberworm\CSS\Value\Size */
                                    if ('rem' == $value->getUnit()) {
                                        $value->setSize($value->getSize() * 10);
                                        $value->setUnit('px');
                                        $keepValue = true;
                                    }
                                    break;
                                case 'Sabberworm\CSS\Value\RuleValueList':
                                    /* @var $value \Sabberworm\CSS\Value\RuleValueList */
                                    foreach ($value->getListComponents() as $c) {
                                        if ($c instanceof \Sabberworm\CSS\Value\Size) {
                                            if ('rem' == $c->getUnit()) {
                                                $c->setSize($c->getSize() * 10);
                                                $c->setUnit('px');
                                                $keepValue = true;
                                            }
                                        }
                                    }
                                    break;
                            }
                            if ($keepValue) {
                                $keepRules[] = $rule;
                            }
                        }
                    }

                    if (count($keepRules)) {
                        $oItem = new \Sabberworm\CSS\RuleSet\DeclarationBlock();
                        $oItem->setSelectors($block->getSelectors());
                        foreach ($keepRules as $rule) {
                            $oItem->addRule($rule);
                        }

                        $dstCssDoc->append($oItem);
                    }
                }
            }
        }

        $output->writeln('Write '.$dst);
        file_put_contents($dst, $dstCssDoc->render(\Sabberworm\CSS\OutputFormat::createPretty()));
    }
853340
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->input = $input;
        $this->output = $output;

        $this->arguments = $input->getArguments();
        $this->options = $input->getOptions();
        $this->stub = $this->getStub();

        if ($this->stub) {
            $this
                ->replaceFrequency()
                ->replaceConstraint()
                ->replaceCommand()
                ->replacePath()
                ->replaceDescription()
            ;
        }

        if ($this->save()) {
            $output->writeln('<info>The task file generated successfully</info>');
        } else {
            $output->writeln('<comment>There was a problem when generating the file. Please check your command.</comment>');
        }
    }
34339
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->startCommand($output);

        $this
            ->currencyExchangeRatesPopulator
            ->populate($output);

        $this->finishCommand($output);
    }
24071
protected function execute(InputInterface $input, OutputInterface $output) : void
    {
        $io     = $this->getIO($input, $output);
        $config = $this->getConfig($input->getOption('configuration'));

        $configurator = new Creator($io, $config);
        $configurator->force($input->getOption('force'))
                     ->extend($input->getOption('extend'))
                     ->advanced($input->getOption('advanced'))
                     ->run();
    }
503861
public function execute(InputInterface $input, OutputInterface $output)
    {
        $this->output = $output;
        try {
            $this->doExecute($input, $output);
        } catch (\Exception $e) {
            $this->writeException($e);
        }
    }
153146
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $method = method_exists($this, 'process') ? 'process' : 'handle';

        return $this->{$method}();
    }
419662
public function execute(InputInterface $input, OutputInterface $output)
    {
        $argument = $input->getArgument($this->argumentName);
        $path = $this->basePath.'/'.$argument.'.php';

        if ($input->hasOption('restful') && $input->getOption('restful') == true) {
            $this->restful = true;
        } else {
            $this->restful = false;
        }

        $response = $this->runFileGeneratorCommand($path, $argument);

        if ($response === true) {
            $this->type ?: $this->type = 'Command';
            $output->writeln(ucfirst($this->type).' created successfully');

            return;
        }
        $output->writeln($response);
    }
983759
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->setIo($input, $output);

        $repo = $this->prepareRepository();

        $this->rebuild();

        $this->deployWithGit($repo);
    }
496129
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $created = $this->scaffold(
            'ajax',
            [
                'CLASSNAME' => $input->getArgument('name'),
            ],
            [
                'ACTION' => $input->getOption('action'),
            ]
        );

        if ($created === true) {
            $output->writeln("<info>{$input->getArgument('name')} was created successfully</info>");
        } else {
            $output->writeln("<error>{$input->getArgument('name')} could not be created</error>");
        }
    }
32411
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->init($input, $output);

        $this->force_prompt();
                
        $this->publish_packages($this->get_packages());
        
        // Feedback how many files were copied.
        if (\count($this->copied)) {
            $this->output->writeln(
                \sprintf(
                    "\n<info>Published %d %s successfully:\n%s</info>",
                    \count($this->copied),
                    _n('file', 'files', \count($this->copied)),
                    \implode($this->copied, "\n")
                )
            );
            exit;
        }
        
        $this->output->writeln("\n<info>Nothing needed to be published</info>");
    }
694970
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $files = $input->getArgument('files');
        $fileSuffix = ' -f ' . implode(' -f ', $files);

        $command = sprintf('%s stop -d', $fileSuffix);
        $response = $this->getFacade()->runDockerCompose($command);

        if ($output->isVerbose()) {
            $output->writeln($response);
        }
    }
1292311
public function execute(InputInterface $input, OutputInterface $output)
    {
        return $this->go(new Input($input), new Output($output));
    }
390096
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->initializeLicenser($input, $output);

        $sources = $input->getArgument('sources');

        $this->licenser->check($sources);
    }
863939
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $persistence = $this->getPersistence();
        $output->writeln(sprintf(
            'Pulling translations in %s',
            $persistence->getDirectoryName()
        ));

        $gitOutput = $persistence->pullTranslations();
        $output->writeln($gitOutput);

        $output->writeln('Done.');
    }
623294
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->output = $output;
        $outputFile = null;
        if ($file = $input->getOption('output-file')) {
            $outputFile = $file;
        }
        $this->service($input->getArgument($this->argument), $outputFile);
    }
828092
protected function execute(InputInterface $input, OutputInterface $output)
    {
        $this->input = $input;
        $this->addOption('--environment', '-e', InputArgument::OPTIONAL);
        $input->setOption('environment', getenv('RAD_ENVIRONMENT'));
        parent::execute($input, $output);
    }
1194065
public function execute(InputInterface $input, OutputInterface $output)
    {
        $host = $input->getArgument('host');

        $remove = $this->hostFile->remove($host);

        $output->writeLn("$host was removed from file.");
    }