Menu qui change en fonction du controleur

bonjour,

dans mon application, j’ai plusieurs controleurs. en gros, j’ai un menu
horizontal, en haut de la page, qui permet de passer d’un controleur
à l’autre
(les controleurs font un découpage fonctionnel), et à gauche de la page un
sous-menu, qui en fonction du controleur permet d’accéder à différentes
actions
du controleur.

comme j’utilise le layout “application”, j’ai fait dans celui-ci un gros
switch/case sur le controleur, et selon le controleur je mets les lignes
du menu
qui vont bien.

je trouve ça très moche (“programmatiquement” parlant), pas franchement
pratique
à maintenir… mais je sais pas faire autrement )-:

un conseil ?

merci (-:

gUI

sinon voir peut etre http://agilewebdevelopment.com/plugins/simple_sidebar

je connaissais pas ! au mieux je le prend tel quel, au pire je m’en
inspirerai !

merci (((-:

gUI

Bonjour,
Je bais certainement dire une connerie mais je me lance.
Moi je ferais une boucle sur un tableau associatif dans ton layout (si
il est définie)
et a charge a chaque controlleur de définir le tableau de type {:nom =>
“index”,:action => “action”},{:nom => “voir”,:action => “view”}

voilà c pt pas super mais bon…

sinon voir peut etre
http://agilewebdevelopment.com/plugins/simple_sidebar
Guillaume B. a écrit :

qui vont bien.

Guillaume BELLEGUIC
LES ACCORDEURS DE RESEAUX
e-ngoma / Ker data
4, cours Kennedy
35000 Rennes

[email protected]
http://www.e-ngoma.net

tèl : +33 (0)299 33 87 48
fax : +33 (0)299 33 97 31

RCS Rennes 487 799 892


j’ai fait dans celui-ci un gros switch/case sur le controleur, … je
trouve ça très moche

C’est très moche :slight_smile:

De tête (donc pas testé)

  1. je mettrai dans le controlleur d’application une méthode
    diplay_menu()
    (par ex.) qui m’affiche le menu par défaut.
  2. Dans chaque controleur je définierai une méthode diplay_menu() qui
    irait
    charche le “partial” qui va bien.

Si dans mon layout j’ai qqpart <%= diplay_menu %> il ira (je pense)
chercher le bon.

Encore un fois j’ai pas testé, mais je suis sûr que la bonne solution
passe
par un polymorphisme de ce genre.

Encore un fois j’ai pas testé, mais je suis sûr que la bonne solution passe
par un polymorphisme de ce genre.

C’est pas mal ça ! Je tenterai également (-:

gUI

Salut,

Voici un article interessant sur le sujet :

On 2/7/07, Guillaume B.
[email protected]

Voici un article interessant sur le sujet : Strut Your Structs — err.the_blog

alors ça, c’est enoooorme !

extrait de la fin : “Let’s recap. Larry can now define content_for
:sidebar in a
view, define it for a whole set of controller views, and also have a
site-wide
default. All at the same time. Talk about power!”

ca répond à une de mes vieilles questions, ou je me demandais comment
arriver à
hiérarchiser les différents morceaux, entre :

  • layout application
  • layout controleur
  • vue action
    en effet, le fait que le layout application ne soit executé que si il n’y
    a pas
    de layout controleur, empeche cette hiérarchie…

avec ce truc, c’est réglé !!!

gUI

Je confirme, j’utilise ce plugin

plugin ? tu parles de simple_sidebar ?

gUI

Le mercredi 07 février 2007 à 17:23 +0100, Guillaume B. a écrit :

alors ça, c’est enoooorme !

avec ce truc, c’est réglé !!!

gUI

Je confirme,

j’utilise ce plugin dans une application en cours de développement et ça
fonctionne sans problèmes.

Mourad

Ben si quelqu’un pouvait m’expliquer pourquoi yield peut se substituer Ã
content_for il aurait ma gratitude éternelle :wink:

C’est un des ces trucs un peu trop magiques qui n’aident pas forcément
la
compréhension.

On 2/8/07, Guillaume B.
[email protected]

Voici un article interessant sur le sujet : Strut Your Structs — err.the_blog

j’ai lu et appliqué çà hier. c’est tout bete à mettre en place, et ultra
souple
!

c’est exactement ce que je cherchais (-:

par contre, n’utilisant pas les partiels (c’est juste que je m’y suis
jamais
mis, j’ai rien contre), je risque de tomber dans l’utilisation exclusive
du
yield/content_for. je suppose chacun a ses utilisations adaptées, ses
recommendations, mais j’ai du mal à voir… qqu’un saurait-il me
l’expliquer ?

gUI

Le Jeu 8 février 2007 08:48, philippe lachaise a écrit :

Ben si quelqu’un pouvait m’expliquer pourquoi yield peut se substituer à
content_for il aurait ma gratitude éternelle :wink:

C’est un des ces trucs un peu trop magiques qui n’aident pas forcément la
compréhension.

Le yield(:toto) permet simplement d’accéder à ce qui est créé par le
content_for(:toto) { … }.
Avant on utilisait une variable d’instance @content_for_toto mais comme
un
peu sur tout, on tente d’utiliser des accesseurs pour plus
d’abstraction.
Ils ont simplement eu la mauvaise idée de réutiliser le mot clé “yield”
des blocs en se disant que le concept était assez similaire.

Tiens, par contre, si vous utilisez un macro layout, vous aurez trois
étapes (et plus seulement deux). Perso j’ai ça depuis quelques temps et du
coup mon layout intermédiaire ressent souvent le besoin de modifier les
content_for() créés avant de les repasser au macro layout.

Perso j’ai eu besoin de créer le code suivant, reprenne qui veut :
module ApplicationHelper
def replace_content_for(name, &block)
eval “@content_for_#{name} = capture(&block)”
end
end

Ce n’est pas grand chose mais ça permet de faire des trucs comme :
replace_content_for(:toto) do

” + yield(:toto) + “

end


Éric Daspet
http://eric.daspet.name/

Le jeudi 08 février 2007 à 10:08 +0100, Eric D. a écrit :

Avant on utilisait une variable d’instance @content_for_toto mais comme un
peu sur tout, on tente d’utiliser des accesseurs pour plus d’abstraction.
Ils ont simplement eu la mauvaise idée de réutiliser le mot clé “yield”
des blocs en se disant que le concept était assez similaire.

Je pensais qu’il s’agissait de la méthode yield standard de ruby définie
dans generator.rb

yield utilise la notion de continuation concept très ésotérique pour
moi. il faudrait que j’étudie ça un jour

Yields an element to the generator.

def yield(value)
if @cont_yield = callcc { |c| c }
@queue << value
@cont_next.call(nil)
end

self

end

Hammiche :

Le yield(:toto) permet simplement d’accéder à ce qui est créé par le
content_for(:toto) { … }.
Avant on utilisait une variable d’instance @content_for_toto mais
comme un peu sur tout, on tente d’utiliser des accesseurs pour
plus d’abstraction. Ils ont simplement eu la mauvaise idée de
réutiliser le mot clé “yield” des blocs en se disant que le concept
était assez similaire.

Je pensais qu’il s’agissait de la méthode yield standard de ruby
définie dans generator.rb

Non, yield est un mot-clé de Ruby.

yield utilise la notion de continuation concept très ésotérique
pour moi. il faudrait que j’étudie ça un jour

Non, ce n’est pas du tout comme cela que je le comprends.

Dans une méthode, yield permet d’exécuter le bloc de code
(le block) attaché lors de l’appel de cette méthode.

yield ne sert pas qu’à ça, mais ça sert entre autres à
itérer sur une collection d’objets.

class Foo
def initialize(n)
@n = n
end

def each
0.upto(@n) { |i| yield i }
end
end

Foo.new(5).each { |elem| puts elem }

donc là c’est comme si j’avais un objet collection d’entiers
de 0 à 5, collection que je peux parcourir.

Generator va me fournir un itérateur à partir de mon objet.
Il peut également en créer un à partir d’un bloc, où les
éléments seront fournis via un appel #yield, pour copier
l’utilisation de yield comme dans ma méthode #each au-dessus.

exemple :

n = 5
g = Generator.new do |g|
0.upto(n) { |i| g.yield i }
end

Et on voit que l’écriture est proche car ça a été étudié
pour :slight_smile:

Après, dans Generator, comment fonctionne #yield ?

Yields an element to the generator.

def yield(value)
if @cont_yield = callcc { |c| c }
@queue << value
@cont_next.call(nil)
end

Ben, il utilise les continuations.

Donc dans ce cas précis de Generator, yield est en
quelque sorte lié à la notion de continuation, mais
pas en général.

yield est lié aux blocks donc plus ou moins à la notion
de fermeture (closure).

Enfin, Matz avait laissé supposé qu’il allait laisser tomber
les continuations dans Ruby 1.9.1 (mais je ne sais pas
s’il a changé d’avis). Par contre s’il décidait de laisser
tomber yield, donc les blocks, Ruby ne serait plus Ruby :slight_smile:

– Jean-François.