Ahora que sabemos cómo representar los
elementos de un documento HTML, es momento de ir a por lo realmente
interesante: cómo analizar el documento e ir extrayendo elemento a
elemento, separando unas cosas de otras, decidiendo dónde empieza y
dónde acaba cada cosa.
Afortunadamente, Ruby es, además de un
lenguaje de programación moderno, una mezcla de características de
otros lenguajes. De aquellas características que más le gustaban a
su creador.
Y entre ellas estaban las expresiones
regulares.
Expresiones regulares
Hay veces que necesitas saber si una cadena sigue o no un determinado patrón. Que si comienza así, que si termina de aquel modo, que si contiene tal cosa... Pues bien, para representar los patrones se utilizan las expresiones regulares.
Mira este ejemplo:
| irb(main):001:0> /a.*b/.match('123a11b456')
=> #<MatchData "a11b"> |
Vamos por partes. Para empezar, eso de
/a.*b/ es la expresión regular. Las expresiones regulares se
encierran entre barras “/” pero, como ocurre con las almejas, lo
que nos interesa es lo de dentro. Y ahí pone “a.*b”.
¿Qué significa eso? Bueno, la letra
“a” inicial no tiene demasiado misterio. Quiere decir que la
expresión regular, al compararse con la cadena, trata primero de
encontrar una letra “a”.
Lo de “.*” merece mención aparte.
El punto “.” es un comodín que significa “cualquier carácter”.
Pero no queda ahí la cosa: al punto le sigue un asterisco, *, que, en la
jerga de las expresiones regulares, quiere decir “repite esto
último tantas veces como haga falta. Cero o más veces”.
En definitiva, “.*” podría
traducirse como “repite cualquier carácter cero o más veces”.
O, en otras palabras “aquí me vale cualquier cosa, o incluso
nada”.
Y despúes de “.*” va la “b”.
Resumiendo: /a.*b/ significa que
primero va la “a”, después cualquier cosa de la longitud que sea
y, finalmente, una “b”.
En la cadena que se le pasó como
argumento a “match” en el ejemplo anterior, “123a11b456”, se
puede encontrar ese patrón. Exactamente, a partir del cuarto
carácter tenemos “a11b”. El método “match” lo encuentra y
retorna un objeto de tipo MatchData con la información acerca de qué
coincidencia ha encontrado y dónde la ha hecho.
Sobre expresiones regulares, Ruby y cómo elegir un buen burro
A veces hay más de un posible acierto.
Por ejemplo, imaginemos la misma
expresión regular de antes y la cadena “123a11b456b”. Ahora, la
expresión /a.*b/ tiene dos posibles soluciones: “a11b” y
“a11b456b”. ¿Cuál elige Ruby?
Bueno, la cosa depende (ya se verá más
adelante), pero siguiendo la famosa regla empírica de “mejor el
burro grande, ande o no ande”, lo normal es que se elija la
coincidencia más larga. Y, como no quiero que te creas nada sin
probarlo, vete al irb e inténtalo:
| irb(main):002:0> /a.*b/.match('123a11b456b')
=> #<MatchData "a11b456b"> |
Observa que el valor devuelto no es una
cadena. Es un objeto de tipo MatchData. Si deseas saber qué texto
fue el encontrado y obtenerlo como cadena, puedes utilizar el método
“to_s”
| irb(main):004:0> /a.*b/.match('123a11b456b').to_s
=> "a11b456b" |
Personalmente, creo que no es momento
aún de entrar en más profundidades acerca de cómo funcionan las
expresiones regulares, pero si tú tienes otra opinión, te dejo un
rato para ir a leer el siguiente documento:
| http://www.ruby-doc.org/core/Regexp.html |
Eso sí, vuelve cuando termines. Aquí me quedo esperando.
El tokenizador
Bueno, pues aquí estamos de nuevo. ¿A
qué vino todo ese rollo de las expresiones regulares?
Cuando queremos analizar un documento,
lo primero es ir extrayendo los elementos básicos que lo componen.
Que si una palabra, que si un número,... Esto se llama análisis
lexicográfico y, por hoy, a estos elementos básicos les vamos a
llamar “tokens”.
Después hay que determinar cómo se
relacionan entre sí los elementos para componer estructuras más
complejas. Eso es el análisis sintáctico.
Y, finalmente, hay que ver qué
significan las estructuras que hemos encontrado. El análisis
semántico, vamos.
Por ahora, nos centraremos en el
análisis lexicográfico. Y un poquito del sintáctico. A este nivel,
se trata de hacer cosas como tomar una expresión como:
| contador = contador + 5 |
Y extraer de ella sus tokens e
identificarlos. En el caso anterior, si se pueden ignorar los
espacios, se tendrían cinco tokens:
| Primero hay un nombre de variable, “contador” |
| Después, un operador de asignación “=” |
| Después, un nombre de variable, “contador” |
| Después, un operador aritmético, “+” |
| Después, un número “5” |
Como puedes comprobar, es importante
saber tanto la cadena que representa el token como de qué tipo de
token se trata.
Pues bien, para esto, las expresiones
regulares son muy, muy, muy, muy útiles. Para demostrarlo, vamos a
crear una clase que extraiga los tokens que forman una cadena.
Los objetos de nuestra clase, a la que
llamaremos Tokenizer (así soy de original), necesitarán dos cosas:
- una lista de expresiones regulares, cada una de las cuales tendrá asociado un tipo de token. Por ejemplo, podremos definir una expresión regular consistente en una sucesión de digitos y decir que eso se corresponde con un número entero.
- Una cadena de texto a analizar
Y, una vez les hayamos dado estos
datos, podremos decirle “saca un token y dime qué encuentras y de
qué tipo es”.
Como la mejor forma de demostrar el
movimiento es andando, veamos cómo nos gustaría poder utilizar la
clase. Utilizando irb podríamos empezar por cargar el fichero en que
se define la clase y a crear un objeto Tokenizer
| irb(main):001:0> require './tokenizer.rb'
=> true irb(main):002:0> t = Tokenizer.new('ab28dgadf83a3') => #<Tokenizer:0x8cd7a14 @rules=[], @str="ab28dgadf83a3"> |
Al crearlo, le hemos dicho que queremos analizar la cadena 'ab28dgadf83a3'. Ahora le vamos a añadir dos reglas para reconocer los tokens de esta cadena. Supongamos que queremos reconocer dos tipos de cosas: secuencias de letras y secuencias de números.
Tendremos, pues, dos expresiones
regulares. La primera de ellas, que nos permitirá encontrar los
números, vendrá dada por un hash:
| { :regexp => /[0-9]+/ , :type => :number } |
La expresión regular es /[0-9]+/ .
Cuando en una expresión se encuentra un corchete de apertura y otro
de cierre, “[“ y “]”, eso representa un carácter cualquiera
de los que haya dentro. Así “[abc]” representa “a” o “b”
o “c”. Uno de ellos.
Pero imagina ahora que quieres indicar
que quieres una letra minúscula cualquiera. Podrías poner
| [abcdefghijklmnopqrstuvwxyz] |
¿Qué te parece? ¿No es demasiado
largo? Aparte de que uno puede equivocarse cuando escribe tanto. Por
eso hay una forma alternativa de escribirlo:
| [a-z] |
Con “a-z” se indica “cualquier
carácter desde la “a” hasta la “z”.
De igual forma,
| [0-9] |
… representa cuanquier carácter del
“0” al “9”. Cualquier dígito.
En nuestra expresión regular, después
va un signo más, “+”. Este carácter quiere decir “repite lo
anterior una o más veces”. O sea, y en definitiva, que “[0-9]+”
quiere decir “uno o más dígitos”. Y a eso le asignamos el tipo
:number.
De igual forma, a “[a-z]+”, una
secuencia de letras de longitud mayor que cero, le asignamos el tipo
:letter con
| { :regexp => /[a-z]+/ , :type => :letter } |
Podemos usar un método llamado
addRules para añadir ambas reglas de una sola vez:
| irb(main):003:0> t.addRules([{:regexp=>/[0-9]+/,
:type=>:number},{:regexp=>/[a-z]+/, :type=>:letter}])
=> [{:regexp=>/[0-9]+/, :type=>:number}, {:regexp=>/[a-z]+/, :type=>:letter}] |
Y ya sólo quedaría decirle al objeto
que nos proporcione los tokens que hay en la cadena y hacer algo con
ellos. Habrá un método, getTokens, que lo haga:
| irb(main):004:0> t.getTokens.each {|x| print x.inspect ;
print "\n"}
{:type=>:letter, :string=>"ab"} {:type=>:number, :string=>"28"} {:type=>:letter, :string=>"dgadf"} {:type=>:number, :string=>"83"} {:type=>:letter, :string=>"a"} {:type=>:number, :string=>"3"} => [{:type=>:letter, :string=>"ab"}, {:type=>:number, :string=>"28"}, {:type=>:letter, :string=>"dgadf"}, {:type=>:number, :string=>"83"}, {:type=>:letter, :string=>"a"}, {:type=>:number, :string=>"3"}] |
Observa que el bloque de código contiene dos instrucciones y que, como están en la misma línea, hay que buscar una forma de separarlas. En Ruby, para eso, podemos usar un punto y coma “;”.
getTokens nos extrae todos los tokens de una sola vez. También existirá un método, getToken (en singular) que obtiene sólo un token.
A ambos, getTokens y getToken, le vamos a añadir una característica más. Puede que haya ocasiones y situaciones en que no todos los tipos de tokens sean sintáctica o semánticamente correctos. En que no queramos obtener un token de un tipo inadecuado. Para esos casos, los dos métodos admitirán un parámetro que les indique qué tipos de token queremos reconocer.
Esto nos permitirá tambén utilizar un mismo objeto Tokenizer para distintos análisis. Algunas veces puede venir bien tener este grado de flexibilidad. Y, como veremos, es algo que no cuesta demasiado.
La creación del objeto
Comencemos con los métodos que preparan el objeto para hacer su trabajo. Ahí van los primeros:| # Object creation. Initial text may be provided / Creación
del objeto. Se puede dar texto inicial
def initialize(str='') @rules = [] loadStr(str) end # Load initial text / Cargar el texto inicial def loadStr(str='') @str = str end |
Poco nuevo hay aquí. El objeto tendrá dos variables de instancia, @rules y @str, que contendrán las reglas (lo de las expresiones regulares y sus correspondientes tipos) y la cadena a analizar, respectivamente. Pasemos ahora a la carga de los patrones a buscar:
# Add a rule for token recognition / Añadir regla para reconocimiento de tokien # Parameters / Parámetros: # regexp: String or RegExp with the regular expression. If it doesn't start with \A, \A will be #appended at the start # Cadena o Expresión Regular con la expresión regular. Si no empieza por \A, se le añade al #principio # type: Symbol recommended. A type for the regexp. Several regexp may share a common type # Recomendable que sea Symbol. El tipo asociado a regexp. Varias regexp pueden compartir tipo # opts: Options when applying the regexp # Opciones para aplicar regexp def addRule(regexp, type, opts = Regexp::MULTILINE + Regexp::IGNORECASE) str = case regexp.class.name when 'Regexp' then regexp.source when 'String' then regexp else raise 'Unsupported type for regexp' end if str[0..1] != '\A' str = '\A' + str end myregexp = Regexp.new(str, opts) @rules.push({:regexp=>myregexp, :type=>type}) end |
El método sirve para que le digamos al objeto “cuando encuentres algo que siga este patrón, es que tienes un token de tal tipo. Y recibe tres parámetros.
Para no empezar por el principio, el segundo de los parámetros indica qué tipo de token estamos definiendo. A Ruby no le preocupa demasiado qué Yo recomendaría usar aquí valores de tipo Symbol, salvo que se tenga una razón fundada para hacer otra cosa. Ya veremos por qué.
El primero es una expresión regular o bien una cadena que contiene el texto correspondiente a una expresión regular. Igual me da que pongas una cadena como 'a.*b' que una expresión regular como /a.*b/ . En ambos casos, eso va a indicar el patrón que hay que encontrar.
Y el tercero son unas opciones a utilizar cuando se utilice la expresión regular. Ruby tiene unos cuantos. Por defecto, le diremos que las expresiones regulares pueden ocupar más de una línea y que no nos preocupa si las cosas están en mayúsculas o la minúsculas.
El cuerpo del método comienza con una estructura rara:
| str = case regexp.class.name
when 'Regexp' then regexp.source when 'String' then regexp else raise 'Unsupported type for regexp' end |
Aquí “str” es una variable local al método. Las variables locales se crean al asignarles el valor. Y esta vez el valor que se le asigna es el resultado de evaluar
| case regexp.class.name
when 'Regexp' then regexp.source when 'String' then regexp else raise 'Unsupported type for regexp' end |
Los bloques “case” como éste, toman una expresión (en este caso “regexp.class.name”, una cadena con el nombre de la clase a que pertenece el parámetro “regexp”) y la evalúan. Después miran, una a una, las reglas “when opcion then valor” que siguen. En el caso anterior tenemos
| when 'Regexp' then regexp.source
when 'String' then regexp |
.. lo que quiere decir: si es “Regexp”, entonces el valor a devolver es “regexp.source”. El método “source” de la clase “Regexp” convierte la expresión regular en una cadena. Por otro lado, si ya es “String”, entonces retorna directamente “regexp”.
En definitiva, ¿recuerdas que regexp podía ser una expresión regular o una cadena? Pues estamos asegurándonos de que a partir de ahora vamos a trabajar con una cadena.
Lo de
| else raise 'Unsupported type for regexp' |
… quiere decir que si no se cumple ninguna de las condiciones de las reglas “when … then ...” (eso es el “else”), se genere una excepción de esas que suelen hacer cascar los programas, con el mensaje de error “Unsupported type for regexp” (“Tipo de datos no soportado para regexp”). La instrucción “raise” se encarga de provocar el error.
Quizá no te parezca buena idea esa de hacer reventar tú mism@ tus programas. Que no queda bien eso de que tus aplicaciones terminen de forma rara y con mensajes de error. Pues te aseguro que te equivocas: me sé de una compañía de software cuyos productos no paran de hacerlo y se venden como rosquillas.
Aparte de eso, ocasión habrá de ver como lidiar con las excepciones y utilizarlas en beneficio propio.
Dejando atrás estas disquisiciones y volviendo al grano, como es de esperar, un “end” marca el final de la expresión.
A continuación aparece:
if str[0..1] != '\A'
str = '\A' + str
end |
La instrucción “if” permite ejecutar unas instrucciones si y solo si se cumple una condición. En este caso, se comprueba si “str[0..1] != '\A'”.
Recuerda que “str” era una cadena. Con str[0..1] se obtienen los caracteres de str que ocupan las posiciones a partir de la 0 (el primer carácter) hasta la 1 (el segundo). En definitiva, estamos hablando de los dos primeros caracteres de str. Después va “!=” que significa “es distinto de”.
Tenemos encontces que si los dos primeros caracteres de str no son “\A”, se le pone “\A” al principio. De ese modo nos aseguramos que str va a comenzar por “\A” ¿Y a qué viene este afán?
Bueno, queremos ir obteniendo los tokens en orden, empezando por el principio, y, como vimos, el método “match” de las expresiones regulares busca en cualquier posición de la cadena... a no ser que le digamos lo contrario. Y “\A” es un código especial de las expresiones regulares que indica, precisamente, el inicio del texto.
Seguimos con
| myregexp = Regexp.new(str, opts) |
… que crea una expresión regular a partir de la cadena str y con las opciones que le pasamos al método (recuerda, el tercer parámetro) para después asignársela a la variable local myregexp.
Y acabamos con
| @rules.push({:regexp=>myregexp, :type=>type}) |
… que usa el método “push” para añadir un elemento al final del array @rules . Dicho elemento es un hash cuyos índices :regexp y :type apuntan a la expresión regular y su correspondiente tipo, respectivamente.
Ya tenemos como añadir las reglas de una en una. Si queremos poder hacerlo en modo batch (aquí lo llamamos “a puñaos”), podemos definir otro método con unas cuantas líneas de código más:
| # Utility function to add several rules at once from an array
of hashes with indexes :regexp and :type
# Función de ayuda para añadir varias reglas de una vez a partrir de un array de hashes con índices :regexp y :type # Parameters / Parámetros: # array: the array / el array # opts: options for regexp / opciones para aplicar las regexp def addRules(array, opts = Regexp::MULTILINE + Regexp::IGNORECASE) array.each do |r| addRule(r[:regexp], r[:type], opts) end end |
Usando el objeto
Con lo anterior tenemos suficiente para crear y configurar el objeto. Pero, claro, si no añadimos algunos métodos más, no nos va a servir para nada. Comencemos por determinar si queda o no texto por procesar:| # True if there is nothing more to read / True si no queda
nada por leer def endOfString? return @str == '' end |
Fíjate que le hemos puesto un interrogante al final del nombre del método. Y recuerda que eso era habitual (que no obligatorio) en los métodos que retornaban true o false.
Una sóla línea de instrucciones: “ return @str == '' ”.
Con “@str == '' “ se comprueba si @str es igual a la cadena vacía. El valor resultante de evaluar esta condición es retornado por el método. De hecho, aquí no sería obligatorio poner el “return”, puesto que los métodos retornan, si no se le dice otra cosa, el resultado de evaluar la última instrucción ejecutada. De modo que habría bastado con:
| # True if there is nothing more to read / True si no queda
nada por leer def endOfString? @str == '' end |
Y ahora al meollo de la cuestión: cómo reconocer el primer elemento de la cadena:
| def getToken(types=nil)
if endOfString? return nil end # Select applicable rules myrules = @rules.select{|r| types == nil or types.include?(r[:type])} # Get longest match match, type = myrules.collect{|r| [r[:regexp].match(@str), r[:type]]}.max{|x,y| x[0].to_s.length <=> y[0].to_s.length} string = match.to_s # If found, process output. Else return nil if string != '' # Removed matched text from the input @str = match.post_match # Subclasses may define methods to process each type if private_methods.include?(type) return send(type.to_s, match[0]) else return {:type=>type, :string=>string} end else return nil end end |
Lo primero que hacemos es comprobar si nos queda algo que analizar. En caso contrario, el método retorna “nil” (recuerda: nil significa nada). Lógico: si no hay cadena a procesar, no hay tokens.
Después seleccionamos qué reglas vamos a comprobar. Porque, recuerda, nuestra clase es capaz de comprobar sólo una o varias reglas si se lo decimos. Y para decírselo tenemos el parámetro opcional “types” al que podemos asignar un array de tipos:
| myrules = @rules.select{|r| types == nil or types.include?(r[:type])} |
Observa que se aplica a @rules, un array, el método “select” que permite seleccionar aquellos elementos que cumplen una condición. La condición viene dada por el bloque
| {|r| types == nil or types.include?(r[:type])} |
O lo que es lo mismo, si no se ha pasado ningún array de tipos permitidos (types == nil), se considera que todas las reglas son aplicables. Y si se ha pasado una lista de tipos, se seleccionan sólo aquellas reglas cuyo tipo asociado figure en esa lista.
Observa el uso del operador “or”. Una expresión del tipo “a or b” retorna valor true si a es cierto o, caso de que a sea falso, si b es cierto. Y en otro caso retorna false.
Ahora myrules contiene las reglas aplicables. Vamos a la instrucción más extraña de todas:
| match, type = myrules.collect{|r| [r[:regexp].match(@str), r[:type]]}.max{|x,y| x[0].to_s.length <=> y[0].to_s.length} |
Rara por varias cosas. En primer lugar porque es una asignación, pero en el lado de la izquierda hay dos variables separadas por comas en lugar de sólo una. Ruby permite asignar los elementos de un array a varias variables a la vez.
| irb(main):012:0> v1, v2, v3 = [1, 3, 5]
=> [1, 3, 5] irb(main):013:0> v1 => 1 irb(main):014:0> v2 => 3 irb(main):015:0> v3 => 5 |
Luego, deducirás, lo que hay a la derecha del operador de asignación debe retornar un array de al menos dos elementos. ¡Bien! ¡Se ve que te vas haciendo con la filosofía de Ruby!
Y... ¿qué contiene ese array?
Vamos por partes. En primer lugar, aplicamos el método “collect”. Para cada elemento de myrules, se compara su expresión regular con @str, nuestra cadena de texto a analizar. Después se crea un array de dos elementos: la coincidencia encontrada (que bien podría ser de longitud cero si no se ha encontrado nada) y el tipo de token asociado a la regla aplicada.
Y con todos ellos se crea un nuevo array. Eso significa lo de:
| myrules.collect{|r| [ r[:regexp].match(@str), r[:type] ] } |
Lo ideal sería que, como mucho, existiera una única coincidencia de longitud mayor que cero. Pero... ¿y si hay más de una? En ese caso, nos quedaremos con la que se corresponda a una cadena más larga (otra vez la regla de oro del burro grande). Para eso utilizamos el método “max”, que permite obtener el máximo valor de un array.
Comparando lo incomparable
Si el array contuviera números, está claro cuál sería su máximo: el mayor de todos ellos. Si contuviera cadenas, es de esperar que se eligiera la que álfabéticamente queda en último lugar. Pero estamos procesando un array de arrays... ¿cómo se comparan unos arrays formados por dos elementos: un MatchData y, previsiblemente, un Symbol?Bueno, Ruby quizá no lo sepa, pero sabe que nosotros sí. Que tenemos un criterio en mente. Por eso se le puede pasar a “max” un bloque de código que sirva para evaluar si un elemento es mayor o menor que otro. El valor retornado por el bloque debe usar la misma convención que el operador “<=>”: positivo si el primer valor a comparar se considera mayor que el segundo, negativo si menor y cero si son iguales.
El criterio en este caso es la longitud de la coincidencia encontrada. O sea:
| {|x,y| x[0].to_s.length <=> y[0].to_s.length} |
Donde x e y son arrays de dos elementos. El primer elemento es una coincidencia MatchData y, el segundo, el tipo asociado.
De modo que x[0] e y[0] son las coincidencias. Comparamos sus longitudes... y la mayor de ellas gana y es la seleccionada.
Y ahora que lo tenemos, vamos a ver qué hacemos con ello. Lo primero es comprobar si la cadena que se ha encontrado es vacía o no. Si no es vacía la procesaremos y si sí lo es retornaremos un valor nil, puesto que no hemos encontrado nada.
Para realizar este tipo de cosas son útiles las sentencias “if … else”, cuyo formato es:
| if condición acciones a realizar si la condición es cierta else acciones a realizar si la condición es falsa end |
Volviendo a nuestro método tenemos:
| string = match.to_s
if string != ''
# Removed matched text from the input
@str = match.post_match # Subclasses may define methods to process each type if private_methods.include?(type) return send(type.to_s, match) else return {:type=>type, :string=>string} end else return nil end |
De haber encontrado algo, lo primero es quitarlo de @str, de modo que no se lo vuelva a reconocer la próxima vez que se llame a getToken. Para ello usamos el método “post_match” que devuelve el texto de la cadena que va detrás de la coincidencia.
La pregunta del millón
Y después hacemos una pregunta curiosa: ¿Incluye private_methods, la lista de los métodos privados de nuestra clase, uno cuyo nombre sea igual al valor representado por el tipo de la regla seleccionada? O sea, y por poner un ejemplo, si la regla tuviera asignado el tipo :entero... ¿Tiene la clase un método privado llamado “entero”?Pero ¿acaso no sabemos nosotros, que estamos haciendo la clase, si tenemos o no algún método privado y cómo se llama? ¿a qué viene esta pregunta?
Bueno, de hecho esta clase no va a tener ningún método privado. Así que la cosa estaría clara. Pero recuerda lo de la herencia y las subclases. Quién sabe qué van a tener las subclases que podamos crear a partir de ahora.
Si el método privado existe, ejecutamos otra instrucción llamativa:
| send(type.to_s, match[0]) |
El método send es una forma de invocar los métodos aplicables a un objeto. Es lo mismo poner
| 3 + 1 |
… que
| 3.+(1) |
… que
| 3.send('+',1) |
… que
| 3.send(:+,1) |
Fíjate: al usar “send”, en los parámetros primero se pone el identificador del método a invocar, como cadena o como Symbol, y después, si es necesario, los parámetros que hay que pasarle.
Nosotros usamos “send” para que futuras subclases puedan definir qué hacen cada vez que encuentran algo. Y, por si no lo hacen, prevemos que por defecto vamos a retornar un hash de dos elementos, de índices :type y :string, que contienen el tipo de token encontrado y la cadena reconocida.
Pues ya hemos casi acabado. Para simplificar las cosas podemos definir un método que saque todos los tokens de una cadena, uno trás otra, y cree un array con ellos:
| def getTokens(types=nil, str=nil)
if str != nil loadStr(str) end return_value = [] while (r = getToken(types)) != nil return_value.push(r) end return return_value end |
Lo único que llama aquí la atención es eso del while:
| while (r = getToken(types)) != nil
return_value.push(r) end |
La construcción while realiza una comprobación y, si es falsa, no hace nada. Si es cierta, ejecuta un conjunto de instrucciones y, cuando las termina, vuelve a empezar con la comprobación.
La condición consiste en comparar dos valores y ver si son distintos. El primer valor es el resultado de evaluar
| (r = getToken(types)) |
Una asignación. Asignamos a “r” el resultado de obtener un token. Recuerda que una asignación se evalúa al valor asignado. En nuestro caso, el token.
Si eso es distinto de nil es que algún token encontramos. Así que cogemos ese token y lo añadimos al final del array return_value:
| return_value.push(r) |
Para, cuando todo acabe, retornar este array:
| return return_value |
Ya está todo listo...
La clase completa
Y esto es lo que tenemos:| # Class to parse a text and extract tokens from it
class Tokenizer # Object creation. The initial text may be provided / Creación del objeto. Se le puede dar el texto inicial def initialize(str='') @rules = [] loadStr(str) end # Load initial text / Cargar el texto inicial def loadStr(str='') @str = str end # Add a rule for token recognition / Añadir regla para reconocimiento de tokien # Parameters / Parámetros: # regexp: String or RegExp with the regular expression. If it doesn't start with \A, \A will be appended at the start # Cadena o Expresión Regular con la expresión regular. Si no empieza por \A, se le añade al principio # type: Symbol recommended. A type for the regexp. Several regexp may share a common type # Recomendable que sea Symbol. El tipo asociado a regexp. Varias regexp pueden compartir tipo # opts: Options when applying the regexp # Opciones para aplicar regexp def addRule(regexp, type, opts = Regexp::MULTILINE + Regexp::IGNORECASE) str = case regexp.class.name when 'Regexp' then regexp.source when 'String' then regexp else raise 'Unsupported type for regexp' end if str[0..1] != '\A' str = '\A' + str end myregexp = Regexp.new(str, opts) @rules.push({:regexp=>myregexp, :type=>type}) end # Utility function to add several rules at once from an array of hashes with indexes :regexp and :type # Función de ayuda para añadir varias reglas de una vez a partrir de un array de hashes con índices :regexp y :type # Parameters / Parámetros: # array: the array / el array # opts: options for regexp / opciones para aplicar las regexp def addRules(array, opts = Regexp::MULTILINE + Regexp::IGNORECASE) array.each do |r| addRule(r[:regexp], r[:type], opts) end end # True if there is nothing more to read def endOfString? return @str == '' end # Get the next token. An array with the allowed types may be provided # Returns nil if no match was found def getToken(types=nil) if endOfString? return nil end # Select applicable rules myrules = @rules.select{|r| types == nil or types.include?(r[:type])} # Get longest match match, type = myrules.collect{|r| [r[:regexp].match(@str), r[:type]]}.max{|x,y| x[0].to_s.length <=> y[0].to_s.length} string = match.to_s # If found, process output. Else return nil if string != '' # Removed matched text from the input @str = match.post_match # Subclasses may define methods to process each type if private_methods.include?(type) return send(type.to_s, match) else return {:type=>type, :string=>string} end else return nil end end # Get tokens from a String. A list of applicable types and a string may be provided def getTokens(types=nil, str=nil) if str != nil loadStr(str) end return_value = [] while (r = getToken(types)) != nil return_value.push(r) end return return_value end end #class Tokenizer |
Guárdalo en un fichero llamado “tokenizer.rb” y... experimenta un poco.
