Le principal mérite de tout concepteur de sites Web est de pouvoir comprendre - et même organiser - ce qui se passe dans les coulisses.

À tout le moins, vous devriez prendre des leçons de programmation. Je ne parle pas des langages frontaux comme HTML et CSS - vous en connaissez probablement déjà beaucoup. Je parle de trucs de back-end.

Si vous savez poser les bases, vous comprendrez mieux comment concevoir le reste du site. Le fait est qu'apprendre à programmer fera de vous un concepteur plus érudit. De plus, qui ne voudrait pas embaucher un designer qui sait tout, de la conception au développement de sites Web ?

L'astuce consiste à choisir un endroit pour commencer. Apprendre la programmation peut être un processus délicat, surtout si vous choisissez l'un des langages les plus difficiles comme C++ ou PHP.

Alors, quel est le meilleur endroit pour commencer ? Il n'y a qu'une seule réponse : Ruby on Rails est l'un des meilleurs langages de programmation et frameworks pour apprendre les bases du design.

Pourquoi Ruby est-il le meilleur choix ?

Pour les débutants, Ruby est l'un des langages les plus faciles à apprendre, surtout si vous avez une certaine expérience HTML ou CSS que la plupart des concepteurs ont.

L'un des premiers programmes que vous ferez lorsque vous commencerez à apprendre une langue est le tristement célèbre Hello World, qui consiste à afficher ces mots à l'écran.

Avec des langages comme C++, il peut y avoir de cinq à sept lignes de code juste pour afficher ces deux mots. Mais si vous utilisez Ruby, il n'y aura qu'une seule ligne et une seule commande.

Met "hello, world!"

C'est tout! C'est tout ce dont vous avez besoin pour taper les mots "Hello world!" sur l'écran. Assez facile, non?

Ruby on Rails est aussi un langage très sec. En tant que l'un des principes de développement, DRY (dry) signifie « Ne vous répétez pas » - c'est-à-dire, ne programmez pas à nouveau l'élément lorsque vous pouvez utiliser celui que vous avez déjà créé. Cela fait de Ruby un langage de programmation très léger et souvent utilisé pour le développement, car il vise à terminer rapidement et efficacement un projet.

Rubis ou Rails ?

Ruby est un langage de programmation. Rails est un framework qui utilise Ruby pour faire le travail. Le framework Ruby on Rails est une collection de code pré-construit ou pré-écrit qui peut aider à accélérer le processus de création de nouveaux projets. Il a été créé à l'origine pour développer l'outil de gestion de projet Basecamp. Outre Basecamp, il existe d'autres applications Web populaires construites avec Rails telles que 500px, ThemeForest et MyFitnessPal.

Une fois que vous avez compris comment travailler avec le langage Ruby et que le matériel fonctionne dans le framework Ruby on Rails, vous pouvez commencer à créer des applications Web.

Ruby est à son apogée !

Avec l'explosion des appareils mobiles et la technologie toujours connectée, Ruby est incroyablement populaire en ce moment. Et, probablement, il en sera ainsi à l'avenir. L'indice TIOBE classe Ruby comme le 13ème langage de programmation le plus populaire. Conformément aux tendances émergentes, selon Indeed.com, Ruby connaît également une demande étonnamment forte.

Indice TIOBE

Dans tous les cas, quel que soit votre choix - demande ou popularité - Ruby est très populaire. Cela en fait l'un des meilleurs endroits pour commencer, car une fois que vous maîtrisez la langue, vous pouvez faire le travail assez rapidement. Et c'est avant de commencer à apprendre une autre langue pour élargir vos compétences.

Ruby a une base solide !

Certains des autres langages existent depuis plus longtemps, c'est vrai, mais même ainsi, le support et la documentation sont dérisoires par rapport à ce qui est disponible pour Ruby. D'autres langues manquent également de cohésion sociale autour d'un cadre hautement pris en charge.

Grâce au framework Ruby On Rails, il existe déjà des tonnes de code préexistant que vous pouvez utiliser dans vos propres projets. Ruby Gems, une bibliothèque de frameworks Ruby, propose plus de 600 000 bibliothèques parmi lesquelles choisir.

Chaque fois que vous apprenez quelque chose de nouveau, vous avez besoin de beaucoup de documentation et de support. Il existe une tonne d'endroits pour trouver des tutoriels, des tutoriels, des guides et même des forums de questions-réponses. Si vous rencontrez un problème spécifique, une simple recherche sur le Web le résoudra probablement. C'est important.

Une documentation simple et un accès facile au support sont essentiels lorsque vous apprenez une nouvelle langue - lorsque vous apprenez réellement quelque chose de nouveau.

Ruby "permet" plus de contrôle sur la conception

Si vous n'êtes qu'un concepteur de sites Web, la création d'un site Web peut être un processus long et complexe. Lorsque vous vous asseyez pour travailler avec un programmeur et discuter du back-end nécessaire pour votre site, vous devez souvent sacrifier le front-end pour que tout fonctionne correctement.

En fin de compte, cela peut conduire à un produit qui semble complètement différent de votre vision d'origine. Le programmeur ne s'en souciera peut-être pas, mais ce sera probablement problématique pour vous.

Vous ne rencontrerez pas de problèmes de ce genre si vous programmez vous-même. Vous n'avez pas besoin de dépendre des autres pour obtenir un projet fini, et vous aurez une bien meilleure compréhension de ce qui peut être réalisé en termes de développement. Il y a sûrement eu un moment ou deux où les objectifs de votre projet étaient trop élevés pour un programmeur ou une équipe de développement ? Lorsque vous apprenez une langue comme Ruby, vous pouvez en revanche profiter de la facilité de compréhension des besoins et des possibilités.

Fondamentalement, Ruby est destiné à être utilisé dans les applications Web et le développement Web, c'est donc l'endroit idéal pour les concepteurs Web en herbe. Une fois que vous aurez compris ce langage et appris à utiliser le framework Ruby on Rails, vous aurez beaucoup plus de contrôle sur vos projets.

Où apprendre Ruby ?

La meilleure façon d'apprendre une langue est de s'immerger et de travailler avec elle. Il existe également de nombreux tutoriels et tutoriels auxquels vous pouvez vous référer. Si vous avez une mémoire visuelle développée et que vous comprenez mieux grâce aux présentations visuelles, alors allez-y sur YouTube - il y a un grand choix de vidéos de formation.

Si vous souhaitez un apprentissage traditionnel en classe, vous pouvez vous former sur des sites dédiés à l'apprentissage de la programmation. Vous n'avez pas besoin d'aller à l'université ou au collège pour obtenir un diplôme professionnel.

L'une de mes ressources préférées - et entièrement gratuite - pour apprendre Rails est le didacticiel Rails de Michael Hartl. Il vous guidera d'un projet simple à un projet complexe à votre propre rythme d'apprentissage, et vous pourrez repartir de zéro sans aucune connaissance de Ruby on Rails.

Quelle que soit la voie d'apprentissage que vous choisissez, rappelez-vous que seule la pratique mène à l'excellence. Fixez-vous des objectifs personnels pour passer un certain temps chaque jour à travailler avec Ruby. Tenez-vous-en à ces objectifs et persévérez. Avant de connaître ce langage jusqu'au bout, vous serez déjà un expert capable de créer des projets fantastiques.

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

Après l'avoir lu, vous découvrirez :

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

Hypothèses dans ce guide

Ce tutoriel est destiné aux débutants qui souhaitent démarrer une application Rails à partir de zéro. Cela ne signifie pas que vous avez déjà travaillé avec Rails.

Rails est un framework de développement Web écrit dans le langage de programmation Ruby. Si vous débutez avec Ruby, il peut être difficile de démarrer immédiatement avec Rails. Il existe de bonnes ressources en anglais pour apprendre Ruby, par exemple :

Notez que certaines ressources, bien qu'elles soient toujours excellentes, couvrent toujours les anciennes versions de Ruby telles que 1.6, et surtout 1.8, et n'incluent pas une partie de la syntaxe que vous verrez dans votre développement Rails quotidien.

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 utilisant 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 que les autres langages et frameworks. Les développeurs professionnels de Rails notent également que le développement d'applications Web est plus amusant avec =)

Rails est un logiciel magistral. Il part du principe qu'il existe une "meilleure" façon de faire quelque chose, et il est conçu pour encourager cette façon - et dans certains cas même décourager les alternatives. Si vous étudiez "The Rails Way", vous découvrirez probablement une augmentation significative de la productivité. Si vous persistez et transférez d'anciennes habitudes d'autres langages dans le développement Rails, et essayez d'utiliser des modèles appris ailleurs, votre expérience de développement sera moins heureuse.

La philosophie de 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 plus extensible et moins bogué.
• Convention sur la configuration: Rails a des opinions sur les meilleures façons de faire beaucoup de choses dans une application Web, et ces conventions sont définies par défaut, au lieu de vous obliger à modifier de nombreux fichiers de configuration dans de petits détails.

Créer un nouveau projet Rails

La meilleure façon d'utiliser ce didacticiel est de le parcourir étape par étape. Toutes les étapes sont essentielles à l'exécution de l'exemple d'application et aucun code ou étape supplémentaire n'est requis.

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

Les exemples suivants utilisent $ pour désigner la chaîne d'entrée du terminal sur les systèmes d'exploitation de type UNIX, bien qu'elle puisse être configurée différemment. Si vous utilisez Windows, la ligne ressemblera à c: \ code_source>

3.1. Installation des rails

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

Ouvrez les applications de ligne de commande. Sur macOS, ouvrez Terminal.app, sur Windows, choisissez Exécuter dans le menu Démarrer et tapez cmd.exe. Toutes les commandes commençant par un signe dollar $ doivent être exécutées sur la ligne de commande. Assurez-vous que la version actuelle de Ruby est installée :

$ ruby ​​​​-v ruby ​​​​2.5.0

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

Pour installer rapidement Ruby et Ruby on Rails sur un système, les utilisateurs Windows peuvent utiliser le programme d'installation de Rails. 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 utilisez 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 de type UNIX sont livrés avec une version acceptable de SQLite3. Sous Windows, si vous avez installé Rails à l'aide du programme d'installation de Rails, vous avez déjà installé SQLite. Les autres utilisateurs peuvent se référer aux instructions d'installation sur le site Web de SQLite3. Vérifiez qu'il est correctement installé et inclus dans votre PATH :

$ sqlite3 --version

Le programme doit signaler sa version.

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

$ gem installer des rails

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

$ rails --version

Si vous voyez quelque chose comme "Rails 6.0.0", vous pouvez continuer.

3.2. Création de l'application Blog

Rails est livré avec un certain nombre de scripts appelés générateurs, conçus pour faciliter la vie du développeur en créant tout ce qu'il faut pour démarrer une tâche donnée. L'un est le New Application Generator, qui vous fournit les bases 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 le dossier où vous avez l'autorisation de créer des fichiers et écrivez :

$ rails nouveau blog

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 à l'aide de l'installation du bundle.

Lors de l'utilisation du sous-système Windows pour Linux, il existe certaines restrictions sur les messages du système de fichiers, ce qui signifie que les gems spring et listen doivent être désactivés, ce qui peut être fait en exécutant rails new blog --skip-spring --skip-listen.

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

Une fois que vous avez créé l'application de blog, accédez à son dossier :

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

Dossier de fichiers	Rendez-vous
application /	Contient des contrôleurs, des modèles, des vues, des assistants, des expéditeurs, des canaux, des travaux et des actifs pour votre application. Nous examinerons ce dossier plus en détail plus tard.
poubelle /	Contient des 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 /	Les configurations de route, la 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 en rack utilisés pour exécuter l'application. Pour plus d'informations sur Rack, consultez le site Web Rack.
db /	Contient le schéma actuel de votre base de données ainsi que les migrations de base de données.
Gemfile Gemfile.lock	Ces fichiers vous permettent de spécifier les dépendances gems dont votre application Rails a besoin. Ces fichiers sont utilisés par la gem Bundler. Pour plus d'informations sur Bundler, consultez le site Web de Bundler.
lib /	Modules externes pour votre application.
Journal /	Fichiers journaux des applications.
package.json	Ce fichier vous permet de spécifier quelles dépendances npm sont nécessaires pour votre application Rails. Ce fichier est utilisé par Yarn. Pour plus d'informations sur Yarn, consultez le site Web Yarn.
Publique /	Le seul dossier accessible de l'extérieur tel quel. Contient des fichiers statiques et des actifs compilés.
Rakefile	Ce fichier recherche et charge les tâches qui peuvent être exécutées à partir de 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/tâches de l'application.
LISEZMOI.md	Il s'agit d'un didacticiel d'introduction à votre application. Il doit être édité pour dire aux autres ce que fait votre application, comment la configurer, etc.
espace de rangement /	Fichiers de stockage actifs pour le service de disque. 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 didacticiel Testing Rails Applications.
tmp /	Fichiers temporaires (tels que les fichiers cache et pid)
vendeur /	Un emplacement pour le code tiers. Dans une application Rails typique, inclut des gems externes.
.gitignore	Ce fichier indique à git les fichiers (explicitement ou sauvagement) à ignorer. Pour plus d'informations sur l'ignorance des fichiers, consultez GitHub - Ignorer les fichiers.
.ruby-version	Ce fichier contient la version Ruby par défaut.

Salut les Rails !

Tout d'abord, affichons du texte à l'écran. Cela nécessite un serveur en cours d'exécution pour votre application Rails.

4.1. Lancement du serveur Web

En fait, vous avez déjà une application Rails fonctionnelle. 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 :

Si vous utilisez Windows, vous devez diriger les scripts du dossier bin directement vers l'interpréteur Ruby, c'est-à-dire le serveur ruby ​​bin \ rails.

La compression des actifs JavaScript nécessite une exécution JavaScript sur votre système, et son absence entraînera une erreur execjs lors de la compression des actifs. Généralement, macOS et Windows sont livrés avec un runtime JavaScript installé. therubyrhino est l'environnement d'exécution recommandé pour les utilisateurs de JRuby et est ajouté au fichier Gemfile si l'application est générée avec JRuby. Vous pouvez tout savoir sur les runtimes pris en charge dans ExecJS

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

Pour arrêter le serveur Web, appuyez sur Ctrl + C dans le terminal où il s'exécute. Vous devriez voir à nouveau le curseur de la ligne de commande pour vérifier que le serveur a été arrêté. Pour la plupart des 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 d'arrêter le serveur ; toutes les modifications que vous apportez aux fichiers sont automatiquement récupérées par le serveur.

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

4.2. Dites bonjour à Rails

Pour que Rails dise bonjour, vous devez créer au moins manette et vyuhu(performance).

Le contrôleur a pour but de recevoir des requêtes spécifiques pour l'application. Routage décide quel contrôleur recevra quelles demandes. Il y a souvent plus d'une route vers chaque contrôleur, et différentes routes peuvent être gérées différemment. jeux d'action... Le but de chaque action est de collecter des informations à présenter à la vue.

Le but d'une vue est d'afficher ces informations dans un format lisible. Une distinction importante à faire est que le lieu de collecte des informations est manette, 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 démarrez le générateur « contrôleur » et lui dites que vous voulez un contrôleur nommé « Bienvenue » avec une action nommée « index », comme ceci :

$ rails generate controller Index de bienvenue

Rails va créer des fichiers et un itinéraire.

Créer une application / contrôleurs / route welcome_controller.rb obtenir "bienvenue / index" invoquer erb créer une application / vues / bienvenue créer une application / vues / bienvenue / index.html.erb invoquer test_unit créer un test / contrôleurs / welcome_controller_test.rb invoquer l'aide créer une application / helpers / welcome_helper.rb invoquer test_unit invoquer des actifs invoquer scss créer une application / actifs / feuilles de style / welcome.scss

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

Ouvrez 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 !", "Texte" => "Ceci est mon premier article.") Autorisé : false>

Cette action affiche maintenant les paramètres de l'article provenant du formulaire. Cependant, cela reste inutile. Oui, vous pouvez voir les paramètres, mais essentiellement ne faites rien avec eux.

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

Les modèles dans Rails utilisent un nom au singulier et leur table de base de données correspondante 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 :

$ rails generate model Titre de l'article : string text : text

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

Rails créera une série de fichiers en réponse. Maintenant, 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 chargé de créer la structure de la base de données, c'est pourquoi nous l'examinerons plus loin.

Active Record est suffisamment intelligent pour associer automatiquement les noms de colonnes aux attributs du modèle, ce qui signifie que vous n'avez pas besoin de déclarer les attributs dans les modèles Rails, Active Record le fera automatiquement.

5.5. Exécution de la migration

Comme vous l'avez vu, les rails génèrent le modèle généré le fichier migrations de bases 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 les migrations, et il est possible d'annuler la migration une fois qu'elle a été appliquée à votre base de données. Le nom du fichier de migration comprend un horodatage pour garantir qu'ils sont exécutés dans l'ordre dans lequel ils ont été créés.

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

Créer des articles de classe< 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 appelée lorsque cette migration démarre. 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, elle crée une table d'articles avec une colonne de chaîne et une colonne de texte. Il créera également deux champs d'horodatage pour suivre quand l'article a été créé et mis à jour.

Nous devons maintenant utiliser la commande rails pour lancer la migration :

$ rails db : migrer

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

Créer des articles : migrer ================================================ == - create_table (: articles) -> 0.0019s == CreateArticles: migré (0.0020s) ============================== ============

Puisque vous travaillez dans l'environnement de développement par défaut, cette commande s'appliquera à la base de données définie dans la section développement de votre fichier config/base de données.yml. Si vous souhaitez migrer dans un environnement différent, par exemple en production, vous devez le passer explicitement lorsque vous invoquez la commande : rails db: migrate RAILS_ENV = production.

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

De retour dans ArticlesController, nous devons modifier l'action de création pour utiliser le nouveau modèle d'article afin de conserver les données dans la base de données. Ouvrez app/controllers/articles_controller.rb et modifiez l'action de création comme suit :

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 se lieront automatiquement aux colonnes de 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). Ensuite, @ article.save est responsable de l'enregistrement du 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, bien que toutes les autres références d'articles de ce didacticiel soient toutes en minuscules. 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 rouvrez app / controllers / articles_controller.rb, vous pouvez voir que nous ne vérifions pas le résultat de l'appel de @ 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

La nouvelle action crée maintenant une nouvelle variable d'instance nommé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 que l'objet @article soit renvoyé au nouveau modèle lorsqu'il est rendu. Ce rendu est fait dans le cadre de la même demande que la soumission du formulaire, tandis que redirect_to indique au navigateur de faire une autre demande.

5.11. Mise à jour des articles

Nous avons découvert la partie "CR" de CRUD. Concentrons-nous maintenant sur la partie "U", en mettant à jour les articles.

La première étape consiste à ajouter une action d'édition à ArticlesController, généralement entre les actions new et create, 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 finir

La vue contiendra un formulaire similaire à celui que nous avons utilisé lors de la création de nouveaux articles. Créez un fichier nommé app/views/articles/edit.html.erb et ajoutez-y les éléments suivants :

Rédaction d'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 %>

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

Passer un objet article à la méthode form_with définira automatiquement l'URL pour soumettre le formulaire d'article modifié. Cette option indique à Rails que nous voulons que ce formulaire soit soumis en utilisant PATCH, la méthode HTTP qui devrait être utilisée pour renouvellement 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 de création et la méthode privée :

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 accepte 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 afficher à nouveau 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 passer tous les attributs à 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 ajoutez également au modèle app / vues / articles / show.html.erb afin que le lien "Modifier" se trouve également sur la page de l'article. Ajoutez ce qui suit à la fin de votre modèle :

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

Et voici à quoi ressemble notre application maintenant :

5.12. Utilisation de partiels pour nettoyer la répétition dans les vues

Notre page d'édition est très similaire à la nouvelle page, en fait, ils utilisent le même code pour rendre 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 à jour maintenant la vue app/views/articles/new.html.erb pour utiliser ce nouveau partiel en le réécrivant dans son intégralité :

Nouvel article

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

Et idem 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 à développer la partie "D" de CRUD, en la supprimant de la base de données. Conformément à la convention REST, la route pour supprimer des articles dans la sortie des routes de rails est la suivante :

SUPPRIMER /articles/:id(.:format) articles # détruire

La méthode de routage de suppression doit être utilisée pour les routes qui détruisent les ressources. Si vous la laissez comme une 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 à une action de destruction 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 le 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

Le contrôleur d'articles complet dans app/controllers/articles_controller.rb devrait maintenant ressembler à ceci :

Articles de classeContrôleur< 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 les objets Active Record lorsque vous souhaitez les supprimer de la base de données. Notez que nous n'avons pas besoin d'ajouter une vue pour cette action, car nous redirigeons vers l'index.

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 options comme autre argument. La méthode :: delete et data: (confirmez: "Êtes-vous sûr?") Les options sont utilisées comme attributs html5, donc lorsque le 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 de suppression . Cela se fait à l'aide du fichier JavaScript rails-ujs, qui est automatiquement inclus dans la mise en page 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 détruire les articles.

Ajout d'un deuxième modèle

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

6.1. Génération du modèle

Nous avons l'intention d'utiliser le même générateur que celui 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 le terminal :

$ rails generate model Commenter commenter : chaîne corps : texte article : références

Cette commande génère quatre fichiers :

Tout d'abord, jetez un œ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_à : article, qui définit lien Enregistrement actif. Vous verrez des liens dans la section suivante du guide.

Le mot-clé (:references) utilisé dans la commande bash est un type de données spécial pour les modèles. Il crée une nouvelle colonne dans votre base de données avec le nom du modèle présenté avec _id ajouté, qui peut contenir des 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 CréerCommentaires< ActiveRecord::Migration def change create_table:comments do |t| t.string:commenter t.text:body t.references:article, null: false, foreign_key: true t.timestamps end end end

La ligne t.references crée une colonne numérique nommée article_id, un index pour celle-ci et une contrainte de clé étrangère pointant vers la colonne id de la table articles. Ensuite, nous commençons la migration :

$ rails db : migrer

Rails est suffisamment intelligent pour effectuer uniquement les migrations qui n'ont pas encore été exécutées pour la base de données actuelle, dans notre cas, vous verrez :

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

6.2. Lier des modèles

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

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

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

Commentaire de classe< ApplicationRecord belongs_to:article end

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

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

Ces deux annonces mettent automatiquement à disposition une grande variété d'options. Par exemple, si vous avez 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. Ajout d'un itinéraire pour commentaires

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

Ressources : les articles font les ressources : les commentaires se terminent

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

6.4. Générer un contrôleur

Avec le modèle en main, tournons notre attention vers la création du contrôleur approprié. Utilisons le même générateur que nous avons utilisé auparavant :

$ rails generate controller Commentaires

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

Comme pour tout blog, nos lecteurs publieront 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é pris en compte. À cet égard, notre CommentsController sert à créer des commentaires et à supprimer le spam, le cas échéant.

Tout d'abord, nous allons étendre le modèle d'exposition d'article (app / views / articles / show.html.erb) pour permettre l'ajout d'un 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, créant un nouveau commentaire lorsque l'action de création est appelée sur le CommentsController. L'appel form_with utilise ici un tableau, qui créera une route imbriquée telle que / articles / 1 / comments.

Écrivons créer dans app / controllers / comments_controller.rb :

Commentaires de la classeContrôleur< 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 l'article contrôleur. Il s'agit d'un effet secondaire de la pièce jointe que vous avez configurée. Chaque demande de commentaire garde une trace de l'article auquel le commentaire est attaché, nous résolvons donc d'abord le problème de la récupération de l'article en appelant find sur le modèle Article.

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

Une fois que nous avons créé un nouveau commentaire, nous ramenons l'utilisateur à l'article d'origine en utilisant l'assistant article_path (@article). Comme nous l'avons vu, il appelle l'action show sur ArticlesController, qui à son tour rend le modèle show.html.erb. C'est là que nous voulons 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 %>

Commenter: <%= 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 à votre blog et les afficher aux bons endroits.

Refactorisation

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

7.1. Rendu des collections partielles

Tout d'abord, faisons un commentaire partiel montrant tous les commentaires pour l'article. Créez un fichier app/views/commentaires/_comment.html.erb et placez-y les éléments suivants :

Commentateur : <%= comment.commenter %>

Commenter: <%= comment.body %>

Ensuite, vous pouvez modifier app / vues / 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 maintenant l'application / vues / commentaires / _comment.html.erb partielle une fois pour chaque commentaire dans la collection @ article.comments. Puisque la méthode render itère sur la collection @ article.comments, elle affecte chaque commentaire à une variable locale portant le même nom que le partiel, dans notre cas comment, qui est à notre disposition dans le partiel à afficher.

7.2. Rendre une forme de manière partielle

Déplaçons également la nouvelle section de commentaires dans notre partiel. Encore une fois, créez un fichier app/views/commentaires/_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 suit :

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 du partiel que nous voulons rendre, les commentaires/formulaires. Rails est assez intelligent pour mettre un trait de soulignement sur cette ligne et réaliser que vous vouliez rendre le fichier _form.html.erb dans le répertoire app/views/commentaires.

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

Supprimer des commentaires

Une autre caractéristique 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 %>

Commenter: <%= comment.body %>

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

En cliquant sur ce nouveau lien "Destroy Comment" exécutera DELETE / articles // article_id / comments // id 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 / comments_controller.rb) :

Commentaires de la classeContrôleur< 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 visualisons, trouvera le commentaire dans la collection @ article.comments, puis le supprimera de la base de données et nous ramènera pour voir l'article.

8.1. Suppression d'objets associés

Si vous supprimez un article, les commentaires 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 de l'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, tout le monde 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 un système d'authentification, nous allons le définir 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, donc nous écrivons comme ceci :

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

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

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

Maintenant, si vous essayez de créer un nouvel article, vous rencontrerez un défi d'authentification de base HTTP :

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

9.2. D'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écurisation de votre application Rails est décrite plus en détail dans le guide Sécurisation des applications Rails. La façon 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 ce domaine, le symptôme le plus courant est un losange noir avec un point d'interrogation à l'intérieur qui apparaît dans le navigateur. Un autre symptôme courant est l'apparition de caractères tels que "ü" au lieu 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 résolus. Cependant, s'il existe des données externes qui ne sont pas stockées en UTF-8, cela peut entraîner ce genre de problèmes qui ne peuvent pas être automatiquement détectés par Rails et résolus.

Les deux sources de données les plus courantes qui ne sont pas en 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 modèles (comme é) 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 ne définissent pas la valeur par défaut sur UTF-8 (comme certaines versions de Dreamweaver) offrent un moyen de modifier les valeurs par défaut en UTF-8. Faites ceci.
• Votre base de données : Rails convertit les données de votre base de données en UTF-8 par défaut à la frontière. Cependant, si votre base de données n'utilise pas UTF-8 en interne, il se peut qu'elle ne puisse pas stocker tous les caractères saisis par l'utilisateur. Par exemple, si votre base de données utilise en interne Latin-1 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.

Créez de vraies applications à l'aide de Ruby on Rails. Vous avez peut-être essayé Ruby on Rails, mais vous l'avez trouvé trop compliqué et vous avez besoin d'une introduction plus complète. Peut-être que votre patron ou votre client vous a lancé un projet Ruby on Rails et a besoin de se renseigner rapidement sur Rails ? Ou peut-être avez-vous décidé d'ajouter le développement Web et Ruby on Rails à votre CV. Si c'est le cas, vous êtes au bon endroit. Ce cours vous apprend à créer des applications Web à l'aide de Ruby on Rails.

Pourquoi Ruby on Rails ?

Ruby on Rails est un moyen rapide et efficace de développer des applications Web. Il simplifie les tâches répétitives courantes qui prennent beaucoup de temps à créer dans d'autres langues. Il est beaucoup plus facile d'obtenir un produit de haute qualité en Ruby on Rails que dans d'autres langues.

Étant donné que le framework est mature, il existe une tonne de projets/codes open source que vous pouvez utiliser qui sont extrêmement puissants et vous donnent vraiment un avantage dans la création d'applications Web robustes.

De plus, il utilise le langage de programmation Ruby. Le code Ruby se lit comme l'anglais, ce qui le rend beaucoup plus facile à comprendre si vous débutez en programmation. En tant que langue à typage dynamique, Ruby n'a pas toutes les règles strictes et rapides que les autres langues ont et est à bien des égards similaire à une langue parlée. Cela vous donne la possibilité de résoudre les problèmes de manière plus humaine que les autres langages de programmation.

Qu'est-ce qui est couvert?

Certaines des fonctionnalités couvertes par le cours comprennent ...

Git Basics, Rails core "7 methodes" et comment ils font "CRUD", Rails Routing, Strong Parameters, Custom Callbacks, Custom Validation, Partials,

Bootstrap 4, générateurs Rails, authentification utilisateur, authentification utilisateur, gestion de contenu, déploiement, téléchargement de base de données, envoi/réception d'e-mails à l'aide de l'application Rails, configuration de Sidekiq, configuration de Redis sur Heroku et serveur privé, installation de modèles, messages de validation personnalisés, ajout d'actifs au Rails Pipeline, en téléchargeant des images sur votre propre serveur, en téléchargeant sur AWS, en ajoutant WYSIWYG - ce que vous voyez est ce que vous obtenez de l'éditeur et bien plus encore !

Pourquoi s'inscrire à ce cours est la meilleure décision que vous puissiez prendre.

Ces cours utilisent des exemples simples pour effectuer des tâches complexes. Le but est de vous faire comprendre exactement ce que vous faites et les raisons pour lesquelles, plutôt que d'entrer du code que vous ne comprenez pas. Aucun code n'est masqué car il est important que vous compreniez ce que fait chaque ligne.

À la fin de ce cours, vous aurez les compétences nécessaires pour créer vos propres applications Web à l'aide de Ruby on Rails.

Plus tôt vous vous inscrivez à ce cours, plus tôt vous aurez les compétences et les connaissances dont vous avez besoin pour augmenter votre expérience. Les développeurs Ruby on Rails sont très demandés ! Pourquoi ne pas commencer sur Ruby on Rails aujourd'hui ?

Dans cet article, je veux vous montrer comment créer une application de base de données MySQL simple dans Ruby on Rails 3. Considérez cela comme un guide étape par étape pour les programmeurs Rails novices.

Ainsi, pour fonctionner, nous avons besoin de rails et de rubygems installés. J'ai eu un problème avec ce dernier hier, j'ai donc dû supprimer le paquet rubygems1.8, on ne sait pas comment il s'est retrouvé dans le système et installer rubygems1.9. Laissez-moi vous rappeler que je développe sur Ubuntu, bien que pour Windows 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 assez bien écrit sur l'installation.

Vérification des liens

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

selon ce que vous voulez filtrer.

Créer une candidature

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 les choses, en particulier 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 un squelette de la future application.

[email protégé]: ~ / ruby ​​​​# rails 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 Gemfile
créer une application
créer une application / contrôleurs / application_controller.rb
créer une application / helpers / application_helper.rb
créer une application / des e-mails
créer une application / des modèles
créer une application / vues / mises en page / application.html.erb
créer une configuration
créer config / routes.rb
créer config/application.rb
créer config / environnement.rb
créer des config/environnements
créer config / environnements / development.rb
créer config / environnements / production.rb
créer config/environnements/test.rb
créer une configuration / initialiseurs
créer la configuration / initialiseurs / backtrace_silencers.rb
créer config / initialiseurs / inflections.rb
créer config / initialiseurs / mime_types.rb
créer la configuration / initialiseurs / secret_token.rb
créer config / initialiseurs / session_store.rb
créer la configuration / les paramètres régionaux
créer config/locales/en.yml
créer config / boot.rb
créer config/base de données.yml
créer une base de données
créer db/semences.rb
créer un document
créer un document / README_FOR_APP
créer une bibliothèque
créer une bibliothèque / des tâches
créer lib/tâches/.gitkeep
créer un journal
créer un journal / server.log
créer un journal / production.log
créer un journal / development.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 public / images
créer public / images / rails.png
créer des feuilles de style publiques
créer public / stylesheets / .gitkeep
créer public / javascript
créer public / javascripts / application.js
créer public / javascripts / control.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 / des rails
créer un test
créer des tests / montages
créer un test / fonctionnel
créer test / intégration
créer test / performance / navigation_test.rb
créer un test / test_helper.rb
créer un test / une unité
créer tmp
créer tmp/sessions
créer tmp / sockets
créer tmp/cache
créer tmp/pids
créer un fournisseur/des plugins
créer un fournisseur / plugins / .gitkeep

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

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

[email protégé]: ~ / ruby ​​​​/ app> installation du bundle sudo
Utilisation du râteau (0.8.7)
Utilisation du résumé (1.0.0)
Utiliser activesupport (3.0.0)
Utilisation du constructeur (2.1.2)
Utiliser i18n (0.4.2)
Utilisation d'activemodel (3.0.0)
Utiliser erubis (2.6.6)
Utilisation du rack (1.2.1)
Utilisation du montage en rack (0.6.13)
Utilisation du rack-test (0.5.6)
Utilisation de tzinfo (0.3.23)
Utilisation du pack d'action (3.0.0)
Utilisation des types mime (1.16)
Utilisation polyglotte (0.3.1)
Utilisation de la cime des arbres (1.4.8)
Utiliser le courrier (2.2.9)
Utiliser actionmailer (3.0.0)
Utiliser arel (1.0.1)
Utilisation d'activerecord (3.0.0)
Utilisation de la ressource active (3.0.0)
Utiliser le bundler (1.0.3)
Utilisation de mysql2 (0.2.6)
Utiliser thor (0.14.4)
Utiliser des rails (3.0.0)
Utiliser des rails (3.0.0)
Votre forfait est complet ! Utilisez « bundle show » pour voir où un joyau groupé est installé.

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 à partir de rubygems et les installera. C'est ce que j'ai raté en php pendant longtemps, en fait il s'avère que l'installateur du 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. On indique le chemin, dans mon cas ce sera (/home/andrey/ruby/app) et le nom du projet (app). Pour la plate-forme Ruby, nous sélectionnons celle installée sur le système, pas 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 nom d'utilisateur 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). L'environnement est l'environnement dans lequel notre application s'exécutera,

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

rails generate model Nom d'utilisateur : chaîne hashed_password : chaîne sel : chaîne

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

invoquer active_record
créer db/migrer/20101107054200_create_users.rb
créer une application / modèles / user.rb
invoquer test_unit
créer test / unité / user_test.rb
créer test / fixtures / users.yml

Super, maintenant nous devons créer une base de données. Pour cela nous effectuons :

[email protégé]: ~ / ruby ​​​​/ app $ rake db : créer
(dans / home / andrey / ruby ​​​​/ app)
[email protégé]: ~ / ruby ​​​​/ app $ rake db : migrer
(dans / home / andrey / ruby ​​​​/ app)
== CreateUsers: migration ============================================== =====
- create_table ( : utilisateurs)
-> 0,0061s
== CreateUsers: migré (0.0063s) ==========================================

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

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

[email protégé]: ~ / ruby ​​​​/ app console $ rails
Chargement de l'environnement de développement (Rails 3.0.0)
irb (principal) : 001 : 0> user1 = User.new
=> #
irb (principal) : 002 : 0> user1.name = "andrey"
=> "André"
irb (principal) : 003 : 0> user1.save
=> vrai
irb (principal) : 004 : 0> user2 = User.new
=> #
irb (principal) : 005 : 0> user2.name = "vasiliy"
=> "Vassily"
irb (principal) : 006 : 0> user2.save
=> vrai

irb (principal) : 007 : 0> sortie
[email protégé]: ~ / rubis / application $

Regardons la base de données, et en effet nous avons deux utilisateurs. Notez que Rails lui-même a ajouté les colonnes de clé primaire et les champs created_at (date de création) et updated_at (date de modification) au modèle.

Nous avons le modèle, les données aussi. Il est temps de lancer notre application.

[email protégé]: ~/ruby ​​/app serveur $ rails
=> Démarrage de WEBrick
=> Application Rails 3.0.0 en cours de développement sur http://0.0.0.0:3000
=> Appel 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 # début : 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'appli fonctionne. Mais il affiche une page HTML normale du dossier /public/index.html. Et nous voulons du dynamique. Nous ouvrons la deuxième fenêtre de la console (car dans la première, nous avons le ver-server Ruby en cours d'exécution - WebRick), accédez au dossier avec le projet et tapez la commande suivante :

[email protégé]: ~ / ruby ​​​​/ app $ rails génèrent un index d'index de contrôleur
créer une application / contrôleurs / index_controller.rb
itinéraire obtenir "index / index"
invoquer erb
créer une application / des vues / un index
créer une application / vues / index / index.html.erb
invoquer test_unit
créer un test / fonctionnel / index_controller_test.rb
invoquer l'assistant
créer une application / helpers / index_helper.rb
invoquer test_unit
créer test / unité / helpers / index_helper_test.rb
[email protégé]: ~ / rubis / application $

Avec cela, nous avons créé le contrôleur Index, dans lequel se trouve l'action Index et le type de cette action index.html.erb Nous effectuons un Refresh (F5) dans NetBeans et regardons nos fichiers. Merveilleux. Nous devons maintenant rediriger d'une manière ou d'une autre la route 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"

Mais au lieu de bienvenue, nous écrivons également index. Bon, j'ai l'habitude depuis Zend Framework que le contrôleur et l'action sont nommés index par défaut. N'oubliez pas de supprimer (ou renommer) le fichier public / index.html).

root : to => "index # index"

Nous mettons à jour la page dans le navigateur, et nous voyons que notre vue est maintenant affichée.

Indice # indice

Amende. Maintenant, vous pouvez coder. Allons à notre contrôleur nouvellement créé (Controllers -> index_controller.rb) et écrivez le texte d'action suivant :

classe IndexController< ApplicationController
indice de déf
@users = User.find (: tous)
finir
finir

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

Indice # indice

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

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

<% end %>

Cela indique à Rails de parcourir le tableau des utilisateurs et d'afficher leurs noms. Nous mettons à jour la page et voyons la liste des utilisateurs en bas.

Indice # indice

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

Andreï
vasil

Amende! 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 :

Ruby a commencé le développement le 23 février 1993 et ​​est sorti en 1995. Le nom est inspiré du langage Perl, dont une grande partie de la syntaxe et de la sémantique sont empruntées à Ruby (pearl - "pearl", ruby ​​​​- "ruby"). L'objectif du développement était de créer un "vrai langage de programmation orienté objet", facile à développer et interprété.

Le langage a une implémentation multithread indépendante du système d'exploitation, un typage dynamique fort, un ramasse-miettes et de nombreuses autres fonctionnalités. La mise en œuvre multiplateforme de l'interpréteur de langue est entièrement gratuite.

Ruby on Rails (RoR) est un framework écrit dans le langage de programmation Ruby. Il implémente le modèle architectural Modèle-Vue-Contrôleur pour les applications Web et fournit également une intégration avec le serveur Web et le serveur de base de données. Il s'agit d'un logiciel open source et sous licence MIT.

Pour vous aider à explorer ces technologies, nous avons compilé une sélection de livres. Comme toujours, si vous connaissez un livre qui n'était pas inclus dans ce matériel, partagez-le dans les commentaires.

Ce livre est pour ceux qui veulent écrire Ruby comme un pro. Il explique comment concevoir de belles API et travailler avec des techniques de programmation fonctionnelles. Le livre ne convient pas aux débutants, mais pour ceux qui comprennent déjà Ruby, il sera certainement utile.

Le but de ce livre est d'enseigner aux lecteurs comment utiliser efficacement le langage Ruby. Ce livre couvre Ruby 2.1. La publication contient environ 400 exemples différents, accompagnés d'un énoncé clair du problème et de sa solution avec des commentaires détaillés.

Le livre a un seuil d'entrée assez bas. Vous n'avez pas besoin de connaître les bases du développement Web pour l'apprendre. Le livre reprend des informations sur Ruby on Rails, un framework populaire pour le développement d'applications Web, à partir de zéro. L'auteur Michael Hartl, en plus de Ruby on Rails, familiarise le lecteur avec les bases du langage Ruby lui-même, le langage de requête SQL, CSS, HTML. Le livre accorde une grande attention à l'utilisation pratique des capacités du framework. Vous pouvez également lire un fragment du livre.

Et ce livre est utile pour les débutants. Sa complexité augmente de plus en plus, et dans chaque section suivante, les compétences acquises dans les précédentes sont utilisées.

Avec "Learning Ruby", vous apprendrez de manière simple et amusante en pratique toutes les fonctionnalités de ce langage, qui a d'abord rapidement conquis le cœur des programmeurs en Californie, puis en Russie.

Après avoir lu ce livre, vous apprendrez à écrire un code élégant qui tire parti de toutes ses fonctionnalités uniques.

Ce livre examine en détail les rouages ​​du langage Ruby. Le lecteur n'a pas besoin de connaître Ruby lui-même, mais la connaissance du C et, en particulier, des principes de la POO sera un énorme plus.

Ce livre est une excellente introduction à Ruby. Il couvre toutes les bases dont vous avez besoin, de l'installation de la langue à la gestion des fichiers et à la POO. Chaque sujet est fourni avec des exemples clairs.

Ce livre couvre l'une des fonctionnalités les plus intéressantes de Ruby - les blocs. Ils sont similaires aux fermetures et aux lambdas et sont utilisés à la fois dans des structures de langage simples comme des blocs et dans des astuces complexes.

Ce livre est divisé en plusieurs sections, de complexité variable. Il couvre d'abord la configuration et les fonctionnalités de base de Ruby, puis il parle de la bibliothèque standard et des thèmes avancés.