Je voulais apprendre Ruby on Rails à un niveau de base depuis longtemps. Sans objectif précis. Plutôt, juste pour vous-même, pour mieux comprendre ce qu'il a de si spécial (contrairement à 100 500 autres technologies et frameworks), qui vous permet de créer et de faire évoluer rapidement des projets Internet assez chargés. Une raison secondaire était le désir d’essayer de nouvelles approches d’apprentissage. Lorsque j'étudiais pour devenir programmeur, nous n'avions que des livres et des forums où l'on pouvait demander conseil. Il existe désormais des manuels interactifs et des écoles de programmation en ligne, quantité énorme des screencasts (presque un rêve : regarder des programmes de gourous), des bases de connaissances comme stackoverflow.com et des tonnes de code source sur GitHub, où vous pouvez passer des heures à étudier le code source de vrais pros. J'ai décidé de réserver les nuits suivantes (et il n'y avait tout simplement pas de temps pendant la journée) pour essayer de nouvelles façons d'apprendre par l'action.

Première nuit

Commencer à apprendre Ruby on Rails sans au moins une connaissance minimale de Ruby lui-même serait étrange. J'ai déjà suivi le guide interactif ruby-lang.org. Mais dès que je l'ai passé, j'ai tout de suite tout oublié. Ses créateurs promettent qu'il faudra quinze minutes pour compléter et maîtriser la syntaxe de Ruby. Il m'en a fallu trente. C'est vrai, avec une distraction constante sur Twitter. Le processus ressemble à ceci. Ils vous disent : « Les tableaux dans Ruby sont déclarés comme ceci, et les données sont récupérées à partir de tableaux comme celui-ci. Essayons maintenant de créer un tableau et d'en extraire N éléments. Nous allons vérifier." Vous lisez comment tout fonctionne et essayez-le tout de suite. Bien sûr, vous n’apprendrez pas Ruby de cette façon. Il vaut mieux y penser comme à un cours super-express qui fonctionne.

Et pourtant Ruby lui-même est très loin du framework Ruby on Rails. Je voulais maîtriser les rails. De notre article sur l'éducation en ligne, je me suis certainement souvenu du cours sensationnel Zombie for Rails railsforzombies.org. C'est la même chose que Try Ruby, tutoriel interactif, qui commence à vous apprendre dès le départ à préparer des candidatures ferroviaires. Tout d'abord, ils vous donnent une mini-conférence (en anglais, mais tout est très clair - activez les sous-titres) sur la structure des fichiers d'une application ferroviaire, l'approche CRUD du travail avec les données, ils expliquent comment le modèle MVC est implémenté dans les rails , et ainsi de suite. Après chaque vidéo, il vous est demandé d'effectuer des tâches pour consolider le matériel. Tout semble simple et clair, le parcours passe inaperçu en une heure ou deux (c'est court). Mais! Après le cours, ai-je senti que je pouvais rédiger une candidature ferroviaire ? Hélas, non !

Deuxième nuit

Une des raisons pour lesquelles certaines personnes apparaissent après Rails for Zombies connaissances de base, mais il n'y a pas de confiance - il s'agit d'un environnement virtuel dans lequel se déroule la formation. D’une part, cela réduit le seuil d’entrée à la limite : vous n’avez pas à vous soucier de votre environnement. D’un autre côté, vous ne créez rien de réel en cours de route – pas de « Hello World » pour vous à la sortie. Et surtout, de quel côté aborder sa création n’est pas clair. À partir de ce moment-là, j'ai voulu essayer Ruby on Rails en action, en l'installant sur le système (avant cela, je n'avais même pas besoin d'essayer) et créer une application simple à partir de zéro.

Je ne me souviens pas comment, mais tout à fait par hasard, je suis tombé sur un cours de screencast très réussi sur rails.hasbrains.org russe. Merci à l'auteur pour sa présentation compétente : il explique méthodiquement en détail les principes de fonctionnement de l'application ferroviaire, vous plongeant au passage dans toutes les subtilités nécessaires. Pour faire court, j'ai passé toute la deuxième nuit de l'expérience à regarder la première moitié de plus de trente épisodes de ces screencasts.

J'ai enfin eu une idée en tête de la façon dont une application est générée, comment travailler avec la console ferroviaire, comment créer des modèles et des migrations, comment mettre à jour les modèles et comment valider les données qu'ils contiennent, les contrôleurs RESTful, etc. En regardant chacun des épisodes, j'ai immédiatement tout essayé en action, en créant une application ferroviaire entièrement fonctionnelle. Il est devenu clair comment les rails sont conçus en principe.

Troisième nuit

Le troisième soir, il restait les derniers épisodes des screencasts, que j'ai réussi à regarder d'un seul coup : travailler avec les rails ne me paraissait plus si sauvage. À ce moment-là, quelqu'un m'a dit que le cours Rails for Zombies avait une suite judicieuse et beaucoup plus profonde. Certes, le cours est déjà payant et est hébergé au sein de l'école de programmation Code School www.codeschool.com. Ce n'était pas une honte de payer 25 dollars pour avoir accès à tous les cours de l'école. Il s'agit d'un prix mensuel, donc si vous ne l'aimez pas, n'oubliez pas d'annuler votre abonnement.

Le cours Rails for Zombies 2 s’est avéré être un véritable succès. Il est vrai qu’il s’agissait en grande partie d’une répétition de ce que j’avais vu dans les screencasts, mais c’était même en partie agréable. Cinq niveaux et cinq blocs d'exercices que vous réalisez directement dans la console interactive. À ce stade, les rails semblaient déjà logiques, compréhensibles et utilisables.

Dans Code School, vous pouvez programmer directement dans le navigateur tout en effectuant les devoirs du cours.

Quelle est la prochaine étape ?

Ai-je appris à réaliser des projets complexes ? Non. Mais j'ai définitivement réalisé les approches utilisées dans les rails et compris leur commodité. J'ai appris à créer rapidement des applications simples et à augmenter ses fonctionnalités en très peu de temps en utilisant des gemmes écrites par la communauté. J'ai pris le courage et continue d'apprendre avec plaisir les meilleures pratiques en Programmes de codeÉcole (je regarde actuellement un cours sur les tests unitaires). Et cela me rend vraiment heureux que l’apprentissage de la technologie soit devenu si simple.

Saviez-vous que 40 % des utilisateurs quittent des sites Web mal conçus ? Pourquoi perdre du profit ? Choisissez et installez-en un dès maintenant 44 000 modèles de sites Web premium. Le choix idéal pour votre entreprise!

Beaucoup de mes amis développeurs ont fait l’éloge de Rails, mais je ne comprenais pas pourquoi. Qu'est-ce que Rails et en quoi diffère-t-il de Ruby on Rails ? Est-ce difficile d’apprendre ? Est-ce même un langage de programmation ? Que dois-je savoir avant d’apprendre Ruby on Rails ?

Ces questions et bien d’autres me trottait constamment dans la tête, mais il s’est avéré que je n’étais pas le seul. Nos lecteurs étaient également intéressés par ce numéro, alors pour en savoir plus, j'ai décidé de poser à un de mes collègues quelques questions de base sur Ruby. C’est ainsi qu’est né cet article.

Es-tu prêt? Allons-y!

13 faits sur Ruby on Rails – Que devez-vous savoir ?

1. Qu'est-ce que Rails ?

Rails est un framework d'application Web conçu pour écrire du code en Ruby. Cela semble déroutant, non ?

Essayons encore. Il existe un langage de programmation appelé Ruby. C'est un plaisir d'écrire dessus. À propos, celui qui l'a créé a déclaré que son objectif principal était de créer un langage qui améliorerait la vie des programmeurs. N'est-ce pas merveilleux ?

Laissez-moi vous donner un exemple.

Si je veux afficher du texte à l'écran en PHP, je dois écrire

faire écho à « Bonjour tout le monde » ;

Vous voyez le point-virgule ? Et cet « écho », qu’est-ce que cela signifie ?

D'un autre côté, si je devais faire la même chose dans Ruby, je devrais écrire ce qui suit :

met "Hello World"

Il n'y a pas de point-virgule, et même si « puts » peut paraître un peu juvénile, cela a plus de sens pour moi que « echo ». Lorsque vous passez des heures à écrire du code, de petits détails comme celui-ci font une GRANDE différence.

Le seul problème avec Ruby était qu’il n’était pas conçu pour créer des applications Web. Autrement dit, vous ne pourrez pas, par exemple, créer un site Web dessus. C'était le cas avant Rails. Je ne sais pas si Rails a été le premier framework Web pour Ruby, mais il est définitivement devenu le plus populaire.

Le but de Rails est de fournir une plateforme et des fonctionnalités qui permettraient de créer des applications, notamment un site Web, en Ruby. Cela semble assez vague pour le moment, alors je vais essayer de l'expliquer comme ceci. Si j'écrivais

met "Hello World"

alors dans le document HTML, vous verriez l’intégralité du texte. Mais je veux que vous voyiez UNIQUEMENT ceci :

Bonjour le monde

En termes simples, Rails vous permet de le faire. Mais ce n'est pas tout.

2. Qu'est-ce que Ruby on Rails ?

Ruby on Rails est le nom officiel COMPLET du framework Rails. Mais dans les conversations, les développeurs ne disent généralement pas la première partie et l'appellent simplement Rails. Donc, si vous voulez être "au courant" et paraître féru de technologie, vous devez absolument l'appeler Rails, mais RAPPELEZ-VOUS ce que signifie cette première partie - "Ruby on" -.

3. J'ai entendu dire que Rails était idéal pour les débutants. Pourquoi?

Il y a plusieurs raisons pour lesquelles Rails est idéal pour les débutants. Le premier est que le langage Ruby lui-même est vraiment bon pour les débutants, et c'est le premier avantage. Apprendre à coder en Ruby est beaucoup plus facile que dans d'autres langages, car le langage est assez flexible et libéral, ce qui vous épargnera les nerfs et vous permettra de passer plus de temps à apprendre les bases de la programmation.

Pourquoi Rails est-il si amusant pour les débutants ? Il est tout simplement très stable et fait une énorme quantité de travail pour vous.

Pour moi, travailler sur Rails, c'est comme conduire un camion. C'est incroyablement puissant, regardez-vous : vous conduisez un camion !!! Cependant, savez-vous comment fonctionne la voiture que vous conduisez ?

Le fait que Rails s'occupe de bien plus de tâches, les faisant pour vous, vous apportera une satisfaction immédiate. un grand nombre des avantages intéressants. Cependant, cela peut parfois aussi jouer contre vous si vous prenez de l'avance et n'apprenez pas pleinement les bases que vous devez simplement connaître.

Pour cette raison, il est très important d’apprendre Ruby on Rails à partir de zéro. Et plus important encore, vous devez vous assurer que vous êtes vraiment à l'aise avec Ruby. Sinon, vous sortirez du camion à mi-chemin et vous vous direz : « Attendez, est-ce que je conduisais vraiment ce truc ?

4. Quelle est la différence entre un développeur Rails et un développeur Ruby ?

Formellement, la différence est qu'un pur « développeur Ruby » créera des applications en Ruby, mais pas en Rails. Bien que cela ne se produise généralement pas. Il est certainement possible de créer des applications Web dans Ruby en utilisant d'autres frameworks comme Sinatra, mais je suis prêt à parier que 99% du temps, il est peu probable que vous soyez embauché en tant que programmeur Ruby uniquement. Par conséquent, vous devez dans tous les cas apprendre Rails.

5. Dans quelle mesure devrais-je connaître Ruby ? Que dois-je apprendre avant de commencer une formation ?

Il y a avis différents, mais en m'en tenant à l'exemple du gros camion, je pense que vous devez être à l'aise avec Ruby pour vous plonger dans Rails. Tout comme, disons, il est préférable d'apprendre d'abord à faire du vélo avant de passer à une voiture, puis de penser à conduire un camion.

Et voici autre chose. Lorsque vous travaillerez sur Rails, vous passerez beaucoup de temps à écrire du code dans Ruby. Pour cette raison, vous devez très bien connaître ce langage, notamment ses bases : types de données, méthodes, orientation objet, débogage et bien plus encore. Et vous n'avez pas besoin d'être un programmeur Ruby super expérimenté - vous avez juste besoin de vous sentir en confiance lorsque vous travaillez avec, comme un canard dans l'eau.

6. Pourquoi devrais-je apprendre Rails ? Qu’est-ce qui le rend spécial ?

C'est exquis et tout simplement magnifique. Que devez-vous savoir d’autre ? Lorsque Rails est apparu pour la première fois, c'est devenu une véritable découverte et une réussite de l'art du design. En gardant à l'esprit les meilleures pratiques lors de sa création, Rails vous met pratiquement sur la voie de l'écriture d'un code de qualité, même si vous ne le souhaitez pas (ou ne savez pas comment).

Si vous souhaitez créer des applications Web robustes qui évolueront selon les besoins tout en étant faciles à maintenir à l'avenir, Rails est une excellente option. De plus, il est populaire parmi de nombreuses entreprises sympas. Dernier raison importante Ce qui rend Rails si populaire parmi les startups, c'est qu'il est idéal pour le prototypage rapide. En quelques heures seulement, vous pouvez imaginer, créer et lancer l'application Rails dont vous avez besoin. Il existe en fait très peu d’autres frameworks capables de gérer cela.

7. Que pouvez-vous créer avec Rails ?

Que veux-tu créer ? Rails convient à toute application Web. Pour illustrer, consultez ces excellents exemples de sites construits avec Rails : Hulu, Airbnb et Basecamp.

8. Puis-je créer des applications mobiles à l'aide de Rails ?

Oui et non. Vous ne pourrez pas créer d'applications mobiles avec Rails, mais avec Rails, vous pouvez certainement créer une application Web et l'utiliser comme back-end pour application mobile.

Il existe également un outil appelé RubyMotion qui facilite la création d'applications iOS et Android natives dans Ruby (mais pas Rails). Autrement dit, vous n'utiliserez pas SPÉCIFIQUEMENT Rails pour créer une application mobile pour Magasin d'applications, mais Rails peut certainement devenir une partie importante de votre projet mobile. J'espère que l'image est maintenant plus claire.

9. Ruby on Rails – Quel type de travail puis-je obtenir ?

Rails est l'une des compétences les plus demandées de nos jours, il existe donc de nombreuses entreprises parmi lesquelles travailler. Les startups, comme Zearn, aiment particulièrement Rails. Il s’agit d’une start-up informatique éducative à but non lucratif. Vous pouvez également en choisir davantage grande entreprise comme Bloomberg et participent au développement de sites Internet et d'applications utilisés par des millions d'utilisateurs. Le travail indépendant est également une bonne option pour les développeurs Rails. Étant indépendant, vous pourrez choisir vous-même à quels projets vous souhaitez participer : petits et à court terme ou sérieux et à long terme.

10. J'ai essayé un autre langage de programmation, mais je ne l'ai pas aimé. Dois-je essayer Rails ?

Je tiens à souligner à nouveau que Rails n'est en fait pas un langage de programmation, mais un framework. Si vous vous êtes déjà demandé s'il était utile d'essayer de tomber amoureux d'un langage de programmation, tout ce que je peux dire, c'est que Ruby est le langage de programmation le plus vénéré et le plus apprécié des utilisateurs au monde. Je n’abandonnerais donc pas la programmation tant que vous n’aurez pas essayé Ruby.

11. Dois-je apprendre JavaScript avec Rails ?

Au lieu de cela – non. De plus – SANS DOUTE.

Un développeur Rails devra apprendre JavaScript(). Ce n'est pas une exigence pour apprendre Rails, mais c'est une compétence dont vous aurez besoin au fur et à mesure de votre apprentissage.

Soyons honnêtes, au fur et à mesure que vous approfondirez le domaine de la technologie, vous commencerez à réaliser que vous devrez avoir pas mal de compétences (en gros, cela signifie que tout le monde devrait s'efforcer d'être un développeur Full-Stack). Heureusement, au fur et à mesure que vous gagnerez en expérience, il vous sera plus facile d'apprendre à la fois de nouveaux langages et de nouveaux frameworks.

Quant à savoir s’il faut choisir JavaScript ou Rails, je vais vous dire sans détour que vous ne pouvez pas vous tromper dans les deux cas. Je trouve Ruby beaucoup plus facile à apprendre que JavaScript. De plus, je connais de nombreuses personnes qui ont trouvé JavaScript plus facile après avoir appris Ruby pour la première fois. Mais comme je l’ai dit plus haut, vous ne pouvez certainement pas vous tromper si vous étudiez les deux.

12. Combien de temps durera la formation ?

Combien de temps par jour devrez-vous consacrer à étudier ? Je pense qu'une bonne compréhension de Rails nécessite plusieurs mois de formation dédiée. Mais comme pour toute autre compétence, vous aurez besoin de dizaines de milliers d’heures pour devenir un pro de Rails, il est donc préférable de commencer dès maintenant.

Votre vitesse d’apprentissage sera grandement influencée par votre niveau de connaissances dans le domaine de la programmation en général. Mais si vous êtes un débutant complet, cela vaut la peine d'essayer de commencer avec Ruby et Rails.

13. Ruby on Rails – Par où commencer ?

Je recommande de commencer par le meilleur cours Ruby on Rails disponible aujourd'hui. Si vous n'avez pas écrit une seule ligne de code dans votre vie, la première chose à faire est de suivre le cours HTML et CSS. Heureusement, il est assez facile de trouver des cours sur HTML et CSS. Après cela, vous devrez apprendre Ruby, Git et la ligne de commande.

Le programme de formation vous présentera généralement progressivement Rails, vous montrant comment travailler avec Sinatra et ActiveRecord. Cela ne vous dit encore rien, mais le fait est qu'avant de transporter ce « camion » dont j'ai parlé plus tôt, vous devez commencer par cours simples conduire sur Rails.

La meilleure chose à faire lorsque l'on étudie est de créer son propre projet, de travailler sur quelque chose et de se développer, de comprendre que l'on va dans la bonne direction, et aussi d'avoir bon soutien! Au cours du processus d'apprentissage, vous vous poserez des millions de petites questions et pour y parvenir meilleur résultat Il est important que vous ayez quelqu'un qui puisse vous aider à comprendre et vous donner des conseils en cas de difficultés.

Alexander est le fondateur du projet de site Web « Web Laboratory of Success », créé pour soutenir les entrepreneurs Internet débutants et confirmés. C'est un bourreau de travail convaincu avec une expérience professionnelle dans la gestion de la rédaction d'un magazine en ligne, la création et la gestion de sa propre boutique en ligne. Occupation principale : promotion d'entreprises (y compris de boutiques en ligne) via Facebook et Google Adwords. Hobby principal : monétiser des sites Web via des outils de marketing d'affiliation et Google Adsense. Records personnels confirmés : 3 millions de visiteurs de blog par mois.

13 février 2012 à 16h06

La meilleure façon d'apprendre Rails

• Rubis sur Rails

Bonne journée!

Préface

Un jour, je voulais mieux connaître Rails, mais je ne savais pas par où commencer jusqu'à ce que cet article attire mon attention. Vous verrez ensuite une traduction mélangée à ma propre expérience et à mes propres expressions lexicales et phraséologiques. Alors, allons-y.

Introduction

J'ai beaucoup d'expérience avec PHP, mais je travaille maintenant en tant que développeur Rails. Le plus grand défi pour la plupart des personnes qui tentent d’apprendre quelque chose de nouveau est le processus d’apprentissage lui-même. Lorsque vous maîtrisez un langage ou un framework et que vous le connaissez parfaitement, passer à quelque chose de nouveau ne semble pas nécessaire.

Cependant, apprendre Ruby on Rails est assez simple. Il s'agit d'un cadre incroyablement puissant qui bénéficie d'une énorme communauté qui le fait avancer. La question que nous nous posons est donc : quelle est la meilleure façon d’apprendre Rails ? Le voici : le plan de cours.

Cet article est plan complet les leçons nécessaires pour vous familiariser avec Rails et commencer à travailler avec lui dans les plus brefs délais. Tout ce que vous avez à faire est de suivre les étapes ci-dessous, répertoriées dans l’ordre.

Point 1 : travailler avec des exercices dans Try Ruby

Vous pourriez penser qu’apprendre Ruby est la meilleure chose ici étape importante, mais ce n'est pas vrai. Certains de ceux qui commencent à étudier Ruby en détail arrêtent d'étudier et continuent simplement à travailler avec langue actuelle et le cadre. Ne fais pas ça !. N'ayez pas peur d'apprendre cette langue (ou toute autre). Ruby est une langue amusante, géniale et facile à apprendre. De plus, n’oubliez pas que vous n’êtes pas obligé de l’étudier à 100 %. Il vous suffit de connaître les bases.

L'outil le plus recommandé pour se plonger dans la syntaxe Ruby est le site Web TryRuby. Il fournit un environnement interactif qui vous permet d'essayer la syntaxe en action. Si vous composez aide, vous serez invité à regarder un tutoriel d'une quinzaine de minutes qui vous apprendra les bases. N'oubliez pas que le manuel comporte deux chapitres, que vous pouvez lire en tapant aide 2.

Si vous travaillez bien sur ces tâches pendant un certain temps, vous aurez bonne base connaissance. Tout ce que j'ai fait d'abord, c'est d'étudier ces deux manuels. Le reste, j'ai appris en développant des sites sur Rails, ainsi qu'en recherchant sur Google et en m'exerçant avec IRB.

Point 2 : Installer Ruby et Ruby on Rails

Si vous souhaitez apprendre Rails, vous devrez sans doute l'installer sur votre ordinateur. Voici plusieurs solutions basées sur le système d’exploitation dont vous disposez. Si vous possédez un ordinateur Mac ou Linux, je vous recommande d'utiliser RVM. C'est un excellent outil pour installer Ruby. En fait, voici les instructions pour l'installation elle-même. Si vous disposez de Windows, vous devrez utiliser RubyInstaller.

L'étape suivante consiste à installer Rails lui-même. Pour ce faire, vous devez installer RubyGems. Si vous utilisez RVM, alors félicitations : RubyGems est déjà installé. Si vous avez Windows, alors je vous conseille de suivre ici. Pour installer Rails, vous devez utiliser la commande rails d'installation de pierres précieuses et puis, tout est fait !

Point 3 : Lire l'introduction à Rails de Jeffrey Way

Dans ce screencast de 40 minutes, Jeffrie Way vous explique ce que vous devez savoir pour utiliser Rails. Il contient de nombreuses informations utiles, notamment sur des sujets tels que :

• Modèles et générateurs
• Développement piloté par les tests (TDD)
• Enregistrement actif
• RSpec et Capybara
• Partiels

et bien plus encore...

Point 4 : Suivez le cours Rails For Zombies

J'ai toujours pensé qu'apprendre par l'exemple était le meilleur moyen d'apprendre un langage ou un framework. Un cours gratuit et incroyablement puissant que vous devriez absolument consulter est Rails For Zombies, créé par les gars d'EnvyLabs. Ce cours est interactif, ce qui signifie qu'après avoir visionné chaque vidéo, vous travaillerez sur des exercices utiles et intéressants.

En attendant, je vous parlais d'outils interactifs et gratuits. Le temps des cadeaux est terminé ! Vous devriez maintenant acheter un livre intitulé Agile Web Development with Rails. Il est conçu pour vous apprendre à utiliser Rails en créant un site Web à partir de zéro. Il passe en revue les bases telles que les contrôleurs, les modèles, les échafaudages, les tests fonctionnels et également un peu d'AJAX. Achetez au moins la dernière édition.

Point 6 : Créer un blog simple

Je sais que ça semble plutôt ennuyeux ( au moins pour moi), mais ça excellent exemple, qui est utilisé partout car il est assez simple et rapide à écrire. En suivant ce chemin, vous contribuerez à consolider vos connaissances et vos compétences. Mais je vous suggère de ne pas copier-coller (vous n'obtiendrez rien en faisant cela, à part peut-être 10 minutes d'électricité gaspillée), mais d'essayer de l'écrire progressivement, de mémoire, parfois simplement en regardant le livre pour voir comment telle ou telle méthode fonctionne.

Point 7 : Ajoutez de nouvelles fonctionnalités à votre blog

Fabuleux! Avez-vous finalement construit le vôtre ? propre blog. Néanmoins, il ne dispose pas de fonctionnalités à part entière, mais présente uniquement les fonctions de base inhérentes à chaque blog. Bon, travaillons un peu et ajoutons un système d'authentification.

En fait, je ne veux pas vous forcer à faire quelque chose de difficile pour le moment, parce que vous avez déjà travaillé dur. Vous pouvez utiliser une gemme prête à l'emploi (Omniauth, par exemple) comme système d'authentification. En même temps, vous découvrirez comment implémenter des gemmes dans votre projet.

Je recommande également de regarder ce screencast de Ryan Bates, qui décrit la création d'un système d'authentification simple à partir de zéro. Après avoir implémenté le système, vous devez ajouter la possibilité de supprimer/modifier des publications si vous ne l'avez pas déjà fait. Si la tâche est déjà terminée, il est temps de passer au point suivant.

Point 8 : créer quelque chose qui vous est propre

À ce stade, il est temps pour vous de faire preuve de plus de créativité et de penser à créer une sorte de service (par exemple, l'hébergement de photos). Ne vous arrêtez pas à la conception de votre deuxième site Web. Prenez quelque chose de tout fait. Par exemple,

Ce guide couvre l'installation et l'exécution de Ruby on Rails.

Après l'avoir lu, vous apprendrez :

• Comment installer Rails, créer une nouvelle application Rails et attacher votre application à une base de données.
• La structure générale d'une application Rails.
• Principes de base de la conception basée sur MVC (Model, View Controller) et RESTful.
• Comment générer rapidement le code initial pour une application Rails.

Hypothèses contenues dans ce manuel

Ce tutoriel s'adresse aux débutants qui souhaitent démarrer une application Rails à partir de zéro. Cela ne suppose pas que vous ayez déjà travaillé avec Rails.

Rails est un framework de développement Web écrit dans le langage de programmation Ruby. Si vous n'avez aucune expérience avec Ruby, vous aurez peut-être du mal à vous lancer directement dans l'apprentissage de Rails. Il existe plusieurs bonnes ressources en anglais dédiées à l'apprentissage de Ruby, par exemple :

Veuillez noter que certaines ressources, bien que toujours excellentes, couvrent toujours les anciennes versions de Ruby telles que la 1.6, et en particulier la 1.8, et n'incluent pas certaines des syntaxes que vous verrez dans le développement quotidien de Rails.

Qu’est-ce que Rails ?

Rails est un framework de développement Web écrit dans le langage de programmation Ruby. Il est conçu pour faciliter la programmation d'applications Web en faisant un certain nombre d'hypothèses sur ce dont chaque développeur a besoin pour créer un nouveau projet. Il vous permet d'écrire moins de code lors de la programmation par rapport à d'autres langages et frameworks. Les développeurs professionnels de Rails notent également que cela rend le développement d'applications Web plus amusant =)

Rails est un logiciel capricieux. Il part du principe qu'il existe une « meilleure » ​​façon de faire quelque chose, et il est conçu de telle manière qu'il encourage cette façon de procéder - et dans certains cas, décourage même les alternatives. Si vous apprenez "The Rails Way", vous découvrirez peut-être une augmentation significative de votre productivité. Si vous persistez à intégrer d'anciennes habitudes d'autres langages dans le développement Rails et essayez d'utiliser des modèles appris ailleurs, vous vivrez une expérience de développement moins heureuse.

La philosophie Rails comprend deux principes directeurs importants :

• Ne vous répétez pas : DRY est un principe de développement logiciel qui stipule que « chaque élément d'information doit avoir une représentation unique, non redondante et faisant autorité dans le système ». N'écrivez pas les mêmes informations encore et encore, le code sera plus facile à maintenir et sera plus extensible et moins buggé.
• Convention sur la configuration : Rails a des opinions sur les meilleures façons de faire beaucoup de choses dans une application Web et applique par défaut ces conventions plutôt que de vous obliger à bricoler de nombreux fichiers de configuration.

Création d'un nouveau projet Rails

La meilleure façon d’utiliser ce guide est de le parcourir étape par étape. Toutes les étapes sont essentielles à l’exécution de l’exemple d’application. En dehors de celles-ci, aucune autre étape n’est requise. code supplémentaire ou des étapes.

En suivant ce tutoriel, vous créerez un projet Rails appelé blog, un blog web très simple. Avant de commencer à créer une application, nous devons nous assurer que Rails lui-même est installé.

Les exemples suivants utilisent $ pour indiquer une ligne d'entrée de terminal dans un format de type UNIX systèmes d'exploitation ah, même si cela peut être configuré différemment. Si vous utilisez Windows, la ligne ressemblera à c:\source_code>

3.1. Installation des rails

Avant d'installer Rails, vous devez vous assurer que les pré-dépendances requises sont installées sur votre système. Ceux-ci incluent Ruby et SQLite3.

Candidatures ouvertes pour ligne de commande. Sur macOS, ouvrez Terminal.app, sous Windows, sélectionnez « Exécuter » dans le menu Démarrer et écrivez « cmd.exe ». Toutes les commandes commençant par le signe dollar $ doivent être exécutées sur la ligne de commande. Assurez-vous d'avoir installé version actuelle Rubis:

$ rubis ​​-v rubis ​​2.5.0

Rails nécessite l'installation de Ruby version 2.4.1 ou ultérieure. Si le numéro de version est inférieur, vous devrez installer nouvelle copie Rubis.

Pour installer rapidement Ruby et Ruby on Rails sur un système, les utilisateurs Windows peuvent utiliser Rails Installer. Des méthodes d'installation supplémentaires pour la plupart des systèmes d'exploitation peuvent être consultées sur ruby-lang.org.

Si vous travaillez sous Windows, vous devez installer le kit de développement Ruby Installer.

Vous aurez également besoin d'une installation de base de données SQLite3.

De nombreux systèmes d'exploitation populaires de type UNIX sont livrés avec une version raisonnable de SQLite3. Sous Windows, si vous avez installé Rails à l’aide du programme d’installation de Rails, SQLite est déjà installé. Les autres utilisateurs peuvent se référer au site Web SQLite3 pour obtenir des instructions d'installation. Vérifiez qu'il est correctement installé et qu'il est contenu dans votre PATH :

$sqlite3 --version

Le programme doit signaler sa version.

Pour installer Rails, utilisez la commande gem install fournie par RubyGems :

$ gemme installer des rails

Pour vérifier que tout est correctement installé, vous devez procéder comme suit :

$rails --version

S'il indique quelque chose comme « Rails 5.1.1 », vous pouvez continuer.

3.2. Création d'une application de blog

Rails est livré avec un certain nombre de scripts, appelés générateurs, conçus pour faciliter la vie d'un développeur en générant tout ce dont il a besoin pour démarrer une tâche spécifique. L'un d'eux est le New Application Generator, qui vous donne le cadre d'une application Rails afin que vous n'ayez pas à l'écrire vous-même.

Pour utiliser ce générateur, ouvrez un terminal, allez dans un dossier où vous avez l'autorisation de créer des fichiers et écrivez :

nouveau blog $rails

Cela créera une application Rails nommée Blog dans le répertoire du blog et installera les gems dont les dépendances sont mentionnées dans le Gemfile lorsque en utilisant le paquet installer.

À en utilisant Windows Sous-système pour Linux, il existe certaines restrictions sur les messages du système de fichiers qui signifient que vous devez désactiver les gemmes Spring et Listen, ce que vous pouvez faire en exécutant Rails New Blog --skip-spring --skip-listen .

Vous pouvez voir toutes les options de ligne de commande possibles acceptées par le générateur d'applications Rails en exécutant rails new -h .

Une fois que vous avez créé l'application de blog, rendez-vous dans son dossier :

Le répertoire du blog contient plusieurs fichiers et dossiers générés automatiquement qui définissent la structure d'une application Rails. La plupart du travail de ce didacticiel se déroulera dans le dossier app, mais pour l'instant, passons en revue les fonctions de chaque dossier que Rails crée par défaut dans une nouvelle application :

Fichier/Dossier	But
application/	Contient des contrôleurs, des modèles, des vues, des assistants, des mailers, des canaux, des tâches et des actifs de votre application. Nous examinerons ce dossier plus en détail ensuite.
poubelle/	Contient les scripts Rails qui démarrent votre application, et le répertoire peut également contenir d'autres scripts que vous utilisez pour configurer, mettre à jour, déployer ou exécuter.
configuration/	Configurations d'itinéraires, base de données de votre application, etc. Ceci est couvert plus en détail dans Configuration des applications Rails.
config.ru	Configuration en rack pour les serveurs basés sur rack utilisés pour exécuter l'application. Pour plus d'informations sur Rack, visitez le site Web de Rack.
db/	Contient votre schéma de base de données actuel ainsi que les migrations de bases de données.
Fichier de pierres précieuses Gemfile.lock	Ces fichiers vous permettent de spécifier les dépendances gem dont votre application Rails a besoin. Ces fichiers sont utilisés par la gem Bundler. Pour plus d’informations sur Bundler, visitez le site Web Bundler.
lib/	Modules externes pour votre application.
enregistrer/	Fichiers journaux des applications.
package.json	Ce fichier vous permet de spécifier quelles dépendances npm sont requises pour votre application Rails. Ce fichier est utilisé par Yarn. Pour plus d’informations sur Yarn, visitez le site Web de Yarn.
publique/	Le seul dossier accessible de l'extérieur tel quel. Contient des fichiers statiques et des actifs compilés.
Fichier rake	Ce fichier recherche et charge les tâches pouvant être exécutées sur la ligne de commande. Une tâche spécifique est disponible dans tous les composants Rails. Au lieu de modifier le Rakefile, vous pouvez ajouter vos propres tâches en ajoutant des fichiers au répertoire lib/tasks de l'application.
LISEZMOI.md	Ceci est un guide d’introduction à votre candidature. Il doit être modifié pour indiquer aux autres ce que fait votre application, comment la configurer, etc.
stockage/	Fichiers de stockage actif pour le service Disk. Ceci est couvert dans le guide Présentation du stockage actif.
test/	Tests unitaires, montages et autres appareils de test. Ceci est couvert dans le guide des applications Testing Rails.
tmp/	Fichiers temporaires (tels que les fichiers cache et pid)
fournisseur/	Place pour le code tiers. Dans une application Rails typique, elle inclut des gemmes externes.
.gitignore	Ce fichier indique à git quels fichiers (explicitement ou par conception) il doit ignorer. Pour plus d’informations sur l’ignorance des fichiers, consultez GitHub – Ignorer les fichiers.
.version ruby	Ce fichier contient la version par défaut de Ruby.

Bonjour Rails!

Tout d’abord, affichons du texte à l’écran. Pour ce faire, vous avez besoin d'un serveur en cours d'exécution pour votre application Rails.

4.1. Démarrage du serveur Web

En fait tu as déjà application fonctionnelle sur Rails. Pour être sûr, vous devez exécuter un serveur Web sur votre machine. Cela peut être fait en exécutant la commande suivante à partir du répertoire du blog :

$ serveur bin/rails

Si vous utilisez Windows, vous devez transmettre les scripts de dossiers poubelle directement dans l'interpréteur Ruby, c'est-à-dire le serveur ruby ​​​​bin\rails.

La compilation de CoffeeScript et la compression des ressources JavaScript nécessitent un environnement Exécution JavaScript sur votre système, et son absence entraînera une erreur execjs lors de la compilation des actifs. Généralement, macOS et Windows sont livrés avec environnement établi Exécution JavaScript. Rails ajoute la gem mini_racer au Gemfile généré de la nouvelle application dans une ligne commentée, vous pouvez la décommenter si nécessaire. therubyrhino est le runtime recommandé pour les utilisateurs de JRuby et est ajouté au Gemfile si l'application est générée sous JRuby. Vous pouvez tout savoir sur les environnements d'exécution pris en charge dans ExecJS

Cela lancera Puma, un serveur web distribué avec Rails par défaut. Pour voir l'application en action, ouvrez une fenêtre de navigateur et accédez à http://localhost:3000. Vous devriez voir la valeur par défaut page d'informations Rails :

Pour arrêter le serveur Web, appuyez sur Ctrl+C dans le terminal où il s'exécute. Pour vérifier que le serveur a été arrêté, vous devriez voir à nouveau le curseur de ligne de commande. Pour la plupart Systèmes de type UNIX, y compris macOS, ce sera le signe dollar $. En mode développement, Rails ne nécessite généralement pas l'arrêt du serveur ; toutes les modifications que vous apportez aux fichiers sont automatiquement récupérées par le serveur.

La page Welcome Aboard est une sorte de test pour une nouvelle application Rails : elle montre que vos programmes sont suffisamment configurés correctement pour afficher la page.

4.2. Dites bonjour à Rails

Pour que Rails dise "Bonjour", vous devez créer au moins contrôleur Et voir(performance).

Le but du responsable du traitement est de recevoir des demandes spécifiques adressées à l'application. Routage décide quel contrôleur recevra quelles demandes. Il existe souvent plusieurs routes vers chaque contrôleur, et différentes routes peuvent être gérées différemment action. Le but de chaque action est de collecter des informations pour les fournir à la vue.

Le but de la vue est d'afficher ces informations dans un format lisible par l'homme. Une distinction importante à noter est que le lieu où les informations sont collectées est contrôleur, pas une vue. La vue ne doit afficher que ces informations. Par défaut, les modèles de vue sont écrits dans un langage appelé eRuby (Embedded Ruby), qui est converti par une boucle de requête Rails avant d'être envoyé à l'utilisateur.

Pour créer un nouveau contrôleur, vous devez exécuter le générateur « contrôleur » et lui dire que vous voulez un contrôleur appelé « Bienvenue » avec une action appelée « index », comme ceci :

$ bin/rails génère l'index de bienvenue du contrôleur

Rails créera des fichiers et un itinéraire.

Créer une route app/controllers/welcome_controller.rb obtenir "welcome/index" invoquer erb créer app/views/welcome créer app/views/welcome/index.html.erb invoquer test_unit créer test/controllers/welcome_controller_test.rb invoquer assistant créer une application/ helpers/welcome_helper.rb invoquer test_unit invoquer les actifs invoquer le café créer app/assets/javascripts/welcome.coffee invoquer scss créer app/assets/stylesheets/welcome.scss

Les plus importants d'entre eux sont bien entendu le contrôleur, situé dans app/controllers/welcome_controller.rb, et la vue, située dans app/views/welcome/index.html.erb.

Ouvrez le fichier app/views/welcome/index.html.erb dans un éditeur de texte. Supprimez tout le code existant dans le fichier et remplacez-le par la ligne de code suivante :

Si vous soumettez à nouveau le formulaire, vous verrez quelque chose comme ce qui suit :

"Premier article!", "text"=>"Ceci est mon premier article.") autorisé : false>

Désormais, cette action affiche les paramètres de l'article provenant du formulaire. Cependant, cela reste inutile. Oui, vous voyez les paramètres, mais vous ne faites rien avec eux.

5.4. Création d'un modèle d'article

Les modèles dans Rails utilisent un nom au singulier, tandis que leur table correspondante dans la base de données utilise un nom au pluriel. Rails fournit un générateur de modèles que la plupart des développeurs Rails utilisent pour créer de nouveaux modèles. Pour créer un nouveau modèle, exécutez cette commande dans votre terminal :

$ bin/rails génère un modèle Titre de l'article : chaîne texte : texte

Avec cette commande, nous disons à Rails que nous voulons un modèle Article avec l'attribut titre type de chaîne et attribut texte type de texte. Ces attributs seront automatiquement ajoutés à la table articles et liés au modèle Article.

Rails répondra en créant une série de fichiers. Désormais, nous ne nous intéressons qu'à app/models/article.rb et db/migrate/20140120191729_create_articles.rb (votre nom peut être légèrement différent). Ce dernier est responsable de la création de la structure de la base de données, nous y reviendrons donc ensuite.

Active Record est suffisamment intelligent pour associer automatiquement les noms de colonnes aux attributs du modèle, ce qui signifie qu'à l'intérieur des modèles Rails, il n'est pas nécessaire de déclarer des attributs, Active Record le fera automatiquement.

5.5. Démarrer une migration

Comme vous l'avez déjà vu, le modèle de génération bin/rails a créé le fichier migration de base de données dans le répertoire db/migrate. Migrations est une classe Ruby conçue pour faciliter la création et la modification de tables de base de données. Rails utilise des commandes rake pour exécuter des migrations, et il est possible d'annuler une migration une fois qu'elle a été appliquée à votre base de données. Le nom du fichier de migration inclut un horodatage pour garantir qu'il est exécuté dans l'ordre dans lequel il a été créé.

Si vous regardez dans le fichier db/migrate/YYYYMMDDHHMMSS_create_articles.rb (rappelez-vous, votre fichier a un nom légèrement différent), voici ce que vous y trouverez :

Classe CréerArticles< ActiveRecord::Migration def change create_table:articles do |t| t.string:title t.text:text t.timestamps end end end

Cette migration crée une méthode de modification qui est appelée lors de l'exécution de cette migration. Les actions définies dans cette migration sont également réversibles, ce qui signifie que Rails sait comment annuler les modifications apportées par cette migration au cas où vous décideriez de les annuler ultérieurement. Lorsque vous exécutez cette migration, une table d'articles est créée avec une colonne de chaîne et une colonne de texte. Il créera également deux champs d'horodatage pour suivre la date de création et de mise à jour de l'article.

Nous devons maintenant utiliser la commande bin/rails pour démarrer la migration :

$ bin/rails db: migrer

Rails exécutera cette commande de migration et signalera qu'il a créé la table Articles.

CreateArticles : migration ================================================ === -- create_table(:articles) -> 0,0019s == CreateArticles : migré (0,0020s) ============================ ==============

Puisque vous exécutez par défaut dans l'environnement de développement, cette commande sera appliquée à la base de données définie dans la section développement de votre fichier config/database.yml. Si vous souhaitez effectuer des migrations dans un autre environnement, tel que la production, vous devez le transmettre explicitement lors de l'appel de la commande : bin/rails db:migrate RAILS_ENV=production .

5.6. Sauvegarde des données dans le contrôleur

De retour au ArticlesController, nous devons modifier l'action de création pour utiliser le nouveau modèle Article pour enregistrer les données dans la base de données. Ouvrez app/controllers/articles_controller.rb et modifiez l'action de création pour qu'elle ressemble à ceci :

Def create @article = Article.new(params[:article]) @article.save redirect_to @article end

Voici ce qui se passe ici : chaque modèle Rails peut être initialisé avec les attributs appropriés, qui seront automatiquement liés aux colonnes de la base de données correspondantes. Dans la première ligne, nous faisons exactement cela (rappelez-vous que params[:article] contient les attributs qui nous intéressent). @article.save se charge ensuite de sauvegarder le modèle dans la base de données. Enfin, nous redirigeons l'utilisateur vers l'action show, que nous définirons plus tard.

Vous vous demandez peut-être pourquoi le A dans Article.new est en majuscule alors que tous les autres liens d'articles de ce guide sont en majuscule. Dans ce contexte, nous faisons référence à une classe appelée Article, qui est définie dans app/models/article.rb. Les noms de classe en Ruby doivent commencer par une lettre majuscule.

Maintenant qu'il y a des validations, appeler @article.save sur un article invalide renverra false . Si vous ouvrez à nouveau app/controllers/articles_controller.rb, vous verrez que nous ne vérifions pas le résultat de l'appel @article.save dans l'action de création. Si @article.save échoue dans cette situation, nous devons à nouveau montrer le formulaire à l'utilisateur. Pour ce faire, remplacez les actions new et create dans app/controllers/articles_controller.rb par celles-ci :

Def new @article = Article.new end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end private def article_params params.require(:article).permit(:title , :texte) fin

Maintenant, la nouvelle action crée une nouvelle variable d'instance appelée @article , et vous verrez pourquoi dans quelques paragraphes.

Notez que dans l'action de création, nous avons utilisé render au lieu de redirect_to lorsque save renvoie false. La méthode render est utilisée pour garantir que l'objet @article est renvoyé au nouveau modèle lors de son rendu. Ce rendu est effectué dans la même requête que la soumission du formulaire, tandis que redirect_to indique au navigateur de faire une requête différente.

5.11. Mises à jour des articles

Nous avons couvert la partie "CR" de CRUD. Concentrons-nous maintenant sur la partie « U », la mise à jour des articles.

La première étape consiste à ajouter une action d'édition au ArticlesController, généralement entre les actions de création et de création, comme indiqué.

Def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end fin

La vue contiendra un formulaire similaire à celui que nous avons utilisé lors de la création de nouveaux articles. Créez un fichier appelé app/views/articles/edit.html.erb et ajoutez-y ce qui suit :

Modification de l'article

<%= form_with(model: @article, local: true) do |form| %> <% if @article.errors.any? %> <% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %> <%= link_to "Back", articles_path %>

Pour le moment, nous pointons le formulaire vers une action de mise à jour, qui n'a pas encore été définie, mais nous le ferons bientôt.

Passer l'objet article à la méthode définira automatiquement l'URL de soumission du formulaire d'article modifié. Cette option indique à Rails que nous souhaitons que ce formulaire soit soumis en utilisant PATCH , une méthode HTTP qui devrait être utilisée pour mises à jour ressources conformément au protocole REST.

Ensuite, vous devez créer une action de mise à jour dans app/controllers/articles_controller.rb . Ajoutez-le entre l'action create et la méthode private :

Def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end private def article_params params.require(:article).permit(:title, :text) end

La nouvelle méthode, update , est utilisée lorsque vous souhaitez mettre à jour un enregistrement qui existe déjà et nécessite un hachage contenant les attributs que vous souhaitez mettre à jour. Comme auparavant, s'il y a une erreur lors de la mise à jour de l'article, nous souhaitons à nouveau afficher le formulaire à l'utilisateur.

Nous avons réutilisé la méthode article_params que nous avons définie précédemment pour l'action de création.

Il n'est pas nécessaire de transmettre tous les attributs pour mettre à jour . Par exemple, si @article.update(title: "A new title") a été appelé, Rails mettra à jour uniquement l'attribut title, laissant tous les autres attributs intacts.

<% @articles.each do |article| %> <% end %>

Titre	Texte
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>

Et nous ajouterons également app/views/articles/show.html.erb au modèle afin que le lien « Modifier » soit également sur la page de l'article. Ajoutez ce qui suit à la fin du modèle :

... <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Et voici à quoi ressemble notre application maintenant :

5.12. Utiliser des partiels pour nettoyer les répétitions dans les vues

Notre page d'édition est très similaire à la nouvelle page, en fait elles utilisent le même code pour afficher le formulaire. Supprimons cette duplication en utilisant une vue partielle. Par convention, les fichiers partiels commencent par un trait de soulignement.

Créez un nouveau fichier app/views/articles/_form.html.erb avec le contenu suivant :

<%= form_with model: @article, local: true do |form| %> <% if @article.errors.any? %>

<% end %>

<%= form.label:title %>
<%= form.text_field:title %>

<%= form.label:text %>
<%= form.text_area:text %>

<%= form.submit %>

<% end %>

Mettons maintenant à jour la vue app/views/articles/new.html.erb pour utiliser ce nouveau partiel en le réécrivant complètement :

Nouvel article

<%= render "form" %> <%= link_to "Back", articles_path %>

Et pareil pour la vue app/views/articles/edit.html.erb :

Modifier l'article

<%= render "form" %> <%= link_to "Back", articles_path %>

5.13. Supprimer des articles

Nous sommes maintenant prêts à couvrir la partie "D" de CRUD, en la supprimant de la base de données. Conformément à la convention REST, la route pour supprimer les articles dans la sortie des routes bin/rails est la suivante :

SUPPRIMER /articles/:id(.:format) articles#destroy

La méthode de suppression de routage doit être utilisée pour les itinéraires qui détruisent des ressources. Si elle est laissée comme route d'obtention normale, il serait possible de créer les URL malveillantes suivantes :

regarde ce chat !

Nous utilisons la méthode delete pour détruire les ressources, et cette route est associée à l'action destroy dans app/controllers/articles_controller.rb, qui n'existe pas encore. La méthode destroy est généralement la dernière action CRUD dans un contrôleur et, comme les autres actions CRUD publiques, elle doit être placée avant toute méthode privée ou protégée. Ajoutons-le :

Def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end

L'intégralité du ArticlesController dans le fichier app/controllers/articles_controller.rb devrait maintenant ressembler à ceci :

Contrôleur d'articles de classe< ApplicationController def index @articles = Article.all end def show @article = Article.find(params[:id]) end def new @article = Article.new end def edit @article = Article.find(params[:id]) end def create @article = Article.new(article_params) if @article.save redirect_to @article else render "new" end end def update @article = Article.find(params[:id]) if @article.update(article_params) redirect_to @article else render "edit" end end def destroy @article = Article.find(params[:id]) @article.destroy redirect_to articles_path end private def article_params params.require(:article).permit(:title, :text) end end

Vous pouvez appeler destroy sur Objets actifs Enregistrez quand vous souhaitez les supprimer de la base de données. Notez que nous n'avons pas besoin d'ajouter une vue pour cette action puisque nous redirigeons vers l'action d'indexation.

Liste des articles

<%= link_to "New article", new_article_path %> <% @articles.each do |article| %> <% end %>

Titre	Texte
<%= article.title %>	<%= article.text %>	<%= link_to "Show", article_path(article) %>	<%= link_to "Edit", edit_article_path(article) %>	<%= link_to "Destroy", article_path(article), method: :delete, data: { confirm: "Are you sure?" } %>

Ici, nous utilisons link_to d'une manière différente. Nous passons la route nommée comme deuxième argument et les options comme autre argument. Les options méthode : :delete et data: (confirm: "Are you sure?") sont utilisées comme attributs html5, donc lorsqu'un lien est cliqué, Rails montrera d'abord à l'utilisateur une boîte de dialogue de confirmation, puis enverra le lien en utilisant la méthode delete . Cela se fait à l'aide du fichier JavaScript rails-ujs, qui est automatiquement inclus dans la présentation de l'application (app/views/layouts/application.html.erb) lorsque l'application est générée. Sans ce fichier, la boîte de dialogue de confirmation ne s'affichera pas.

Félicitations, vous pouvez désormais créer, visualiser tous et individuellement, mettre à jour et supprimer des articles.

Ajout d'un deuxième modèle

Il est temps d'ajouter un deuxième modèle à l'application. Le deuxième modèle traitera les commentaires sur les articles.

6.1. Générer le modèle

Nous avons l'intention d'utiliser le même générateur que celui que nous avons utilisé précédemment lors de la création du modèle Article. Cette fois, nous allons créer un modèle de commentaire contenant un lien vers l'article. Exécutez la commande suivante dans un terminal :

$ bin/rails génère un modèle Commentateur de commentaire : corps de chaîne : article de texte : références

Cette commande génère quatre fichiers :

Jetons d'abord un coup d'œil à app/models/comment.rb :

Commentaire de classe< ApplicationRecord belongs_to:article end

Ceci est très similaire au modèle Article que nous avons vu plus tôt. La différence réside dans la ligne Appartient_to:article, qui définit connexion Enregistrement actif. Vous en apprendrez davantage sur les connexions dans la section suivante du guide.

Le mot-clé (:references) utilisé dans la commande bash est type spécial données pour les modèles. Il crée une nouvelle colonne dans votre base de données avec le nom du modèle représenté avec _id ajouté, qui peut contenir valeurs numériques. Pour mieux comprendre, analysez le fichier db/schema.rb après avoir effectué la migration.

En plus du modèle, Rails a également effectué une migration pour créer la table de base de données correspondante :

Classe CreateComments< ActiveRecord::Migration def change create_table:comments do |t| t.string:commenter t.text:body t.references:article, foreign_key: true t.timestamps end end end

La ligne t.references crée une colonne numérique nommée article_id , un index dessus et une contrainte de clé étrangère pointant vers la colonne id de la table articles. Ensuite, nous démarrons la migration :

$ bin/rails db: migrer

Rails est suffisamment intelligent pour exécuter uniquement des migrations qui n'ont pas déjà été exécutées sur la base de données actuelle. Dans notre cas, vous verrez :

CreateComments : migration ================================================ == -- create_table(:comments) -> 0,0115s == CreateComments : migré (0,0119s) ============================== ============

6.2. Modèles de connexion

Les relations Active Record vous permettent de déclarer facilement des relations entre deux modèles. Dans le cas de commentaires et d’articles, vous pourriez décrire la relation comme suit :

• Chaque commentaire appartient à un article.
• Un article peut contenir plusieurs commentaires.

En fait, c'est très proche de la syntaxe que Rails utilise pour déclarer cette connexion. Vous avez déjà vu la ligne de code dans le modèle Comment (app/models/comment.rb) qui fait que chaque commentaire appartient à un article :

Commentaire de classe< ApplicationRecord belongs_to:article end

Vous devez modifier app/models/article.rb pour ajouter l'autre côté du lien :

Article de classe< ApplicationRecord has_many:comments validates:title, presence: true, length: { minimum: 5 } [...] end

Ces deux publicités mettent automatiquement à disposition grand nombre opportunités. Par exemple, si vous disposez d'une variable d'instance @article contenant un article, vous pouvez obtenir tous les commentaires appartenant à cet article dans un tableau en appelant @article.comments .

6.3. Ajouter un itinéraire pour les commentaires

Comme pour le contrôleur de bienvenue, nous devons ajouter une route pour que Rails sache à quelle adresse nous voulons nous rendre pour voir les commentaires. Ouvrez à nouveau le fichier config/routes.rb et modifiez-le comme suit :

Ressources : articles font ressources : fin des commentaires

Cela créera des commentaires comme ressource imbriquée dans les articles. C’est l’autre aspect de la capture des relations hiérarchiques qui existent entre les articles et les commentaires.

6.4. Générer un contrôleur

Ayant le modèle, tournons notre attention vers la création du contrôleur approprié. Nous utiliserons à nouveau le même générateur que nous avons utilisé auparavant :

$ bin/rails génère un contrôleur Commentaires

Cinq fichiers et un répertoire vide seront créés :

Comme tout autre blog, nos lecteurs créeront leurs commentaires immédiatement après avoir lu l'article, et après avoir ajouté un commentaire, ils seront redirigés vers la page d'affichage de l'article et verront que leur commentaire a déjà été reflété. À cet égard, notre CommentsController sert à créer des commentaires et à supprimer le spam, le cas échéant.

Nous allons d'abord étendre le modèle d'affichage d'articles (app/views/articles/show.html.erb) pour vous permettre d'ajouter nouveau commentaire:

Titre: <%= @article.title %>

Texte: <%= @article.text %>

Ajouter un commentaire :

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Cela ajoutera un formulaire à la page d'affichage de l'article qui crée un nouveau commentaire lorsque l'action de création est appelée sur CommentsController . Ici, l'appel form_with utilise un tableau, qui créera une route imbriquée telle que /articles/1/comments .

Écrivons create dans app/controllers/comments_controller.rb :

Contrôleur de commentaires de classe< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

C'est un peu plus compliqué que ce que vous avez vu dans le contrôleur d'articles. Il s’agit d’un effet secondaire de la pièce jointe que vous avez configurée. Chaque demande de commentaire garde la trace de l'article auquel le commentaire est attaché, nous résolvons donc d'abord le problème de récupération de l'article en appelant find sur le modèle Article.

De plus, le code tire parti de certaines méthodes disponibles pour les connexions. Nous utilisons la méthode create sur @article.comments pour créer et enregistrer un commentaire. Cela lie automatiquement le commentaire afin qu'il appartienne à un article spécifique.

Une fois que nous avons créé un nouveau commentaire, nous ramenons l'utilisateur à l'article d'origine à l'aide de l'assistant article_path (@article). Comme nous l'avons déjà vu, il appelle l'action show sur ArticlesController, qui à son tour restitue le modèle show.html.erb. C'est ici que nous souhaitons afficher les commentaires, ajoutons donc ce qui suit à app/views/articles/show.html.erb.

Titre: <%= @article.title %>

Texte: <%= @article.text %>

Commentaires

<% @article.comments.each do |comment| %>

Commentateur : <%= comment.commenter %>

Commentaire: <%= comment.body %>

<% end %>

Ajouter un commentaire :

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Vous pouvez désormais ajouter des articles et des commentaires sur votre blog et les afficher dans aux bons endroits.

Refactorisation

Maintenant que nous avons des articles de travail et des commentaires, jetons un coup d'œil au modèle app/views/articles/show.html.erb. C'est devenu long et inconfortable. Utilisons des partiels pour le soulager.

7.1. Rendu de collections de partiels

Tout d'abord, nous allons créer un commentaire partiel montrant tous les commentaires d'un article. Créez un fichier app/views/comments/_comment.html.erb et mettez-y ce qui suit :

Commentateur : <%= comment.commenter %>

Commentaire: <%= comment.body %>

Ensuite, vous pouvez modifier app/views/articles/show.html.erb comme ceci :

Titre: <%= @article.title %>

Texte: <%= @article.text %>

Commentaires

<%= render @article.comments %>

Ajouter un commentaire :

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Cela rendra désormais le app/views/comments/_comment.html.erb partiel une fois pour chaque commentaire de la collection @article.comments. Étant donné que la méthode render parcourt la collection @article.comments, elle attribue chaque commentaire à une variable locale nommée comme le partial, dans ce cas comment , qui est à notre disposition dans le partiel pour l'affichage.

7.2. Rendre un formulaire de manière partielle

Déplaçons également la nouvelle section de commentaires vers notre partiel. Encore une fois, créez un fichier app/views/comments/_form.html.erb contenant :

<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>

<%= form.label:commenter %>
<%= form.text_field:commenter %>

<%= form.label:body %>
<%= form.text_area:body %>

<%= form.submit %>

<% end %>

Modifiez ensuite app/views/articles/show.html.erb comme ceci :

Titre: <%= @article.title %>

Texte: <%= @article.text %>

Commentaires

<%= render @article.comments %>

Ajouter un commentaire :

<%= render "comments/form" %> <%= link_to "Edit", edit_article_path(@article) %> | <%= link_to "Back", articles_path %>

Le deuxième rendu définit simplement le modèle partiel que nous voulons restituer, comments/form . Rails est suffisamment intelligent pour mettre un trait de soulignement sur cette ligne et comprendre que vous vouliez afficher le fichier _form.html.erb dans le répertoire app/views/comments.

L'objet @article est disponible dans tous les partiels rendus dans la vue, puisque nous l'avons défini comme variable d'instance.

Supprimer des commentaires

Une autre fonctionnalité importante du blog est la possibilité de supprimer le spam. Pour ce faire, vous devez insérer un lien dans la vue et une action de destruction dans le CommentsController.

Commentateur : <%= comment.commenter %>

Commentaire: <%= comment.body %>

<%= link_to "Destroy Comment", , method: :delete, data: { confirm: "Are you sure?" } %>

En cliquant sur ce nouveau lien "Détruire le commentaire", DELETE /articles/:article_id/comments/:id sera exécuté dans notre CommentsController qui sera ensuite utilisé pour trouver le commentaire que nous voulons supprimer. Ajoutons donc une action de destruction à notre contrôleur (app/ contrôleurs/commentaires_controller.rb) :

Contrôleur de commentaires de classe< ApplicationController def create @article = Article.find(params[:article_id]) @comment = @article.comments.create(comment_params) redirect_to article_path(@article) end def destroy @article = Article.find(params[:article_id]) @comment = @article.comments.find(params[:id]) @comment.destroy redirect_to article_path(@article) end private def comment_params params.require(:comment).permit(:commenter, :body) end end

L'action de destruction trouvera l'article que nous consultons, trouvera le commentaire dans la collection @article.comments, puis le supprimera de la base de données et nous ramènera à l'affichage de l'article.

8.1. Suppression d'objets associés

Si vous supprimez un article, les commentaires qui y sont associés doivent également être supprimés, sinon ils prendront simplement de la place dans la base de données. Rails vous permet d'utiliser l'option dépendante sur un lien pour y parvenir. Modifiez le modèle d'article, app/models/article.rb , comme suit :

Article de classe< ApplicationRecord has_many:comments, dependent: :destroy validates:title, presence: true, length: { minimum: 5 } [...] end

Sécurité

9.1. Authentification de base

Si vous publiez votre blog en ligne, n'importe qui peut ajouter, modifier et supprimer des articles ou supprimer des commentaires.

Rails fournit un système d'authentification HTTP de base qui fonctionne bien dans cette situation.

Dans ArticlesController, nous avons besoin d'un moyen de bloquer l'accès à diverses actions si l'utilisateur n'est pas authentifié. Ici, nous pouvons utiliser la méthode Rails http_basic_authenticate_with pour autoriser l'accès aux actions requises, si la méthode le permet.

Pour utiliser le système d'authentification, nous le définirons en haut de notre ArticlesController dans app/controllers/articles_controller.rb. Dans notre cas, nous voulons que l'utilisateur soit authentifié pour chaque action sauf index et show , nous l'écrirons donc comme ceci :

Contrôleur d'articles de classe< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show] def index @articles = Article.all end # пропущено для краткости

Nous souhaitons également autoriser uniquement les utilisateurs authentifiés à supprimer des commentaires. Dans CommentsController (app/controllers/comments_controller.rb), nous écrirons :

Contrôleur de commentaires de classe< ApplicationController http_basic_authenticate_with name: "dhh", password: "secret", only: :destroy def create @article = Article.find(params[:article_id]) # ... end # пропущено для краткости

Désormais, si vous essayez de créer un nouvel article, vous rencontrerez un appel d'authentification HTTP de base :

D'autres méthodes d'authentification sont également disponibles pour les applications Rails. Deux modules complémentaires populaires pour Rails sont Devise et Authlogic, entre autres.

9.2. Autres réflexions sur la sécurité

La sécurité, en particulier dans les applications Web, est un domaine vaste et détaillé. La sécurité de votre application Rails est traitée plus en détail dans le guide Sécurité des applications Rails. La manière la plus simple de travailler avec Rails est de stocker toutes les données externes en UTF-8. Sinon, les bibliothèques Ruby et Rails seront souvent capables de convertir vos données natives en UTF-8, mais cela ne fonctionne pas toujours de manière fiable, il est donc préférable de s'assurer que toutes les données externes sont en UTF-8.

Si vous faites une erreur dans cette zone, le symptôme le plus courant est un diamant noir avec un point d'interrogation à l'intérieur apparaissant dans le navigateur. Un autre symptôme courant est l'apparition de symboles tels que « Ã¼ » à la place de « ü ». Rails prend un certain nombre de mesures internes pour atténuer les cas courants de problèmes qui peuvent être automatiquement détectés et corrigés. Cependant, s'il existe des données externes qui ne sont pas stockées dans UTF-8, cela peut conduire à ce type de problèmes que Rails ne peut pas détecter et résoudre automatiquement.

Les deux sources de données les plus courantes qui ne sont pas au format UTF-8 sont :

• Votre éditeur de texte : la plupart des éditeurs de texte (tels que TextMate) enregistrent les fichiers au format UTF-8 par défaut. Si votre éditeur de texte ne le fait pas, les caractères spéciaux saisis dans vos motifs (tels que é) peuvent apparaître sous la forme d'un losange avec un point d'interrogation dans le navigateur. Cela s'applique également à vos fichiers de traduction i18N. La plupart des éditeurs qui n'utilisent pas UTF-8 par défaut (comme certaines versions de Dreamweaver) proposent un moyen de modifier la valeur par défaut en UTF-8. Faites ceci.
• Votre base de données : Rails convertit par défaut les données de votre base de données en UTF-8 en périphérie. Cependant, si votre base de données n'utilise pas UTF-8 en interne, elle ne pourra peut-être pas stocker tous les caractères que votre utilisateur saisira. Par exemple, si votre base de données utilise Latin-1 en interne et que votre utilisateur saisit des caractères russes, hébreux ou japonais, les données seront perdues dès leur entrée dans la base de données. Si possible, utilisez UTF-8 comme stockage interne dans votre base de données.

Dans cet article, je veux vous expliquer comment créer une application simple qui fonctionne avec une base de données MySQL dans l'environnement Ruby on Rails 3. Vous pouvez considérer ce matériel comme suit. guide étape par étape pour les programmeurs Rails débutants.

Donc, pour le travail, nous avons besoin de rails et de rubygems installés. Hier, j'ai eu un problème avec ce dernier, j'ai donc dû supprimer le package rubygems1.8 (on ne sait pas comment il s'est retrouvé dans le système) et installer rubygems1.9. Permettez-moi de vous rappeler que je développe sur Ubuntu, bien que pour Windows Je pense que les commandes de la console Rails seront les mêmes. En tant qu'environnement de développement, j'utilise NetBeans avec un plugin pour Ruby on Rails. Mon collègue a bien écrit sur l'installation.

Vérification des liens

Vous devez vous assurer que le répertoire /usr/bin contient liens symboliques rails, rake, ruby, bundler vers des fichiers du répertoire /usr/local/ruby/bin. Pour afficher les liens, utilisez la commande :

en fonction de ce que vous souhaitez filtrer.

Création d'une application

J'ai créé un répertoire spécial pour mes applications Ruby.

mkdir /home/andrey/ruby
cd /home.andrey/ruby

Rails dispose de nombreux utilitaires de console qui facilitent grandement votre travail, notamment pour le prototypage. Pour créer une application utilisant MySQL comme base de données, exécutez la commande :

app est le nom de notre nouvelle application. Après avoir exécuté la commande, nous verrons comment rails a fait de nous le framework de la future application.

root@vaio:~/ruby# lance la nouvelle application -d mysql
créer
créer un fichier README
créer un fichier Rake
créer config.ru
créer.gitignore
créer un fichier Gem
créer une application
créer app/controllers/application_controller.rb
créer app/helpers/application_helper.rb
créer des applications/mailers
créer des applications/modèles
créer app/views/layouts/application.html.erb
créer une configuration
créer config/routes.rb
créer config/application.rb
créer config/environment.rb
créer une configuration/des environnements
créer config/environments/development.rb
créer config/environments/production.rb
créer config/environments/test.rb
créer une configuration/initialiseurs
créer config/initializers/backtrace_silencers.rb
créer config/initializers/inflections.rb
créer config/initializers/mime_types.rb
créer config/initializers/secret_token.rb
créer config/initializers/session_store.rb
créer une configuration/locales
créer config/locales/en.yml
créer config/boot.rb
créer config/database.yml
créer une base de données
créer db/seeds.rb
créer un document
créer doc/README_FOR_APP
créer une bibliothèque
créer une bibliothèque/tâches
créer lib/tasks/.gitkeep
créer un journal
créer un journal/server.log
créer un journal/production.log
créer un journal/développement.log
créer un journal/test.log
créer du public
créer public/404.html
créer public/422.html
créer public/500.html
créer public/favicon.ico
créer public/index.html
créer public/robots.txt
créer du public/des images
créer public/images/rails.png
créer des feuilles de style publiques
créer public/stylesheets/.gitkeep
créer du public/javascripts
créer public/javascripts/application.js
créer public/javascripts/controls.js
créer public/javascripts/dragdrop.js
créer public/javascripts/effects.js
créer public/javascripts/prototype.js
créer public/javascripts/rails.js
créer un script
créer un script/rails
créer un test
créer des tests/appareils
créer un test/fonctionnel
créer un test/une intégration
créer test/performance/browsing_test.rb
créer test/test_helper.rb
créer un test/une unité
créer tmp
créer tmp/sessions
créer des tmp/sockets
créer tmp/cache
créer tmp/pids
créer un fournisseur/plugins
créer un fournisseur/plugins/.gitkeep

Nous allons dans le dossier avec celui-ci et installons les gemmes nécessaires. Les gemmes sont des bibliothèques de plug-ins nécessaires au projet (analogues aux PECL et PEAR de PHP).

Après cela, la console affichera quelque chose comme ceci :

andrey@vaio:~/ruby/app> installation du bundle sudo
Utiliser le râteau (0.8.7)
Utiliser le résumé (1.0.0)
Utilisation d'activesupport (3.0.0)
Utilisation du constructeur (2.1.2)
Utilisation de i18n (0.4.2)
Utilisation du modèle actif (3.0.0)
Utiliser l'érubis (2.6.6)
Utilisation du support (1.2.1)
Utilisation du montage en rack (0.6.13)
Utilisation du test en rack (0.5.6)
Utiliser tzinfo (0.3.23)
Utilisation du pack d'action (3.0.0)
Utiliser des types MIME (1.16)
Utiliser polyglotte (0.3.1)
Utiliser la cime des arbres (1.4.8)
Utiliser le courrier (2.2.9)
Utiliser Actionmailer (3.0.0)
Utilisation d'Arel (1.0.1)
Utilisation d'ActiveRecord (3.0.0)
Utilisation d'activeresource (3.0.0)
Utilisation du bundler (1.0.3)
Utiliser MySQL2 (0.2.6)
Utiliser Thor (0.14.4)
Utilisation de railties (3.0.0)
Utiliser des rails (3.0.0)
Votre pack est complet ! Utilisez `bundle show ` pour voir où une gemme groupée est installée.

Cela signifie que toutes les gemmes sont installées et connectées. S'il manque quelque chose, le bundle lui-même les téléchargera depuis Rubygems et les installera. C'est ce qui me manquait depuis longtemps en PHP ; il s'avère essentiellement qu'il s'agit d'un installateur de projet. La liste des gems dépendantes se trouve dans le Gemfile à la racine du projet.

Configuration

Nous devons maintenant spécifier les détails d'accès à la base de données de notre projet. Ouvrez le projet dans NetBeans : Nouveau projet -> Ruby -> Application Ruby on Rails avec la source existante. Nous indiquons le chemin, dans mon cas ce sera (/home/andrey/ruby/app) et le nom du projet (app). Pour la plateforme Ruby, nous sélectionnons celle installée sur le système, plutôt que celle intégrée à NetBeans. Cliquez sur Terminer et le projet est créé. Ouvrez le pseudo-dossier Configuration et le fichier database.yml. Ici, vous devez spécifier le login et le mot de passe pour accéder à la base de données, de préférence pour les trois environnements (développement, test, production) à la fois. L'environnement est l'environnement dans lequel notre application s'exécutera,

• développement - ordinateur du développeur,
• serveur de production - exploitation industrielle,
• test - travaillez en mode test sur le serveur d'intégration continue ou sur l'ordinateur du testeur.

les rails génèrent le modèle Nom d'utilisateur : chaîne hasched_password : chaîne salt : chaîne

Vous pouvez immédiatement voir ce que Rails a généré pour nous :

invoquer active_record
créer db/migrate/20101107054200_create_users.rb
créer app/models/user.rb
invoquer test_unit
créer test/unit/user_test.rb
créer test/fixtures/users.yml

Super, nous devons maintenant créer une base de données. Pour ce faire nous faisons :

andrey@vaio:~/ruby/app$ rake db:create
(dans /home/andrey/ruby/app)
andrey@vaio:~/ruby/app$ rake db:migrate
(dans /home/andrey/ruby/app)
== CreateUsers : migration ============================================== =======
— create_table(:utilisateurs)
-> 0,0061s
== CreateUsers : migré (0,0063 s) ========================================== ============== ==

La console affiche les données ajoutées. Nous regardons dans phpmyadmin et voyons les nouvelles bases de données app_development et app_test, ainsi que les tables qu'elles contiennent. Il est maintenant temps d'ajouter des données réelles. Pour cela, lancez la console Rails

Une console n'est pas seulement une console, mais une console IRB dans le contexte de votre application. A titre d'exemple, créons deux utilisateurs :

andrey@vaio:~/ruby/app$ rails console
Chargement de l'environnement de développement (Rails 3.0.0)
irb(main):001:0> user1 = User.new
=> #
irb(main):002:0> user1.name = "andrey"
=> "andré"
irb(principal):003:0> user1.save
=> vrai
irb(main):004:0> user2 = User.new
=> #
irb(main):005:0> user2.name = "vasiliy"
=> "vasiliy"
irb(principal):006:0> user2.save
=> vrai

irb (principal): 007: 0> quitter
andrey@vaio:~/ruby/app$

Regardons la base de données, et nous avons effectivement deux utilisateurs. Je voudrais noter que Rails lui-même a ajouté des colonnes de clé primaire et des champs create_at (date de création) et update_at (date de modification) au modèle.

Nous avons un modèle et nous avons aussi des données. Il est temps de lancer notre application.

andrey@vaio:~/ruby/app$ serveur rails
=> Démarrage de WEBrick
=> Application Rails 3.0.0 commençant en développement sur http://0.0.0.0:3000
=> Appeler avec -d pour se détacher
=> Ctrl-C pour arrêter le serveur
INFO WEBrick 1.3.1
INFO rubis 1.9.2 (2010-08-18)
INFO WEBrick::HTTPServer#start : pid=4193 port=3000

L'application est en cours d'exécution, ouvrez le navigateur à l'adresse et consultez la page de test.

Super, l'application fonctionne. Mais il affiche une page HTML normale du dossier /public/index.html. Et nous voulons du dynamisme. Ouvrez la deuxième fenêtre de la console (puisque dans la première nous avons le serveur Ruby en cours d'exécution - WebRick), allez dans le dossier contenant le projet et tapez-y la commande suivante :

andrey@vaio : ~/ruby/app$ les rails génèrent l'index du contrôleur
créer app/controllers/index_controller.rb
route obtenir "index/index"
invoquer erb
créer une application/vues/index
créer app/views/index/index.html.erb
invoquer test_unit
créer test/fonctionnel/index_controller_test.rb
appeler l'assistant
créer app/helpers/index_helper.rb
invoquer test_unit
créer test/unit/helpers/index_helper_test.rb
andrey@vaio:~/ruby/app$

Avec cela, nous avons créé un contrôleur d'index, il contient une action Index et le type de cette action est index.html.erb. Nous effectuons l'actualisation (F5) dans NetBeans et regardons nos fichiers. Incroyable. Nous devons maintenant rediriger d'une manière ou d'une autre l'itinéraire de la page principale vers l'action du contrôleur que nous avons créée. Ouvrez le fichier routes (Configuration/routes.rb) et décommentez-y la ligne suivante :

# Vous pouvez faire router la racine de votre site avec « root »
# n'oubliez pas de supprimer public/index.html.
root:to => "bienvenue#index"

Seulement, au lieu de bienvenue, nous écrivons également index. Eh bien, je suis habitué au Zend Framework où le contrôleur et l'action sont appelés index par défaut. N'oubliez pas de supprimer (ou de renommer) le fichier public/index.html.

racine:to => "index#index"

Nous actualisons la page dans le navigateur et constatons que notre vue est désormais affichée.

Index#index

Super. Nous pouvons maintenant coder. Accédez à notre contrôleur nouvellement créé (Contrôleurs -> index_controller.rb) et écrivez-y le texte d'action suivant :

classe IndexController< ApplicationController
indice déf
@users = Utilisateur.find(:all)
fin
fin

Ouvrez maintenant la vue Views/index/index.html.erb et écrivez-y le code suivant :

Index#index

Trouvez-moi dans app/views/index/index.html.erb

<% for user in @users -%>
<%=user.name%>

<% end %>

En faisant cela, nous demandons à Rails de parcourir le tableau d'utilisateurs et d'afficher leurs noms. Nous actualisons la page et voyons la liste des utilisateurs ci-dessous.

Index#index

Trouvez-moi dans app/views/index/index.html.erb

andré
Vassili

Super! L'application est créée !

Merci!

Si cet article vous a aidé ou si vous souhaitez soutenir mes recherches et mon blog, voici la meilleure façon de le faire :