f.error_messages dans les Rails 3.0

Rails 3.0 obsolète f.error_messages et maintenant, nécessite un plugin pour fonctionner correctement - je toutefois vous voulez apprendre comment afficher les messages d'erreur de la (nouvelle) natif moyen. Je suis à la suite de la guide de mise en route, qui utilise la méthode dépréciée lors de la mise en œuvre du formulaire de commentaires. Par exemple:

<h2>Add a comment:</h2>
<%= form_for([@post, @post.comments.build]) do |f| %>
  <%= f.error_messages %>
<div class="field">
  <% f.label :commenter  %><br />
  <%= f.text_field :commenter  %>
</div>
<div class="field">
  <%= f.label :body %><br />
  <%= f.text_area :body %>
</div>
<div class="actions">
  <%= f.submit %>
</div>
<% end %>

Ici est la bonne façon de le faire (comme généré par l'échafaudage):

<%= form_for(@post) do |f| %>
  <% if @post.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(@post.errors.count, "error") %> prohibited this post from being saved:</h2>

      <ul>
      <% @post.errors.full_messages.each do |msg| %>
        <li><%= msg %></li>
      <% end %>
      </ul>
    </div>
  <% end %>
 . . .

Je comprends que j'utilise le @post variable dans le dernier exemple, mais ce que variable dois-je faire référence à l'ancienne pour obtenir les messages d'erreur pour le commentaire de la création?

Votre question est en contradiction avec. Ici vous demandez comment obtenez des messages d'erreur pour les commentaires "à l'ancienne", par exemple, qui indique que vous vous posez à propos de l'affaire avec f.error_messages. (Ou avez-vous voulu dire "dans la forme", pas "à l'ancienne"?) Cependant, dans les commentaires, vous vous demandez comment obtenez des messages d'erreur "sans l'aide de f.error_messages". Alors, qui est-il?

InformationsquelleAutor Craig Smitham | 2010-10-06

0

Je viens de regarder dans le docrails github questions, et ils ont décidé de supprimer des f.error_messages au lieu d'expliquer comment faire de la validation des commentaires.

InformationsquelleAutor bunwich
23

Le meilleur et propre façon de mettre en œuvre error_messages dans votre formulaire par la mise en œuvre error_messages dans un FormBuilder.

Par exemple, voici la error_messages méthode que j'ai mis en place pour mon dernier projet.
Par implemeting votre propre FormBuilder vous pouvez suivre les règles et les styles de votre webdesigner...
Voici un exemple de sortie de la liste d'erreurs à l'ul/li avec certains styles personnalisés :
```
class StandardBuilder < ActionView::Helpers::FormBuilder
  def error_messages
    return unless object.respond_to?(:errors) && object.errors.any?

    errors_list = ""
    errors_list << @template.content_tag(:span, "There are errors!", :class => "title-error")
    errors_list << object.errors.full_messages.map { |message| @template.content_tag(:li, message) }.join("\n")

    @template.content_tag(:ul, errors_list.html_safe, :class => "error-recap round-border")
  end
end
```
Puis dans mes formulaires :
```
= f.error_messages
```
Et c'est tout.
- Salut Nicolas, étaient aurais-je ajouter cette FormBuilder?
- dans app/helpers...
- Toujours pas de travail pour moi. J'ai coupé et collé le code dans un nouveau fichier app/helpers/standard_builder.rb, mais <%= f.error_messages %> dans mon formulaire donne l'erreur "undefined method `error_messages" pour #<ActionView::Assistants::FormBuilder:0x45ceef8>". Dois-je faire autre chose pour le rendre disponible?
- Merci, j'ai trouvé que, pour faire ce travail, j'ai dû aussi faire ce qui suit dans application_helper.rb: ActionView::Base.default_form_builder = StandardBuilder (Voir alexreisner.com/code/form-builders-in-rails)
InformationsquelleAutor Nicolas Blanco
13

Je suis sûr que tout vous devez faire est de référence @post.comments

De sorte que vous pourriez faire quelque chose comme:
```
<% @post.comments.each do |comment| %>
    <% if comment.errors.any? %>

    <% comment.errors.full_messages.each do |msg| %>
        <li><%= msg %></li>
    <% end %>

    <% end %>
<% end %>
```
Ou il suffit de tirer toutes les erreurs out:
```
comment_errors = @post.comments.map(&:errors)
```
puis parcourir en boucle dans votre logique d'affichage à la sortie de chaque commentaire erreurs.
- Merci pour la tentative, mais non, ce n'est pas de travail. Peut-être un moyen plus simple de poser la question "Comment puis-je afficher le commentaire des erreurs sans l'aide de "f.error_messages" donné "[@post, @post.commentaires.construire]" au lieu de quelque chose de simple comme @post?
- honnêtement, je n'ai jamais vu quelqu'un faire form_for([@post, @post.comments.build]). C'est plutôt toujours été form_for(@post) do |p| et puis p.fields_for(@post.comments.build) do |c|. Ainsi, vous pouvez rechercher à l'aide de champs pour l'intérieur de la poste le formulaire à la place?
- Eh bien, en fait son la façon dont les "Rails - guide de mise en route est de le faire.
InformationsquelleAutor Lukas
7

Cette fonctionnalité existe autonome, gem dynamic_form.

Ajouter les éléments suivants à votre Gemfile
```
gem 'dynamic_form'
```
De la page github:

DynamicForm détient quelques aides méthode pour vous aider à composer avec votre Rails3 des modèles, ils sont:
- input(record, method, options = {})
- form(record, options = {})
- error_message_on(object, method, options={})
- error_messages_for(record, options={})
Il ajoute également f.error_messages et f.error_message_on à votre formulaire constructeurs.

InformationsquelleAutor Justin Tanner
3

Voici ma solution pour l'ensemble de l'erreur de la scène.

J'ai créé une partielle qui utilise simplement une variable de modèle, celui qui passe lors de son affichage:
```
<%# app/views/errors/_error.html.erb %>

<%= content_for :message do %>
  <% if model.errors.any? %>
    <ul>
      <% model.errors.full_messages.each do |msg| %>
        <li><%= msg %></li>
      <% end %>
    </ul>
  <% end %>
<% end %>
```
Vous pouvez facilement ajouter du html dynamique de la classe et/ou de noms de code, basé sur le nom du modèle, ainsi que des génériques.

J'ai des choses de l'installation où mes messages d'erreur rendre dans tous la même place dans un fichier de mise en page:
```
<%# app/views/layouts/application.html.erb %>

<%= yield :message %>
```
Si l'on ne voulait pas de cette fonctionnalité, le retrait de la content_for dans le partiel ferait l'affaire.

Alors en tout point de vue que vous voulez, vous pouvez simplement écrire:
```
<%= render 'errors/error', model: @some_model %>
```
On pourrait étendre cette par la création d'un partiel qui prend une collecte et exploite l'erreur partielle ci-dessus:
```
<%# app/views/errors/_collection.html.erb %>

<% collection.each do |model| %>
  <%= render 'errors/error', model: model %>
<% end %>
```
Rendre avec:
```
<%= render 'errors/collection', collection: @some_model.some_has_many_association %>
```
J'aime de cette façon. Il est simple, facile à gérer et à maintenir, et incroyablement tweakable.

J'espère que cela aide!

EDIT: Tout en HAML
```
-# app/views/errors/_error.html.haml

= content_for :message do
  - if model.errors.any?
    %ul
      - model.errors.full_messages.each do |msg|
        %li= msg
```
```
-# app/views/layouts/application.html.haml

= yield :message
```
```
= render 'errors/error', model: @some_model
```
```
-# app/views/errors/_collection.html.haml

- collection.each do |model|
  = render 'errors/errors', model: @some_model
```
```
= render 'errors/_collection', collection: @some_model.some_has_many_association
```
- Je suis nouveau à cela et je l'ai trouvé confus, si possible pouvez-vous poster le lien github pour le code?
- Si je reçois un peu de temps libre pour écrire de base d'une application Rails, la démonstration de cette fonctionnalité, je vous le ferai savoir. Vous avez une question spécifique à propos de ce que j'ai créé? La pièce qui est source de confusion?
InformationsquelleAutor Benjamin
1

Je suppose que le [@post, @post.comments.build] tableau est passé juste à polymorphic_path à l'intérieur de form_for. Cela génère un sous-chemin d'accès aux ressources pour les commentaires (comme /posts/1/comments dans ce cas). Donc, il semble que votre premier exemple utilise des observations à titre de sous-ressources à des postes, à droite?.

Donc en fait le contrôleur qui sera appelé ici est la CommentsController. La raison pour laquelle Lukas solution ne fonctionne pas pour vous, peut-être que vous n'utilisez pas @poste.commentaires.construire à l'intérieur de la manette lors de la création du commentaire (il n'a pas d'importance que vous utilisez dans la vue lors de l'appel de form_for). Le CommentsController#create méthode devrait ressembler à ceci (plus ou moins):
```
def create
  @post = Post.find(params[:post_id]
  @comment = @post.comments.build(params[:comment])

  if(@comment.save)
    # you would probably redirect to @post
  else
    # you would probably render post#show or wherever you have the form
  end
end
```
Ensuite, vous pouvez utiliser le code généré par un échafaudage, ne remplacez @post variable d'instance avec @comment dans toutes les lignes sauf form_for appel.

Je pense qu'il peut aussi être une bonne idée d'ajouter la @comment = @post.comment.build à la méthode de contrôleur qui affiche ce formulaire et l'utilisation form_for([@post, @comment], ...) pour garder la forme contenu est affiché dans le formulaire si il y a des erreurs.

Si cela ne fonctionne pas et que vous n'êtes pas en mesure de le comprendre, s'il vous plaît ajouter votre CommentsController#create méthode à la question.

InformationsquelleAutor Matt

Vous devez vous connecter pour publier un commentaire.