Question syntaxe Ruby

Community FR
#1

Bonjour,

Je profite de la réponse de Zifro (merci à lui) pour poser une question de
syntaxe Ruby. j’arrive pas à comprendre cette
tournure :

Inflector.inflections do |inflect|
inflect.irregular ‘jeu’, ‘jeux’
end

Je la recopie bêtement et ça marche, mais… comprends pas.

Ce dont j’ai l’impression c’est que ça veut dire :

“Pour chaque inflection que tu trouves dans Inflector, nomme la inflect,
et exécute la(les) instruction(s) suivante(s).”

Du coup j’ai du mal à voir le rapport avec “ajoute une règle” (ou qqchose de
ce gout-là), qui serait, intuitivement, là
chose à faire…

gUI

–
Pour la santé de votre ordinateur, préférez les logiciels libres !

Guillaume B. : (05 61) 19 40 65 / bureau S723

#2

Sans avoir lu le code source, je le comprends plutôt comme ça :

Hé toi la classe Inflector, donne moi un objet représentant les
inflections, que je les manipule !
Tiens, j’ajoute un irrégulier : “jeu” qui va s’écrire “jeux” au pluriel.

#3

A mon avis, il faut plus le voir comme :

File.open(filename, ‘w’) do |output_file|
output_file << ‘coucou les gens’
end

Stéphane

Le 07/12/06, Guillaume B.
[email protected]
a écrit :

#4

Hé toi la classe Inflector, donne moi un objet représentant les
inflections, que je les manipule !

pourquoi pas, mais en quoi on en ajoute une nouvelle, et pas on remplace
celles existantes ? a moins que ca veuille dire
qu’il n’y en avait pas auparavent, donc en effet on n’écrase rien ?

gUI

–
Pour la santé de votre ordinateur, préférez les logiciels libres !

Guillaume B. : (05 61) 19 40 65 / bureau S723

#5

On 12/7/06, Guillaume B.
[email protected] wrote:

Hé toi la classe Inflector, donne moi un objet représentant les
inflections, que je les manipule !

pourquoi pas, mais en quoi on en ajoute une nouvelle, et pas on remplace celles existantes ? a moins que ca veuille dire
qu’il n’y en avait pas auparavent, donc en effet on n’écrase rien ?

Pour savoir ce que signifie la syntaxe, je te suggère de voir 1) le
code source de Inflector.inflections sur
http://www.rubyonrails.org/api/classes/Inflector.html#M000944 et 2) de
lire l’introduction et le code source des méthodes de
http://www.rubyonrails.org/api/classes/Inflector/Inflections.html

Instructif :slight_smile:

#6

C’est très bien expliqué dans la doc, chercher “Inflector.inflections”

Voici l’exemple plus complet qui est proposé :

Inflector.inflections do |inflect|
inflect.plural /^(ox)$/i, ‘\1\2en’
inflect.singular /^(ox)en/i, ‘\1’
inflect.irregular ‘octopus’, ‘octopi’
inflect.uncountable “equipment”
end

Ca montre qu’on n’est pas limité au sens singulier -> pluriel et qu’on
peut
s’appuyer sur des expression régulières

#7

pourquoi pas, mais en quoi on en ajoute une nouvelle, et pas on remplace celles existantes ? a moins que ca veuille dire
qu’il n’y en avait pas auparavent, donc en effet on n’écrase rien ?

Inflector.inflections do |inflect|
inflect.irregular ‘jeu’, ‘jeux’
end

C’est aussi “un peu” comme si on écrivait :

ReglesInflection.to_h do |regles|
regles[‘jeu’] = ‘jeux’
end

On ne peut remplacer que la règle existante pour ‘jeu’, pas les autres.

Les migrations fonctionnent aussi avec une classe à qui on demande de
créer une table et à qui (la classe) on passe un bloc qui remplit
ladite table.

#8

N.B : l’instance d’Inflector retournée par Inflector.inflections est un
singleton.

Et heureusement sinon on pourrait avoit plusieurs pluralisations
concurrentes.

Ce qui laisse penser qu’il vaut mieuw traiter ça au départ de l’appli (
application.rb) et ne pas y toucher en cours de route.

#9

Je sais pas si j’ai été super clair, mais bon… :slight_smile:

Très clair !!! Question subsidiaire…

aurais-je donc pu tout simplement écrire :

Inflector.inflections.irregular ‘jeu’,‘jeux’

au lieu de :

Inflector.inflections do |inflect|
inflect.irregular ‘jeu’, ‘jeux’
end

si oui, l’interet est-il dans la facilité d’ajouter des lignes ? dans la
syntaxe de style bloc qui permet de limiter
“géographiquement” les instructions ?

gUI

–
Pour la santé de votre ordinateur, préférez les logiciels libres !

Guillaume B. : (05 61) 19 40 65 / bureau S723

#10

Si tu regardes dans les sources de Rails et plus précisément dans
ActiveSupport à cette adresse :
http://dev.rubyonrails.org/svn/rails/trunk/activesupport/lib/active_support/inflector.rb

Tu te rends compte que la classe ‘Inflections’ du module ‘Inflector’ a
des attributs en lectures qui sont des tableaux :

attr_reader :plurals, :singulars, :uncountables

C’est ces tableaux qui sont manipulés dans les méthodes ‘plural’,
‘singular’, ‘irregular’, etc…

Si tu regardes un peu plus bas l’implémentation de la méthode
‘irregular’ on s’aperçoit qu’elle appelle successivement la méthode
‘plural’ et la méthode ‘singular’
qui vont modifier respectivement les tableaux ‘@plurals’ et
‘@singulars’.

Donc l’appel à la méthode >> irregular(‘jeu’, ‘jeux’)
appellera donc :

plural(Regexp.new("(j)eu$", “i”), ‘\1’ + ‘eux’)
singular(Regexp.new("(j)eux$", “i”), ‘\1’ + ‘eu’)

Et donc ajoutera des nouvelles règles dans les tableaux “@plurals” et
“@singular” pour pouvoir les manipuler ensuite dans ton appli.

Et donc :

Inflector.inflections do |inflect|
inflect.irregular ‘jeu’, ‘jeux’
end

Veut bien dire donne moi l’instance de la classe
‘Inflector::Inflections’ et mets la dans la variable ‘inflect’ (Si on
fait un ‘inflect.class’ on a bien ‘Inflector::Inflections’) et avec
cette variable (‘inflect’) appelle la méthode ‘irregular’ qui est une
méthode qui va modifier les tableaux de la classe
‘Inflector::Inflections’ en y ajoutant de nouvelles règles.

Pour vérifier que ‘irregular’ a bien modifié les tableaux ‘@plurals’
et ‘@singulars’ on peut appeler cette méthode :

Inflector.pluralize(‘jeu’)
=> “jeux”

Pour connaître les règles déjà présentes, elles se trouvent ici :
http://dev.rubyonrails.org/svn/rails/trunk/activesupport/lib/active_support/inflections.rb

Et comme l’a dit Philippe, l’instance d’Inflector::Inflections est un
singleton donc qu’une seule instance de cet objet.

Je sais pas si j’ai été super clair, mais bon… :slight_smile:
Voilou

Mathieu

On 12/7/06, philippe lachaise [email protected] wrote:

Railsfrance mailing list
[email protected]
http://lists.rubyonrails.fr/mailman/listinfo/railsfrance

–
Mathieu Fosse

http://blog.kawooa.org
http://www.ziki.com/people/pointcom

#11

Je sais pas si j’ai été super clair, mais bon… :slight_smile:

Très clair !!! Question subsidiaire…

Merci

aurais-je donc pu tout simplement écrire :

Inflector.inflections.irregular ‘jeu’,‘jeux’

au lieu de :

Inflector.inflections do |inflect|
inflect.irregular ‘jeu’, ‘jeux’
end

La réponse est oui.

si oui, l’interet est-il dans la facilité d’ajouter des lignes ? dans la syntaxe de style bloc qui permet de limiter
“géographiquement” les instructions ?

Non c’est juste que le bloc est peut être plus approprié car il faut
souvent ajouter plusieurs règles à une application (surtout si tu veux
la Franciser). Mais si tu en a vraiment qu’une alors tu peux utiliser
:

Inflector.inflections.irregular ‘jeu’,‘jeux’

–
Mathieu Fosse

http://blog.kawooa.org
http://www.ziki.com/people/pointcom

#12

La réponse est oui.

J’ai donc compris (-:

la syntaxe elle-meme est donc tout simplement :

liste_d’objets do |var|
instructions
end

pour dire :
pour chaque objet de la liste, mets le dans la variable “var” et execute
“instructions”.

le “piège” (pour le noob que je suis) résidais donc dans :

  • le singleton (la boucle qui ne tourne qu’une fois en fait)
  • la méthode irregular qui est plus évoluée que son nom le fait paraitre :
    elle ajoute une règle

promis, je vais me mettre à rédiger quelque “best of de la liste”, en tous
cas en ce qui me concerne : les questions
vraiment de base (j’en suis à 3 ou 4 qui sont réellement des incontournables
pour le parfait néophyte).

encore merci et bravo à tous (-;

gUI

–
Pour la santé de votre ordinateur, préférez les logiciels libres !

Guillaume B. : (05 61) 19 40 65 / bureau S723

#13

Désolé pour l’orthographe et la grammaire plus que désastreuse…
faut vraiment que je me relise.

Jonathan

#14

Le 7 déc. 06 à 12:14, Guillaume B. a écrit :

la syntaxe elle-meme est donc tout simplement :

liste_d’objets do |var|
instructions
end

pour dire :
pour chaque objet de la liste, mets le dans la variable “var” et
execute “instructions”.

Pour moi tu fait une petite méprise, la syntaxe de block n’a rien à
voir (même si elle peut être utilisé pour cela) avec une boucle (ou
une itération).

Le principe d’un block c’est uniquement de passé à une méthode un
“block”, qui sera ensuite appeler avec (ou sans paramètre) par la-
dite méthode.

Par exemple :

1…5.each do |var|
puts var
end

On passe le block {puts var} à la méthode #each qui elle va appelé le
block avec en paramètre 1 puis 2 puis 3… jusque 5.

Mais la syntaxe
do |x|
end

ou

{|x| }

n’est en rien lié à une quelconque notion de boucle, c’est uniquement
un “bout de code” passé à une fonction et qui pourra être appelé par
celle-ci.

Voilà je ne sais pas si j’ai été clair.

Tron J.
http://jonathan.tron.name

#15

Mais la syntaxe
do |x|
end

ou

{|x| }

n’est en rien lié à une quelconque notion de boucle, c’est uniquement
un “bout de code” passé à une fonction et qui pourra être appelé par
celle-ci.

Le rapport avec le concept de boucle (passer ce rapport sous silence
rique
d’entretenir la confusion) est qu’on retrouve le plus souvent des blocs
en
conjonction avec des ITERATEURS.

Et qu’est-ce qu’un itérateur sinon une façon moderne de faire une boucle
?

(ceux qui ont tapé 1.000.000 de fois, for ( int i = 0 ; i < count ; i++
) {
… } comprendront bien :wink:

L’exemple tarte à la crème :

mon_tableau.each do | element |
puts element.to_s # Fait qqchose avec l’élément
end

Il y a des fois où le concept de boucle (ou d’itérateur) n’est PAS
associé Ã
l’usage d’un bloc, et c’est le cas pour :

Inflector.inflections do |inflect|
inflect.irregular ‘jeu’, ‘jeux’

…

end

C’est juste un raccourci d’écriture pratique pour rassembler, Ã
l’intérieur
d’un bloc, plusieurs actions sur une inflection.