635 votes

Comment utiliser les préoccupations de 4 Rails

La valeur par défaut de Rails 4 projet générateur crée le répertoire "préoccupations" sous les contrôleurs et les modèles. J'ai trouvé quelques explications sur la façon de l'utilisateur de routage des préoccupations, mais rien sur les automates ou les modèles.

Je suis assez sûr qu'il a à faire avec le courant "DCI tendance" dans la communauté et voudrais lui donner un essai.

La question est, comment suis-je censé utiliser cette fonctionnalité, il existe une convention sur la façon de définir la désignation de la classe de la hiérarchie pour le faire fonctionner? Comment puis-je inclure un sujet de préoccupation dans un modèle ou d'un contrôleur?

626voto

yagooar Points 4082

Alors j'ai trouvé par moi-même. Il est en fait assez simple, mais puissant concept. Il a à voir avec la réutilisation de code comme dans l'exemple ci-dessous. Fondamentalement, l'idée est d'extraire des communes et / ou le contexte spécifique des morceaux de code afin de nettoyer les modèles et éviter de les faire trop gros et trop salissant.

Comme exemple, je vais mettre un bien connu motif, le tagable modèle:

# app/models/product.rb
class Product
  include Taggable

  ...
end

# app/models/concerns/taggable.rb
# notice that the file name has to match the module name 
# (applying Rails conventions for autoloading)
module Taggable
  extend ActiveSupport::Concern

  included do
    has_many :taggings, as: :taggable
    has_many :tags, through: :taggings

    class_attribute :tag_limit
  end

  def tags_string
    tags.map(&:name).join(', ')
  end

  def tags_string=(tag_string)
    tag_names = tag_string.to_s.split(', ')

    tag_names.each do |tag_name|
      tags.build(name: tag_name)
    end
  end

  # methods defined here are going to extend the class, not the instance of it
  module ClassMethods

    def tag_limit(value)
      self.tag_limit_value = value
    end

  end

end

Suite à l'échantillon de Produit, vous pouvez ajouter Tagable à toute la classe que vous désirez et de partager ses fonctionnalités.

C'est assez bien expliqué par DHP:

Dans les Rails 4, nous allons inviter les programmeurs à utiliser les préoccupations avec l' par défaut app/models/préoccupations et app/controllers/préoccupations des répertoires qui sont automatiquement une partie du chemin de chargement. En collaboration avec le ActiveSupport::Préoccupation wrapper, c'est juste assez de soutien pour faire de cette la lumière-poids de l'affacturage mécanisme de briller.

384voto

Aaditi Jain Points 166

J'ai lu sur l'aide de modèle de préoccupations pour la peau-connaître modèles de matières grasses ainsi que de SÉCHER votre modèle de codes. Voici une explication avec des exemples:

1) l'Assèchement des modèles de codes

Considérons un modèle Article, un modèle d'Événement et un Commentaire de Modèle. Un article ou Un événement a de nombreux commentaires. Un commentaire appartient soit de l'article ou de l'événement.

Traditionnellement, les modèles peuvent ressembler à ceci:

Modèle Commentaire:

class Comment < ActiveRecord::Base
  belongs_to :commentable, polymorphic: true
end

L'Article Modèle:

class Article < ActiveRecord::Base
  has_many :comments, as: :commentable 

  def find_first_comment
    comments.first(created_at DESC)
  end

  def self.least_commented
   #return the article with least number of comments
  end
end

Modèle D'Événement

class Event < ActiveRecord::Base
  has_many :comments, as: :commentable 

  def find_first_comment
    comments.first(created_at DESC)
  end

  def self.least_commented
   #returns the event with least number of comments
  end
end

Comme on peut le remarquer, il existe un important morceau de code commun aux deux Cas et Modèle de l'Article. À l'aide des préoccupations que nous pouvons extraire de cette commune code dans un module séparé Commentable.

Pour cela créer un commentable.rb fichier app/model/préoccupations.

module Commentable
    extend ActiveSupport::Concern

    included do 
        has_many :comments, as: :commentable 
    end

    # for the given article/event returns the first comment
    def find_first_comment
        comments.first(created_at DESC)
    end

    module ClassMethods     
        def least_commented
           #returns the article/event which has the least number of comments
        end
    end 
end

Et Maintenant, vos modèles ressembler à ceci :

Modèle Commentaire:

    class Comment < ActiveRecord::Base
      belongs_to :commentable, polymorphic: true
    end

L'Article Modèle:

class Article < ActiveRecord::Base
    include Commentable
end

Modèle D'Événement:

class Event < ActiveRecord::Base    
    include Commentable
end

2) Peau-nizing Modèles de matières Grasses.

Considérons un modèle d'Événement. Un événement a de nombreux auditeurs et les commentaires.

Généralement, le modèle d'événement pourrait ressembler à ceci

 class Event < ActiveRecord::Base   
    has_many :comments
    has_many :attenders


    def find_first_comment
        # for the given article/event returns the first comment
    end

    def find_comments_with_word(word)
        # for the given event returns an array of comments which contain the given word
    end 

    def self.least_commented
        # finds the event which has the least number of comments
    end

    def self.most_attended
        # returns the event with most number of attendes
    end

    def has_attendee(attendee_id)
        # returns true if the event has the mentioned attendee
    end
end

Les modèles avec de nombreuses associations et ailleurs ont tendance à accumuler plus de et plus de code et de devenir ingérable.Les préoccupations de fournir un moyen pour la peau-connaître la graisse des modules de les rendre plus modulaire et facile à comprendre.

Le modèle ci-dessus peut être reconstruit à l'aide des préoccupations comme ci-dessous: Créer un attendable.rd et commentable.rb fichier app/model/préoccupation/event dossier

attendable.rb

module Attendable
    extend ActiveSupport::Concern

    included do 
        has_many :attenders
    end

    def has_attender(attender_id)
        # returns true if the event has the mentioned attendee
    end

    module ClassMethods
      def most_attended
        # returns the event with most number of attendes
      end
    end
end

commentable.rb

module Commentable
    extend ActiveSupport::Concern

    included do 
        has_many :comments
    end

    def find_first_comment
        # for the given article/event returns the first comment
    end

    def find_comments_with_word(word)
        # for the given event returns an array of comments which contain the given word
    end   

    module ClassMethods
      def least_commented
        # finds the event which has the least number of comments
      end
    end
end

Et Maintenant, à l'aide de Préoccupations , de votre Événement en modèle réduit à

class Event < ActiveRecord::Base    
    include Commentable
    include Attendable
end

* Lors de l'utilisation des préoccupations de sa conseillé d'y aller pour "domaine" de regroupement en fonction de la plutôt que de la "technique" de regroupement. Domaine en Fonction de regroupement est comme "Commentable', 'Photoable', 'Attendable'. Technique de regroupement signifie 'ValidationMethods', 'FinderMethods", etc

  • -

56voto

aminhotob Points 392

Il s’agit d’un bon poste, je comprends les préoccupations http://blog.andywaite.com/2012/12/23/exploring-concerns-for-rails-4/ d’elle

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X