Bonjour,
 
Ce que j'essaie de faire est "simple". J'ai une classe ElementsController, cette classe est héritée par plein de monde et elle contient plein de routines utilisées sous forme "directe" ou via spécialisation par ses classes filles.
Ce que je veux c'est que chaque classe fille (par exemple FilleController) obtienne des accesseurs "à son nom" sans que je doive les définir explicitement dans chaque classe (sinon je vais les oublier et pis c'est moche).
 
Donc j'aimerais que FilleController ait une variable d'instance @fille qui soit crée et accessible (comme si je faisais un attr_accessor :fille quoi)
 
J'ai tenté de faire la chose suivante mais ça ne marche pas :
 

class ElementsController < ApplicationController
 
  attr_accessor self.to_s.demodulize.gsub('Controller','').downcase.singularize.to_sym
 
...
end
 
class FilleController < ElementsController
end

 
Mais si je fais un  
 

f = FilleController.new
f.fille = "Je suis une fille"

 
Bein ça ne marche pas ...
 

Quelqu'un voit le pourquoi? Sinon vous croyez qu'il y a mieux/plus simple? Parce que je trouve quand même pas super joli comme truc

Ton attr_accessor est exécuté une seule fois dans le contexte de ElementsController

Faut faire ton bricolage au niveau de la métaclasse (la classe dont ton ElementsController est une instance).

edit: http://whytheluckystiff.net/articl [...] early.html et si c'est pas suffisant, google.

Voilà c'est exactement sur ce genre de truc que j'ai des lacunes
Bon bein merci, je vais chercher de la doc parce que là son  
 

class Object
   # The hidden singleton lurks behind everyone
   def metaclass; class << self; self; end; end
   def meta_eval &blk; metaclass.instance_eval &blk; end
 
   # Adds methods to a metaclass
   def meta_def name, &blk
     meta_eval { define_method name, &blk }
   end
 
   # Defines an instance method within a class
   def class_def name, &blk
     class_eval { define_method name, &blk }
   end
 end

 
J'y comprend juste absolument rien.

class Object
   # The hidden singleton lurks behind everyone
   def metaclass; class << self; self; end; end
   def meta_eval &blk; metaclass.instance_eval &blk; end
 
   # Adds methods to a metaclass
   def meta_def name, &blk
     meta_eval { define_method name, &blk }
   end
 
   # Defines an instance method within a class
   def class_def name, &blk
     class_eval { define_method name, &blk }
   end
 end

Non mais faut lire le texte hein, ça c'est juste l'exemple initial "zomg magic happens here totoz", derrière il reprend tout de 0

Oui oui j'ai vu qu'il reprend pas mal de notions par la suite (je suis même tombé sur un site plus "terre à terre" ( http://practicalruby.blogspot.com/ [...] ction.html ) que je suis en train de lire..
Mais y a des trucs que je comprend pas encore quand même..
 
Par exemple, pourquoi il ne fait pas juste?
 

def meta_eval &blk; self.instance_eval &blk; end

 
Je capte pas la différence..

Bon j'ai un peu avancé grâce à la doc que j'ai lue, mais reste que je comprend pas quelque chose  
 

class Test
        define_method(:fille){ "Je suis une fille" }
        
        class << self;self;end.instance_eval do
                def mec
                 "Je suis un mec"
                end
        end
end
 
 
test = Test.new
p test.fille
p test.mec

 
Pourquoi test.mec n'existe pas?
Parce que le truc du define_method est bien ce que je cherche, mais malheureusement j'ai pas trouvé comment remplacer le  
 

def fille= nom
 @fille =  nom
end

 
par un define_method (J'ai l'impression qu'on peut pas lui passer de paramètres, c'est exact? )
 
Edit :  
 
Je viens de tester la chose suivante :
 

test = Test.new
p test.fille
 
class << test
                def mec= name
                 @mec = name
                end
                def mec
                 @mec
                end
end
test.mec = "Jean"
p test.mec

 
Et bien entendu ça marche ... Mais comment enfermer ça directement dans la classe?

Bon je suis arrivé à faire marcher le "mec". En fait suffit d'utiliser un class_eval  
 

class Test
        define_method(:fille){ "Je suis une fille" }
        
        class_eval do
 
                def mec= name
                 @mec = name
                end
                def mec
                 @mec
                end
        end
end

 
Mais ça ne résous pas pour autant mon problème de pouvoir définir leur nom "à la volée"  

Bon,  
J'ai encore un peu avancé et j'arrive à faire définir mes méthodes "à la volée"  
 

class Mother
         define_method(self.to_s.downcase){ instance_variable_get '@'<<self.class.to_s.downcase }
         define_method((self.to_s.downcase+'=').to_sym){|nom| instance_variable_set '@'<<self.class.to_s.downcase, nom}
end
class Daughter < Mother
end

 
Le soucis c'est que ça me crée pas de fonction daugther, parce que c'est uniquement executé dans la classe mère    
Je vois vraiment pas comment changer ça  

Bon j'ai trouvé la réponse sur la mailling list
 

class Mother
   def self.attr_eponymous(c=self)
     c.send(:attr_accessor, c.to_s.downcase)
   end
 
   def self.inherited(c)
     attr_eponymous(c)
   end
 
   attr_eponymous
end
class Daughter < Mother
end

 
J'étais tellement focalisé sur toutes les histoires de singleton & co que j'ai oublié le hook self.inherited
Le seul "point noir" de cette méthode c'est que les classes définies dans la classe mère, sont héritées par la classe fille.. Je vais voir, si ça m'embête je passerai un coup de remove_method dans le tas
 
Merci à tous