Ruby on Rails
Le débogage

Application de rails de débogage

Pour pouvoir déboguer une application, il est très important de comprendre le flux de la logique et des données d'une application. Il aide à résoudre les bogues logiques et ajoute de la valeur à l'expérience de programmation et à la qualité du code. Le débogueur (pour Ruby 1.9.2 et 1.9.3) et le byebug (pour ruby> = 2.x) sont deux joyaux populaires pour le débogage.

Pour déboguer les fichiers .rb , procédez comme suit:

1. Ajouter le debugger ou le byebug au groupe de development de Gemfile
2. Exécuter une bundle install
3. Ajouter un debugger ou un byebug comme point d'arrêt
4. Exécuter le code ou faire une demande
5. Voir le journal du serveur de rails arrêté au point d'arrêt spécifié
6. A ce stade, vous pouvez utiliser votre terminal serveur comme la rails console et vérifier les valeurs de la variable et des paramètres.
7. Pour passer à l'instruction suivante, tapez next et appuyez sur enter
8. Pour sortir de type c et appuyez sur enter

Si vous souhaitez déboguer les fichiers .html.erb , un point d'arrêt sera ajouté en tant que <% debugger %>

Déboguer dans votre IDE

Chaque bon IDE fournit une interface graphique pour le débogage interactif des applications Ruby (et donc Rails) où vous pouvez ajouter des points d'arrêt, des montres, une pause automatique à l'exception et suivre l'exécution du code, étape par étape, ligne par ligne.

Par exemple, regardez l'un des meilleurs IDE Ruby, les fonctionnalités de débogage de RubyMine sur la photo.

Débogage rapide de Ruby on Rails + conseils aux débutants

Déboguer en soulevant des exceptions est bien plus simple que de plisser des instructions dans print journaux d’ print et, pour la plupart des bogues, il est généralement beaucoup plus rapide que d’ouvrir un débogueur comme pry ou byebug . Ces outils ne devraient pas être votre première étape.

Débogage rapide de Ruby / Rails:

1. Méthode rapide: élevez une Exception puis .inspect son résultat

Le moyen le plus rapide de déboguer le code Ruby (en particulier Rails) consiste à raise une exception le long du chemin d'exécution de votre code tout en appelant .inspect sur la méthode ou l'objet (par exemple, foo ):

raise foo.inspect

Dans le code ci-dessus, raise déclenche une Exception qui interrompt l'exécution de votre code et renvoie un message d'erreur contenant des informations .inspect sur l'objet / la méthode ( foo ) sur la ligne que vous essayez de déboguer.

Cette technique est utile pour examiner rapidement un objet ou une méthode ( par exemple, est-ce que c'est nil ? ) Et pour confirmer immédiatement si une ligne de code est même exécutée dans un contexte donné.

2. Repli: utilisez un débogueur IRB ruby tel que byebug ou pry

Seulement après avoir des informations sur l'état de votre code flux d'exécution si vous envisagez de passer à un bijou rubis débogueur comme irb pry ou byebug où vous pouvez plonger plus profondément dans l'état des objets dans votre chemin d'exécution.

Pour utiliser le joyau de byebug pour le débogage dans Rails:

1. Ajouter gem 'byebug' dans le groupe de développement de votre Gemfile
2. Exécuter une bundle install
3. Ensuite, pour utiliser, insérez la phrase byebug dans le chemin d’exécution du code que vous voulez examiner.

byebug fois exécutée, byebug variable de byebug ouvrira une session IRB ruby ​​de votre code, vous donnant un accès direct à l'état des objets tels qu'ils sont à ce stade de l'exécution du code.

Les débogueurs IRB tels que Byebug sont utiles pour analyser en profondeur l'état de votre code lors de son exécution. Cependant, leur procédure est plus longue que la génération d'erreurs. Dans la plupart des cas, elles ne devraient donc pas être votre première étape.

Conseil général pour débutant

Lorsque vous essayez de déboguer un problème, il est recommandé de toujours: Lire le message d'erreur! @ # $ Ing (RTFM)

Cela signifie lire les messages d'erreur soigneusement et complètement avant d'agir afin que vous compreniez ce que l'on essaie de vous dire. Lorsque vous déboguez, posez les questions mentales suivantes, dans cet ordre , lors de la lecture d'un message d'erreur:

1. Quelle est la classe de référence de l'erreur? (c.-à -d. ai-je la classe d'objet correcte ou mon objet est-il nil ? )
2. Quelle est la méthode de référence de l'erreur? (c.-à - d. est-ce un type dans la méthode? Puis-je appeler cette méthode sur ce type / cette classe d'objet? )
3. Enfin, en utilisant ce que je peux déduire de mes deux dernières questions, quelles lignes de code dois-je rechercher? (rappelez-vous: la dernière ligne de code de la trace de la pile n’est pas nécessairement à l’endroit du problème.)

Dans la trace de pile, faites particulièrement attention aux lignes de code qui proviennent de votre projet (par exemple, les lignes commençant par app/... si vous utilisez Rails). 99% du temps, le problème concerne votre propre code.

Illustrer pourquoi interpréter dans cet ordre est important ...

Par exemple, un message d'erreur Ruby qui confond beaucoup de débutants:

Vous exécutez du code qui s'exécute à un moment donné en tant que tel:

@foo = Foo.new

...

@foo.bar

et vous obtenez une erreur qui indique:

undefined method "bar" for Nil:nilClass

Les débutants voient cette erreur et pensent que le problème est que la bar méthode n'est pas définie . Ce n'est pas. Dans cette erreur, la vraie partie qui compte est:

for Nil:nilClass

for Nil:nilClass signifie que @foo est @foo ! @foo n'est pas une variable d'instance Foo ! Vous avez un objet qui est Nil . Lorsque vous voyez cette erreur, c'est simplement ruby ​​en essayant de vous dire que la bar méthode n'existe pas pour les objets de la classe Nil . (eh bien, puisque nous essayons d'utiliser une méthode pour un objet de la classe Foo not Nil ).

Malheureusement, en raison de la façon dont cette erreur est écrite ( undefined method "bar" for Nil:nilClass ), il est facile de penser que cette erreur est undefined method "bar" for Nil:nilClass au fait que la bar n'est undefined . Lorsqu'elle n'est pas lue attentivement, cette erreur amène par erreur les débutants à fouiller dans les détails de la méthode de bar sur Foo , manquant complètement la partie de l'erreur qui indique que l'objet est de la mauvaise classe (ici: nil). C'est une erreur qui peut être facilement évitée en lisant l'intégralité des messages d'erreur.

Résumé:

Lisez toujours attentivement le message d'erreur complet avant de commencer tout débogage. Cela signifie: vérifiez toujours le type de classe d'un objet dans un message d'erreur en premier , puis ses méthodes , avant de commencer à rechercher des empilements ou des lignes de code dans lesquels vous pensez que l'erreur se produit. Ces 5 secondes peuvent vous faire économiser 5 heures de frustration.

tl; dr: Ne plissez pas les journaux d'impression : placez plutôt des exceptions. Évitez les trous de lapin en lisant attentivement les erreurs avant le débogage.

Débogage de l'application ruby-on-rails avec pry

Pry est un outil puissant qui peut être utilisé pour déboguer n'importe quelle application Ruby. Mettre en place une application Ruby-on-Rails avec cette gemme est très simple et facile.

Installer

Pour commencer à déboguer votre application avec pry

• Ajoutez gem 'pry' au Gemfile l'application et regroupez-le

group :development, :test do
  gem 'pry'
end

• Accédez au répertoire racine de l'application sur la console du terminal et exécutez l' bundle install . Vous êtes prêt à l'utiliser partout dans votre application.

Utilisation

L'utilisation de Pry dans votre application consiste simplement à inclure binding.pry sur les points d'arrêt que vous souhaitez inspecter lors du débogage. Vous pouvez ajouter des points d'arrêt binding.pry n'importe où dans votre application interprétée par l'interpréteur de ruby ​​(tous les fichiers app / controllers, app / models, app / views)

i) Déboguer un contrôleur

app / controllers / users_controller.rb

class UsersController < ApplicationController
  def show
    use_id = params[:id]
    // breakpoint to inspect if the action is receiving param as expected
    binding.pry
    @user = User.find(user_id)
    respond_to do |format|
      format.html
    end
  end
end

Dans cet exemple, le serveur rails s'arrête avec une console au point d'arrêt lorsque vous essayez de visiter un routage de page pour show action sur UsersController . Vous pouvez inspecter l'objet params et faire une requête ActiveRecord sur User modèle User partir de ce point d'arrêt

ii) Déboguer une vue

app / views / users / show.html.haml

%table
  %tbody
    %tr
      %td ID
      %td= @user.id
    %tr
      %td email
      %td= @user.email
    %tr
      %td logged in ?          
      %td
        - binding.pry
        - if @user.logged_in?
          %p= "Logged in"
        - else
          %p= "Logged out"

Dans cet exemple, le point d'arrêt s'arrête avec la console pry lorsque la page users/show est précompilée sur le serveur rails avant de la renvoyer au navigateur du client. Ce point de rupture permet de déboguer la correction de @user.logged_in? quand il se comporte mal.

ii) Déboguer un modèle

app/models/user.rb

class User < ActiveRecord::Base    
  def full_name
    binding.pry
    "#{self.first_name} #{self.last_name}"
  end      
end

Dans cet exemple, le point de rupture peut être utilisé pour déboguer User méthode par exemple de modèle full_name lorsque cette méthode est appelée à partir de n'importe où dans l'application.

En conclusion, pry est un puissant outil de débogage pour les applications de rails avec une configuration simple et des directives simples de débogage. Essayez ceci.