Handles a Composer 'post-create-project-cmd' script event.

@return void
349921
public function onPostCreateProject()
    {
        // Initialise:
        
        $data = [];
        
        // Output Header:
        
        $this->header($this->getConfig('text-header'));
        
        // Obtain App Name:
        
        $data['app-name'] = $this->ask(
            'App name',
            $this->getConfig('default-name'),
            $data
        );
        
        // Obtain Locale:
        
        $data['locale'] = $this->ask(
            'Default locale',
            $this->getConfig('default-locale'),
            $data
        );
        
        // Obtain Database Name:
        
        $data['database'] = $this->ask(
            'Database name',
            $this->getConfig('default-database'),
            $data
        );
        
        // Obtain Vendor:
        
        $data['vendor'] = $this->ask(
            'Vendor',
            $this->getConfig('default-vendor'),
            $data
        );
        
        // Obtain Author Name:
        
        $data['author-name'] = $this->ask(
            'Author name',
            $this->getConfig('default-author-name'),
            $data
        );
        
        // Obtain Author Email:
        
        $data['author-email'] = $this->ask(
            'Author email',
            $this->getConfig('default-author-email'),
            $data
        );
        
        // Obtain Author Company:
        
        $data['author-company'] = $this->ask(
            'Author company',
            $this->getConfig('default-author-company'),
            $data
        );
        
        // Obtain Author Homepage:
        
        $data['author-homepage'] = $this->ask(
            'Author homepage',
            $this->getConfig('default-author-homepage'),
            $data
        );
        
        // Obtain Repository Name:
        
        $data['repo-name'] = $this->ask(
            'Repository name',
            $this->getConfig('default-repo-name'),
            $data
        );
        
        // Obtain Repository URL:
        
        $data['repo-url'] = $this->ask(
            'Repository URL',
            $this->getConfig('default-repo-url'),
            $data
        );
        
        // Obtain Project Link:
        
        $data['project-link'] = $this->ask(
            'Project link',
            $this->getConfig('default-project-link'),
            $data
        );
        
        // Obtain License Name:
        
        $data['license-name'] = $this->ask(
            'License name',
            $this->getConfig('default-license-name'),
            $data
        );
        
        // Obtain License Link:
        
        $data['license-link'] = $this->ask(
            'License link',
            $this->getConfig('default-license-link'),
            $data
        );
        
        // Obtain Repository Branches:
        
        $data['branch-staging'] = $this->ask(
            'Repository branch:staging',
            $this->getConfig('default-branch-staging'),
            $data
        );
        
        $data['branch-production'] = $this->ask(
            'Repository branch:production',
            $this->getConfig('default-branch-production'),
            $data
        );
        
        // Obtain User Names:
        
        $data['user-staging'] = $this->ask(
            'User name:staging',
            $this->getConfig('default-user'),
            $data
        );
        
        $data['user-production'] = $this->ask(
            'User name:production',
            $this->getConfig('default-user'),
            $data
        );
        
        // Obtain Host Names:
        
        $data['host-staging'] = $this->ask(
            'Host name:staging',
            $this->getConfig('default-host-staging'),
            $data
        );
        
        $data['host-production'] = $this->ask(
            'Host name:production',
            $this->getConfig('default-host-production'),
            $data
        );
        
        // Obtain Deployment Paths:
        
        $data['path-staging'] = $this->ask(
            'Deployment path:staging',
            $this->getConfig('default-path-staging'),
            $data
        );
        
        $data['path-production'] = $this->ask(
            'Deployment path:production',
            $this->getConfig('default-path-production'),
            $data
        );
        
        // Obtain App Namespace:
        
        $data['app-namespace'] = $this->ask(
            'App namespace',
            $this->getConfig('default-app-namespace'),
            $data
        );
        
        // Obtain App Title and Tagline:
        
        $data['app-title'] = $this->ask(
            'App title',
            $this->getConfig('default-app-title'),
            $data
        );
        
        $data['app-tagline'] = $this->ask(
            'App tagline',
            $this->getConfig('default-app-tagline'),
            $data
        );
        
        // Define Year:
        
        $data['year'] = date('Y');
        
        // Write Namespace and Data:
        
        $result = false;
        
        if ($this->writeNamespace($data['app-namespace'], $this->getConfig('namespace-files'))) {
            $result = $this->writeData($data, $this->getConfig('files'));
        }
        
        // Handle Installation Result:
        
        if ($result) {
            
            // Report Success:
            
            $this->io()->write(
                $this->color(
                    $this->getConfig('text-install-success'),
                    $this->getConfig('fg-success')
                )
            );
            
        } else {
            
            // Report Failure:
            
            $this->io()->write(
                $this->color(
                    $this->getConfig('text-install-failure'),
                    $this->getConfig('fg-failure')
                )
            );
            
        }
    }
1345179
public function onCommand(CommandEvent $event)
    {
        switch ($event->getCommandName()) {
            case 'dump-autoload':
                $_this = new DumpAutoloadEventHandler(
                    $this->__installer->getComposer()->getPackage(),
                    $this->__installer->getComposer()
                );
                break;
            default: break;
        }
    }
69053
public function handle(): void
    {
        $name = $this->getNameInput();

        $path = app_path($name);

        // First we will check to see if the class already exists. If it does, we don't want
        // to create the class and overwrite the user's code. So, we will bail out so the
        // code is untouched. Otherwise, we will continue generating this class' files.
        if ($this->files->exists($path)) {
            $this->error($this->type.' already exists!');

            return;
        }

        // Next, we will generate the path to the location where this class' file should get
        // written. Then, we will build the class and make the proper replacements on the
        // stub files so that it gets the correctly formatted namespace and class name.
        $stubs = __DIR__.'/../../../resources/stubs/module';
        $this->processStubs($stubs, $path);
        $this->generateSamples();

        $this->info($this->type.' created successfully.');
    }
614672
public function handle()
    {
        // It's possible for the developer to specify the tables to modify in this
        // schema operation. The developer may also specify if this table needs
        // to be freshly created so we can create the appropriate migrations.
        $name = trim($this->input->getArgument('name'));

        $table = $this->input->getOption('table');
        $content = $this->input->getArgument('content');
        $create = $this->input->getOption('create') ?: false;

        // If no table was given as an option but a create option is given then we
        // will use the "create" option as the table name. This allows the devs
        // to pass a table name into this option as a short-cut for creating.
        if (! $table && is_string($create)) {
            $table = $create;

            $create = true;
        }

        // Now we are ready to write the migration out to disk. Once we've written
        // the migration out, we will dump-autoload for the entire framework to
        // make sure that the migrations are registered by the class loaders.
        $this->writeMigration($name, $table, $create,$content);

        $this->composer->dumpAutoloads();
    }
1159702
public function handle()
    {
        // Next, we will check to see if a path option has been defined. If it has
        // we will use the path relative to the root of this installation folder
        // so that migrations may be run for any path within the applications.
        $this->migrator->run($this->getMigrationPaths(), []);

        // Once the migrator has run we will grab the note output and send it out to
        // the console screen, since the migrator itself functions without having
        // any instances of the OutputInterface contract passed into the class.
        foreach ($this->migrator->getNotes() as $note) {
            $this->output->writeln($note);
        }
    }
100217
public function handle()
    {
        // setup
        $this->setSettings();
        $this->getResourceName($this->getUrl(false));

        // check the path where to create and save file
        $path = $this->getPath('');
        if ($this->files->exists($path) && $this->optionForce() === false) {
            return $this->error($this->type . ' already exists!');
        }

        // make all the directories
        $this->makeDirectory($path);

        // build file and save it at location
        $this->files->put($path, $this->buildClass($this->argumentName()));

        // output to console
        $this->info(ucfirst($this->option('type')) . ' created successfully.');
        $this->info('- ' . $path);

        // if we need to run "composer dump-autoload"
        if ($this->settings['dump_autoload'] === true) {
            if ($this->confirm("Run 'composer dump-autoload'?")) {
                $this->composer->dumpAutoloads();
            }
        }
    }
693963
public function handle()
    {
        // generate command class
        $commandName  = $this->input->getArgument('name');

        $commandNamespace = $this->getNamespace('Commands', $commandName);

        $commandStubs = $this->filesystem->get(__DIR__.'/../stubs/MakeCommand.txt');
        $commandStubs = str_replace([ 'dummyCommandName', 'dummyNamespace', '\\\\' ], [ basename($commandName), $commandNamespace, '\\' ], $commandStubs);

        if(!file_exists($filename = app_path() ."/Commands/{$commandName}Command.php")) {
            $this->filesystem->create($filename, $commandStubs);
            $this->info("{$commandName} command has been created successfully.");
        } else {
            $this->info("{$commandName} command already exists.");
        }

        // generate command handler class
        $commandHandlerNamespace = $this->getNamespace('Handlers', $commandName);
        $commandClassName = basename($commandName);
        $commandHandlerUse = "{$commandNamespace}\\{$commandClassName}";

        $commandHandlerStubs = $this->filesystem->get(__DIR__.'/../stubs/MakeCommand-handler.txt');
        $commandHandlerStubs = str_replace(
            [ 'dummyCommandName', 'dummyNamespace', 'dummyUse', '\\\\' ],
            [ basename($commandName), $commandHandlerNamespace, $commandHandlerUse, '\\' ], $commandHandlerStubs
        );

        if(!file_exists($filename = app_path() ."/Handlers/{$commandName}CommandHandler.php")) {
            $this->filesystem->create($filename, $commandHandlerStubs);
            $this->info("{$commandName} handler has been created successfully.");
        } else {
            $this->info("{$commandName} handler already exists.");
        }
    }
703427
public function handle()
    {

        if ( ! $this->confirm("Are you sure you want to run the analysis tool? This tool will make modifications to the template storage.".PHP_EOL."While it is intended to clean up the template storage, it could potentially fail. [yes|no]", false))
        {
            $this->comment('Analysis aborted by user');
            return;
        }

        $this->info('Starting analysis of template store...');
        $this->line('Store located at ' . $this->templateStorageEngine->getStoragePath());
        $vendors      = $this->templateStorageEngine->getInstalledVendors();
        $packages     = $this->templateStorageEngine->getInstalledPackages(true);
        $packageCount = 0;
        foreach ($packages as $package) {
            $packageCount += count($package['packages']);
        }
        $this->line('Found ' . count($vendors) . ' vendors and ' . $packageCount . ' packages...');


        $this->comment(PHP_EOL . 'Searching for failed update processes...');
        $failedUpdateProcesses     = [];
        $garbagePackageDirectories = [];

        foreach ($packages as $vp) {
            foreach ($vp['packages'] as $package) {
                if (Str::endsWith($package['path'], '_{updating_in_progress}')) {
                    $garbagePackageDirectories[] = $package;
                    $this->line('Identified package as possible garbage ' . $package['path']);
                } else {
                    if ($this->files->exists($package['path'] . DIRECTORY_SEPARATOR . '_newup_update_initiated')) {
                        $failedUpdateProcesses[] = $package;
                        $this->line('Identified failed package update process ' . $package['path']);
                    }
                }
            }
        }

        $this->line('Found ' . count($failedUpdateProcesses) . ' failed update processes');
        $this->line('Found ' . count($garbagePackageDirectories) . ' update directories ready for cleanup');

        $this->comment(PHP_EOL . 'Analyzing search results...');
        $recoverablePackages    = [];
        $nonRecoverablePackages = [];

        foreach ($failedUpdateProcesses as $failedUpdate) {
            if ($this->files->exists($failedUpdate['path'] . '_{updating_in_progress}')) {
                $this->line('Identified package as recoverable '.$failedUpdate['path']);
                $recoverablePackages[] = $failedUpdate;
            } else {
                $this->line('Identified a non-recoverable package '.$failedUpdate['path']);
                $nonRecoverablePackages[] = $failedUpdate;
            }
        }

        $this->line('Found '.count($recoverablePackages).' recoverable failed update processes');
        $this->line('Found '.count($nonRecoverablePackages).' non-recoverable failed update processes');

        $this->comment(PHP_EOL.'Cleaning up non-recoverable update processes...');
        if (count($nonRecoverablePackages) > 0) {
            foreach ($nonRecoverablePackages as $nonRecoverablePackage) {
                $this->files->deleteDirectory($nonRecoverablePackage['path'], false);
                $this->line('Cleaning up directory '.$nonRecoverablePackage['path']);
            }
        } else {
            $this->line('Nothing to clean up');
        }


        $this->comment(PHP_EOL.'Cleaning up failed update processes...');
        if (count($garbagePackageDirectories) > 0 ) {
            foreach ($garbagePackageDirectories as $garbage) {
                $originalPackagePath = $garbage['path'];
                $originalPackagePath = str_replace('_{updating_in_progress}', '', $originalPackagePath);

                if ($this->files->exists($originalPackagePath)) {
                    if ($this->files->exists($originalPackagePath.DIRECTORY_SEPARATOR.'_newup_update_initiated')) {
                        $this->comment('Recovering failed update process for '.$originalPackagePath);
                        $this->line('Removing failed update files at '.$originalPackagePath);
                        $this->files->deleteDirectory($originalPackagePath);
                        $this->line('Recovering files...');
                        $this->files->copyDirectory($garbage['path'], $originalPackagePath);
                        if ($this->files->exists($originalPackagePath)) {
                            $this->info('Recovered files at '.$originalPackagePath);
                        } else {
                            $this->error('Could not recover files at '.$originalPackagePath);
                        }
                        $this->line('Cleaning up garbage files at '.$garbage['path']);
                        $this->files->deleteDirectory($garbage['path']);
                    } else {
                        // Original package path does not exist, remove trash.
                        $this->line('Removing garbage '.$garbage['path'].' because '.$originalPackagePath.' no longer exists');
                        $this->files->deleteDirectory($garbage['path']);
                    }
                } else {
                    // Original package path does not exist, remove trash.
                    $this->line('Removing garbage '.$garbage['path'].' because '.$originalPackagePath.' no longer exists');
                    $this->files->deleteDirectory($garbage['path']);
                }
            }
        } else {
            $this->line('Nothing to clean up');
        }

        $this->comment(PHP_EOL.'Analysis complete');

    }
353521
public function handle()
    {
        $wasUpdated = $this->composer->selfUpdate();

        if ($wasUpdated) {
            $this->info('Composer was updated');
            $this->comment($this->composer->getVersion());
        } else {
            $this->comment('Composer is already up to date');
        }

    }
582021
public function handle()
    {
        parent::handle();

        $viewGenerator = new ViewGenerator($this->commandData);
        $viewGenerator->generate();

        $this->performPostActions();
    }
909964
public function execute()
    {
        $composerLocation = $this->phpci->findBinary(array('composer', 'composer.phar'));

        $cmd = '';

        if (IS_WIN) {
            $cmd = 'php ';
        }

        $cmd .= $composerLocation . ' --no-ansi --no-interaction ';

        if ($this->preferDist) {
            $this->phpci->log('Using --prefer-dist flag');
            $cmd .= ' --prefer-dist';
        }

        if ($this->preferSource) {
            $this->phpci->log('Using --prefer-source flag');
            $cmd .= ' --prefer-source';
        }

        if ($this->nodev) {
            $this->phpci->log('Using --no-dev flag');
            $cmd .= ' --no-dev';
        }

        $cmd .= ' --working-dir="%s" %s';

        return $this->phpci->executeCommand($cmd, $this->directory, $this->action);
    }
289573
public function handle()
    {
        $name = explode('/', $this->argument('name'));
        $p_name = $name[1];
        $name = $name[0] . '/' . $name[1];
        $path = $this->option('path') ? base_path($this->option('path')) : base_path(config('bootpack.base_path'));
        $path = $path . '/' . $name;

        $this->logo('By Èrik Campobadal - erik.cat');

        $this->comment('The package root will be: ' . $path);
        if ($this->confirm('The package creation is going to start, type yes to begin', 'yes')) {
            if (!is_dir($path)) {
                $this->comment('Creating the root folder...');
                mkdir($path, 0777, true);
                $this->info("Project root created at: {$path}");
                $this->comment('Collecting package information...');

                $package = $this->package($name);

                $this->comment('Great, confirm the following data before we go ahead!');

                $this->table(array_keys(get_object_vars($package)), [get_object_vars($package)]);

                while (!$this->confirm('Everything looks cool?', 'yes')) {
                    $this->comment('Woah! Let me ask you everything again!');

                    $package = $this->package($name);

                    $this->comment('Great, confirm the following data before we go ahead!');

                    $this->table(array_keys(get_object_vars($package)), [get_object_vars($package)]);
                };

                $this->comment('Fantastic! Let me create the composer.json for you...');

                file_put_contents($path . '/composer.json', $package->json());

                $this->info("The package configuration has been saved in " . $path . '/composer.json');

                $this->comment('Woah, this is getting dirty, lets create the package structure');

                Helpers::copyDir(__DIR__ . '/../Source', $path . '/src');

                $this->info('Package structure created');

                $this->comment("Things are going fast artisan, let's add your package information into them");

                Helpers::massStrReplaceFile('{{ NAMESPACE }}', $package->namespace, $path);
                Helpers::massStrReplaceFile('{{ NAME }}', $p_name, $path);
                Helpers::massStrReplaceFile('{{ UCNAME }}', ucfirst($p_name), $path);

                rename(
                    $path . '/src/Config/config.php',
                    $path . '/src/Config/' . $p_name . '.php'
                );
                rename(
                    $path . '/src/ServiceProvider.php',
                    $path . '/src/' . ucfirst($p_name) . 'ServiceProvider.php'
                );
                rename(
                    $path . '/src/Controllers/Controller.php',
                    $path . '/src/Controllers/' . ucfirst($p_name) . 'Controller.php'
                );
                rename(
                    $path . '/src/Commands/Command.php',
                    $path . '/src/Commands/' . ucfirst($p_name) . 'Command.php'
                );
                rename(
                    $path . '/src/Middleware/Middleware.php',
                    $path . '/src/Middleware/' . ucfirst($p_name) . 'Middleware.php'
                );
                rename(
                    $path . '/src/Migrations/2017_08_11_171401_create_some_table.php',
                    $path . '/src/Migrations/2017_08_11_171401_create_' . ucfirst($p_name) . '_table.php'
                );
                rename(
                    $path . '/src/Contracts/Contract.php',
                    $path . '/src/Contracts/' . ucfirst($p_name) . 'Contract.php'
                );
                rename(
                    $path . '/src/Classes/Class.php',
                    $path . '/src/Classes/' . ucfirst($p_name) . 'Class.php'
                );

                $this->info('Yey! The package structure is ready for action!');
                $this->comment('Hey we are almost done with this! Let me add the class loader to the current composer project...');

                $l_composer = json_decode(file_get_contents(base_path('composer.json')), true);
                $l_composer['autoload']['psr-4'][$package->namespace.'\\'] = str_replace(base_path().'/', '', $path).'/src';
                file_put_contents(
                    base_path('composer.json'),
                    json_encode($l_composer, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)
                );

                $this->info('Your main composer.json file has been updated.');
                $this->comment('Seems like the only thing left is to dump the composer autoload...');
                if ($this->confirm('Do you want to dump composer auto-load?', 'yes')) {
                    if ($this->confirm('Do you have composer command in your path?', 'yes')) {
                        print shell_exec('cd ' . base_path() . ' && composer dump-autoload');
                    } else {
                        if ($this->confirm('Do you want me to try using the downloaded binary?', 'yes')) {
                            $c_path = base_path('vendor/composer/composer/bin/composer');
                            print shell_exec('cd ' . base_path() . ' && ' . $c_path . ' dump-autoload');
                        } else {
                            $c_path = $this->ask('Please specify the full composer executable file path');
                            print shell_exec('cd ' . base_path() . ' && ' . $c_path . ' dump-autoload');
                        }
                    }
                    $this->table(['namespace', 'path'], [[
                        'namespace' => $package->namespace,
                        'path' => str_replace(base_path() . '/', '', $path)
                    ]]);
                } else {
                    $this->line('Skipping the composer dump autoload...');
                    $this->line('Pleae manually dump the autoload: composer dump-autoload');
                }

                if ($this->confirm('Do you want to create README.md?', 'yes')) {
                    $this->comment('Creating README.md...');

                    $readme = fopen("$path/README.md", "w");
                    fwrite($readme, "# $package->name\n\n$package->description");
                    fclose($readme);

                    $this->info('Very cool! The README.md has been created!');
                } else {
                    $this->line('Skipping the creation of README.md...');
                }

                $this->comment('Searching for license File...');

                $licenses = scandir(__DIR__ . '/../Licenses');

                if (in_array($package->license, $licenses)) {
                    copy(__DIR__ . "/../Licenses/$package->license", "$path/LICENSE");
                    Helpers::strReplaceFile('{{ YEAR }}', date('Y'), "$path/LICENSE");
                    Helpers::strReplaceFile('{{ AUTHOR }}', $package->author, "$path/LICENSE");
                    $this->info('Nice! The LICENSE file is ready!');
                } else {
                    $this->error("Whoops! The License of your package is unknown for Bootpack so cannot be created automatically");
                }


                if ($this->confirm('Do you want to continue? Make sure the auto-load was dumped', 'yes')) {
                    $this->comment('Registering the service provider in the current laravel application...');

                    Helpers::strReplaceFile(
                        'App\\Providers\\RouteServiceProvider::class,',
                        "App\\Providers\\RouteServiceProvider::class,\n\t\t"
                        . $package->namespace . "\\" . ucfirst($p_name) . 'ServiceProvider::class,',
                        base_path('config/app.php')
                    );

                    $this->info('Very cool! The service provider is registered!');

                    if ($this->confirm('Feeling like creating the git repository as well?', 'yes')) {
                        if ($this->confirm('Do you have git command in your path?', 'yes')) {
                            print shell_exec('cd ' . $path . ' && git init');
                        } else {
                            $g_path = $this->ask('Please specify the full git executable file path');
                            print shell_exec('cd ' . $path . ' && ' . $g_path . '  init');
                        }
                    }

                    $this->line('');
                    $this->logo('Please donate if you found this usefull');
                    $this->info('Congratulations! Your package is created, configured and ready to be coded :)');
                    $this->line('Package location: ' . $path);
                } else {
                    $this->line("Uhhh... Well... You'll need to dump the auto-load next time...");
                    $this->line("You'll also need to register the package service provider to the application before developing...");
                    $this->info('Aborted package extra steps...');
                    $this->line('Package location: ' . $path);
                }
            } else {
                $this->error("The folder '{$path}' already exists");
            }
        }
    }
288013
private function registerEventMakeCommand()
    {
        $this->app->bindShared('command.make.package.event', function ($app)
        {
            return new EventMakeCommand($app['files'], $app['packages']);
        });

        $this->commands('command.make.package.event');
    }
1171697
public function run() {

        
        
        // Create a new project
        if (Console::getArg('--create')) {
            $this->createProject(Console::getArg('--create'));
            return;
        // Initialize the current workspace    
        } elseif (Console::getArg('--init')) {
            $this->initProject();
            return;
        // Run a command from an application    
        } elseif (Console::getArg('--run')) {
            $this->runAction(Console::getArg('--run'), json_decode(Console::getArg('--data', '[]'), true));
            return;
        } else {        
            $this->help();
        }
    }
1043246
def handle_event(self, event):
        """"""
        if event.get('command'):
            if event['command'] == 'on':
                cmd = 'off'
            else:
                cmd = 'on'

            task = self.send_command_ack(event['id'], cmd)
            self.loop.create_task(task)
549862
public function handleAddDir(): void
	{
		if ($this->presenter->isAjax() && $this->editable) {
			$files = $this->getFiles();
			$dirName = $this->generateName('newDir');
			mkdir($this->getFullPath($dirName));
			array_unshift($files, $this->rename($dirName));
			$this->template->files = $files;
			$this->redrawControl();
		} else {
			exit;
		}
	}
144523
public function handleUninstall(PackageEvent $event): void
    {
        if (!$this->enabled) {
            return;
        }

        $operation = $event->getOperation();
        if ($operation instanceof UninstallOperation) {
            $package = $operation->getPackage();
            if (in_array($package->getName(), $this->excluded)) {
                $this->io->write(sprintf('<info>Rikudou installer: Package %s ignored in composer settings</info>', $package->getName()));

                return;
            }
            $this->projectType = ProjectTypeGetter::get($this->composer);
            if (is_null($this->projectType)) {
                return;
            }
            $handler = new PackageHandler($package, $this->projectType, $this->composer);
            if ($handler->canBeHandled()) {
                $this->io->write('<comment>=== [Rikudou Installer] ===</comment>');
                foreach ($handler->handleUninstall() as $operationResult) {
                    foreach ($operationResult->getMessagesCollection()->getGenerator() as $message) {
                        if ($message->isStatusMessage() || $message->isWarningMessage()) {
                            $this->io->write($message->getMessage());
                        } else {
                            $this->io->writeError($message->getMessage());
                        }
                    }
                }
                $this->io->write('<comment>=== [Rikudou Installer] ===</comment>');
            }
        }
    }