Bonjour à tous, J'ai lu quelques trucs à propos du DCI (Data Context Integration) et je ne sais pas quoi en penser. J'aimerais avoir votre avis sur la question.
Pour ceux qui ne connaissent pas, je vous conseil de lire ceci : http://mikepackdev.com/blog_posts/24-the-right-way-to-code-dci-in-ruby. J'aime bien le concept de rôle. Dans l'application que je fais j'ai des utilisateurs et un type d’utilisateur spécial, le collectionneur. Si j'ai bien compris le concept il faut écrire un role comme ceci : module CollectorRole def paintings Painting.where(user_id: self.id) end end Et pour avoir toutes les peintures d'un collectionneur je pourrais faire ceci : user = User.new user.extend CollectorRole user.paintings Je n'aurais donc que deux modèles minimaux, User et Painting, représentant uniquement les données (présente dans la base donnée). Si je veux ajouter un comportement à mon utilisateur je l'ajouterai dans un rôle. Je respect donc plus facilement le SRP (Single Responsability Principle). Ça remplace un héritage. Là ou j'ai du mal c'est au niveau du context et du contrôleur. Un exemple qui fonctionne pas trop mal serait dans le cas ou je voudrais faire une fonctionnalité qui permet aux utilisateurs de contacter les collectionneurs. Je ferais un truc du genre : class UserContactCollectorContext attr_reader :user_from, user_to def self.call(user_from, user_to) UserContactCollectorContext.new(user_from, user_to).call end def initialize(user_from, user_to) @user_from, @user_to = user_from, user_to @user_to.extend CollectorRole end def call @paintings = @user_to.paintings # traitement et envoi du mail end end Et dans mon contrôleur j'aurais ceci : class MessagesController < ApplicationController def send_message_to_collector UserContactCollectorContext.call(User.find(params[:user_from]), User.find(params[:user_to])) end end Ce code me convient. Là ou ça ne me convient pas c'est quand je veux tout simplement la liste des utilisateurs. Il faudrait faire un contrôleur du genre : class UsersController < ApplicationController def index @users = UserAllContext.call end end Il y a un exemple similaire ici : https://github.com/randx/rails-dci-example/blob/master/app/controllers/documents_controller.rb Franchement, créé un context pour chaque action de ce type je trouve que c'est trop. C'est plus simple de faire "@users = User.all". L'avantage c'est que ça sépare vraiment la logique. Le contrôleur n'a pas à savoir ce que fait le context. S'il y a un mail envoyé, un géocodage ou tout le reste, le contrôleur ne le sait pas. C'est vraie pour l'inverse. Le context ne sait pas ce que fait le contrôleur. On a donc un séparation franche entre la logique métier et la partie système. J'ai lu le livre CleanRuby. Je penses que Jim Gay va trop loin. Il créé un context "framework agnostic" qui appel des fonctions du contrôleur. J'ai du mal à comprendre pourquoi il écrit un livre prônant la valeur du "Skinny Controller" alors qu'il a du code comme ceci : https://github.com/radiant/radiant/blob/master/app/models/page.rb. Qu'en pensez-vous? Est-ce que quelqu'un d'entre vous à mis en pratique ce concept? Quels sont vos impressions? Merci à tous! -- -- Vous avez reçu ce message, car vous êtes abonné au groupe "Railsfrance" de Google Groups. Pour transmettre des messages à ce groupe, envoyez un e-mail à l'adresse [email protected] Pour résilier votre abonnement envoyez un e-mail à l'adresse [email protected] --- Vous recevez ce message, car vous êtes abonné au groupe Google Groupes Railsfrance. Pour vous désabonner de ce groupe et ne plus recevoir d'e-mails le concernant, envoyez un e-mail à l'adresse [email protected]. Pour plus d'options, visitez le site https://groups.google.com/groups/opt_out .
