Page d’accueil / de bienvenue dans Ruby on Rails – meilleure pratique

Ma page d’accueil (ou page d’accueil) sera composée de données provenant de deux modèles (appelons-les auteurs et messages). Je suis nouveau sur les rails et je ne suis pas certain de la meilleure façon d’y parvenir.

Dois-je créer un nouveau contrôleur appelé welcome qui rassemble les données des auteurs et des publications, puis les affiche dans la vue d’index de bienvenue? Ou devrais-je avoir une vue bienvenue sous le modèle de post qui obtient également des données des auteurs? Ou tout autre moyen d’y parvenir?

Je comprends comment faire tout cela techniquement, mais je ne suis pas sûr de savoir quelle est la meilleure méthode d’utilisation du framework de rails.

La question est la suivante: votre page d’accueil est-elle simplement une page de destination ou s’agira-t-il d’un groupe de pages? Si ce n’est qu’une page de destination, vous ne vous attendez pas à ce que vos utilisateurs restnt longtemps, sauf pour aller ailleurs. S’il s’agit d’un groupe de pages ou similaire à un groupe existant, vous pouvez append une action au contrôleur le plus proche.

Ce que j’ai fait pour mon projet actuel est de créer un contrôleur nommé Static , car j’ai besoin de 3 pages statiques. La page d’accueil en est une, car il n’y a rien à voir ou à faire, sauf aller ailleurs.

Pour mapper une route par défaut, utilisez ce qui suit dans routes.rb :

 # Place at the end of the routing! map.root :controller => 'MyController', :action => :index 

Dans mon cas, ce serait:

 map.root :controller => 'static', :action => :index 

Si vous le souhaitez, vous pouvez créer un contrôleur uniquement pour cette page d’accueil. Je l’appellerais principale, ou quelque chose dont vous vous souvenez, qui se rapporte à la page d’accueil. De là, vous pouvez obtenir vos données et vos modèles et vous reporter à la vue de sortie.

 class MainController < ApplicationController def index @posts = Posts.find(:all, :limit => 10, :order => 'date_posted', :include => :user) end end 

En supposant que vos relations de modèle soient définies correctement, le modèle à adapter sera très simple.

Bonne chance, j’espère que ça aide.

Il ne semble pas y avoir de meilleure pratique.

(1) Le fichier standard config/routes.rb semble suggérer que la page racine (ou la page d’accueil / d’accueil) devrait être gérée par welcome#index . Si vous deviez être guidé par cela, alors vous pouvez utiliser la commande suivante pour générer l’action / le contrôleur d’ welcome#index correspondant:

 rails generate controller Welcome index 

Ensuite, dans config/routes.rb , vous pouvez supprimer le routage GET ( get "welcome/index" ) ajouté automatiquement par le générateur, et placez la racine du répertoire root 'welcome#index' (ou root :to => 'welcome#index' dans Rails < 4 ) en haut du fichier, car ce sera probablement votre itinéraire le plus populaire et devrait être comparé en premier.

Rappelez-vous également de supprimer public/index.html dans Rails < 4 .

(2) Le guide de routage officiel Ruby on Rails utilise PagesController . Il suggère en fait des pages#main , bien que pour moi, cela a plus de sens d'aller avec les pages#home (parce que "homepage" est le terme / concept omniprésent). De plus, ce contrôleur peut gérer d'autres actions orientées page telles que les pages#about , les pages#contact , les pages#terms , les pages#privacy , etc.

(3) Le tutoriel Ruby on Rails va avec static_pages#home et static_pages#help , etc., mais je n'aime pas l'idée de désigner ce contrôleur avec "static". Ces pages auront probablement encore des aspects dynamics, en particulier la page d'accueil!

(4) Bien qu’il n’aborde pas la manière de gérer une page d’accueil , RailsCast # 117 sur les pages semi-statiques suggère une autre série d’approches pour montrer uniquement les ressources.

Je ressens une préférence pour 1 et / ou 2. Avec le scénario "et", vous pouvez utiliser welcome # index et pages # about, alors qu'avec le scénario "ou", vous pouvez utiliser les pages # home, pages # à propos, etc. Si je suis forcé de choisir, j'irais avec l'option 2 juste parce que vous vous retrouvez avec moins de code. Et btw, 2 et 3 sont à peu près les mêmes, à part le mot "statique".

Je me suis demandé quelque chose comme ça quand j’ai commencé Rails. Voici ce que vous devez savoir:

  • Les modèles ne sont pas nécessairement liés directement aux contrôleurs et aux vues.

En d’autres termes, une combinaison contrôleur / vue particulière peut fonctionner avec autant de modèles que nécessaire pour générer cette page particulière.

Le contrôleur a pour but de préparer le jeu de données à afficher, quels que soient les modèles utilisés pour stocker ces données.

L’objective de la vue est d’afficher ensuite ces données de la manière la plus appropriée.

En d’autres termes, les combinaisons contrôleur / vue ne sont jamais «sous» un modèle particulier. Ils utilisent des modèles, mais ne sont pas sous eux dans une relation hiérarchique. En fait, ils sont pairs à tous les modèles qu’ils utilisent.

Je pense que la confusion vient de l’exemple de générateur d’échafaudage que l’on trouve dans AWDR et d’autres textes d’introduction, tels que:

script ruby ​​/ générer contrôleur de modèle d’échafaudage

Je sais que cette relation implicite entre le modèle et le contrôleur / les vues m’a un peu troublée. Mais il n’y a pas de relation ssortingcte, vraiment. S’il y en avait, il serait très difficile de faire quelque chose de compliqué avec l’approche MVC. Et clairement, ce n’est pas le cas.

J’espère que cela t’aides.

— John

La meilleure pratique serait votre première suggestion. Créez un contrôleur de bienvenue et appelez les enregistrements de tous les modèles souhaités. Avoir un itinéraire racine pointe vers ce contrôleur. Très propre et correct.

Veuillez noter que dans Rails3, la manière correcte de gérer cela consiste à append la ligne suivante à la fin du fichier routes.rb:

 root :to => "welcome#index" 

et supprimer public / index.html.erb.

Notez également que welcome # index correspond à une action d’indexation dans un WelcomeController et que le code de la réponse de The Wicked Flea ressemble à ceci:

 class WelcomeController < ApplicationController def index @posts = Posts.find(:all, :limit => 10, :order => 'date_posted', :include => :user) end end 

Cette réponse est comme celle de Rails 3.2.1.

Configurez d’abord un contrôleur pour les pages, nommé par exemple static :

 $ rails generate controller static 

Dans le fichier app/controllers/static_controller.rb :

 class StaticController < ApplicationController def index end end 

Créez le nouveau fichier View app/views/index.html.erb

Et enfin configurer votre config/routes.rb :

 MyApp::Application.routes.draw do match 'home', :to => "static#index" root :to => "static#index" end 

Cela fera à la fois /home et / aller à ce que vous avez mis dans le fichier View que vous venez de créer.

Créez un nouveau contrôleur nommé de la manière la plus appropriée. SummaryController? StartController? DailyFrontPageController? Vous aurez une idée.

De plus, je pense sérieusement à créer un nouveau modèle, non basé sur ActiveRecord, qui recueille les informations de vos modèles Author et Post (ou quels que soient leurs vrais noms) pour les présenter à votre vue. L’alternative consiste à assembler les données dans le contrôleur, ce qui sera presque certainement désordonné – c’était à chaque fois que je l’essayais, et je l’essayais beaucoup. Un modèle séparé semble beaucoup mieux rangé.

Si le traitement est relativement simple, pourquoi ne pas essayer de créer les données dans le contrôleur, puis envelopper le résultat dans un Struct, puis remplacer le Struct par une classe réelle et y déplacer la construction, en procédant à un refactoring complet. Il ne devrait pas append trop à la durée totale (la plupart du code peut être réutilisé) et vous aurez une bonne idée de ce qui fonctionne le mieux pour vous.