Cómo crear un generador de clases de Python para VS Code

###IntroducciónSi odias eliminar clases de Python, aquí te mostramos cómo crear una extensión en Visual Studio Code para que lo haga por ti. En este artículo, verás cómo crear esa extensión. Usaremos varias técnicas para hacerlo.

• Solicitud de entrada del usuario
• Funciones de mapa y unión de matrices
• Literales de plantilla ES6
• Escribir en el sistema de archivos

Creará una nueva extensión, solicitará al usuario una entrada, convertirá la entrada en una cadena que represente el nuevo archivo de clase y escribirá el resultado.

Creando el proyecto

Para comenzar a desarrollar extensiones de código, necesitará tener instalados dos paquetes NPM diferentes, “yo” y “generator-code”.

Para generar su proyecto, ejecute el siguiente comando.

yo code

A continuación, se le harán varias preguntas sobre su proyecto. Elija JavaScript o TypeScript para su extensión.

Después de responder todas las preguntas, abra el proyecto recién creado en VS Code.

Se crearán varios archivos diferentes para usted, los dos más importantes son los archivos package.jsony extension.js.

Comience abriendo el extension.jsarchivo. Luego, cambie el nombre del comando de extensión a createPyClass.

Luego, en el package.jsonarchivo, cambie el nombre del evento de activación y del comando para que coincida con el nombre del comando.

Actualice también el título, que es lo que escribirá el usuario para activar el comando.

Para ejecutar la extensión, abre el panel de depuración (parece un error) y presiona reproducir. Esto abrirá una nueva instancia de VS Code. Abre el símbolo del sistema ( Comando + Shift + P en Mac y Control + Shift + P en Windows) y escribe “Crear clase Python”.

Y deberías ver el mensaje "Hola mundo".

Solicitar entrada al usuario

Necesitamos solicitarle al usuario información sobre la clase (nombre de la clase y propiedades) y convertir esa entrada en una cadena que podamos escribir en el nuevo archivo de clase.

Comencemos por asegurarnos de que el usuario tenga una carpeta abierta actualmente. Si no es así, no tenemos un lugar donde escribir el nuevo archivo de clase. Si el usuario no tiene una carpeta abierta, mostramos un mensaje de error y volvemos.

if (!vscode.workspace.workspaceFolders) {  return vscode.window.showErrorMessage(    "Please open a directory before creating a class."  );}

Ahora podemos pedirle al usuario el nombre de la clase que desea crear. Si el usuario, por alguna razón, cierra el mensaje de entrada (presionando escape), regresamos.

const className = await vscode.window.showInputBox({  prompt: "Class Name?"});if (!className) return;

Queremos permitir que el usuario ingrese tantas propiedades como desee. Para ello, solicitamos inicialmente una propiedad y luego ejecutamos un bucle while que recupera las propiedades hasta que el usuario ingresa "listo".

let count = 1;let property = await vscode.window.showInputBox({  prompt: `Property #${count}? ('done' when finished)`});const properties = [];while (property != "done") {  properties.push(property);  count++;  property = await vscode.window.showInputBox({    prompt: `Property #${count}? ('done' when finished)`  });}

Vuelva a ejecutar su extensión, ingrese datos válidos e imprima la información del usuario para asegurarse de que se vea correcta.

Crear la cadena de contenido de la clase

Ahora comenzamos a tomar la entrada del usuario para generar el contenido de la clase. Comencemos creando la línea de definición de la clase y la definición del constructor.

const classDefinition = `class ${className}:`;const constructorDefinition = `def __init__(self, ${properties.join(", ")}):`;

Luego, podemos crear las líneas de asignación del constructor. Aquí es donde el usuario inicializará las variables sobre sí mismo, utilizando los valores de los parámetros del constructor. Para esto, utilizamos map(como lo haremos a partir de ahora) para convertir cada una de las entradas de la propiedad de alguna manera.

const constructorAssignments = properties  .map(property = `self.${property} = ${property}ntt`)  .join("");

Ahora, para cada propiedad, creamos una función de obtención. Nuevamente, usamos mappara convertir cada propiedad en una cadena que representa su función de obtención.

const classGetters = properties  .map(    property = `tdef get_${property}(self):nttreturn self.${property}nn`  )  .join("");

Lo último que queremos crear es la función de cadena que le indicará a Python cómo imprimir este objeto. Nuevamente, usamos la mapfunción para convertir cada propiedad imprimiendo el nombre de la propiedad y luego su valor.

Tenga en cuenta que en el valor de retorno del mapa, agregamos una coma y un signo más. Esto significa que, para la última propiedad, agregaríamos caracteres innecesarios al final. Por este motivo, convertimos la matriz resultante en una cadena y eliminamos los últimos 11 caracteres mediante el uso de splice.

const dunderStrString = `tdef __str__():n ttreturn ${properties  .map(property = '"' + property + ': "' + " + " + property + ' + " , " + ')  .join("")  .slice(0, -11)}`;

¡Tomemos estas piezas individuales y pongámoslas todas juntas!

const classString = `${classDefinition}    ${constructorDefinition}        ${constructorAssignments}${classGetters}${dunderStrString}`;

Cree una declaración de registro y ejecútela nuevamente para asegurarse de que su cadena de clase se vea bien.

Creando el archivo de clase

Ahora, necesitamos escribir esa cadena en un nuevo archivo. Para trabajar con archivos, necesitamos importar los módulos “fs” y “path” desde Node en la parte superior de la página.

const fs = require("fs");const path = require("path");

Luego, necesitamos obtener la ruta del directorio abierto actualmente por el usuario. Puedes obtener una referencia a los directorios abiertos mediante vscode.workspace.workspaceFolders. Luego, obtenemos el primero de la matriz resultante, tomamos su URI y lo convertimos en una cadena. La cadena de ruta resultante incluía un prefijo, por lo que lo eliminamos dividiendo en dos puntos y tomando lo que viene después de los dos puntos.

const folderPath = vscode.workspace.workspaceFolders[0].uri  .toString()  .split(":")[1];

Ahora podemos usar el módulo fs, la ruta de la carpeta y el nombre del archivo de clase para escribir la cadena de clase en nuestro nuevo archivo.

fs.writeFile(path.join(folderPath, `${className}.py`), classString, err = {});

Podemos llevarlo un paso más allá y brindarle al usuario información basada en si la escritura del archivo fue exitosa o no.

fs.writeFile(path.join(folderPath, `${className}.py`), classString, err = {  if (err) {    vscode.window.showErrorMessage("Something went wrong");    return console.log(err);  }  vscode.window.showInformationMessage(`${className} Class created.`);});

Ejecútalo

Actualice su instancia de depuración o comience de nuevo siguiendo los pasos anteriores. Con la instancia de depuración de VS Code abierta, ejecute nuevamente el comando “Crear clase Python”. Luego, ingrese el nombre de la clase que desea crear. “Persona” en este caso.

Luego ingrese sus propiedades, primero “nombre”.

Luego “edad”.

Luego “hecho” para finalizar.

El archivo se ha creado correctamente.

Luego, vuelva a verificar que su archivo realmente se creó y se ve bien.

Conclusión

En este tutorial, creaste una extensión para resolver un problema específico. Te brinda la oportunidad de aprender más sobre VS Code y también es algo que beneficiará a otros.