Forem: Roberto Manchado

Developing with css inline

Roberto Manchado — Fri, 17 Mar 2023 12:28:31 +0000

First all, dont try this technic free. I use this technic when not use WebPack :

composer require symfony/webpack-encore-bundle

I hate use dependences for my projects when, you can like backend developer, write inline inside style tag, and then, remove them from the code and compress on fly.

let's see how...

This is:


class CssCompressService {

    public function compress(string $html): Response
    {
        $buffer = preg_replace('!/\*[^*]*\*+([^/][^*]*\*+)*/!', '',     $this->getCssInline($html));

        $buffer = str_replace(': ', ':', $buffer);

        $buffer = str_replace(array("\r\n", "\r", "\n", "\t", '  ', '    ', '    '), '', $buffer);

        ob_start("ob_gzhandler");

        $response = new Response($buffer);
        $response->headers->set('Content-type',' text/css');

        return $response;
    }

    private function getCssInline($html) : string
    {
        preg_match_all('/<style[^>]*>([^<]+)<\/style>/', $html, $matches, PREG_OFFSET_CAPTURE);

        $css = '' ;
        foreach ($matches[0] as $match) {
            $css .= strip_tags($match[0]) ;
        }

        return $css;
    }
}

then you have to add this tag inside your head:


    <link href="{{ path(app.request.get('_route'),app.request.get('_route_params')) }}?compress=true" rel="stylesheet">

the twig function app.request.get allow get the name of your Controller that intercept your request and the params of your request. This way, you dont need write the path of your Controller each time.

Inside your Controller, you only need add this snippet of code:


if($this->requestStack->getCurrentRequest()->query->has('compress')){
    return $this->cssCompressService->compress($html);
}

Now, we need remove the style tag from the html code rendered. We can use the DomDocument class for get the style nodes and remove them.


class DomService {

    public function __construct(private readonly TidyService $tidyService){}

    public function output(string $html): Response
    {
        $dom = new DOMDocument('1.0', 'UTF-8');
        @$dom->loadHTML($html);
        $script_tags = $dom->getElementsByTagName('style');

        while($script_tags->item(0) != null) {
            if(is_object($script_tags->item(0)->parentNode)) {
                $script_tags->item(0)->parentNode->removeChild($script_tags->item(0));
            }
        }
        return $this->tidyService->parse(new Response($dom->saveHTML()));

    }

}

Pay attention on the constructor class. We are injected the TidyService. A class that use the Tidy extension php, for sort the html rendered. Very beautifull....

And our Controller is as follow:


 #[Route('/blog/{page}', name: 'app_blog')]
    public function blog(
        PostRepository $postRepository,
        int $page = 1
    ): Response
    {
        $this->seoMetaTagsService->generate(
            $this->requestStack->getCurrentRequest(),
            true,
            [],
            'Blog',
            ''
        );

        $html = $this->render('blog/index.html.twig', [
            'posts_results_paginated' => $postRepository->paginate($page),
            'posts_results_all' => $postRepository->findAll()
        ])->getContent() ;
        if($this->requestStack->getCurrentRequest()->query->has('compress')){
            return $this->cssCompressService->compress($html);
        }

        return $this->domService->output($html);

    }

With this way, you can write css inline as follow:


{% macro print(skill,loop) %}
    {% if loop.first %}
    <style>
        td a {
            color: #1c262f;
        }
        td a:hover {
            color: #46a80f;
            text-decoration: none;
        }
        td i {
            cursor: pointer;
        }
    </style>
    {% endif %}
    <tr>
        <td><strong>{{ skill.name }}</strong></td>
        <td>{{ skill.description }}</td>
        <td style="width: 100px">
            <a href="{{ path('skill_update', {'skillId': skill.id }) }}" title="update skill">
                <i class="fa fa-edit"></i>
            </a>
            <a href="{{ path('skill_delete', {'skillId': skill.id }) }}" title="remove skill">
                <i class="fa fa-eraser"></i>
            </a>
        </td>
    </tr>
{% endmacro %}

In our macros from Twig, you can write css inline, without fear that the style tag embbebed on your html code. Your css code will be compress and when you do a request to the controller, you will have a response with the css compressed like that :


body {background-color:#1c262f;}.navbar.top-nav-collapse {border-bottom:1px dashed darkseagreen;}.active > .page-link, .page-link.active {background-color:#1c262f;border-color:#1c262f;}.page-link {color:#1c262f;}.page-link:hover {color:seagreen;}.dataTables_wrapper .dataTables_length select {border:1px solid black;}.dataTables_wrapper .dataTables_filter input {border:1px solid black;}button {padding:0 15px 0 15px;}button i {padding:5px ;}table#datatable {background-color:#c1d6cc;}body {background-color:darkseagreen;}section#posts {margin-top:5em;}td a {color:#1c262f;}td a:hover {color:#46a80f;text-decoration:none;}td i {cursor:pointer;}td img {border:1px solid darkslategrey;}

Some considerations

When you put css inside your macros, you should add the loop variable if you are using a loop, because the style css inline will be repeated.
You will have two requests. One, the request with the compress parameter that render your css inline compress without tools like WebPack, UglyFy, CSS compresors, etc etc, and the normal request that render your template Twig.
You can use the style tags as many times as you want. They will be removed from your code and injected on the fly in the header.
If you know about css, you can use the specificity for avoid css style colisions more easy. Each page, macro, template,,, have own css.

UserChecker Symfony.6.0.15

Roberto Manchado — Sun, 27 Nov 2022 17:14:44 +0000

Liquid syntax error: Tag '{% if error %}' was not properly terminated with regexp: /\%\}/

How test your listener events on Symfony with phpunit

Roberto Manchado — Sun, 03 Oct 2021 11:51:23 +0000

Test a listener using the Symfony's events, is easy.

The listener is listening an event for example, when an exception has happened.
When the onKernelException event has happened, you can intercept the request and catch the data of request
thanks to the ExceptionEvent Object.

In fact, you can transform the response as follows:

class JsonExceptionResponseTransformerListener
{
    public function onKernelException(ExceptionEvent $event): void
    {
        $exception = $event->getThrowable();

        if ($exception instanceof HttpExceptionInterface) {
            $data = [
                'class' => \get_class($exception),
                'code' => $exception->getStatusCode(),
                'message' => $exception->getMessage(),
            ];

            $response = $this->prepareResponse($data, $data['code']);

            $event->setResponse($response);
        }
    }

    private function prepareResponse(array $data, int $statusCode): JsonResponse
    {
        $response = new JsonResponse($data, $statusCode);
        $response->headers->set('Server-Time', \time());
        $response->headers->set('X-Error-Code', $statusCode);

        return $response;
    }
}

On onKernelException you can catch the Exception and prepare a response. You can modify the status of the response and the type of the response for example.
This is useful when you want response with a json response like in an api-app.

But.. how test this with php-unit ??

In a first instance, only need the EventDispatcher. The idea is use an instance of EventDispatcher, and trigger the event with the
ListenerObject that you has created. ( see up )
You don't need Mocks for the ExceptionEvent o dependencies of other classes.

Only, need trigger the event inside phpunit, and catch the event. Then you can use the asserts of php-unit for get the response and the type of the response expected.

Like this:

class JsonExceptionResponseTransformerListener extends TestCase
{

    /** @var EventDispatcher **/
    private $dispatcher;

    public function setUp(){
        $this->dispatcher = new EventDispatcher();
    }

    public function test_should_get_a_json_response() : void
    {
        // instance our own listener
        $listener = new JsonExceptionResponseTransformerListener();
        $this->dispatcher->addListener('onKernelException', [$listener, 'onKernelException']);

        // dispatch your event here
        $event = new ExceptionEvent();
        $dispatcher->dispatch($event, 'onKernelException');
        $this->assertInstanceOf(JsonResponse::class,$event->getResponse());
    }

}

You can , of course, add more assert to the response, like the status code, the params of the header response, etc etc....

fdo:roberto manchado

Storing workflow data as artifacts

Roberto Manchado — Fri, 27 Aug 2021 07:47:54 +0000

About workflow artifacts

Artifacts allow you to persist data after a job has completed, and share that data with another job in the same workflow. An artifact is a file or collection of files produced during a workflow run. For example, you can use artifacts to save your build and test output after a workflow run has ended.

GitHub Enterprise stores full build logs and artifacts for 90 days. The retention period for a pull request restarts each time someone pushes a new commit to the pull request.

These are some of the common artifacts that you can upload:

Log files and core dumps
Test results, failures, and screenshots
Binary or compressed files
Stress test performance output and code coverage results

https://docs.github.com/es/enterprise-server@2.22/actions/guides/storing-workflow-data-as-artifacts

create a fake webmail with roundcube like mailtrap

Roberto Manchado — Tue, 24 Aug 2021 16:23:24 +0000

you can use a fake webmail for catch your emails from
a smtp docker server. Like mailtrap.io

first of all, you need use the image:eaudeweb/mailtrap
in your docker-compose file.

Then you can config the mapping of ports and the enviroments
variables for access.

As follow:



 mail:
    container_name: sys_mail
    restart: unless-stopped
    image: eaudeweb/mailtrap
    ports:
      - "8125:80"
      - "2525:25"
    environment:
      - MT_USER=mailtrap
      - MT_PASSWD=mailtrap
      - MT_MAILBOX_LIMIT=512000001
      - MT_MESSAGE_LIMIT=102400001
    networks:
      orion-office-network:
        ipv4_address: 172.16.4.3

Very important your address network! because
your enviroment variable for you should be the address of your container address:

this



###> symfony/mailer ###
MAILER_DSN=smtp://172.16.4.3:25?verify_peer=0
###< symfony/mailer ###

you can acces to the admin-panel in :



172.16.4.3:80

user:mailtrap # MT_USER enviroment variables
pass:mailtrap # MT_PASSWD enviroment variables

Other important thing is the ?verify_peer parameter
by default with value true.

if you have problems with the TLS Peers, you can
disabled only for debug . TLS Peer verification

Thanks friends of Eau de web

Cómo superar una prueba técnica PHP - tercera parte

Roberto Manchado — Mon, 23 Aug 2021 18:35:00 +0000

Una vez creada nuestra pequeña arquitectura, tan solo tenemos que implementar las clases que modificaran la prioridad de visualización de la película.

En este ejemplo, se implementa la clase estreno, que determina si la película es de tipo estreno, entonces variará la propiedad prioridad.

amespace App\ArrayMap\Estreno;

use App\Interfaces\RuleInterface;
use App\Rule;

class Estreno extends Rule implements RuleInterface
{
    const prioridadMin  = 0;

    public function map(array $arrayElements) : array
    {
        return array_map(function ($e) {
            if ($e->bloqueante()) {
                // según esten definidos los requisitos
                $e->prioridad = $e->prioridad - 2;
                if ($e->prioridad < self::prioridadMin) {
                    $e->prioridad = self::prioridadMin;
                }
            }
            return $e;
        }, $arrayElements);
    }
}

namespace App\ArrayMap\Descripcion;

use App\Interfaces\RuleInterface;
use App\Rule;

class Descripcion extends Rule implements RuleInterface
{
    const prioridadMin  = 0;

    public function map(array $arrayElements) : array
    {
        return array_map(function ($e) {
            // según esten definidos los requisitos
            if (strlen($e->descripcion()) > 100 && strlen($e->descripcion()) < 500) {
                $e->prioridad = $e->prioridad - 0.5 ;
            } elseif (strlen($e->descripcion()) > 500) {
                $e->prioridad = $e->prioridad - 0.7 ;
            } elseif (strpos($e->descripcion(), '</a>') !== false) {
                $e->prioridad = $e->prioridad - 0.5 ;
            }

            if ($e->prioridad < self::prioridadMin) {
                $e->prioridad = self::prioridadMin;
            }
            return $e;
        }, $arrayElements);
    }
}

Dejo que termines la clase asociada al título.
Como ves, superar una prueba técnica PHP es de lo más entrenido. Las variantes como ya comenté, suelen tener además tests unitarios cuyas aserciones, deben ser cumplidas todas. En esto último, el nivel de precisión debe ser casi excelente.

Espero que hayais disfrutado con este post, al igual que yo escribíendolo. Podeís clonar el repositorio
de reglas en Rules-Filter

Parte 2

Os dejo un librito recomendado. Que aproveche !

fdo: roberto manchado

Cómo superar una prueba técnica PHP - segunda parte

Roberto Manchado — Mon, 23 Aug 2021 18:34:30 +0000

Una vez definido nuestro directorio de trabajo y configurado nuestro composer.json, debemos crear las interfaces
necesarias, esto es:

namespace App\Interfaces;

interface MovieDispatcherInterface
{
    public function match(): void;

    public function addTask(MovieInterface $movie): void;

    public function removeTask(MovieInterface $movie): void;

    public function movies(): array;
}

Necesitaremos una clase que encapsule las reglas discriminatorias de manera escalables. Utilizaremos en esta clase el principio Open/Close.

namespace App\Interfaces;

interface RuleInterface
{
    // map some items from a array
    public function map(array $arrayElements) : array ;
}

Y por último la interfaz con los métodos a implementar para las películas:

namespace App\Interfaces;

interface MovieInterface
{
    public function id(): int;

    public function prioridad(): float;

    public function titulo(): string;

    public function estreno(): bool;

    public function descripcion(): string;
}

Una variante de la prueba técnica, consiste en que ya tienes el código preparado. Tan sólo tienes que crear las clases que te solicitan. En esta variante, es muy posible que tengas que ejecutar tests unitarios.

Una vez diseñados nuestras interfaces, procedemos a construir las clases:

declare(strict_types = 1);

namespace App;

use App\Interfaces\MovieInterface;

class Movie implements MovieInterface
{
    public int $id;

    public float $prioridad;

    public string $titulo;

    public bool $estreno;

    public string $description;

    public function __construct(int $id, string $titulo, bool $estreno, string $description)
    {
        $this->prioridad = 5.00 ;
        $this->id = $id;
        $this->titulo = $titulo;
        $this->estreno = $estreno;
        $this->description = $description;
    }

    public function id() : int
    {
        return $this->id;
    }

    public function prioridad() : float
    {
        return $this->prioridad;
    }

    public function titulo() : string
    {
        return $this->titulo;
    }

    public function estreno() : bool
    {
        return $this->estreno;
    }

    public function descripcion() : string
    {
        return $this->description;
    }
}

Nuestro contenedor de reglas, que permitirá añadir las reglas discriminatorias para nuestros requerimientos.
La idea, es tener un conjunto de reglas que comparten una interfaz en común, y cada regla discrimina o actualiza
el array de películas de forma diferente. De esta manera podemos "escalar" el código sin modificar su estructura. (Principios SOLID)

declare(strict_types = 1);

namespace App;

class ContainerRulesArrayMap
{
    private $rules = [];

    private $items = [];

    public function __construct(array $tasks)
    {
        $this->items = $tasks;
    }

    public function addRule(Rule $rule) : void
    {
        $this->rules[] = $rule;
    }

    /**
     * execRule
     *
     * run each rule and aply the filter method
     * to each item from array origin
     *
     *
     * @return void
     */

    public function execRule() : void
    {
        foreach ($this->rules as $rule) {
            $this->items = $rule->map($this->items);
        }
    }
}

Y nuestro flamante MovieDispatcher:

    declare(strict_types = 1);

    namespace App;

    use App\Interfaces\MovieDispatcherInterface;
    use App\Interfaces\MovieInterface;
    use App\ContainerRulesArrayMap;
    use App\ArrayMap\Titulo;
    use App\ArrayMap\Estreno;
    use App\ArrayMap\Descripcion;

    class MovieDispatcher implements MovieDispatcherInterface
    {
        private array $movies;

        public function addMovie(MovieInterface $movie) : void
        {
            $this->movies[] = $movie;
        }

        public function match() : void
        {
            $rule = new ContainerRulesArrayMap($this->movies);

            $rule->addRule(new Titulo());
            $rule->addRule(new Estreno());
            $rule->addRule(new Descripcion());
            $rule->execRule();

            usort($this->movies, function ($a, $b) {
                return $a->prioridad() > $b->prioridad();
            });
        }

        public function movies() : array
        {
            return $this->movies;
        }

        public function removeMovie(MovieInterface $movie) : void
        {
            $this->movies = array_filter($this->movies, function ($c) use ($movie) {
                return $c->id() !== $movie->id();
            });
        }
    }

Parte 3

Parte 1

Cómo superar una prueba técnica PHP - primera parte

Roberto Manchado — Mon, 23 Aug 2021 18:20:55 +0000

Pasar una prueba técnica no suele ser fácil, sobre todo, sino disponemos de mucho tiempo.

Las pruebas técnicas suelen ser de varios tipos:

Tipo test: preguntas variadas, incidiendo en varios temas importantes o básicos según el puesto de empleo.

PROS: no necesitas desplegar ningún repositorio, ni tampoco pensar en como resolver un problema o desarrollar una mini-aplicación.
CONTRAS: requiere concentración, conexión a internet, tiempo acotado. Alguna variante, las preguntas suelen estar en inglés.

Tipo desarrollo: en este tipo de pruebas, deberás desarrollar una pequeña funcionalidad o algoritmo, para resolver
algún tipo de problema recurrente para ese puesto de trabajo o que lo requiere tu perfil técnico.

PROS: suelen ser muy entrenidas, y te pueden servir como entrenamiento. Si desarrollas varias, te pueden servir para otras futuras pruebas técnicas y eso que te ahorras.
CONTRAS: pueden requerir tiempo, y si le sumas test unitarios, vas a requerir bastante precisión.

Tipo Mixtas: suelen tener preguntas tipo test y preguntas de desarrollo.

PROS: dependiendo del perfil, suelen abordarse bastante bien y las preguntas suelen llevar poco tiempo.
CONTRAS: si alguna pregunta no la sabes, no sabrás la respuesta .

Consejos útiles : independientemente de que tipo de prueba estés realizando, guarda o haz captura de pantalla para futuras revisiones.
Quizá no pases la prueba, pero te servirá de punto de partida para la siguiente.

Un ejemplo de prueba técnica PHP es como sigue:

Movie dispatcher

Tarea

Movie dispatcher es un priorizador de películas que te dice qué película es la primera que debes visionar en base a una serie de parámetros. Hay intención de tener en cuenta más parámetros a la hora de priorizar, así que el desarrollo debe ser extensible.

Tu tarea consiste en crear un programa que ordene las pélículas en función de la importancia de estas.

Recibirás un listado de películas, cada una tendrá los datos de cada película.

Cada película tendrá los siguientes campos:

Título.
Estreno.
Descripción.

Cálculo de prioridades

Una película siempre tendrá una prioridad con un valor de 0-5 siendo 0 su prioridad más alta y 5 su prioridad más baja. Por defecto, toda película tendrá una prioridad de 5.

En el caso del listado de películas. Si el formato es erróneo, no será capaz de priorizar ninguna película.

Las prioridades variarán en función de cada campo de la película.

Titúlo: En función del titulo, la película tendrá más prioridad o menos. Los posibles títulos que afectan a la prioridad son:
- Torrente, el brazo tonto de la Ley: Restará 1,2 puntos a la prioridad.
- Rambo 6 : Restará 0,7 puntos a la prioridad.
- EL vengador tóxico atacaca de nuevo: Restará 0,5 puntos a la prioridad.
- Jay y Bob el Silencioso: Restará 1 punto a la prioridad.
- El precio del poder: Sumará 1 punto a la prioridad.
Estreno: En función de si la película ya ha sido estrenada o no, la prioridad variará.
- Si es bloqueante restará 2 puntos.
- Si no es bloqueante no restará a la prioridad.
Descripción: En función de la extensión de la tarea, la prioridad se calculará de la siguiente manera:
- Si tiene menos de 100 caracteres: No restará nada a la prioridad.
- Si tiene entre 100 – 500 caracteres: Restará 0,5 puntos.
- Si tiene más de 500 caracteres: Restará 0,7 puntos.
- Si contiene un enlace: Restará 0,5 puntos.

Al final debe aparecer el listado de películas escrito por pantalla en el orden correcto.

Siéntete libre a la hora de organizar la entrada de datos como quieras. CSV, JSON… Puedes usar cualquier framework de PHP que quieras. No es necesario interfaz de usuario ni acceso a base de datos. Tampoco es obligatorio leer la entrada de datos de los archivos del sistema. Es aceptable leerlo desde stdin, formulario, archivo… como quieras.

La tarea está diseñada para darnos una idea de cómo piensas cuando te enfrentas a una tarea de cierta complejidad.
Estamos interesados en ver cómo estructuras tu código para que sea fácilmente extensible, si cumple buenas prácticas y si es fácil de entender o modificar por otros.
También estamos interesados en ver cómo de eficiente es tu algoritmo.
El dominio de GIT también es importante, siéntete libre de hacer todos los commits que necesites.

Y esto es todo, el plazo de entrega varía entre dos días y 1 hora. Además dependiendo del puesto, quizá en esa hora, debes ejecutar
una serie de test unitarios que deben encajar a la perfección.
Como ves, este tipo de pruebas, son perfectas, ya que, el candidato debe demostrar pericia y maestría a la hora de ofrecer una solución.

En primer lugar, lo que debemos crear es nuestro composer.json :

{
  "name": "app/movie-dispatcher",
  "autoload": {
    "psr-4": {
      "MovieDispatcher\\": "src/"
    }
  }
}

Parte 2

Cómo generar un brainstorming a partir de un logotipo

Roberto Manchado — Fri, 20 Aug 2021 18:06:27 +0000

El otro día, estuve viajando en autobus hacía mi pueblo, y reparé en un camión a mi derecha, de pequeñas proporciones, en cuya parte trasera se podía leer: http://glub-glub.com

En su lado izquierdo, se podía visualizar un pez abisal, y de nuevo el logo tipo: http://glub-glub.com.

Me paré un momento a pensar, que tipo de empresa o a que tipo de servicio se dedica una empresa que tiene de logotipo un pez abisal y un título para la web que se titula: http://glub-glub.com.
Me propuse adivinar, el objetivo o servicio al que se dedicaba, sin visitar su página web.

Entonces, empecé a pensar. Bien podría tratarse de transporte de pescado o congelados. Pero el camión era de pequeñas proporciones. Un poco mayor que una furgoneta, pero mucho menor que un camión de logística de alimentos.

Descarté la logística de pescado u congelados por tratarse de un camión pequeño. Mi razonamiento, fue el siguiente:
Si el logotipo es un pez, independientemente de que tipo de pez, y utiliza para representar el nombre de la empresa colores fríos, como los azules, tiene que estar relacionado con peces o algo relacionado con el mar.

La intriga se estaba haciendo interesante, y entonces me acordé de un programa-documental, en la que se transportaba acuarios y peces exóticos, hacia ricachones que no sabían cómo decorar su casa. ¿ Que me sobra espacio ? Pues me compro un acuario con tiburones y peces abisales. Hay de todo en la viña del señor.

En fin, que ya tenía mi segunda alternativa, madurada, aunque sabía, que el pequeño camión bien se podría dedicar a otro
servicio. El camión, dudo mucho que pueda contener, un acuario de grandes proporciones. Pero estaba bien encaminado.

El logotipo era el siguiente:

Creí haber resuelto el acertijo, y sabía que las prisas me pasarían facturas.
Me moría de ganas de averiguar, a qué demonios se dedicaba la empresa del camión, que circulaba a mi lado.
O pescado y/o congelados, o transporte de animales marinos exóticos.

No volví a pensar ni un segundo más y lo busqué en su página web.

Mi decepción posterior, aunque para nada me extrañaba, me cogió de improviso. La empresa se dedicaba a la iluminación y soluciones técnicas para espectáculos.

Aunque bien se podría haber dedicado a otra cosa, el haber utilizado colores fríos, un pez abisal, y las palabras glub-glub (sonidos que hace una persona cuando se ahoga),
mi cerebro lo asimiló hacia algun servicio relacionado con el mar.

Sin embargo, el bueno del diseñador del logotipo probablemente utilizó un pez abisal, de esos que tienen una especie de linterna en la cabeza, para hacer referencia, a la iluminación en su concepto más abstracto. De ahí, el ejercicio lógico de fijarse en todo y conclusiones
que puedan llegar a darse, a partir de un logotipo.

Aunque fue frustrante no haber averiguado a que sé dedicaba la empresa, me dio ideas, para utilizarlo en otros ejemplos y desencadenar un brainstorming, o tormenta de ideas, para resolver un problema o hallar una solución.
A partir de un logotipo en un camión, tratar de descubrir, de la manera más lógica posible, en que sector y que tipo de servicios se encarga.

Me pareció un ejercicio divertido, cuando te aburres viajando, pero también se podría utilizar cualquier otro ejemplo en cualquier otro lugar.

P.D : en el camión no se mostraba de ninguna manera ninguna referencia hacia arquitecturas audiovisuales.

fdo: roberto manchado

Cómo aumentar brutalmente el rendimiento de PHP-STORM

Roberto Manchado — Fri, 20 Aug 2021 18:01:44 +0000

Para los que tenemos equipos de bajas prestaciones (Ver Cómo conseguir un equipo de desarrollador de bajo presupuesto, donde medimos
cada kilobyte de memoria, (tabs, aplicaciones, daemons), a veces nos pasa factura y herramientas imprescindibles para el desarrollo en PHP como lo es PHP-STORM puede verse penalizado y el desarrollo puede ser verdaderamente incómodo.

Para trabajar cómodamente con PHP-STORM y no tener la sensación de estar circulando por un camino lleno de piedras, con una bici de ciclismo, deberemos desactivar el indexador de archivos y clases. Precisamente la herramienta por la que merece la pena usar PHP-STORM y tanto amamos.

Para desactivar la sincronización del índice cada vez que se abra PHP-STORM o se actualice el sistema de ficheros:



System Settings -> Synchronize files on frame or editor tab activation.

El precio a pagar, será tener que escribir correctamente los métodos y los namespaces,tener que refrescar el sistema de ficheros cuando escribamos o añadamos un nuevo directorio.

Sin embargo, el rendimiento del pc, aumenta considerablemente y el desarrollo se vuelve más fluido. Ya no parece que nuestro equipo se cala.

La otra opción es gastarse un poco más de nuestro presupuesto, utilizar i5,i7,i9, placas con formato
micro-ATX en lugar de mini-ITX.... pero no tengo dinero.

Cómo crear un equipo de bajo presupuesto para desarrollar

Roberto Manchado — Fri, 20 Aug 2021 17:56:23 +0000

Desarrollar con open-source no tiene que ser costoso, sino todo lo contrario.
Con un equipo con lo justo de memoria RAM y un procesador bastante mediocre se puede escribir código incluso utilizar herramientas como Docker.

Eso sí, no esperes utilizarlo para herramientas o programas que requieran alto nivel de gráficos o excesivo rendimiento.

Es para lo que es. Para desarrollar.

Mi equipo consta de :

Software:

Git
Lubuntu 18.04 lts
PHP 7.2,7.4,8.0
Docker
Mysql
PHPSTORM

Componentes Hardware:

Placa base : Biostar H81MHV3 Placa Base (DDR3-SDRAM, DIMM, Dual, Intel, Celeron, Core i3, Core i5, Core i7, Pentium, Socket H3 (LGA 1150))

Total: 60 euros
Caja segunda mano NZXT

Total: 50 euros
Teclado mecánico

Total: 25 euros
Ratón Logitech

Total: 5 euros
Auriculares

Total: 20 euros;

Total presupuesto: 160 euros.

Si te paras a pensar, con lo que vale un imac puedes conseguir 10 pcs de bajo presupuesto como el anterior.

Ahorro sin ninguna duda.

fdo: roberto manchado

Cómo testear con métodos privados en PHPUNIT

Roberto Manchado — Fri, 20 Aug 2021 17:52:23 +0000

A la hora de desarrollar nuestros tests, podremos tener problemas con el ámbito de privacidad de los métodos.
Según las buenas prácticas en el desarrollo de test, estos métodos deben ser públicos, sin embargo, en algunos casos, en la implementación de una api estos métodos disponen de métodos privados y clases finales.

Aquí el ejemplo:


/**
     * @param array $data
     *
     * @return array
     */
    private function deserializeCompetitions(array $data): array
    {
        $sportArray = [];

        foreach ($data as $entry) {
            if (!empty($entry['id'])) {
                $sportArray[] = $this->deserializeCompetition($entry);
            }
        }

        return $sportArray;
    }

Si queremos deserializar los datos para poder validar alǵun método que estemos desarrollando la única manera 'sana', para poder realizar este proceso es utilizar el propio o los propios métodos de la clase que los implementa.
El problema es que estos métodos son privados, y la clase que lo implementa es una clase final. Perfectamente lógico y además bien hecho.

En este caso, y para salir del paso, podemos usar la Api de de reflexión de PHP para manipular el ámbito de los métodos.

Esto es:

    // obtenemos un nuevo objeto con la clase ReflectionMethod .
    // los párametros son la clase que implementa el método privado, y el nombre del método privado 
    $method = new ReflectionMethod(SportsDataClient::class, 'deserializeCompetition');
    // lo configuramos para que pueda ser accesible
    $method->setAccessible(true);
    // instanciamos nuestra clase a testar
    $testClient = new SportdataClientTest();
    $contentClient = $testClient->createInstance();
    // recuperamos los datos que queremos deserializar en formato por ejemplo .json
    $optaCompetition = $this->getOptaJson('opta-competition')['competition'];
    // con _invoke, ejecutamos el método ahora accesible junto con los datos de entrada
    // los parámetros son la clase que implementa el método y el/los parámetros de entrada
    $competition = $method->invoke($contentClient, $optaCompetition);
    // creamos un Mock, con lo que podremos retornar un valor de la clase Competition
    // con los datos deserializados en el formato correspondiente.
    $sportDataclientMock
        ->expects($this->any())
        ->method('getCompetitionBySportIdAndCompetitionId')
        ->willReturn($competition);

Y nuestro método que necesitamos :

/**
     * @param array $data
     *
     * @return Competition
     */
    private function deserializeCompetition(array $data): Competition
    {
        $sportsId = SportsDataId::build($data['id']);
        $seasons = $this->deserializeSeasons($data);

        return Competition::build(
            $sportsId,
            $data['name'] ?? '',
            $data['short_name'] ?? '',
            $data['url'] ?? '',
            $data['path'] ?? '',
            $data['active_season'] ?? '',
            $seasons
        );
    }

De esta forma, no saltará ninguna excepción de PHP UNIT por intentar acceder a un método privado desde una clase final.

fdo: roberto manchado