En este video, me gustaría mostrarle los
análisis avanzados de código que puede hacer con Nautilus.
Entonces abramos Nautilus. Consideramos por ejemplo
una clase simple, NumberParser.
Ahora miramos lo que
llamamos Senders y los Implementers
A menudo, comprobamos si alguien habla con fluidez en Pharo cuando
ha entendido cómo usar Senders y Implementers
para encontrar información. Echemos un vistazo: cuando
considero un método, Me gustaría saber quien
llama a este método, ¿qué voy ha hacer?
Utilizaré Senders Of.
¿Qué obtendré con Senders Of?
Solo tengo un método
que llama a los Senders Of, se llama
ReadExponent y llama ExponentLetters.
Es una información interesante.
Ahora imaginemos que voy al protocolo
publico, elijo NextInteger. Si pregunto a los Senders,
obtendré esta
lista de Senders potenciales
De hecho, son todos los lugares que envían el mensaje NextInteger.
Aquí veo que estoy en la clase
NumberParser y que llamo a self.
Pues utilizo self para hacer una llamada y sera
necesariamente el método que tengo aquí
Ahora, en los paquetes o en la clase XML, no se muestra
porque necesariamente no lo conoce, al ser Pharo
un lenguaje no tipado, No estoy seguro
si este es el método en cuestión.
De hecho, el sistema muestra que un mensaje
con el mismo nombre ha sido enviado.
Para comprobar esto, puedo, por ejemplo
podria preguntarme, digamos que me gustaría saber
¿cuáles son los implementadores, cuantas veces este
método esta implementado en el sistema.
Para hacer esto, seleccionaré Implementors Of.
Implementors Of. Ah bah mira, mientras en el otro
caso solo tenía un método, por lo que necesariamente era el que estaba
llamado aquí, tengo varios de ellos
Este método, NextInteger, esta definido
en NumberParser, pero también esta definido en XMLInteger.
XMLInteger esta incluso definido en dos clases
diferentes, entonces veo que estos
métodos, estas llamadas, son llamadas de envío de
mensajes y que se resolverán seguramente sobre estos métodos.
Puede ver que Sender y Implementor son
muy importantes. Implementor, le permitirá
ver todas las clases del sistema que implementan un método.
Sender le mostrara todas las llamadas realizadas a un método.
Entonces los Senders, son muy importantes porque
le permiten mirar ejemplos,
le mostrara cómo se invoca un método.
Aquí he seleccionado un método sin argumento,
pero si hubiera elegido un método con un argumento,
por ejemplo Number, NextNumberBase y entonces hago
Sender, ¿Que va a
Mostrarme? Tengo un argumento, y veo que es
la base.
Aquí parece que no es un argumento,
es solo una llamada que pasa un argumento,
pero en esta prueba aquí, veo que
si instancío NumberParser en Stream,
y que luego envío el mensaje NextNumberBase
y el argumento 10.
Esto me permite comprender, ah si, es así como
debo usar la API.
Se usa tanto dispone de atajos de teclado.
Nautilus fue diseñado en origen Para que pueda
hacer todas estas operaciones sin tocar el mouse.
Observe aquí que B significa browse.
Entonces haremos browse Sender, N es para el sender.
busco Implementor, M es para Implementor.
Si selecciono solo "NextNumber" por ejemplo,
y busco N, obtendré
los Senders de NextNumber.
De la misma manera, si selecciono, voila, los obtengo
Ahora si quiero obtener los Implementors Browse M,
Obtengo los implementors.
Es igual sobre las clases, me gustaría
saber cuales son las otras clases del sistema que utilizan
NumberParser. Para saber esto,
Yo selecciono Analize y tengo Class
references. Y obtengo todas
las clases. Obtengo todos los métodos que utilizan
Aquí veo que son principalmente pruebas.
Mira en ClassInteger, llamo
al Parser.
Aquí, el consejo para entender com recordar,
el atajo de teclado, es decirse que aqui es
Browse shift N, es
una mayúscula porque es como
llamar un método, excepto aquí queremos
llamar una clase y una clase es mayor que
un método, entonces tenemos una mayscula.