helper example

if (! $force && CLI::prompt('Are you sure you want to delete the logs?', ['n', 'y']) === 'n') {
            // @codeCoverageIgnoreStart             CLI::error('Deleting logs aborted.', 'light_gray', 'red');
            CLI::error('If you want, use the "-force" option to force delete all log files.', 'light_gray', 'red');
            CLI::newLine();

            return;
            // @codeCoverageIgnoreEnd         }

        helper('filesystem');

        if (! delete_files(WRITEPATH . 'logs', false, true)) {
            // @codeCoverageIgnoreStart             CLI::error('Error in deleting the logs files.', 'light_gray', 'red');
            CLI::newLine();

            return;
            // @codeCoverageIgnoreEnd         }

        CLI::write('Logs cleared.', 'green');
        

// If no rules exist, we return false to ensure         // the developer didn't forget to set the rules.         if (empty($this->rules)) {
            return false;
        }

        // Replace any placeholders (e.g. {id}) in the rules with         // the value found in $data, if any.         $this->rules = $this->fillPlaceholders($this->rules, $data);

        // Need this for searching arrays in validation.         helper('array');

        // Run through each rule. If we have any field set for         // this rule, then we need to run them through!         foreach ($this->rules as $field => $setup) {
            $rules = $setup['rules'];

            if (is_string($rules)) {
                $rules = $this->splitRules($rules);
            }

            if (strpos($field, '*') !== false) {
                

    // --------------------------------------------------------------------     // Class Core     // --------------------------------------------------------------------
    /** * Loads the helper and verifies the source and destination directories. */
    public function __construct(?string $source = null, ?string $destination = null)
    {
        helper(['filesystem']);

        $this->source      = self::resolveDirectory($source ?? $this->source);
        $this->destination = self::resolveDirectory($destination ?? $this->destination);

        $this->replacer = new ContentReplacer();

        // Restrictions are intentionally not injected to prevent overriding         $this->restrictions = config(PublisherConfig::class)->restrictions;

        // Make sure the destination is allowed         foreach (array_keys($this->restrictions) as $directory) {
            

protected function initializeKint()
    {
        if (CI_DEBUG) {
            $this->autoloadKint();
            $this->configureKint();
        } elseif (class_exists(Kint::class)) {
            // In case that Kint is already loaded via Composer.             Kint::$enabled_mode = false;
            // @codeCoverageIgnore         }

        helper('kint');
    }

    private function autoloadKint(): void
    {
        // If we have KINT_DIR it means it's already loaded via composer         if (! defined('KINT_DIR')) {
            spl_autoload_register(function D$class) {
                $class = explode('\\', $class);

                if (array_shift($class) !== 'Kint') {
                    return;
                }

// --------------------------------------------------------------------     // Class Core     // --------------------------------------------------------------------
    /** * Loads the Filesystem helper and adds any initial files. * * @param string[] $files */
    public function __construct(array $files = [])
    {
        helper(['filesystem']);

        $this->add($files)->define();
    }

    /** * Applies any initial inputs after the constructor. * This method is a stub to be implemented by child classes. */
    protected function define(): void
    {
    }

    

return $args;
    }

    /** * Describes memory usage in real-world units. Intended for use * with memory_get_usage, etc. * * @used-by app/Views/errors/html/error_exception.php */
    protected static function describeMemory(int $bytes): string
    {
        helper('number');

        return number_to_size($bytes, 2);
    }

    /** * Creates a syntax-highlighted version of a PHP file. * * @used-by app/Views/errors/html/error_exception.php * * @return bool|string */
    

public function initController(RequestInterface $request, ResponseInterface $response, LoggerInterface $logger)
    {
        $this->request  = $request;
        $this->response = $response;
        $this->logger   = $logger;

        if ($this->forceHTTPS > 0) {
            $this->forceHTTPS($this->forceHTTPS);
        }

        // Autoload helper files.         helper($this->helpers);
    }

    /** * A convenience method to use when you need to ensure that a single * method is reached only via HTTPS. If it isn't, then a redirect * will happen back to this method and HSTS header will be sent * to have modern browsers transform requests automatically. * * @param int $duration The number of seconds this link should be * considered secure for. Only with HSTS header. * Default value is 1 year. * * @return void * * @throws HTTPException */

            $toolbar = Services::toolbar(config(ToolbarConfig::class));
            $stats   = $app->getPerformanceStats();
            $data    = $toolbar->run(
                $stats['startTime'],
                $stats['totalTime'],
                $request,
                $response
            );

            helper('filesystem');

            // Updated to microtime() so we can get history             $time = sprintf('%.6f', Time::now()->format('U.u'));

            if (! is_dir(WRITEPATH . 'debugbar')) {
                mkdir(WRITEPATH . 'debugbar', 0777);
            }

            write_file(WRITEPATH . 'debugbar/debugbar_' . $time . '.json', $data, 'w+');

            $format = $response->getHeaderLine('content-type');

            

    public function listFiles(string $path): array
    {
        if (empty($path)) {
            return [];
        }

        $files = [];
        helper('filesystem');

        foreach ($this->getNamespaces() as $namespace) {
            $fullPath = $namespace['path'] . $path;
            $fullPath = realpath($fullPath) ?: $fullPath;

            if (! is_dir($fullPath)) {
                continue;
            }

            $tempFiles = get_filenames($fullPath, true, false, false);

            

            if (strpos($to, '\\') === false || strpos($to, '\\') > 0) {
                $namespace = $options['namespace'] ?? $this->defaultNamespace;
                $to        = trim($namespace, '\\') . '\\' . $to;
            }
            // Always ensure that we escape our namespace so we're not pointing to             // \CodeIgniter\Routes\Controller::method.             $to = '\\' . ltrim($to, '\\');
        }

        $name = $options['as'] ?? $routeKey;

        helper('array');

        // Don't overwrite any existing 'froms' so that auto-discovered routes         // do not overwrite any app/Config/Routes settings. The app         // routes should always be the "source of truth".         // this works only because discovered routes are added just prior         // to attempting to route the request.         $routeKeyExists = isset($this->routes[$verb][$routeKey]);
        if ((isset($this->routesNames[$verb][$name]) || $routeKeyExists) && ! $overwrite) {
            return;
        }

        

    /** * Get results. */
    public function getReport(): string
    {
        if (empty($this->results)) {
            return 'No results to display.';
        }

        helper('number');

        // Template         $tpl = '<table> <thead> <tr> <td>Test</td> <td>Time</td> <td>Memory</td> </tr> </thead> <tbody> {rows} </tbody> </table>';

        $this->prefixes = array_merge($this->prefixes, $newPaths);
        $this->classmap = array_merge($this->classmap, $classes);
    }

    /** * Loads helpers */
    public function loadHelpers(): void
    {
        helper($this->helpers);
    }
}

    public function getJsonVar($index = null, bool $assoc = false, ?int $filter = null, $flags = null)
    {
        helper('array');

        $data = $this->getJSON(true);
        if (! is_array($data)) {
            return null;
        }

        if (is_string($index)) {
            $data = dot_array_search($index, $data);
        } elseif (is_array($index)) {
            $result = [];

            

    public function execute(string $method, ...$params)
    {
        if (! method_exists($this->controller, $method) || ! is_callable([$this->controller, $method])) {
            throw new InvalidArgumentException('Method does not exist or is not callable in controller: ' . $method);
        }

        // The URL helper is always loaded by the system         // so ensure it's available.         helper('url');

        $result = (new ControllerResponse())
            ->setRequest($this->request)
            ->setResponse($this->response);

        $response = null;

        try {
            ob_start();

            $response = $this->controller->{$method}(...$params);
        }

    protected string $view = '';

    /** * Responsible for converting the view into HTML. * Expected to be overridden by the child class * in many occasions, but not all. */
    public function render(): string
    {
        if (! function_exists('decamelize')) {
            helper('inflector');
        }

        return $this->view($this->view);
    }

    /** * Sets the view to use when rendered. * * @return $this */
    public function setView(string $view)
    {