<![CDATA[Millancore Blog]]>https://millancore.comRSS for NodeWed, 15 Apr 2026 17:26:15 GMT60<![CDATA[Search, Preview and Edit with Nvim]]>https://millancore.com/search-preview-and-edit-with-nvimhttps://millancore.com/search-preview-and-edit-with-nvimWed, 25 Mar 2026 09:43:38 GMTWhen working on the console, every millisecond counts; regardless of the tools used, the pursuit of efficiency is paramount. As a source of satisfaction, finding the best way to combine individual tools to achieve results leads us to explore new ways of working.

This small function was born from that impulse. The pattern is familiar: you search for something with ripgrep, scan through a wall of file:line:match output, copy a path, open it, jump to the line. Each step is trivial, but the repetition adds up. It breaks the flow.

So I connected three tools into a single gesture.

https://gist.github.com/millancore/20d26e7befdc58c7386e2060c9a07383

The flow

vrg <pattern> sends your search through ripgrep, then hands the results to fzf for interactive filtering. As you move through the list, bat renders a syntax-highlighted preview of each file, with the matching line marked. When you find what you are looking for, you press enter and neovim opens exactly where you need to be. If nothing is relevant, escape and move on. Nothing opens, nothing changes.

The whole loop, from thought to cursor on the right line, collapses into a few keystrokes.

Setup

Drop the function into your .bashrc or .zshrc and make sure the four dependencies are installed: ripgrep, fzf, bat, and neovim.

If you prefer a different editor, replace nvim "+\({line}" "\){file}" with the equivalent command. Most editors accept a +line or :line flag.

]]><![CDATA[PHP has a new Template Engine.]]>https://millancore.com/php-has-a-new-template-enginehttps://millancore.com/php-has-a-new-template-engineTue, 26 Aug 2025 13:46:19 GMTPesto is a traditional Italian sauce that originated in Genoa (Liguria region), It is also the place where a new template engine for PHP is being developed, seeking simplicity, minimal code, and full compatibility with HTML.

Pesto is a project with zero dependencies and in constant evolution, yuo can check it directly on Github.

composer require millancore/pesto

The first time you see the syntax, you know what's going to happen. It's expressive.

XSS Security

Pesto only uses one type to print PHP expressions {{ $variable }}, And all of them are escaped according to the context in which they are found, whether they are in a js block, css, html attribute or comment, it is able to determine what their context is and how it should escape the values to make them secure.

It is also possible to specify that we do not want to escape, thanks to filters. {{ $trust | raw }}

php-* Attributes

Very few attributes are actually used, but they are more than enough to build interfaces.

  • php-partial To incluide other views, this is use with php-with to pass data to partial view.

  • php-slot It is used to define the content of a slot (only named slots) defined in a partial view.

  • php-if php-elseif php-else simple condition

  •   <p php-if="$user->isAdmin()">Admin</p>
  <p php-elseif="$user->isModerator()">Moderator</p>
  <p php-else>Guest</p>

    php-foreach Iterate elements

  •   <li php-foreach="$list as $item">{{ $item }}</li>

The <template> Tag

We do not always want to include the HTML tag where we have defined the attribute. We can use the <template> tag, which allows us to organise the view in a better way, The template tag is not included in the final view.

<template php-foreach="$list as $item">
    <li>{{ $item }}</li>
</template>

View Composition

In Pesto, any view can be used as a partial, as many times as necessary. Simply define the slots that will have the content defined in the final view, Although the “| slot” filter is not mandatory, but provides a visual marker that defines it as a slot.

<!--- layouts/app.php -->
<!DOCTYPE html>
<html lang="en">
<head>
    <title>{{ $title }}</title>
</head>
<body>
    <header>{{ $header | slot }}</header>

    <main>{{ $main | slot }}</main>
</body>
</html>

View:

<!--- views/home.php -->
<template php-partial="layouts/app.php" php-with="['title' => 'Home']">

    <!-- Named slot -->
    <nav php-slot="header">
        <a href="/">Home</a>
        <a href="/about">About</a>
    </nav>

    <!--Main Slot -->
    <section>
        <h1>Home</h1>
        <p>Lorem ipsum dolor sit amet consectetur adipisicing elit. Quisquam, quae.</p>
    <section>
</template>

You can find installation instructions and more detailed usage notes in the repository.

https://github.com/millancore/pesto

Thanks

I will write several articles about pesto. I hope you enjoy them as much as I enjoyed building it.

]]><![CDATA[The Memory-Efficient Guide to Blazing Fast CSV Filtering with PHP]]>https://millancore.com/the-memory-efficient-guide-to-blazing-fast-csv-filtering-with-phphttps://millancore.com/the-memory-efficient-guide-to-blazing-fast-csv-filtering-with-phpMon, 25 Nov 2024 20:13:08 GMTWhen it comes to processing large CSV files, memory consumption can quickly become a bottleneck. Loading a 10-million-line CSV file into memory? That's a recipe for an out-of-memory error. But what if I told you that you could Filter such a file using just 2MB of RAM and process it in few seconds.

Before diving into performance testing, you'll need a substantial dataset. Here's how to generate a 10-million-line CSV using the Faker library

composer require fakerphp/faker

Generate dataset script whit Faker

Now that we have a dataset, we must start by reading it, the most efficient way is to use a Generator which is also an Iterator, this provide elegant approach to memory-efficient CSV processing. They're perfect for processing large datasets because they maintain their state between iterations without keeping the entire dataset in memory.

function readLines() : Generator
{
    $file = fopen(__DIR__.'/data.csv', 'r');

    while (($data = fgetcsv($file)) !== false) {
            yield Record::fromArray($data);
    }
    fclose($file);
}

Now the next key piece is Filters, PHP provides the built-in FilterIterator class, which efficiently implements the filtering logic while maintaining memory efficiency when working with large datasets.

lets create a some filters:

class AgeFilter extends FilterIterator {

    public function __construct(
        Iterator $iterator,
        private readonly int $age
    ) {
        parent::__construct($iterator);
    }

    public function accept(): bool
    {
        return $this->current()->age == $this->age;
    }
}

class GenderFilter extends FilterIterator {

    public function __construct(
        Iterator $iterator,
        private readonly string $gender
    ) {
        parent::__construct($iterator);
    }

    public function accept(): bool
    {
        return $this->current()->gender == $this->gender;
    }
}

Next, we need to create a filter chain to process the previous result. To simplify this task, we can leverage the PipelineFilterIterator library.

composer require millancore/pipeline-iterator

use Millancore\PipelineIterator\PipelineFilterIterator;

$iterator = PipelineFilterIterator::create(readLines())
    ->filter(GenderFilter::class, 'F')
    ->filter(AgeFilter::class, 30);

foreach($iterator as $item) {
   echo $item->name.PHP_EOL;
}

/**
* Records: 10.000.000
* File size: 227 MiB
* Time: 7.65 seconds
* Memory: 2 MB
*/

It's that simple! This approach ensures our filters are reusable, testable, and easily combinable to suit your needs.

Bonus

You can use built-in Filters as CallbackFilterIterator or RegexIterator

 # Regex filter names containing 'ana'
 ->filter(RegexIterator::class, '/ana/')

To use RegexIterator the class must implement __toString to apply the filter.

Thanks

]]><![CDATA[De PHP a GO Capitulo 3 - Arreglos y otras cosas!]]>https://millancore.com/de-php-a-go-capitulo-3-arreglos-y-otras-cosashttps://millancore.com/de-php-a-go-capitulo-3-arreglos-y-otras-cosasWed, 04 Mar 2020 16:32:11 GMTCapitulo Anterior: De PHP a GO Capitulo 2 - "Objetos"

El universo esta hecho de Arrays, después de el Hidrogeno los arreglos son el elemento mas abundante a donde quieras que mires.

Regresando a nuestro amando PHP donde los arreglos se definen con abundancia, soportando todo tipo de datos y en cantidades escandalosas, no nos viene mal aprender un poco de mesura y austeridad.

Y es que GO es ese padre que nos reprende en pro de disciplinarnos pero luego se apiada de nosotros y nos da formas mas sencillas de hacer las cosas.

Arrays

Como ya lo sospecharas, los arrays tiene un tamaño y un tipo definido, esto hace que se reserve en memoria solo una vez.

var names [3]string

Si no le asignamos un valor a la hora de definir un array todos sus elementos se inician el 0 en caso de ser numéricos, "" para string y false para booleanos.

Pero GO sabe de nuestro turbio pasado y que a lo mejor ponernos a contar cuantos elementos tiene nuestro arreglo hará que abandonemos todo, así que nos permite definirlo de una manera en la que él cuenta los elementos por nosotros (vagos!!).

names := [...]string{"esto", "es","el","colmo!"}

Pero no os emocionéis, siguen siendo inmutables!

Algo curioso con lo que nos podemos encontrar a la hora de crear arreglos con elemento de tipo String con mas de una palabra es que a la hora de imprimirlos no sabemos donde comienza o termina cada elemento.

names := [3]string{"Miguel Angel", "Picasso","Vincent van Gogh"}
fmt.Println(names)

[Miguel Angel Picasso Vincent van Gogh]

Esto se soluciona fácilmente haciendo una impresión con formato quote

fmt.Printf("%q", names)

Aqui las diferentes opciones de formato fmt

Slices

Y aquí viene nuestro padre bondadoso luego de vernos luchar infructuosamente con nuestra falta de detenimiento a pensar que a lo mejor los elementos que estamos almacenando no van a cambiar de tamaño.

Y es que los Slices nos permiten tener arreglos dinámicos en relación a su tamaño.

Pero antes de tomar la magia y hacernos fanáticos ciegamente, viene bien saber que los Slices son una envoltura de los arreglos y realmente no almacenan nuestros datos si no que hacen referencia a un Array.

Cuando nosotros cortamos un Array lo que estamos generando es un Slice (de ahí su definición) un arreglo lo podemos cortar de la siguiente manera.

numbers := [5]int{1,2,3,4,5}
sliceFromNumbers := numbers[0:3]

Para definir un Slice sin hacer un corte basta con que NO definamos el numero de elementos a contener.

names := []string{"Miguel Angel", "Picasso","Vincent van Gogh"}
names = append(names, "Salvador Dali")

Una buena practica es usar make de esa manera se puede iniciar un numero de elementos y/o definir el tamaño del Slice.

numbers := make([]int, 6, 18)

Y como no todo puede ser paz y armonía, una vez has agregado elementos a un Slice te preguntas instintivamente, ¿como se eliminan?, estarás confiando de que habrá algún método para hacerlo de manera simple y elegante, pero... No!!

Para quitar un elemento, se debe cortar los elementos antes de ese elemento, cortar los elementos después de ese elemento y a continuación, anexar estos dos nuevos Slices juntos sin el elemento que se desea quitar.

Asi como leiste! yo lo he apuntado en un papel para meditarlo cuando la vida se me complica y de alguna forma me da esperanza de que mis problemas cotidianos son mas triviales.

Si deseamos eliminar el elemento con indexe 2 lo que debemos hacer es lo siguiente.

names = append(names[:2], names[3:]...)

Si estas pensando hacer una función de borrado no os lo recomiendo, (yo también lo pensé) ya que tendrás que hacer una por cada tipo, solo déjalo ir, luego de un rato ya ni notas su extraña forma.

Maps

En GO también tenemos los arreglos asociativos de los que tanto hacemos uso en PHP solo que debemos de tener en cuenta que las claves y los valores solo pueden ser de un tipo cada una.

record := map[string]string{"status": "open", "type": "red"}

Y se puede acceder, modificar o agregar elementos de la mimas forma que los hacemos en PHP.

// Add
record["newKey"] = "newValue"

// Modify
record["status"] = "close"

//Use 
fmt.Println(record["type"])

Y para eliminar lo bueno es que ya estas preparado para formas únicas y novedosas de borrar elementos. 

delete(record, "type")

Jajajajaja! inesperado!! GO es una montaña rusa de emociones!

]]><![CDATA[De PHP a GO Capitulo 2 - "Objetos"]]>https://millancore.com/de-php-a-go-capitulo-2-objetoshttps://millancore.com/de-php-a-go-capitulo-2-objetosSun, 01 Mar 2020 17:12:56 GMTCapitulo Anterior: De PHP a GO - Comienzo

El viejo C tenia razón y es que a lo mejor no se necesitan los objectos tal y como los conocemos para hacer software robusto y por que muy dentro de nosotros sabíamos que en el paradigma orientado a objetos habían ciertos vacíos que los dejamos a la fe para no complicar mas las cosas.

En GO volvemos a las probadas estructuras, las estructuras son un tipo de datos (Si un tipo de datos!), que los permite crear una colección de campos con sus respectivos tipos.

Ya podes ir tirando por la ventana todo los sabias de orientación a objectos!! pero con cuidado que rescataremos un par de cosas.

Las estructuras son muy simples y sencillas de definir y dentro de sus campos pueden tener otras estructuras.

type User struct {
    id int
    firstName string
    lastName string
    age int
}

Y para instanciarlas

 juan := User{1, "Juan", "Millan", 30}

Ya que la creación de la estructura es muy similar a la de los objetos de Javascript yo prefiero por comodidad mental hacerlo con sus claves (y por que se ve mas bonito ñ_ñ).

juan := User{id: 1, firstName: "Juan", lastName: "Millan", age: 30}

Y para acceder a sus campos basta con hacer juan.firstName.

Y los métodos?

Conociendo las ansias ya se estarán preguntando por los métodos, pero no hay nada de que preocuparse GO nos permite crear métodos y vincularlos a las estructuras.

Los métodos se crean fuera de la estructura (no hay que complicar las cosas) y se vinculan con un receptor el receptor se ubica entre la palabra func y la definición de la función.

func ( u User) fullName() string {
    return u.firstName + " " + u.lastName
}

Como podemos ver antes de definir el nombre de nuestro método hemos agregado el receptor u User que vincula la función con la estructura.

Pero ojo al puntero! Jajajajaja

Punteros

El método anterior esta bien pero estamos pasando la estructura por valor y no por referencia por lo que si deseamos modificar algo de la estructura mediante un método necesitamos usar punteros.

Los puntero son una de las características mas poderosas de C que nos permiten llevar el lenguaje a puntos insospechados sobrepasando las barreras de tiempo y el espacio (sacando las referencias desde el registro de memoria).

GO implementa punteros en su definición mas simple, sin la aritmética de punteros ya que de hacerlo podríamos tirarnos por la ventana también!.

Si no has tenido la oportunidad de trabajar con punteros os los explicare de una manera simple.

cuando definimos una variable, estructura etc, para este elemento se crea una referencia en memoria y esta referencia la podemos almacenar en otra variable pero de tipo puntero.

Puede parecer confuso definir una variable de tipo puntero por que el tipo puntero solo es una referencia en memoria, pero puede ser una referencia en memoria de tipo entero, string, bool o strutc por ello a la hora de definirlo ponemos el tipo.

 var punteroInt *int
 var punteroUser *User

Supongamos que definimos la variable nombre := "Juan" en memoria tendrá la siguiente referencia 0xc0000120a0 nosotros podemos almacenar esa referencia en un puntero de la siguiente manera puntero = &nombre y luego si queremos modificar el valor de la variable nombre lo podemos hacer a través del puntero presidiendolo con un asterisco *puntero = "Esteban"

No os preocupes si no se comprende del todo al principio, el conocimiento ira filtrando las capas del cerebro hasta llegar al centro y allí sentirás la iluminación de los punteros.

Volviendo a los métodos de nuestra estructura creemos uno que si nos permita modificar lo valores de esta. 

func (p *User ) birthday()  {
     p.age ++
}

De esta manera cada vez que se llame el método juan.birthday() tendré un año mas!

Y ya me preguntaran y por que no usaste en el método *p.age ++ y.. GO sabrá como hacer sus cosas!, esto sucede por estamos accediendo a la propiedad age GO detecta automáticamente que se trata del elemento que hay detrás de la referencia en memoria.

Interfaces

Si hay algo que funciona perfectamente en el paradigma orientado a objetos son las interfaces esa capacidad de hacer las cosas modulares e intercambiables es sin lugar a dudas uno de los grandes aciertos.

En PHP una interfaz es un contrato que obliga a la clase que la implementa a cumplir con una serie de métodos, en muchas ocasiones nos hemos visto rellenar métodos vacíos solo para cumplir con un contrato ya que a lo mejor solo vamos a usar una de ellos en nuestra implementación.

En GO las interfaces no condicionan a las estructuras, de esa manera la modularidad es mucho mas amplia ya que cuando definimos un parámetro del tipo de una interfaz, a la hora de pasar el valor del parámetros se validara que cuente con los métodos definidos en la interfaz.

Por lo general las interfaces en GO se definen con la terminación "er" sin importar las raras combinaciones que se puedan llegar a dar.

type Executer interface {
      execute()
}

Una vez definida la interfaz solo basta con que vinculemos a la estructura un método con la misma firma.

type MyRequest struct {
    command func()
}

func (t MyRequest) execute() {
    t.command()
}

Y esta ya podrá ser usada donde se haya definido un parámetro del tipo Executer.

También podemos crear interfaces que contengan a otras esto nos brinda la posibilidad de hacerlas muy simples y reutilizables 

type Reader interface {
    Read(b []byte) (n int, err error)
}

type Writer interface {
    Write(b []byte) (n int, err error)
}

type ReadWriter interface {
    Reader
    Writer
}

Siguente Capitulo: De PHP a GO Capitulo 3 - Arreglos

Ya sabes que me podes dejar comentarios aquí o escribirme por twitter a @millancore

]]><![CDATA[De PHP a Go - Comienzo]]>https://millancore.com/de-php-a-go-comienzohttps://millancore.com/de-php-a-go-comienzoFri, 28 Feb 2020 16:21:20 GMTÚltimamente he tenido la oportunidad de trabajar con GO después de resistirme mucho ya que PHP siempre guarda un espacio en mi corazón, sin embargo una parte de mi es partidaria de que cada lenguaje aporta lo suyo.

En este viaje daré mi visión personal de como se ve GO desde las perspectiva de un desarrollador PHP.

Compilado

Si hay algo que disfrutamos en PHP es modificar algo e ir a ver el resultado abusando de la "magia" de ser un lenguaje interpretado, GO es un lenguaje compilado, pero lo creadores en su inmensa sabiduría y teniendo en cuenta lo ansiosos que solemos ser los desarrolladores han creado un compila-y-ejecuta asi podemos dejar la compilación para el final cuando ya estemos seguros de que no haremos cambios.

go run script.go

Declaración de variables

No es un secreto para nadie que a la hora de declarar variables los que trabajamos con PHP somos de lo mas sucio de la industria (no nos molesta), declaramos variables sin pensar en el tipo o definir un valor inicial.

GO es un lenguaje de tipado fuerte lo que nos indica que debemos de declarar el tipo de nuestras variables y su valor inicial, pero tiene truco y esto se agradece mucho cuando vienes de PHP (Que difícil enderezar un árbol).

Para que GO difiera automáticamente el tipo de una variable podemos usar una sintaxis de declaración especial usando := siempre y cuando estén dentro de una función.

 myVariable := 12

Algo a tener muy en cuenta es que las variables de tipo string NO se declaran con comillas simples, ya podes iros preparando para ver como se rompe todo.

Y ni que decir de que el punto y coma ; al final de las sentencias no se usa (Es broma, lo podes usar!!) pero lo mas común es que no se use.

Si están trabajando con tipos de datos que requieren precisión lo mas recomendable es que se tomen la molestia de declararlos!

Paquetes

En PHP estamos muy acostumbrados a que las funciones del lenguaje se encuentren de manera global, no necesitamos incluir un USE para hacer uso de print, rand, time etc, por otro lado en GO debemos importar sus paquetes para hacer uso de ellas.

package main

import (
    "fmt"
    "time"
    "math"
    "encoding/json"
)

Funciones

La parte mas gratificante (en mi experiencia) han sido las funciones de GO, son bastante sencillas de definir pero tienen un par de detalles que se agradece en demasía.

   func myFunc(a int, b int) int {

   }

Lo primero que se debe tener en cuenta es que las variables van antes de los tipos (al principio costara) una vez integrado esto podemos comenzar a ver sus características especiales.

  1. Si todos los parámetros son del mismo tipo basta con solo definir el ultimo func myFunc(a, b int).

  2. Se pueden retornar mas de un parámetro!! Sii (yo casi lloro) return, a, b y en la llamada los recibes en orden resultA, resultB := myFunc(12, 3)

  3. Puedes definir variables de retorno directamente en la definición de la función y estas re retornaran automáticamente. (Esto ya es demasiado).

   func myFunc(a, b int) (c int) {
        c := a + b
       return
   }

Siguente Capitulo: De PHP a GO Capitulo 2 - "Objetos"

Ya sabes que me podes dejar comentarios aquí o escribirme por twitter a @millancore

]]><![CDATA[How to use laravel Schedule in non-Laravel applications]]>https://millancore.com/how-to-use-laravel-schedule-in-non-laravel-applicationshttps://millancore.com/how-to-use-laravel-schedule-in-non-laravel-applicationsTue, 26 Nov 2019 00:45:12 GMTAlthough Laravel is not available in a modular way like Symfony, we can separate its best features if we know how it works.

The most important thing is to know that the Application. "is just an instance of Container" Container

Nothing to fear!

To extract any feature of Laravel we just need to create our Application, The heart of it all.

This is the Schedule outside of Laravel Illuminate Schedule

Enjoy it!

]]><![CDATA[Laravel ( Illuminate ) Components - Schedule]]>https://millancore.com/laravel-illuminate-components-schedulehttps://millancore.com/laravel-illuminate-components-scheduleFri, 22 Nov 2019 15:50:41 GMTEste no es un componente pero si la joya de la corona del Console de Laravel por lo que merece un tratamiento especial.

En este capitulo veremos como usar el Schedule de Laravel fuera del framework para que podamos usarlo como mejor nos parezca.

Lo primero que vamos hacer es crear un archivo de ejecución con nombre de artisan (ya que se no hace familiar), este sera el que ejecutara nuestro cron tal como esta en la documentación.

* * * * * cd /path-to-your-project && php artisan schedule:run >> /dev/null 2>&1

Antes de comenzar os dejo el repo de github , por que a veces es mas sencillo ver todo desde alli! :D

Veamos nuestro artisan

#!/usr/bin/env php
<?php

use Schedule\Kernel;
use Schedule\Application;
use Illuminate\Events\Dispatcher;

require __DIR__.'/vendor/autoload.php';

$app = new Application;

$app['config'] = [
    'cache.default' => 'file',
    'cache.stores.file' => [
        'driver' => 'file',
        'path' => __DIR__ . '/cache'
    ]
];

$app['files'] = new Filesystem;

$kernel = new Kernel($app, new Dispatcher($app));

$kernel->handle(
    new Symfony\Component\Console\Input\ArgvInput,
    new Symfony\Component\Console\Output\ConsoleOutput
);

Ahora veamos de que va esto, tenemos un Application y un Kernel que se encargara de manejar los diferentes comandos que le pasamos a nuestro artisan.

El Application de Laravel solo es un Container vitaminizado, así que nosotros crearemos nuestro Application solo con las cosas que necesita nuestro Schedule.

veamos las dependencias para nuestro proyecto antes de continuar

{
    "require": {
        "illuminate/console": "^5.8",
        "illuminate/events": "^5.8",
        "illuminate/cache": "^5.8",
        "illuminate/filesystem": "^5.8",
        "dragonmantank/cron-expression": "^2.3"
    },
    "autoload": {
        "psr-4": {
            "Schedule\\": "src/"
        },
        "files": [
            "helpers.php"
        ]
    }
}

Ahora si el Application

<?php

namespace Schedule;

use Illuminate\Cache\CacheManager;
use Illuminate\Console\Scheduling\CacheEventMutex;
use Illuminate\Console\Scheduling\EventMutex;
use Illuminate\Container\Container;
use Illuminate\Contracts\Cache\Factory;

class Application extends Container
{
    public function __construct()
    {
        $this->registerBaseBindings();
        $this->registerScheduleBindings();
    }

    protected function registerBaseBindings()
    {
        static::setInstance($this);
    }

    protected function registerScheduleBindings()
    {
        $this->bind(
            Factory::class,
            function ($app) {
                return new CacheManager($app);
            }
        );

        $this->bind(EventMutex::class, CacheEventMutex::class);
        $this->bind(SchedulingMutex::class, CacheSchedulingMutex::class);
    }

    public function environment()
    {
        return 'prod';
    }

    public function isDownForMaintenance()
    {
        return false;
    }
}

Es un Application bastante sencillo como podemos ver, tenemos un registerBaseBindings que se encarga de setear nuestra instancia para que librerías que usan el container puedan acceder a este de manera global, luego tenemos un registerScheduleBindings en donde registramos un CacheManager y los Mutex estos ultimos se encarga de asignar un ID unico a los los eventos y al schedule para que no se solapen y se guardan en cache para que hacer el proceso mas eficiente.

Luego tenemos un environment y isDownForMaintenance , el primero donde retornamos nuestro entorno, muy util si tenemos tareas en nuestro Schedule con diferentes entornos y el segundo es para apagar el Schedule ambas que pueden llevar a un archivo de configuración. (os dejo los cambio menores).

Ahora desmosle una mirada al nuestro Kernel

<?php

namespace Schedule;

use Illuminate\Console\Application as Artisan;
use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Console\Scheduling\ScheduleRunCommand;
use Illuminate\Events\Dispatcher;

class Kernel
{
    protected $app;
    protected $artisan;
    protected $events;

    protected $commands = [
        #Register command here!!
    ];

    public function __construct(Application $app, Dispatcher $events)
    {
        $this->app = $app;
        $this->events = $events;
    }

    public function handle($input, $output = null)
    {
        $this->bootstrap();
        return $this->getArtisan()->run($input, $output);
    }

    protected function schedule(Schedule $schedule)
    {
         #Schedule comands here!!
    }

    protected function bootstrap()
    {
        $schedule = new Schedule();

        $this->getArtisan()->add(
            new ScheduleRunCommand($schedule)
        );

        $this->schedule($schedule);
    }

    protected function getArtisan()
    {
        if (is_null($this->artisan)) {
            return $this->artisan = (new Artisan($this->app, $this->events, '5.8'))
                ->resolveCommands($this->commands);
        }
        return $this->artisan;
    }
}

Tenemos como de costumbre un Array donde registrar nuestros commands y un método schedule donde agregaremos nuestras tareas. Toda la lógica de ejecución reside en el método handle que se encargara de resolver los comandos que le pasamos a artisan.

Y por ultimo tenemos un helper que usa Schedule para saber donde esta parado :D 

<?php

if (! function_exists('base_path')) {
    /**
     * Get the path to the base of the install.
     *
     * @param  string  $path
     * @return string
     */
    function base_path($path = '')
    {
        return __DIR__;
    }
}

Nunca fue tan fácil usar Schedule!

Espero os sea de ayuda! Alguna duda o sugerencia la podéis dejar como comentario o hacerme una mencion en twitter @millancore

]]><![CDATA[Laravel (illuminate) Components - Validation]]>https://millancore.com/laravel-illuminate-components-validationhttps://millancore.com/laravel-illuminate-components-validationWed, 20 Nov 2019 17:10:15 GMTAlgunas personas no podemos dormir sin saber como funcionan las cosas de fondo, nos puede la curiosidad y deseamos destapar todo, por que a lo mejor desarmar la radio cuando chicos no fue suficiente.

Todos conocemos muy bien el gran potencial de Laravel, pero se nos hace innecesariamente grande para algunos proyectos simples, librerias, sdks, etc, y aun así no queremos separarnos de aquello que Laravel hace muy bien.

En este capitulo veremos como usar el componente Validation de Laravel, illuminate/validation, de manera individual.

Ya veremos que simple!

Lo primero que debemos hacer es instalarlo con composer

composer require illuminate/validation

Los ejemplos de este articulo se han creado con la versión 5.8

Vamos a crear un ejemplo de validación simple en un solo archivo, ya queda en vuestra manos el mejorarlo, llevarlo a facade o una clase que se encargue de las validaciones. 

use Illuminate\Filesystem\Filesystem;
use Illuminate\Translation\FileLoader;
use Illuminate\Translation\Translator;
use Illuminate\Validation;

require_once 'vendor/autoload.php';

$fileLoader = new FileLoader(new Filesystem, 'lang');

$validation = new Validation\Factory(
    new Translator($fileLoader, 'en')
);

En las primeras lineas tenemos algunas dependencias de otros componentes Filesystem, Translation no hay nada de que preocuparse, ya vienen incluidas en la instalación del componente Validation.

Luego tenemos nuestro FileLoader que se encargara de cargar el archivo de las traducciones para las diferentes reglas de validación, al cual se le pasa una instancia de FileSystem y la ruta de nuestra carpeta con las traducciones lang, para simplificar mas las cosas la podemos copiar directamente desde laravel Validation Language Lines siguiendo la misma estructura.

 - lang
    └─ en
       └─ validation.php

Luego tenemos la creación de nuestro validador el cual espera una instancia de Translation al cual le pasamos nuestro FileLoader y el lenguaje local, en este caso 'en'.

Listo ya tenemos nuestro validador!!

Ahora pongamos a prueba, haciendo uso de las reglas Validation Rules 

$data = [ 'email' => 'test@validation.com'];

$rules = [
    'email' => 'required|email|max:55'
];

Cuando tenemos la data que vamos a validar y las reglas podemos pasarlo por el validador.

$validator = $validation->make($data, $rules);

Una vez en al validador podemos hacer uso de los diferentes métodos que tiene para manejar como mejor nos convenga los errores de validación.

$validator->validate() Valida los datos pasados arrojando un ValidationException en caso de no pasar la validación.

$validator->fails() Retorna true si los datos fallan la validación

$validator->errors() Retorna un array con los mensajes de validación.

Espero os sea de ayuda! Alguna duda o sugerencia la podéis dejarla como comentario o hacerme una mencion en twitter @millancore

]]>