Verbal Expressions, la herramienta definitiva para utilizar las expresiones regulares

Desde siempre me ha parecido que hay dos características que definen a los programadores de “pelo en pecho”: El manejarse fluidamente con C++ y el utilizar de forma intensiva las expresiones regulares.

De hecho, las expresiones regulares son una de las grandes malditas del desarrollo por el intenso dolor que produce el utilizarla en código real. Ya que tiene una expresividad y naturalidad en el punto opuesto a todo lo que se pueda denominar lenguaje natural.

Pero gracias a Adrián Fernandez he encontrado la herramienta definitiva para poder utilizarlas de forma sencilla y eficaz en mi código: VerbalExpressions.

La potencia de las Ex con la facilidad de C#

En esta página de GitHub puedo acceder a una colección de código que permite utilizar las expresiones regulares en, prácticamente, cualquier lenguaje moderno. Así tengo esta herramienta para PHP, JS, Perl, Java, Scala, Erlang, Go, Racket, Ruby y un largo etc. Y también lo tengo para C#.

Este último lenguaje, que es el que utilizo diariamente en mi trabajo, es en el que quiero compartir un ejemplo muy sencillo de cómo realizar un método que me compruebe si una url está bien conformada.

Es el ejemplo que trae la propia página de Csharp VerbalExpressions, pero que en la documentación tiene un pequeño error que impide que funcione, y que he corregido en este mini tutorial.

La manera más sencilla y rápida de poder utilizar esta librería en mi proyecto es por medio de Nuget, el gestor de paquetes de Visual Studio. En donde buscaré en los paquetes online por la palabra “csharpverbal”, obteniendo la librería que busco en el primer resultado.

Una vez instalado el paquete en mi proyecto, ya puedo crear un nuevo fichero del tipo clase, en donde añadiré el Namespace “CSharpVerbalExpressions”.

Y ahora debo de hacer (no es TDD) una clase que va a incluir los diferentes tipos de validaciones que requiera el proyecto.

using CSharpVerbalExpressions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace GenbetaDev.Models
{
    public class CompruebaString
    {
    }
}

Y el primero sería EsUnaUrlValida; para lo cual creo el método que me va a devolver una Booleano indicándome si ha pasado o no la validación; y le indico que voy a recibir un parámetro de tipo cadena, que es la url que voy a comprobar.

public bool EsUrlValida(string TextoAcomprobar)
{
  VerbalExpressions esUrlValida = VerbalExpressions.DefaultExpression
                                .StartOfLine()
                                .Then("http")
                                .Maybe("s")
                                .Then("://")
                                .Maybe("www.")
                                .AnythingBut(" ")
                                .EndOfLine();
            
  return esUrlValida.Test(TextoAcomprobar);
}

Ahora, pulsando en el botón derecho, creo una nueva clase de Test en donde voy a añadir las pruebas que me validen que el método hace lo que se espera de él.

Así el primer Test que hago es enviar una dirección correcta y compruebo que el resultado es True.

        [TestMethod()]
        public void EsUrlValidaTest_textoValido_True()
        {
            var CompruebaCadenas = new CompruebaString();
            var textoURL = "https://www.genbetadev.com";

            var resultado = CompruebaCadenas.EsUrlValida(textoURL);

            Assert.AreEqual(true, resultado);
        }

En el segundo test envío un string.empty y compruebo que el resultado sea False.

        [TestMethod()]
        public void EsUrlValidaTest_stringEmpty_False()
        {
            var CompruebaCadenas = new CompruebaString();
            var textoURL = string.Empty;

            var resultado = CompruebaCadenas.EsUrlValida(textoURL);

            Assert.AreEqual(false, resultado);
        }

Y por último, para asegurarme del todo que funciona correctamente, compruebo que no acepta uno de los errores más comunes al escribir una dirección, y que es poner las barras invertidas, a lo cual me debe devolver el valor False.

        [TestMethod()]
        public void EsUrlValidaTest_barrasInvertidas_False()
        {
            var CompruebaCadenas = new CompruebaString();
            var textoURL = "http:\\www.genbetadev.com";

            var resultado = CompruebaCadenas.EsUrlValida(textoURL);

            Assert.AreEqual(false, resultado);
        }

De esta forma tan sencilla he conseguido utilizar la potencia de las expresiones regulares pero con una codificación mucho menos difícil de entender y, sobre todo, de mantener.

Vía | Adrián Fernandez Más información | VerbalExpressions