Programación: Construcción de Lexer con Test-Driven Development

¿Cómo iniciar la construcción de un lexer y los primeros tests?

Desarrollar un lexer efectivo es un arte que requiere paciencia y atención al detalle. Al iniciar este proceso, es fundamental adoptar el enfoque de desarrollo guiado por pruebas (Test-Driven Development, TDD). Esto implica escribir las pruebas antes del código y es una práctica que ayudará a garantizar que tu código funcione como esperas. En esta sesión, vamos a enfocar nuestros primeros tests en tokens ilegales, operadores de un solo carácter y el token EOF (End of File) que nos señala el final del archivo. También, nos enfrentaremos al reto de los delimiters.

Los métodos clave que implementaremos en nuestro lexer incluyen:

• next_token: nuestro principal punto de interacción con el lexer, que continuamente nos proporcionará el siguiente token.
• _read_character: una función privada para leer cada carácter del texto fuente.

¿Cuál es el proceso para escribir nuestros tests?

Los tests actúan como una guía y nos ayudan a verificar continuamente que el código esté en el camino correcto. Aquí se describen los pasos esenciales para escribir tu primer test:

1. Configuración del entorno: Asegúrate de estar en un branch correcto para el desarrollo, como "building del lexer número 1". Corre mypy y nose para verificar que no hay problemas en tu entorno.

2. Estructura del proyecto: Crea un archivo __init__.py dentro de tus carpetas para que mypy y nose puedan reconocer los paquetes. Organiza tu proyecto de manera que todas las pruebas residan en una carpeta test.

3. Escritura del test: Abre un editor de texto para Lexertest y comienza importando TestCase desde unittest. Luego, crea la clase LexerTest que extiende TestCase. Aquí es donde se definirá cada test.

4. Definir el test para tokens ilegales: Por ejemplo, define caracteres ilegales como !, ¿, y @. Inicializa un lexer y usa una lista para almacenar los tokens devueltos tras llamar a next_token.

5. Asserts y errores: Asegúrate de usar assertEqual para verificar que la lista de tokens devueltos coincide con la esperada. Los errores en este punto son valiosos, te guiarán sobre qué ha fallado y cómo solucionarlo.

¿Cómo implementamos las funciones clave del lexer?

Con los tests en su lugar, es momento de codificar las funciones necesarias. Aquí se desglosan los pasos para implementar los métodos de nuestro lexer:

• Inicializar el lexer: Empieza creando una clase Lexer con un constructor que recibe un source. Define también una variable privada _source para almacenar este valor.

• Implementar next_token y _read_character:

  • next_token: Este método regresará un token. Inicialmente, puede devolver un token ilegal con un carácter vacío hasta que se implemente la lógica adecuada.
  • _read_character: Esta función se encargará de avanzar en el texto fuente y deberá actualizar las posiciones de las variables internas.

class Lexer:
    def __init__(self, source: str) -> None:
        self._source = source
        self._read_position = 0
        self._position = 0
        self._character = ''
        self._read_character()

    def next_token(self) -> Token:
        token = Token(TokenType.ILLEGAL, self._character)
        self._read_character()
        return token

    def _read_character(self) -> None:
        if self._read_position >= len(self._source):
            self._character = ''
        else:
            self._character = self._source[self._read_position]
        self._position = self._read_position
        self._read_position += 1

¿Cómo resolver errores y avanzar en el desarrollo?

El desarrollo guiado por pruebas es un ciclo de escribir fallos de tests, solucionarlos y mejorar continuamente. Aquí algunas recomendaciones al enfrentar errores:

• Leer errores atentamente: Estos mensajes a menudo te dicen exactamente dónde está el problema y cómo corregirlo.
• Resolver errores gradualmente: Correcciones pequeñas y frecuentes son preferibles a cambios drásticos que pueden introducir más errores.
• Considerar los errores como aliados: Permiten identificar partes del código que no funcionan como se esperaba y son esenciales para mejorar tu producto final.

Las pruebas y los errores son parte inseparable del proceso de desarrollo, y aprender a manejarlos te convertirá en un mejor desarrollador. ¡Con perseverancia, cada error es una oportunidad de aprendizaje que te acerca más a una solución robusta y optimizada!