Comment peut-on ActiveRecord::Relation objet d'appeler les méthodes de la classe

Comment un ActiveRecord::Relation objet d'appeler les méthodes de la classe?

class Project < ActiveRecord::Base
  has_many :tasks
end

class Task < ActiveRecord::Base
  belongs_to :project

  def self.initial_tasks # class methods
   # here return initial tasks
  end
end

Maintenant, nous pouvons appeler :

Project.first.tasks.initial_tasks # how it works

initial_tasks est une méthode de classe, et nous ne pouvons pas appeler les méthodes de la classe sur un objet.

Project.first.tasks retourne un ActiveRecord::Relation d'objet, alors comment pourrait-il être en mesure d'appeler initial_tasks?

Veuillez expliquer.

Je suis un peu confus. Votre méthode est le nom de l'auto.initial_tasks, mais vous êtes d'appel .initial_task? Laquelle est la bonne?
désolé sa "initial_tasks".
Un peu de chance avec cette mesure?

InformationsquelleAutor Ram Patidar | 2014-02-10

32

Il n'y a pas beaucoup de documentation sur l'application sur les méthodes de la classe à ActiveRecord::Relation objets, mais nous pouvons comprendre ce problème en prenant un oeil à la façon dont ActiveRecord étendues travail.

Première, Rails de modèle portée sera de retour une ActiveRecord::Relation objet. À partir de la documentation:

Méthodes de la classe de votre modèle sont automatiquement disponibles sur les étendues. En supposant que la configuration suivante:
```
class Article < ActiveRecord::Base
  scope :published, -> { where(published: true) }
  scope :featured, -> { where(featured: true) }

  def self.latest_article
    order('published_at desc').first
  end

  def self.titles
    pluck(:title)
  end
end
```
Tout d'abord, l'invocation d'une portée retourne un ActiveRecord::Relation objet:
```
Article.published.class
#=> ActiveRecord::Relation

Article.featured.class
#=> ActiveRecord::Relation
```
Ensuite, vous pouvez faire fonctionner l' ActiveRecord::Relation objet à l'aide du modèle de méthodes de la classe:
```
Article.published.featured.latest_article
Article.featured.titles
```
C'est un peu un rond-point de la voie de la compréhension de la relation entre les méthodes de la classe et ActiveRecord::Relation, mais l'essentiel est ceci:
1. Par définition, modèle étendues de retour ActiveRecord::Relation objets
2. Par définition, les étendues d'avoir accès à des méthodes de la classe
3. Donc, ActiveRecord::Relation objets ont accès à des méthodes de la classe
- vraiment une bonne explication....Merci beaucoup
- Hey ami ce sauve ma journée !!
InformationsquelleAutor zeantsoi
24

Il est extrêmement facile à explorer. Vous venez de faire:
```
class Project < ActiveRecord::Base
  has_many :tasks
end

class Task < ActiveRecord::Base
  belongs_to :project

  def self.initial_tasks  #class methods
    1 / 0
  end
end
```
Alors appel Project.first.tasks.initial_tasks et vous obtenez:
```
  Division by zero
  ...
  .../gems/activerecord-4.1.0/lib/active_record/relation/delegation.rb:70:in `block in re
  .../gems/activerecord-4.1.0/lib/active_record/associations/collection_proxy.rb:872:in `
  .../gems/activerecord-4.1.0/lib/active_record/relation.rb:286:in `scoping'",
  .../gems/activerecord-4.1.0/lib/active_record/associations/collection_proxy.rb:872:in `
  .../gems/activerecord-4.1.0/lib/active_record/relation/delegation.rb:70:in `initial_tasks'",
```
Et que vous n'avez pas besoin en fait. Facile à explorer, mais pas si facile à comprendre.

Maintenant, je vais vous expliquer ce que cela signifie.
Lorsque vous appelez Project#tasks méthode il ne pas retour vous ActiveRecord::Relation d'objet. En fait, il vous renvoie une instance de l'exécution, créé classe nommée Tâche::ActiveRecord_Associations_Collectionproxy hérité de ActiveRecord::Associations::CollextionProxy qui à son tour hérité de ActiveRecord::Relation. Ce runtime-catégorie est liée à la Tâche de la classe et contient de façon dynamique-définis (via method_missing proxy-méthodes de déléguer des appels à la Tâche les méthodes de la classe et de fusion portée association avec la classe-définition du champ d'application retournés par les méthodes de la classe.

Comment ça marche (vraiment non-trivial):
1. Il est ActiveRecord::Base de classe. La classe de l'objet étendu par
  ActiveRecord::Délégation::DelegateCache module ici.
2. DelegateCache a DelegateCache.inherited de rappel qui définit @relation_delegate_cache attribut à chaque fois que vous héritez d'ActiveRecord::Base. Il désigne l'ensemble AR::Base descendant les classes ont un tel attribut. Le rappel appels DelegateCache#initialize_relation_delegate_cache méthode qui, dans l'ordre remplit cache attribut avec l'exécution créé des classes:
```
[
  ActiveRecord::Relation,
  ActiveRecord::Associations::CollectionProxy,
  ActiveRecord::AssociationRelation
].each do |klass|
  delegate = Class.new(klass) {
    include ClassSpecificRelation
  }
  const_set klass.name.gsub('::', '_'), delegate
  cache[klass] = delegate
end
```
  Ici ces classes d'obtenir des noms inhabituels à la Task::ActiveRecord_Associations_CollectionProxy
  mentionné plus tôt.
3. Ok, maintenant, notre modèle de Tâche a des liens vers d'exécution défini par la relation des classes. Ces classes ont une certaine inquiétude appelé ClassSpecificRelation (inclus ici). La préoccupation ajoute method_missing méthode qui détecte votre classe-les appels de méthode sur un objet relation (par exemple l'appel de #initial_tasks sur Project.tasks). Sur cet appel, il définit de manière dynamique nouveau runtime-classe de méthodes d'instance délégué aux méthodes de la classe. Maintenant, vous avez une Tâche de classe liée à la Tâche::ActiveRecord_Associations_Collectionproxy classe contenant tous les niveau de l'instance méthodes proxy appels à la Tâche méthodes de la classe obtenir portée de résultat et de le fusionner avec l'association actuelle portée (ici).
Que l'AR préfère dynamiquement les méthodes définies sur l'exécution créé des classes sur l'utilisation inefficace method_missing appels sur ActiveRecord::Relation.

Je pense que c'est OK si vous ne comprenez pas du tout ce genre de choses. Viens d'appeler les méthodes de la classe sur les associations 🙂
- Merci. Je suis en train d'essayer de comprendre tous les concepts. Commentaires à nouveau si des doutes apparaissent. Dans un premier commentaire, je pense que vous êtes probablement parler de activerecord-4.x.x donc je pense que c'est la raison pour laquelle la classe du résultat de l'appel d' Project#task n'est pas un ActiveRecord::Relation. En outre, les méthodes de la classe d'un ActiveRecord modèle ne sont pas seulement disponibles pour les associations, mais également à ses propres relations ou étendues. Mais je pense que le fait d'avoir "accès" de ces méthodes est le même que vous avez décrite ci-dessus 🙂 Merci, sera mise à jour bientôt.
- Oui, Rails 3.2 utilise juste method_missing sur ActiveRecord::Relation github.com/rails/rails/blob/3-2-stable/activerecord/lib/.... Aussi CollectionProxy n'est pas ActiveRecord::Rapport de la sous-classe github.com/rails/rails/blob/3-2-stable/activerecord/lib/.... Donc, les choses étaient plus simples en 3.2.
InformationsquelleAutor Nikita Shilnikov
0

Ici dans ActiveRecord::la Relation, la Relation est représentant l'ensemble de la table
et votre Post de classe est la carte avec table,

Donc ActiveRecord::Rapport de tableau ou d'un enregistrement unique, il peut accéder à la méthode de classe.

InformationsquelleAutor Kanti

Vous devez vous connecter pour publier un commentaire.